zend_API.h

/*
 +----------------------------------------------------------------------+
 | Zend Engine |
 +----------------------------------------------------------------------+
 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
 +----------------------------------------------------------------------+
 | This source file is subject to version 2.00 of the Zend license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | http://www.zend.com/license/2_00.txt. |
 | 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. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 | Andrei Zmievski <andrei@php.net> |
 | Dmitry Stogov <dmitry@php.net> |
 +----------------------------------------------------------------------+
*/

#ifndefZEND_API_H
#defineZEND_API_H

#include"zend_modules.h"
#include"zend_list.h"
#include"zend_operators.h"
#include"zend_variables.h"
#include"zend_execute.h"
#include"zend_type_info.h"
#include"zend_frameless_function.h"

BEGIN_EXTERN_C()

typedefstruct_zend_function_entry {
constchar*fname;
zif_handlerhandler;
conststruct_zend_internal_arg_info*arg_info;
uint32_tnum_args;
uint32_tflags;
constzend_frameless_function_info*frameless_function_infos;
constchar*doc_comment;
} zend_function_entry;

typedefstruct_zend_fcall_info {
size_tsize;
zvalfunction_name;
zval*retval;
zval*params;
zend_object*object;
uint32_tparam_count;
/* 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;
} zend_fcall_info;

typedefstruct_zend_fcall_info_cache {
zend_function*function_handler;
zend_class_entry*calling_scope;
zend_class_entry*called_scope;
zend_object*object; /* Instance of object for method calls */
zend_object*closure; /* Closure reference, only if the callable *is* the object */
} zend_fcall_info_cache;

#defineZEND_NS_NAME(ns, name) ns "\\" name

/* 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. */
#defineZEND_FN(name) zif_##name
#defineZEND_MN(name) zim_##name

#defineZEND_NAMED_FUNCTION(name) void ZEND_FASTCALL name(INTERNAL_FUNCTION_PARAMETERS)
#defineZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(zif_##name)
#defineZEND_METHOD(classname, name) ZEND_NAMED_FUNCTION(zim_##classname##_##name)

#defineZEND_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, NULL, NULL },

#defineZEND_RAW_FENTRY(zend_name, name, arg_info, flags, frameless_function_infos, doc_comment) { zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos, doc_comment },

/* Same as ZEND_NAMED_FE */
#defineZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL, NULL)

#defineZEND_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL, NULL)
#defineZEND_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, 0, NULL, NULL)
#defineZEND_DEP_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_DEPRECATED, NULL, NULL)
#defineZEND_FALIAS(name, alias, arg_info) ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, 0, NULL, NULL)
#defineZEND_DEP_FALIAS(name, alias, arg_info) ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED, NULL, NULL)
#defineZEND_NAMED_ME(zend_name, name, arg_info, flags) ZEND_FENTRY(zend_name, name, arg_info, flags)
#defineZEND_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags, NULL, NULL)
#defineZEND_DEP_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags | ZEND_ACC_DEPRECATED, NULL, NULL)
#defineZEND_ABSTRACT_ME(classname, name, arg_info) ZEND_RAW_FENTRY(#name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
#defineZEND_ABSTRACT_ME_WITH_FLAGS(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, NULL, arg_info, flags, NULL, NULL)
#defineZEND_MALIAS(classname, name, alias, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##alias, arg_info, flags, NULL, NULL)
#defineZEND_ME_MAPPING(name, func_name, arg_info, flags) ZEND_RAW_FENTRY(#name, zif_##func_name, arg_info, flags, NULL, NULL)
#defineZEND_FRAMELESS_FE(name, arg_info, flags, frameless_function_infos, doc_comment) \
 { #name, zif_##name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos, doc_comment },

#defineZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags) ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags, NULL, NULL)

#defineZEND_NS_RAW_FENTRY(ns, zend_name, name, arg_info, flags) ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, zend_name), name, arg_info, flags, NULL, NULL)
/**
 * Note that if you are asserting that a function is compile-time evaluable, you are asserting that
 *
 * 1. The function will always have the same result for the same arguments
 * 2. The function does not depend on global state such as ini settings or locale (e.g. mb_strtolower), number_format(), etc.
 * 3. The function does not have side effects. It is okay if they throw
 * or warn on invalid arguments, as we detect this and will discard the evaluation result.
 * 4. The function will not take an unreasonable amount of time or memory to compute on code that may be seen in practice.
 * (e.g. str_repeat is special cased to check the length instead of using this)
 */
#defineZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)

/* Same as ZEND_NS_NAMED_FE */
#defineZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)

#defineZEND_NS_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
#defineZEND_NS_FE(ns, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##name, arg_info, 0)
#defineZEND_NS_DEP_FE(ns, name, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##name, arg_info, ZEND_ACC_DEPRECATED)
#defineZEND_NS_FALIAS(ns, name, alias, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, 0)
#defineZEND_NS_DEP_FALIAS(ns, name, alias, arg_info) ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED)

#defineZEND_FE_END { NULL, NULL, NULL, 0, 0, NULL, NULL }

#define_ZEND_ARG_INFO_FLAGS(pass_by_ref, is_variadic, is_tentative) \
 (((pass_by_ref) << _ZEND_SEND_MODE_SHIFT) | ((is_variadic) ? _ZEND_IS_VARIADIC_BIT : 0) | ((is_tentative) ? _ZEND_IS_TENTATIVE_BIT : 0))

/* Arginfo structures without type information */
#defineZEND_ARG_INFO(pass_by_ref, name) \
 { #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 0, 0)), NULL },
#defineZEND_ARG_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, default_value) \
 { #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 0, 0)), default_value },
#defineZEND_ARG_VARIADIC_INFO(pass_by_ref, name) \
 { #name, ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), NULL },

/* Arginfo structures with simple type information */
#defineZEND_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, 0)), NULL },
#defineZEND_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, 0)), default_value },
#defineZEND_ARG_VARIADIC_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, 1, 0)), NULL },

/* Arginfo structures with complex type information */
#defineZEND_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, 0)), default_value },
#defineZEND_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, 0)), default_value },
#defineZEND_ARG_VARIADIC_OBJ_TYPE_MASK(pass_by_ref, name, class_name, type_mask) \
 { #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#class_name, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), NULL },

/* Arginfo structures with object type information */
#defineZEND_ARG_OBJ_INFO(pass_by_ref, name, class_name, allow_null) \
 { #name, ZEND_TYPE_INIT_CLASS_CONST(#class_name, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0, 0)), NULL },
#defineZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(pass_by_ref, name, class_name, allow_null, default_value) \
 { #name, ZEND_TYPE_INIT_CLASS_CONST(#class_name, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 0, 0)), default_value },
#defineZEND_ARG_VARIADIC_OBJ_INFO(pass_by_ref, name, class_name, allow_null) \
 { #name, ZEND_TYPE_INIT_CLASS_CONST(#class_name, allow_null, _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), NULL },

/* Legacy arginfo structures */
#defineZEND_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, 0)), NULL },
#defineZEND_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, 0)), NULL },

#defineZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX2(name, return_reference, required_num_args, class_name, allow_null, is_tentative_return_type) \
 static const zend_internal_arg_info name[] = { \
 { (const char*)(uintptr_t)(required_num_args), \
 ZEND_TYPE_INIT_CLASS_CONST(#class_name, allow_null, _ZEND_ARG_INFO_FLAGS(return_reference, 0, is_tentative_return_type)), NULL },

#defineZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, class_name, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX2(name, return_reference, required_num_args, class_name, allow_null, 0)

#defineZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, class_name, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX2(name, return_reference, required_num_args, class_name, allow_null, 1)

#defineZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO(name, class_name, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX2(name, 0, -1, class_name, allow_null, 0)

#defineZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX2(name, return_reference, required_num_args, type, is_tentative_return_type) \
 static const zend_internal_arg_info name[] = { \
 { (const char*)(uintptr_t)(required_num_args), ZEND_TYPE_INIT_MASK(type | _ZEND_ARG_INFO_FLAGS(return_reference, 0, is_tentative_return_type)), NULL },

#defineZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(name, return_reference, required_num_args, type) \
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX2(name, return_reference, required_num_args, type, 0)

#defineZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_MASK_EX(name, return_reference, required_num_args, type) \
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX2(name, return_reference, required_num_args, type, 1)

#defineZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX2(name, return_reference, required_num_args, class_name, type, is_tentative_return_type) \
 static const zend_internal_arg_info name[] = { \
 { (const char*)(uintptr_t)(required_num_args), ZEND_TYPE_INIT_CLASS_CONST_MASK(#class_name, type | _ZEND_ARG_INFO_FLAGS(return_reference, 0, is_tentative_return_type)), NULL },

#defineZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(name, return_reference, required_num_args, class_name, type) \
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX2(name, return_reference, required_num_args, class_name, type, 0)

#defineZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_TYPE_MASK_EX(name, return_reference, required_num_args, class_name, type) \
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX2(name, return_reference, required_num_args, class_name, type, 1)

#defineZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX2(name, return_reference, required_num_args, type, allow_null, is_tentative_return_type) \
 static const zend_internal_arg_info name[] = { \
 { (const char*)(uintptr_t)(required_num_args), ZEND_TYPE_INIT_CODE(type, allow_null, _ZEND_ARG_INFO_FLAGS(return_reference, 0, is_tentative_return_type)), NULL },

#defineZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX2(name, return_reference, required_num_args, type, allow_null, 0)

#defineZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX2(name, return_reference, required_num_args, type, allow_null, 1)

#defineZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO(name, type, allow_null) \
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX2(name, 0, -1, type, allow_null, 0)

#defineZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args) \
 static const zend_internal_arg_info name[] = { \
 { (const char*)(uintptr_t)(required_num_args), ZEND_TYPE_INIT_NONE(_ZEND_ARG_INFO_FLAGS(return_reference, 0, 0)), NULL },
#defineZEND_BEGIN_ARG_INFO(name, _unused) \
 ZEND_BEGIN_ARG_INFO_EX(name, {}, ZEND_RETURN_VALUE, -1)
#defineZEND_END_ARG_INFO() };

/* Name macros */
#defineZEND_MODULE_STARTUP_N(module) zm_startup_##module
#defineZEND_MODULE_SHUTDOWN_N(module) zm_shutdown_##module
#defineZEND_MODULE_ACTIVATE_N(module) zm_activate_##module
#defineZEND_MODULE_DEACTIVATE_N(module) zm_deactivate_##module
#defineZEND_MODULE_POST_ZEND_DEACTIVATE_N(module) zm_post_zend_deactivate_##module
#defineZEND_MODULE_INFO_N(module) zm_info_##module
#defineZEND_MODULE_GLOBALS_CTOR_N(module) zm_globals_ctor_##module
#defineZEND_MODULE_GLOBALS_DTOR_N(module) zm_globals_dtor_##module

/* Declaration macros */
#defineZEND_MODULE_STARTUP_D(module) zend_result ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
#defineZEND_MODULE_SHUTDOWN_D(module) zend_result ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
#defineZEND_MODULE_ACTIVATE_D(module) zend_result ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
#defineZEND_MODULE_DEACTIVATE_D(module) zend_result ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
#defineZEND_MODULE_POST_ZEND_DEACTIVATE_D(module) zend_result ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
#defineZEND_MODULE_INFO_D(module) ZEND_COLD void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
#defineZEND_MODULE_GLOBALS_CTOR_D(module) void ZEND_MODULE_GLOBALS_CTOR_N(module)(zend_##module##_globals *module##_globals)
#defineZEND_MODULE_GLOBALS_DTOR_D(module) void ZEND_MODULE_GLOBALS_DTOR_N(module)(zend_##module##_globals *module##_globals)

#defineZEND_GET_MODULE(name) \
 BEGIN_EXTERN_C()\
 ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
 END_EXTERN_C()

#defineZEND_BEGIN_MODULE_GLOBALS(module_name) \
 typedef struct _zend_##module_name##_globals {
#defineZEND_END_MODULE_GLOBALS(module_name) \
 } zend_##module_name##_globals;

#ifdefZTS

#defineZEND_DECLARE_MODULE_GLOBALS(module_name) \
 ts_rsrc_id module_name##_globals_id;
#defineZEND_EXTERN_MODULE_GLOBALS(module_name) \
 extern ts_rsrc_id module_name##_globals_id;
#defineZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
 ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
#defineZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) ZEND_TSRMG(module_name##_globals_id, zend_##module_name##_globals *, v)
#ifdefZEND_ENABLE_STATIC_TSRMLS_CACHE
#defineZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK_STATIC(module_name##_globals_id, zend_##module_name##_globals *)
#else
#defineZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK(module_name##_globals_id, zend_##module_name##_globals *)
#endif

#else

#defineZEND_DECLARE_MODULE_GLOBALS(module_name) \
 zend_##module_name##_globals module_name##_globals;
#defineZEND_EXTERN_MODULE_GLOBALS(module_name) \
 extern zend_##module_name##_globals module_name##_globals;
#defineZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
 globals_ctor(&module_name##_globals);
#defineZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) (module_name##_globals.v)
#defineZEND_MODULE_GLOBALS_BULK(module_name) (&module_name##_globals)

#endif

#defineINIT_CLASS_ENTRY(class_container, class_name, functions) \
 INIT_CLASS_ENTRY_EX(class_container, class_name, strlen(class_name), functions)

#defineINIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \
 { \
 memset(&class_container, 0, sizeof(zend_class_entry)); \
 class_container.name = zend_string_init_interned(class_name, class_name_len, 1); \
 class_container.default_object_handlers = &std_object_handlers; \
 class_container.info.internal.builtin_functions = functions; \
 }

#defineINIT_CLASS_ENTRY_INIT_METHODS(class_container, functions) \
 { \
 class_container.default_object_handlers = &std_object_handlers; \
 class_container.constructor = NULL; \
 class_container.destructor = NULL; \
 class_container.clone = NULL; \
 class_container.serialize = NULL; \
 class_container.unserialize = NULL; \
 class_container.create_object = NULL; \
 class_container.get_static_method = NULL; \
 class_container.__call = NULL; \
 class_container.__callstatic = NULL; \
 class_container.__tostring = NULL; \
 class_container.__get = NULL; \
 class_container.__set = NULL; \
 class_container.__unset = NULL; \
 class_container.__isset = NULL; \
 class_container.__debugInfo = NULL; \
 class_container.__serialize = NULL; \
 class_container.__unserialize = NULL; \
 class_container.parent = NULL; \
 class_container.num_interfaces = 0; \
 class_container.trait_names = NULL; \
 class_container.num_traits = 0; \
 class_container.trait_aliases = NULL; \
 class_container.trait_precedences = NULL; \
 class_container.interfaces = NULL; \
 class_container.get_iterator = NULL; \
 class_container.iterator_funcs_ptr = NULL; \
 class_container.arrayaccess_funcs_ptr = NULL; \
 class_container.info.internal.module = NULL; \
 class_container.info.internal.builtin_functions = functions; \
 }


#defineINIT_NS_CLASS_ENTRY(class_container, ns, class_name, functions) \
 INIT_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions)

#defineCE_STATIC_MEMBERS(ce) \
 ((zval*)ZEND_MAP_PTR_GET((ce)->static_members_table))

#defineCE_CONSTANTS_TABLE(ce) \
 zend_class_constants_table(ce)

#defineCE_DEFAULT_PROPERTIES_TABLE(ce) \
 zend_class_default_properties_table(ce)

#defineCE_BACKED_ENUM_TABLE(ce) \
 zend_class_backed_enum_table(ce)

#defineZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
#defineZEND_FCC_INITIALIZED(fcc) ((fcc).function_handler != NULL)

ZEND_APIintzend_next_free_module(void);

BEGIN_EXTERN_C()
ZEND_APIzend_resultzend_get_parameters_array_ex(uint32_tparam_count, zval*argument_array);

/* internal function to efficiently copy parameters when executing __call() */
ZEND_APIzend_resultzend_copy_parameters_array(uint32_tparam_count, zval*argument_array);

#definezend_get_parameters_array(ht, param_count, argument_array) \
 zend_get_parameters_array_ex(param_count, argument_array)
#definezend_parse_parameters_none() \
 (EXPECTED(ZEND_NUM_ARGS() == 0) ? SUCCESS : (zend_wrong_parameters_none_error(), FAILURE))
#definezend_parse_parameters_none_throw() \
 zend_parse_parameters_none()

/* Parameter parsing API -- andrei */

#defineZEND_PARSE_PARAMS_THROW 0 /* No longer used, zpp always uses exceptions */
#defineZEND_PARSE_PARAMS_QUIET (1<<1)
ZEND_APIzend_resultzend_parse_parameters(uint32_tnum_args, constchar*type_spec, ...);
ZEND_APIzend_resultzend_parse_parameters_ex(intflags, uint32_tnum_args, constchar*type_spec, ...);
/* NOTE: This must have at least one value in __VA_ARGS__ for the expression to be valid */
#definezend_parse_parameters_throw(num_args, ...) \
 zend_parse_parameters(num_args, __VA_ARGS__)
ZEND_APIconstchar*zend_zval_type_name(constzval*arg);
ZEND_APIconstchar*zend_zval_value_name(constzval*arg);
ZEND_APIzend_string*zend_zval_get_legacy_type(constzval*arg);

ZEND_APIzend_resultzend_parse_method_parameters(uint32_tnum_args, zval*this_ptr, constchar*type_spec, ...);
ZEND_APIzend_resultzend_parse_method_parameters_ex(intflags, uint32_tnum_args, zval*this_ptr, constchar*type_spec, ...);

ZEND_APIzend_resultzend_parse_parameter(intflags, uint32_targ_num, zval*arg, constchar*spec, ...);

/* End of parameter parsing API -- andrei */

ZEND_APIzend_resultzend_register_functions(zend_class_entry*scope, constzend_function_entry*functions, HashTable*function_table, inttype);
ZEND_APIvoidzend_unregister_functions(constzend_function_entry*functions, intcount, HashTable*function_table);
ZEND_APIzend_resultzend_startup_module(zend_module_entry*module_entry);
ZEND_APIzend_module_entry*zend_register_internal_module(zend_module_entry*module_entry);
ZEND_APIzend_module_entry*zend_register_module_ex(zend_module_entry*module, intmodule_type);
ZEND_APIzend_resultzend_startup_module_ex(zend_module_entry*module);
ZEND_APIvoidzend_startup_modules(void);
ZEND_APIvoidzend_collect_module_handlers(void);
ZEND_APIvoidzend_destroy_modules(void);
ZEND_APIvoidzend_check_magic_method_implementation(
constzend_class_entry*ce, constzend_function*fptr, zend_string*lcname, interror_type);
ZEND_APIvoidzend_add_magic_method(zend_class_entry*ce, zend_function*fptr, zend_string*lcname);

ZEND_APIzend_class_entry*zend_register_internal_class(zend_class_entry*class_entry);
ZEND_APIzend_class_entry*zend_register_internal_class_ex(zend_class_entry*class_entry, zend_class_entry*parent_ce);
ZEND_APIzend_class_entry*zend_register_internal_class_with_flags(zend_class_entry*class_entry, zend_class_entry*parent_ce, uint32_tflags);
ZEND_APIzend_class_entry*zend_register_internal_interface(zend_class_entry*orig_class_entry);
ZEND_APIvoidzend_class_implements(zend_class_entry*class_entry, intnum_interfaces, ...);

ZEND_APIzend_resultzend_register_class_alias_ex(constchar*name, size_tname_len, zend_class_entry*ce, boolpersistent);

staticzend_always_inlinezend_resultzend_register_class_alias(constchar*name, zend_class_entry*ce) {
returnzend_register_class_alias_ex(name, strlen(name), ce, 1);
}
#definezend_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)

ZEND_APIvoidzend_disable_functions(constchar*function_list);
ZEND_APIzend_resultzend_disable_class(constchar*class_name, size_tclass_name_length);

ZEND_APIZEND_COLDvoidzend_wrong_param_count(void);
ZEND_APIZEND_COLDvoidzend_wrong_property_read(zval*object, zval*property);

#defineIS_CALLABLE_CHECK_SYNTAX_ONLY (1<<0)
#defineIS_CALLABLE_SUPPRESS_DEPRECATIONS (1<<1)

ZEND_APIvoidzend_release_fcall_info_cache(zend_fcall_info_cache*fcc);
ZEND_APIzend_string*zend_get_callable_name_ex(zval*callable, zend_object*object);
ZEND_APIzend_string*zend_get_callable_name(zval*callable);
ZEND_APIboolzend_is_callable_at_frame(
zval*callable, zend_object*object, zend_execute_data*frame,
uint32_tcheck_flags, zend_fcall_info_cache*fcc, char**error);
ZEND_APIboolzend_is_callable_ex(zval*callable, zend_object*object, uint32_tcheck_flags, zend_string**callable_name, zend_fcall_info_cache*fcc, char**error);
ZEND_APIboolzend_is_callable(zval*callable, uint32_tcheck_flags, zend_string**callable_name);
ZEND_APIboolzend_make_callable(zval*callable, zend_string**callable_name);
ZEND_APIconstchar*zend_get_module_version(constchar*module_name);
ZEND_APIzend_resultzend_get_module_started(constchar*module_name);

ZEND_APIzend_property_info*zend_declare_typed_property(zend_class_entry*ce, zend_string*name, zval*property, intaccess_type, zend_string*doc_comment, zend_typetype);

ZEND_APIvoidzend_declare_property_ex(zend_class_entry*ce, zend_string*name, zval*property, intaccess_type, zend_string*doc_comment);
ZEND_APIvoidzend_declare_property(zend_class_entry*ce, constchar*name, size_tname_length, zval*property, intaccess_type);
ZEND_APIvoidzend_declare_property_null(zend_class_entry*ce, constchar*name, size_tname_length, intaccess_type);
ZEND_APIvoidzend_declare_property_bool(zend_class_entry*ce, constchar*name, size_tname_length, zend_longvalue, intaccess_type);
ZEND_APIvoidzend_declare_property_long(zend_class_entry*ce, constchar*name, size_tname_length, zend_longvalue, intaccess_type);
ZEND_APIvoidzend_declare_property_double(zend_class_entry*ce, constchar*name, size_tname_length, doublevalue, intaccess_type);
ZEND_APIvoidzend_declare_property_string(zend_class_entry*ce, constchar*name, size_tname_length, constchar*value, intaccess_type);
ZEND_APIvoidzend_declare_property_stringl(zend_class_entry*ce, constchar*name, size_tname_length, constchar*value, size_tvalue_len, intaccess_type);

ZEND_APIzend_class_constant*zend_declare_typed_class_constant(zend_class_entry*ce, zend_string*name, zval*value, intaccess_type, zend_string*doc_comment, zend_typetype);
ZEND_APIzend_class_constant*zend_declare_class_constant_ex(zend_class_entry*ce, zend_string*name, zval*value, intaccess_type, zend_string*doc_comment);
ZEND_APIvoidzend_declare_class_constant(zend_class_entry*ce, constchar*name, size_tname_length, zval*value);
ZEND_APIvoidzend_declare_class_constant_null(zend_class_entry*ce, constchar*name, size_tname_length);
ZEND_APIvoidzend_declare_class_constant_long(zend_class_entry*ce, constchar*name, size_tname_length, zend_longvalue);
ZEND_APIvoidzend_declare_class_constant_bool(zend_class_entry*ce, constchar*name, size_tname_length, boolvalue);
ZEND_APIvoidzend_declare_class_constant_double(zend_class_entry*ce, constchar*name, size_tname_length, doublevalue);
ZEND_APIvoidzend_declare_class_constant_stringl(zend_class_entry*ce, constchar*name, size_tname_length, constchar*value, size_tvalue_length);
ZEND_APIvoidzend_declare_class_constant_string(zend_class_entry*ce, constchar*name, size_tname_length, constchar*value);

ZEND_APIzend_resultzend_update_class_constant(zend_class_constant*c, constzend_string*name, zend_class_entry*scope);
ZEND_APIzend_resultzend_update_class_constants(zend_class_entry*class_type);
ZEND_APIHashTable*zend_separate_class_constants_table(zend_class_entry*class_type);

staticzend_always_inlineHashTable*zend_class_constants_table(zend_class_entry*ce) {
if ((ce->ce_flags&ZEND_ACC_HAS_AST_CONSTANTS) &&ZEND_MAP_PTR(ce->mutable_data)) {
zend_class_mutable_data*mutable_data=
 (zend_class_mutable_data*)ZEND_MAP_PTR_GET_IMM(ce->mutable_data);
if (mutable_data&&mutable_data->constants_table) {
returnmutable_data->constants_table;
 } else {
returnzend_separate_class_constants_table(ce);
 }
 } else {
return&ce->constants_table;
 }
}

staticzend_always_inlinezval*zend_class_default_properties_table(zend_class_entry*ce) {
if ((ce->ce_flags&ZEND_ACC_HAS_AST_PROPERTIES) &&ZEND_MAP_PTR(ce->mutable_data)) {
zend_class_mutable_data*mutable_data=
 (zend_class_mutable_data*)ZEND_MAP_PTR_GET_IMM(ce->mutable_data);
returnmutable_data->default_properties_table;
 } else {
returnce->default_properties_table;
 }
}

staticzend_always_inlinevoidzend_class_set_backed_enum_table(zend_class_entry*ce, HashTable*backed_enum_table)
{
if (ZEND_MAP_PTR(ce->mutable_data) &&ce->type==ZEND_USER_CLASS) {
zend_class_mutable_data*mutable_data= (zend_class_mutable_data*)ZEND_MAP_PTR_GET_IMM(ce->mutable_data);
mutable_data->backed_enum_table=backed_enum_table;
 } else {
ce->backed_enum_table=backed_enum_table;
 }
}

staticzend_always_inlineHashTable*zend_class_backed_enum_table(zend_class_entry*ce)
{
if (ZEND_MAP_PTR(ce->mutable_data) &&ce->type==ZEND_USER_CLASS) {
zend_class_mutable_data*mutable_data= (zend_class_mutable_data*)ZEND_MAP_PTR_GET_IMM(ce->mutable_data);
returnmutable_data->backed_enum_table;
 } else {
returnce->backed_enum_table;
 }
}

ZEND_APIvoidzend_update_property_ex(zend_class_entry*scope, zend_object*object, zend_string*name, zval*value);
ZEND_APIvoidzend_update_property(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, zval*value);
ZEND_APIvoidzend_update_property_null(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length);
ZEND_APIvoidzend_update_property_bool(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, zend_longvalue);
ZEND_APIvoidzend_update_property_long(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, zend_longvalue);
ZEND_APIvoidzend_update_property_double(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, doublevalue);
ZEND_APIvoidzend_update_property_str(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, zend_string*value);
ZEND_APIvoidzend_update_property_string(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, constchar*value);
ZEND_APIvoidzend_update_property_stringl(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, constchar*value, size_tvalue_length);
ZEND_APIvoidzend_unset_property(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length);

ZEND_APIzend_resultzend_update_static_property_ex(zend_class_entry*scope, zend_string*name, zval*value);
ZEND_APIzend_resultzend_update_static_property(zend_class_entry*scope, constchar*name, size_tname_length, zval*value);
ZEND_APIzend_resultzend_update_static_property_null(zend_class_entry*scope, constchar*name, size_tname_length);
ZEND_APIzend_resultzend_update_static_property_bool(zend_class_entry*scope, constchar*name, size_tname_length, zend_longvalue);
ZEND_APIzend_resultzend_update_static_property_long(zend_class_entry*scope, constchar*name, size_tname_length, zend_longvalue);
ZEND_APIzend_resultzend_update_static_property_double(zend_class_entry*scope, constchar*name, size_tname_length, doublevalue);
ZEND_APIzend_resultzend_update_static_property_string(zend_class_entry*scope, constchar*name, size_tname_length, constchar*value);
ZEND_APIzend_resultzend_update_static_property_stringl(zend_class_entry*scope, constchar*name, size_tname_length, constchar*value, size_tvalue_length);

ZEND_APIzval*zend_read_property_ex(zend_class_entry*scope, zend_object*object, zend_string*name, boolsilent, zval*rv);
ZEND_APIzval*zend_read_property(zend_class_entry*scope, zend_object*object, constchar*name, size_tname_length, boolsilent, zval*rv);

ZEND_APIzval*zend_read_static_property_ex(zend_class_entry*scope, zend_string*name, boolsilent);
ZEND_APIzval*zend_read_static_property(zend_class_entry*scope, constchar*name, size_tname_length, boolsilent);

ZEND_APIconstchar*zend_get_type_by_const(inttype);

#defineZEND_THIS (&EX(This))

#definehasThis() (Z_TYPE_P(ZEND_THIS) == IS_OBJECT)
#definegetThis() (hasThis() ? ZEND_THIS : NULL)
#defineZEND_IS_METHOD_CALL() (EX(func)->common.scope != NULL)

#defineWRONG_PARAM_COUNT ZEND_WRONG_PARAM_COUNT()
#defineZEND_NUM_ARGS() EX_NUM_ARGS()
#defineZEND_WRONG_PARAM_COUNT() { zend_wrong_param_count(); return; }

#ifndefZEND_WIN32
#defineDLEXPORT
#endif

#definearray_init(arg) ZVAL_ARR((arg), zend_new_array(0))
#definearray_init_size(arg, size) ZVAL_ARR((arg), zend_new_array(size))
ZEND_APIvoidobject_init(zval*arg);
ZEND_APIzend_resultobject_init_ex(zval*arg, zend_class_entry*ce);
ZEND_APIzend_resultobject_init_with_constructor(zval*arg, zend_class_entry*class_type, uint32_tparam_count, zval*params, HashTable*named_params);
ZEND_APIzend_resultobject_and_properties_init(zval*arg, zend_class_entry*ce, HashTable*properties);
ZEND_APIvoidobject_properties_init(zend_object*object, zend_class_entry*class_type);
ZEND_APIvoidobject_properties_init_ex(zend_object*object, HashTable*properties);
ZEND_APIvoidobject_properties_load(zend_object*object, HashTable*properties);

ZEND_APIvoidzend_merge_properties(zval*obj, HashTable*properties);

ZEND_APIvoidadd_assoc_long_ex(zval*arg, constchar*key, size_tkey_len, zend_longn);
ZEND_APIvoidadd_assoc_null_ex(zval*arg, constchar*key, size_tkey_len);
ZEND_APIvoidadd_assoc_bool_ex(zval*arg, constchar*key, size_tkey_len, boolb);
ZEND_APIvoidadd_assoc_resource_ex(zval*arg, constchar*key, size_tkey_len, zend_resource*r);
ZEND_APIvoidadd_assoc_double_ex(zval*arg, constchar*key, size_tkey_len, doubled);
ZEND_APIvoidadd_assoc_str_ex(zval*arg, constchar*key, size_tkey_len, zend_string*str);
ZEND_APIvoidadd_assoc_string_ex(zval*arg, constchar*key, size_tkey_len, constchar*str);
ZEND_APIvoidadd_assoc_stringl_ex(zval*arg, constchar*key, size_tkey_len, constchar*str, size_tlength);
ZEND_APIvoidadd_assoc_array_ex(zval*arg, constchar*key, size_tkey_len, zend_array*arr);
ZEND_APIvoidadd_assoc_object_ex(zval*arg, constchar*key, size_tkey_len, zend_object*obj);
ZEND_APIvoidadd_assoc_reference_ex(zval*arg, constchar*key, size_tkey_len, zend_reference*ref);
ZEND_APIvoidadd_assoc_zval_ex(zval*arg, constchar*key, size_tkey_len, zval*value);

staticzend_always_inlinevoidadd_assoc_long(zval*arg, constchar*key, zend_longn) {
add_assoc_long_ex(arg, key, strlen(key), n);
}
staticzend_always_inlinevoidadd_assoc_null(zval*arg, constchar*key) {
add_assoc_null_ex(arg, key, strlen(key));
}
staticzend_always_inlinevoidadd_assoc_bool(zval*arg, constchar*key, boolb) {
add_assoc_bool_ex(arg, key, strlen(key), b);
}
staticzend_always_inlinevoidadd_assoc_resource(zval*arg, constchar*key, zend_resource*r) {
add_assoc_resource_ex(arg, key, strlen(key), r);
}
staticzend_always_inlinevoidadd_assoc_double(zval*arg, constchar*key, doubled) {
add_assoc_double_ex(arg, key, strlen(key), d);
}
staticzend_always_inlinevoidadd_assoc_str(zval*arg, constchar*key, zend_string*str) {
add_assoc_str_ex(arg, key, strlen(key), str);
}
staticzend_always_inlinevoidadd_assoc_string(zval*arg, constchar*key, constchar*str) {
add_assoc_string_ex(arg, key, strlen(key), str);
}
staticzend_always_inlinevoidadd_assoc_stringl(zval*arg, constchar*key, constchar*str, size_tlength) {
add_assoc_stringl_ex(arg, key, strlen(key), str, length);
}
staticzend_always_inlinevoidadd_assoc_array(zval*arg, constchar*key, zend_array*arr) {
add_assoc_array_ex(arg, key, strlen(key), arr);
}
staticzend_always_inlinevoidadd_assoc_object(zval*arg, constchar*key, zend_object*obj) {
add_assoc_object_ex(arg, key, strlen(key), obj);
}
staticzend_always_inlinevoidadd_assoc_reference(zval*arg, constchar*key, zend_reference*ref) {
add_assoc_reference_ex(arg, key, strlen(key), ref);
}
staticzend_always_inlinevoidadd_assoc_zval(zval*arg, constchar*key, zval*value) {
add_assoc_zval_ex(arg, key, strlen(key), value);
}

ZEND_APIvoidadd_index_long(zval*arg, zend_ulongindex, zend_longn);
ZEND_APIvoidadd_index_null(zval*arg, zend_ulongindex);
ZEND_APIvoidadd_index_bool(zval*arg, zend_ulongindex, boolb);
ZEND_APIvoidadd_index_resource(zval*arg, zend_ulongindex, zend_resource*r);
ZEND_APIvoidadd_index_double(zval*arg, zend_ulongindex, doubled);
ZEND_APIvoidadd_index_str(zval*arg, zend_ulongindex, zend_string*str);
ZEND_APIvoidadd_index_string(zval*arg, zend_ulongindex, constchar*str);
ZEND_APIvoidadd_index_stringl(zval*arg, zend_ulongindex, constchar*str, size_tlength);
ZEND_APIvoidadd_index_array(zval*arg, zend_ulongindex, zend_array*arr);
ZEND_APIvoidadd_index_object(zval*arg, zend_ulongindex, zend_object*obj);
ZEND_APIvoidadd_index_reference(zval*arg, zend_ulongindex, zend_reference*ref);

staticzend_always_inlinezend_resultadd_index_zval(zval*arg, zend_ulongindex, zval*value)
{
returnzend_hash_index_update(Z_ARRVAL_P(arg), index, value) ? SUCCESS : FAILURE;
}

ZEND_APIzend_resultadd_next_index_long(zval*arg, zend_longn);
ZEND_APIzend_resultadd_next_index_null(zval*arg);
ZEND_APIzend_resultadd_next_index_bool(zval*arg, boolb);
ZEND_APIzend_resultadd_next_index_resource(zval*arg, zend_resource*r);
ZEND_APIzend_resultadd_next_index_double(zval*arg, doubled);
ZEND_APIzend_resultadd_next_index_str(zval*arg, zend_string*str);
ZEND_APIzend_resultadd_next_index_string(zval*arg, constchar*str);
ZEND_APIzend_resultadd_next_index_stringl(zval*arg, constchar*str, size_tlength);
ZEND_APIzend_resultadd_next_index_array(zval*arg, zend_array*arr);
ZEND_APIzend_resultadd_next_index_object(zval*arg, zend_object*obj);
ZEND_APIzend_resultadd_next_index_reference(zval*arg, zend_reference*ref);

staticzend_always_inlinezend_resultadd_next_index_zval(zval*arg, zval*value)
{
returnzend_hash_next_index_insert(Z_ARRVAL_P(arg), value) ? SUCCESS : FAILURE;
}

ZEND_APIzend_resultarray_set_zval_key(HashTable*ht, zval*key, zval*value);

ZEND_APIvoidadd_property_long_ex(zval*arg, constchar*key, size_tkey_len, zend_longl);
ZEND_APIvoidadd_property_null_ex(zval*arg, constchar*key, size_tkey_len);
ZEND_APIvoidadd_property_bool_ex(zval*arg, constchar*key, size_tkey_len, zend_longb);
ZEND_APIvoidadd_property_resource_ex(zval*arg, constchar*key, size_tkey_len, zend_resource*r);
ZEND_APIvoidadd_property_double_ex(zval*arg, constchar*key, size_tkey_len, doubled);
ZEND_APIvoidadd_property_str_ex(zval*arg, constchar*key, size_tkey_len, zend_string*str);
ZEND_APIvoidadd_property_string_ex(zval*arg, constchar*key, size_tkey_len, constchar*str);
ZEND_APIvoidadd_property_stringl_ex(zval*arg, constchar*key, size_tkey_len, constchar*str, size_tlength);
ZEND_APIvoidadd_property_array_ex(zval*arg, constchar*key, size_tkey_len, zend_array*arr);
ZEND_APIvoidadd_property_object_ex(zval*arg, constchar*key, size_tkey_len, zend_object*obj);
ZEND_APIvoidadd_property_reference_ex(zval*arg, constchar*key, size_tkey_len, zend_reference*ref);
ZEND_APIvoidadd_property_zval_ex(zval*arg, constchar*key, size_tkey_len, zval*value);

staticzend_always_inlinevoidadd_property_long(zval*arg, constchar*key, zend_longn) {
add_property_long_ex(arg, key, strlen(key), n);
}
staticzend_always_inlinevoidadd_property_null(zval*arg, constchar*key) {
add_property_null_ex(arg, key, strlen(key));
}
staticzend_always_inlinevoidadd_property_bool(zval*arg, constchar*key, boolb) {
add_property_bool_ex(arg, key, strlen(key), b);
}
staticzend_always_inlinevoidadd_property_resource(zval*arg, constchar*key, zend_resource*r) {
add_property_resource_ex(arg, key, strlen(key), r);
}
staticzend_always_inlinevoidadd_property_double(zval*arg, constchar*key, doubled) {
add_property_double_ex(arg, key, strlen(key), d);
}
staticzend_always_inlinevoidadd_property_str(zval*arg, constchar*key, zend_string*str) {
add_property_str_ex(arg, key, strlen(key), str);
}
staticzend_always_inlinevoidadd_property_string(zval*arg, constchar*key, constchar*str) {
add_property_string_ex(arg, key, strlen(key), str);
}
staticzend_always_inlinevoidadd_property_stringl(zval*arg, constchar*key, constchar*str, size_tlength) {
add_property_stringl_ex(arg, key, strlen(key), str, length);
}
staticzend_always_inlinevoidadd_property_array(zval*arg, constchar*key, zend_array*arr) {
add_property_array_ex(arg, key, strlen(key), arr);
}
staticzend_always_inlinevoidadd_property_object(zval*arg, constchar*key, zend_object*obj) {
add_property_object_ex(arg, key, strlen(key), obj);
}
staticzend_always_inlinevoidadd_property_reference(zval*arg, constchar*key, zend_reference*ref) {
add_property_reference_ex(arg, key, strlen(key), ref);
}
staticzend_always_inlinevoidadd_property_zval(zval*arg, constchar*key, zval*value) {
add_property_zval_ex(arg, key, strlen(key), value);
}

ZEND_APIzend_result_call_user_function_impl(zval*object, zval*function_name, zval*retval_ptr, uint32_tparam_count, zvalparams[], HashTable*named_params);

#definecall_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)

#definecall_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)

#ifndef__cplusplus
# defineempty_fcall_info (zend_fcall_info) {0}
# defineempty_fcall_info_cache (zend_fcall_info_cache) {0}
#else
# defineempty_fcall_info zend_fcall_info {0}
# defineempty_fcall_info_cache zend_fcall_info_cache {0}
#endif

/** Build zend_call_info/cache from a zval*
 *
 * Caller is responsible to provide a return value (fci->retval), otherwise the we will crash.
 * In order to pass parameters the following members need to be set:
 * fci->param_count = 0;
 * fci->params = NULL;
 * The callable_name argument may be NULL.
 */
ZEND_APIzend_resultzend_fcall_info_init(zval*callable, uint32_tcheck_flags, zend_fcall_info*fci, zend_fcall_info_cache*fcc, zend_string**callable_name, char**error);

/** Clear arguments connected with zend_fcall_info *fci
 * If free_mem is not zero then the params array gets free'd as well
 */
ZEND_APIvoidzend_fcall_info_args_clear(zend_fcall_info*fci, boolfree_mem);

/** Save current arguments from zend_fcall_info *fci
 * params array will be set to NULL
 */
ZEND_APIvoidzend_fcall_info_args_save(zend_fcall_info*fci, uint32_t*param_count, zval**params);

/** Free arguments connected with zend_fcall_info *fci and set back saved ones.
 */
ZEND_APIvoidzend_fcall_info_args_restore(zend_fcall_info*fci, uint32_tparam_count, zval*params);

/** 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.
 */
ZEND_APIzend_resultzend_fcall_info_args(zend_fcall_info*fci, zval*args);
ZEND_APIzend_resultzend_fcall_info_args_ex(zend_fcall_info*fci, zend_function*func, zval*args);

/** 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.
 */
ZEND_APIvoidzend_fcall_info_argp(zend_fcall_info*fci, uint32_targc, zval*argv);

/** 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.
 */
ZEND_APIvoidzend_fcall_info_argv(zend_fcall_info*fci, uint32_targc, va_list*argv);

/** 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.
 */
ZEND_APIvoidzend_fcall_info_argn(zend_fcall_info*fci, uint32_targc, ...);

/** Call a function using information created by zend_fcall_info_init()/args().
 * If args is given then those replace the argument info in fci is temporarily.
 */
ZEND_APIzend_resultzend_fcall_info_call(zend_fcall_info*fci, zend_fcall_info_cache*fcc, zval*retval, zval*args);

/* Zend FCC API to store and handle PHP userland functions */
staticzend_always_inlineboolzend_fcc_equals(constzend_fcall_info_cache*a, constzend_fcall_info_cache*b)
{
if (UNEXPECTED((a->function_handler->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE) &&
 (b->function_handler->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE))) {
returna->object==b->object
&&a->calling_scope==b->calling_scope
&&a->closure==b->closure
&&zend_string_equals(a->function_handler->common.function_name, b->function_handler->common.function_name)
 ;
 }
returna->function_handler==b->function_handler
&&a->object==b->object
&&a->calling_scope==b->calling_scope
&&a->closure==b->closure
 ;
}

staticzend_always_inlinevoidzend_fcc_addref(zend_fcall_info_cache*fcc)
{
ZEND_ASSERT(ZEND_FCC_INITIALIZED(*fcc) &&"FCC Not initialized, possibly refetch trampoline freed by ZPP?");
/* If the cached trampoline is set, free it */
if (UNEXPECTED(fcc->function_handler==&EG(trampoline))) {
zend_function*copy= (zend_function*)emalloc(sizeof(zend_function));

memcpy(copy, fcc->function_handler, sizeof(zend_function));
fcc->function_handler->common.function_name=NULL;
fcc->function_handler=copy;
 }
if (fcc->object) {
GC_ADDREF(fcc->object);
 }
if (fcc->closure) {
GC_ADDREF(fcc->closure);
 }
}

staticzend_always_inlinevoidzend_fcc_dup(/* restrict */zend_fcall_info_cache*dest, constzend_fcall_info_cache*src)
{
memcpy(dest, src, sizeof(zend_fcall_info_cache));
zend_fcc_addref(dest);
}

staticzend_always_inlinevoidzend_fcc_dtor(zend_fcall_info_cache*fcc)
{
ZEND_ASSERT(fcc->function_handler);
if (fcc->object) {
OBJ_RELEASE(fcc->object);
 }
/* Need to free potential trampoline (__call/__callStatic) copied function handler before releasing the closure */
zend_release_fcall_info_cache(fcc);
if (fcc->closure) {
OBJ_RELEASE(fcc->closure);
 }
*fcc=empty_fcall_info_cache;
}

ZEND_APIvoidzend_get_callable_zval_from_fcc(constzend_fcall_info_cache*fcc, zval*callable);

/* Moved out of zend_gc.h because zend_fcall_info_cache is an unknown type in that header */
staticzend_always_inlinevoidzend_get_gc_buffer_add_fcc(zend_get_gc_buffer*gc_buffer, zend_fcall_info_cache*fcc)
{
ZEND_ASSERT(ZEND_FCC_INITIALIZED(*fcc));
if (fcc->object) {
zend_get_gc_buffer_add_obj(gc_buffer, fcc->object);
 }
if (fcc->closure) {
zend_get_gc_buffer_add_obj(gc_buffer, fcc->closure);
 }
}

/* Can only return FAILURE if EG(active) is false during late engine shutdown.
 * If the call or call setup throws, EG(exception) will be set and the retval
 * will be UNDEF. Otherwise, the retval will be a non-UNDEF value. */
ZEND_APIzend_resultzend_call_function(zend_fcall_info*fci, zend_fcall_info_cache*fci_cache);

/* Call the FCI/FCC pair while setting the call return value to the passed zval*. */
staticzend_always_inlinezend_resultzend_call_function_with_return_value(
zend_fcall_info*fci, zend_fcall_info_cache*fci_cache, zval*retval)
{
ZEND_ASSERT(retval&&"Use zend_call_function() directly if not providing a retval");
fci->retval=retval;
returnzend_call_function(fci, fci_cache);
}

/* 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_APIvoidzend_call_known_function(
zend_function*fn, zend_object*object, zend_class_entry*called_scope, zval*retval_ptr,
uint32_tparam_count, zval*params, HashTable*named_params);

staticzend_always_inlinevoidzend_call_known_fcc(
constzend_fcall_info_cache*fcc, zval*retval_ptr, uint32_tparam_count, zval*params, HashTable*named_params)
{
zend_function*func=fcc->function_handler;
/* Need to copy trampolines as they get released after they are called */
if (UNEXPECTED(func->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
func= (zend_function*) emalloc(sizeof(zend_function));
memcpy(func, fcc->function_handler, sizeof(zend_function));
zend_string_addref(func->op_array.function_name);
 }
zend_call_known_function(func, fcc->object, fcc->called_scope, retval_ptr, param_count, params, named_params);
}

/* Call the provided zend_function instance method on an object. */
staticzend_always_inlinevoidzend_call_known_instance_method(
zend_function*fn, zend_object*object, zval*retval_ptr,
uint32_tparam_count, zval*params)
{
zend_call_known_function(fn, object, object->ce, retval_ptr, param_count, params, NULL);
}

staticzend_always_inlinevoidzend_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);
}

staticzend_always_inlinevoidzend_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_APIvoidzend_call_known_instance_method_with_2_params(
zend_function*fn, zend_object*object, zval*retval_ptr, zval*param1, zval*param2);

/* Call method if it exists. Return FAILURE if method does not exist or call failed.
 * If FAILURE is returned, retval will be UNDEF. As such, destroying retval unconditionally
 * is legal. */
ZEND_APIzend_resultzend_call_method_if_exists(
zend_object*object, zend_string*method_name, zval*retval,
uint32_tparam_count, zval*params);

ZEND_APIzend_resultzend_set_hash_symbol(zval*symbol, constchar*name, size_tname_length, boolis_ref, intnum_symbol_tables, ...);

ZEND_APIzend_resultzend_delete_global_variable(zend_string*name);

ZEND_APIzend_array*zend_rebuild_symbol_table(void);
ZEND_APIvoidzend_attach_symbol_table(zend_execute_data*execute_data);
ZEND_APIvoidzend_detach_symbol_table(zend_execute_data*execute_data);
ZEND_APIzend_resultzend_set_local_var(zend_string*name, zval*value, boolforce);
ZEND_APIzend_resultzend_set_local_var_str(constchar*name, size_tlen, zval*value, boolforce);

staticzend_always_inlinezend_resultzend_forbid_dynamic_call(void)
{
zend_execute_data*ex=EG(current_execute_data);
ZEND_ASSERT(ex!=NULL&&ex->func!=NULL);

if (ZEND_CALL_INFO(ex) &ZEND_CALL_DYNAMIC) {
zend_string*function_or_method_name=get_active_function_or_method_name();
zend_throw_error(NULL, "Cannot call %.*s() dynamically",
 (int) ZSTR_LEN(function_or_method_name), ZSTR_VAL(function_or_method_name));
zend_string_release(function_or_method_name);
returnFAILURE;
 }

returnSUCCESS;
}

ZEND_APIZEND_COLDconstchar*zend_get_object_type_case(constzend_class_entry*ce, boolupper_case);

staticzend_always_inlineconstchar*zend_get_object_type(constzend_class_entry*ce)
{
returnzend_get_object_type_case(ce, false);
}

staticzend_always_inlineconstchar*zend_get_object_type_uc(constzend_class_entry*ce)
{
returnzend_get_object_type_case(ce, true);
}

ZEND_APIboolzend_is_iterable(constzval*iterable);

ZEND_APIboolzend_is_countable(constzval*countable);

ZEND_APIzend_resultzend_get_default_from_internal_arg_info(
zval*default_value_zval, zend_internal_arg_info*arg_info);

END_EXTERN_C()

#ifZEND_DEBUG
#defineCHECK_ZVAL_STRING(str) \
 ZEND_ASSERT(ZSTR_VAL(str)[ZSTR_LEN(str)] == '\0' && "String is not null-terminated");
#else
#defineCHECK_ZVAL_STRING(z)
#endif

staticzend_always_inlineboolzend_str_has_nul_byte(constzend_string*str)
{
returnZSTR_LEN(str) !=strlen(ZSTR_VAL(str));
}
staticzend_always_inlineboolzend_char_has_nul_byte(constchar*s, size_tknown_length)
{
returnknown_length!=strlen(s);
}

/* Compatibility with PHP 8.1 and below */
#defineCHECK_ZVAL_NULL_PATH(p) zend_str_has_nul_byte(Z_STR_P(p))
#defineCHECK_NULL_PATH(p, l) zend_char_has_nul_byte(p, l)

#defineZVAL_STRINGL(z, s, l) do { \
 ZVAL_NEW_STR(z, zend_string_init(s, l, 0)); \
 } while (0)

#defineZVAL_STRING(z, s) do { \
 const char *_s = (s); \
 ZVAL_STRINGL(z, _s, strlen(_s)); \
 } while (0)

#defineZVAL_EMPTY_STRING(z) do { \
 ZVAL_INTERNED_STR(z, ZSTR_EMPTY_ALLOC()); \
 } while (0)

#defineZVAL_PSTRINGL(z, s, l) do { \
 ZVAL_NEW_STR(z, zend_string_init(s, l, 1)); \
 } while (0)

#defineZVAL_PSTRING(z, s) do { \
 const char *_s = (s); \
 ZVAL_PSTRINGL(z, _s, strlen(_s)); \
 } while (0)

#defineZVAL_EMPTY_PSTRING(z) do { \
 ZVAL_PSTRINGL(z, "", 0); \
 } while (0)

#defineZVAL_CHAR(z, c) do { \
 char _c = (c); \
 ZVAL_INTERNED_STR(z, ZSTR_CHAR((zend_uchar) _c)); \
 } while (0)

#defineZVAL_STRINGL_FAST(z, s, l) do { \
 ZVAL_STR(z, zend_string_init_fast(s, l)); \
 } while (0)

#defineZVAL_STRING_FAST(z, s) do { \
 const char *_s = (s); \
 ZVAL_STRINGL_FAST(z, _s, strlen(_s)); \
 } while (0)

#defineZVAL_ZVAL(z, zv, copy, dtor) do { \
 zval *__z = (z); \
 zval *__zv = (zv); \
 if (EXPECTED(!Z_ISREF_P(__zv))) { \