1 /*
2    +----------------------------------------------------------------------+
3    | Zend Engine                                                          |
4    +----------------------------------------------------------------------+
5    | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 2.00 of the Zend license,     |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.zend.com/license/2_00.txt.                                |
11    | If you did not receive a copy of the Zend license and are unable to  |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@zend.com so we can mail you a copy immediately.              |
14    +----------------------------------------------------------------------+
15    | Authors: Andi Gutmans <andi@php.net>                                 |
16    |          Zeev Suraski <zeev@php.net>                                 |
17    |          Andrei Zmievski <andrei@php.net>                            |
18    |          Dmitry Stogov <dmitry@php.net>                              |
19    +----------------------------------------------------------------------+
20 */
21 
22 #ifndef ZEND_API_H
23 #define ZEND_API_H
24 
25 #include "zend_modules.h"
26 #include "zend_list.h"
27 #include "zend_operators.h"
28 #include "zend_variables.h"
29 #include "zend_execute.h"
30 
31 
32 BEGIN_EXTERN_C()
33 
34 typedef struct _zend_function_entry {
35 	const char *fname;
36 	zif_handler handler;
37 	const struct _zend_internal_arg_info *arg_info;
38 	uint32_t num_args;
39 	uint32_t flags;
40 } zend_function_entry;
41 
42 typedef struct _zend_fcall_info {
43 	size_t size;
44 	zval function_name;
45 	zval *retval;
46 	zval *params;
47 	zend_object *object;
48 	zend_bool no_separation;
49 	uint32_t param_count;
50 } zend_fcall_info;
51 
52 typedef struct _zend_fcall_info_cache {
53 	zend_function *function_handler;
54 	zend_class_entry *calling_scope;
55 	zend_class_entry *called_scope;
56 	zend_object *object;
57 } zend_fcall_info_cache;
58 
59 #define ZEND_NS_NAME(ns, name)			ns "\\" name
60 
61 #define ZEND_FN(name) zif_##name
62 #define ZEND_MN(name) zim_##name
63 #define ZEND_NAMED_FUNCTION(name)		void ZEND_FASTCALL name(INTERNAL_FUNCTION_PARAMETERS)
64 #define ZEND_FUNCTION(name)				ZEND_NAMED_FUNCTION(ZEND_FN(name))
65 #define ZEND_METHOD(classname, name)	ZEND_NAMED_FUNCTION(ZEND_MN(classname##_##name))
66 
67 #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 },
68 
69 #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 },
70 #define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0)
71 
72 #define ZEND_NAMED_FE(zend_name, name, arg_info)	ZEND_FENTRY(zend_name, name, arg_info, 0)
73 #define ZEND_FE(name, arg_info)						ZEND_FENTRY(name, ZEND_FN(name), arg_info, 0)
74 #define ZEND_DEP_FE(name, arg_info)                 ZEND_FENTRY(name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
75 #define ZEND_FALIAS(name, alias, arg_info)			ZEND_FENTRY(name, ZEND_FN(alias), arg_info, 0)
76 #define ZEND_DEP_FALIAS(name, alias, arg_info)		ZEND_FENTRY(name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
77 #define ZEND_NAMED_ME(zend_name, name, arg_info, flags)	ZEND_FENTRY(zend_name, name, arg_info, flags)
78 #define ZEND_ME(classname, name, arg_info, flags)	ZEND_FENTRY(name, ZEND_MN(classname##_##name), arg_info, flags)
79 #define ZEND_DEP_ME(classname, name, arg_info, flags) ZEND_ME(classname, name, arg_info, flags | ZEND_ACC_DEPRECATED)
80 #define ZEND_ABSTRACT_ME(classname, name, arg_info)	ZEND_FENTRY(name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
81 #define ZEND_MALIAS(classname, name, alias, arg_info, flags) \
82                                                     ZEND_FENTRY(name, ZEND_MN(classname##_##alias), arg_info, flags)
83 #define ZEND_ME_MAPPING(name, func_name, arg_types, flags) ZEND_NAMED_ME(name, ZEND_FN(func_name), arg_types, flags)
84 
85 #define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags)		ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags)
86 
87 #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)
88 #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)			ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
89 
90 #define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info)	ZEND_NS_FENTRY(ns, zend_name, name, arg_info, 0)
91 #define ZEND_NS_FE(ns, name, arg_info)					ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, 0)
92 #define ZEND_NS_DEP_FE(ns, name, arg_info)				ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
93 #define ZEND_NS_FALIAS(ns, name, alias, arg_info)		ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, 0)
94 #define ZEND_NS_DEP_FALIAS(ns, name, alias, arg_info)	ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
95 
96 #define ZEND_FE_END            { NULL, NULL, NULL, 0, 0 }
97 
98 #define ZEND_ARG_INFO(pass_by_ref, name)                             { #name, 0, pass_by_ref, 0},
99 #define ZEND_ARG_PASS_INFO(pass_by_ref)                              { NULL,  0, pass_by_ref, 0},
100 #define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null)  { #name, ZEND_TYPE_ENCODE_CLASS_CONST(#classname, allow_null), pass_by_ref, 0 },
101 #define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null)           { #name, ZEND_TYPE_ENCODE(IS_ARRAY, allow_null), pass_by_ref, 0 },
102 #define ZEND_ARG_CALLABLE_INFO(pass_by_ref, name, allow_null)        { #name, ZEND_TYPE_ENCODE(IS_CALLABLE, allow_null), pass_by_ref, 0 },
103 #define ZEND_ARG_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) { #name, ZEND_TYPE_ENCODE(type_hint, allow_null), pass_by_ref, 0 },
104 #define ZEND_ARG_VARIADIC_INFO(pass_by_ref, name)                             { #name, 0, pass_by_ref, 1 },
105 #define ZEND_ARG_VARIADIC_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) { #name, ZEND_TYPE_ENCODE(type_hint, allow_null), pass_by_ref, 1 },
106 #define ZEND_ARG_VARIADIC_OBJ_INFO(pass_by_ref, name, classname, allow_null)  { #name, ZEND_TYPE_ENCODE_CLASS_CONST(#classname, allow_null), pass_by_ref, 1 },
107 
108 #define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, class_name, allow_null) \
109 	static const zend_internal_arg_info name[] = { \
110 		{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_ENCODE_CLASS_CONST(#class_name, allow_null), return_reference, 0 },
111 
112 #define ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO(name, class_name, allow_null) \
113 	ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, 0, -1, class_name, allow_null)
114 
115 #define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
116 	static const zend_internal_arg_info name[] = { \
117 		{ (const char*)(zend_uintptr_t)(required_num_args), ZEND_TYPE_ENCODE(type, allow_null), return_reference, 0 },
118 #define ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO(name, type, allow_null) \
119 	ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, 0, -1, type, allow_null)
120 
121 #define ZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args)	\
122 	static const zend_internal_arg_info name[] = { \
123 		{ (const char*)(zend_uintptr_t)(required_num_args), 0, return_reference, 0 },
124 #define ZEND_BEGIN_ARG_INFO(name, _unused)	\
125 	ZEND_BEGIN_ARG_INFO_EX(name, 0, ZEND_RETURN_VALUE, -1)
126 #define ZEND_END_ARG_INFO()		};
127 
128 /* Name macros */
129 #define ZEND_MODULE_STARTUP_N(module)       zm_startup_##module
130 #define ZEND_MODULE_SHUTDOWN_N(module)		zm_shutdown_##module
131 #define ZEND_MODULE_ACTIVATE_N(module)		zm_activate_##module
132 #define ZEND_MODULE_DEACTIVATE_N(module)	zm_deactivate_##module
133 #define ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)	zm_post_zend_deactivate_##module
134 #define ZEND_MODULE_INFO_N(module)			zm_info_##module
135 #define ZEND_MODULE_GLOBALS_CTOR_N(module)  zm_globals_ctor_##module
136 #define ZEND_MODULE_GLOBALS_DTOR_N(module)  zm_globals_dtor_##module
137 
138 /* Declaration macros */
139 #define ZEND_MODULE_STARTUP_D(module)		int ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
140 #define ZEND_MODULE_SHUTDOWN_D(module)		int ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
141 #define ZEND_MODULE_ACTIVATE_D(module)		int ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
142 #define ZEND_MODULE_DEACTIVATE_D(module)	int ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
143 #define ZEND_MODULE_POST_ZEND_DEACTIVATE_D(module)	int ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
144 #define ZEND_MODULE_INFO_D(module)			ZEND_COLD void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
145 #define ZEND_MODULE_GLOBALS_CTOR_D(module)  void ZEND_MODULE_GLOBALS_CTOR_N(module)(zend_##module##_globals *module##_globals)
146 #define ZEND_MODULE_GLOBALS_DTOR_D(module)  void ZEND_MODULE_GLOBALS_DTOR_N(module)(zend_##module##_globals *module##_globals)
147 
148 #define ZEND_GET_MODULE(name) \
149     BEGIN_EXTERN_C()\
150 	ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
151     END_EXTERN_C()
152 
153 #define ZEND_BEGIN_MODULE_GLOBALS(module_name)		\
154 	typedef struct _zend_##module_name##_globals {
155 #define ZEND_END_MODULE_GLOBALS(module_name)		\
156 	} zend_##module_name##_globals;
157 
158 #ifdef ZTS
159 
160 #define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
161 	ts_rsrc_id module_name##_globals_id;
162 #define ZEND_EXTERN_MODULE_GLOBALS(module_name)								\
163 	extern ts_rsrc_id module_name##_globals_id;
164 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
165 	ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
166 #define ZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) ZEND_TSRMG(module_name##_globals_id, zend_##module_name##_globals *, v)
167 #if ZEND_ENABLE_STATIC_TSRMLS_CACHE
168 #define ZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK_STATIC(module_name##_globals_id, zend_##module_name##_globals *)
169 #else
170 #define ZEND_MODULE_GLOBALS_BULK(module_name) TSRMG_BULK(module_name##_globals_id, zend_##module_name##_globals *)
171 #endif
172 
173 #else
174 
175 #define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
176 	zend_##module_name##_globals module_name##_globals;
177 #define ZEND_EXTERN_MODULE_GLOBALS(module_name)								\
178 	extern zend_##module_name##_globals module_name##_globals;
179 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
180 	globals_ctor(&module_name##_globals);
181 #define ZEND_MODULE_GLOBALS_ACCESSOR(module_name, v) (module_name##_globals.v)
182 #define ZEND_MODULE_GLOBALS_BULK(module_name) (&module_name##_globals)
183 
184 #endif
185 
186 #define INIT_CLASS_ENTRY(class_container, class_name, functions) \
187 	INIT_CLASS_ENTRY_EX(class_container, class_name, sizeof(class_name)-1, functions)
188 
189 #define INIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \
190 	{															\
191 		memset(&class_container, 0, sizeof(zend_class_entry)); \
192 		class_container.name = zend_string_init_interned(class_name, class_name_len, 1); \
193 		class_container.info.internal.builtin_functions = functions;	\
194 	}
195 
196 #define INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions) \
197 	{															\
198 		class_container.constructor = NULL;						\
199 		class_container.destructor = NULL;						\
200 		class_container.clone = NULL;							\
201 		class_container.serialize = NULL;						\
202 		class_container.unserialize = NULL;						\
203 		class_container.create_object = NULL;					\
204 		class_container.get_static_method = NULL;				\
205 		class_container.__call = NULL;							\
206 		class_container.__callstatic = NULL;					\
207 		class_container.__tostring = NULL;						\
208 		class_container.__get = NULL;							\
209 		class_container.__set = NULL;							\
210 		class_container.__unset = NULL;							\
211 		class_container.__isset = NULL;							\
212 		class_container.__debugInfo = NULL;						\
213 		class_container.serialize_func = NULL;					\
214 		class_container.unserialize_func = NULL;				\
215 		class_container.parent = NULL;							\
216 		class_container.num_interfaces = 0;						\
217 		class_container.trait_names = NULL;						\
218 		class_container.num_traits = 0;							\
219 		class_container.trait_aliases = NULL;					\
220 		class_container.trait_precedences = NULL;				\
221 		class_container.interfaces = NULL;						\
222 		class_container.get_iterator = NULL;					\
223 		class_container.iterator_funcs_ptr = NULL;				\
224 		class_container.info.internal.module = NULL;			\
225 		class_container.info.internal.builtin_functions = functions;	\
226 	}
227 
228 
229 #define INIT_NS_CLASS_ENTRY(class_container, ns, class_name, functions) \
230 	INIT_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions)
231 
232 #define CE_STATIC_MEMBERS(ce) \
233 	((zval*)ZEND_MAP_PTR_GET((ce)->static_members_table))
234 
235 #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
236 
237 ZEND_API int zend_next_free_module(void);
238 
239 BEGIN_EXTERN_C()
240 ZEND_API int _zend_get_parameters_array_ex(int param_count, zval *argument_array);
241 
242 /* internal function to efficiently copy parameters when executing __call() */
243 ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array);
244 
245 #define zend_get_parameters_array(ht, param_count, argument_array) \
246 	_zend_get_parameters_array_ex(param_count, argument_array)
247 #define zend_get_parameters_array_ex(param_count, argument_array) \
248 	_zend_get_parameters_array_ex(param_count, argument_array)
249 #define zend_parse_parameters_none() \
250 	(EXPECTED(ZEND_NUM_ARGS() == 0) ? SUCCESS : (zend_wrong_parameters_none_error(), FAILURE))
251 #define zend_parse_parameters_none_throw() \
252 	(EXPECTED(ZEND_NUM_ARGS() == 0) ? SUCCESS : (zend_wrong_parameters_none_exception(), FAILURE))
253 
254 /* Parameter parsing API -- andrei */
255 
256 #define ZEND_PARSE_PARAMS_QUIET (1<<1)
257 #define ZEND_PARSE_PARAMS_THROW (1<<2)
258 ZEND_API int zend_parse_parameters(int num_args, const char *type_spec, ...);
259 ZEND_API int zend_parse_parameters_ex(int flags, int num_args, const char *type_spec, ...);
260 ZEND_API int zend_parse_parameters_throw(int num_args, const char *type_spec, ...);
261 ZEND_API char *zend_zval_type_name(const zval *arg);
262 ZEND_API zend_string *zend_zval_get_type(const zval *arg);
263 
264 ZEND_API int zend_parse_method_parameters(int num_args, zval *this_ptr, const char *type_spec, ...);
265 ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args, zval *this_ptr, const char *type_spec, ...);
266 
267 ZEND_API int zend_parse_parameter(int flags, int arg_num, zval *arg, const char *spec, ...);
268 
269 /* End of parameter parsing API -- andrei */
270 
271 ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type);
272 ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table);
273 ZEND_API int zend_startup_module(zend_module_entry *module_entry);
274 ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry);
275 ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module);
276 ZEND_API int zend_startup_module_ex(zend_module_entry *module);
277 ZEND_API int zend_startup_modules(void);
278 ZEND_API void zend_collect_module_handlers(void);
279 ZEND_API void zend_destroy_modules(void);
280 ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type);
281 
282 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry);
283 ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce);
284 ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry);
285 ZEND_API void zend_class_implements(zend_class_entry *class_entry, int num_interfaces, ...);
286 
287 ZEND_API int zend_register_class_alias_ex(const char *name, size_t name_len, zend_class_entry *ce, int persistent);
288 
289 #define zend_register_class_alias(name, ce) \
290 	zend_register_class_alias_ex(name, sizeof(name)-1, ce, 1)
291 #define zend_register_ns_class_alias(ns, name, ce) \
292 	zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce, 1)
293 
294 ZEND_API int zend_disable_function(char *function_name, size_t function_name_length);
295 ZEND_API int zend_disable_class(char *class_name, size_t class_name_length);
296 
297 ZEND_API ZEND_COLD void zend_wrong_param_count(void);
298 
299 #define IS_CALLABLE_CHECK_SYNTAX_ONLY (1<<0)
300 #define IS_CALLABLE_CHECK_NO_ACCESS   (1<<1)
301 #define IS_CALLABLE_CHECK_IS_STATIC   (1<<2)
302 #define IS_CALLABLE_CHECK_SILENT      (1<<3)
303 
304 #define IS_CALLABLE_STRICT  (IS_CALLABLE_CHECK_IS_STATIC)
305 
306 ZEND_API void zend_release_fcall_info_cache(zend_fcall_info_cache *fcc);
307 ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *object);
308 ZEND_API zend_string *zend_get_callable_name(zval *callable);
309 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);
310 ZEND_API zend_bool zend_is_callable(zval *callable, uint32_t check_flags, zend_string **callable_name);
311 ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name);
312 ZEND_API const char *zend_get_module_version(const char *module_name);
313 ZEND_API int zend_get_module_started(const char *module_name);
314 
315 ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type);
316 
317 ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment);
318 ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type);
319 ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type);
320 ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type);
321 ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type);
322 ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, int access_type);
323 ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, int access_type);
324 ZEND_API int 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);
325 
326 ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment);
327 ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value);
328 ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length);
329 ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value);
330 ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value);
331 ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value);
332 ZEND_API int zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length);
333 ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value);
334 
335 ZEND_API int zend_update_class_constants(zend_class_entry *class_type);
336 
337 ZEND_API void zend_update_property_ex(zend_class_entry *scope, zval *object, zend_string *name, zval *value);
338 ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zval *value);
339 ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, size_t name_length);
340 ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_long value);
341 ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_long value);
342 ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, size_t name_length, double value);
343 ZEND_API void zend_update_property_str(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_string *value);
344 ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, size_t name_length, const char *value);
345 ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, size_t name_length, const char *value, size_t value_length);
346 ZEND_API void zend_unset_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length);
347 
348 ZEND_API int zend_update_static_property_ex(zend_class_entry *scope, zend_string *name, zval *value);
349 ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, size_t name_length, zval *value);
350 ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, size_t name_length);
351 ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, size_t name_length, zend_long value);
352 ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, size_t name_length, zend_long value);
353 ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, size_t name_length, double value);
354 ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, size_t name_length, const char *value);
355 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);
356 
357 ZEND_API zval *zend_read_property_ex(zend_class_entry *scope, zval *object, zend_string *name, zend_bool silent, zval *rv);
358 ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, size_t name_length, zend_bool silent, zval *rv);
359 
360 ZEND_API zval *zend_read_static_property_ex(zend_class_entry *scope, zend_string *name, zend_bool silent);
361 ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, size_t name_length, zend_bool silent);
362 
363 ZEND_API char *zend_get_type_by_const(int type);
364 
365 #define ZEND_THIS                           (&EX(This))
366 
367 #define getThis()							((Z_TYPE_P(ZEND_THIS) == IS_OBJECT) ? ZEND_THIS : NULL)
368 #define ZEND_IS_METHOD_CALL()				(EX(func)->common.scope != NULL)
369 
370 #define WRONG_PARAM_COUNT					ZEND_WRONG_PARAM_COUNT()
371 #define WRONG_PARAM_COUNT_WITH_RETVAL(ret)	ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
372 #define ARG_COUNT(dummy)					EX_NUM_ARGS()
373 #define ZEND_NUM_ARGS()						EX_NUM_ARGS()
374 #define ZEND_WRONG_PARAM_COUNT()					{ zend_wrong_param_count(); return; }
375 #define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)		{ zend_wrong_param_count(); return ret; }
376 
377 #ifndef ZEND_WIN32
378 #define DLEXPORT
379 #endif
380 
381 #define array_init(arg)				ZVAL_ARR((arg), zend_new_array(0))
382 #define array_init_size(arg, size)	ZVAL_ARR((arg), zend_new_array(size))
383 ZEND_API int object_init(zval *arg);
384 ZEND_API int object_init_ex(zval *arg, zend_class_entry *ce);
385 ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties);
386 ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
387 ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties);
388 ZEND_API void object_properties_load(zend_object *object, HashTable *properties);
389 
390 ZEND_API void zend_merge_properties(zval *obj, HashTable *properties);
391 
392 ZEND_API int add_assoc_long_ex(zval *arg, const char *key, size_t key_len, zend_long n);
393 ZEND_API int add_assoc_null_ex(zval *arg, const char *key, size_t key_len);
394 ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, size_t key_len, int b);
395 ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
396 ZEND_API int add_assoc_double_ex(zval *arg, const char *key, size_t key_len, double d);
397 ZEND_API int add_assoc_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
398 ZEND_API int add_assoc_string_ex(zval *arg, const char *key, size_t key_len, const char *str);
399 ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, size_t key_len, const char *str, size_t length);
400 ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
401 
402 #define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
403 #define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key))
404 #define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key), __b)
405 #define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key), __r)
406 #define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
407 #define add_assoc_str(__arg, __key, __str) add_assoc_str_ex(__arg, __key, strlen(__key), __str)
408 #define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
409 #define add_assoc_stringl(__arg, __key, __str, __length) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
410 #define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
411 
412 ZEND_API int add_index_long(zval *arg, zend_ulong index, zend_long n);
413 ZEND_API int add_index_null(zval *arg, zend_ulong index);
414 ZEND_API int add_index_bool(zval *arg, zend_ulong index, int b);
415 ZEND_API int add_index_resource(zval *arg, zend_ulong index, zend_resource *r);
416 ZEND_API int add_index_double(zval *arg, zend_ulong index, double d);
417 ZEND_API int add_index_str(zval *arg, zend_ulong index, zend_string *str);
418 ZEND_API int add_index_string(zval *arg, zend_ulong index, const char *str);
419 ZEND_API int add_index_stringl(zval *arg, zend_ulong index, const char *str, size_t length);
420 
add_index_zval(zval *arg, zend_ulong index, zval *value)421 static zend_always_inline int add_index_zval(zval *arg, zend_ulong index, zval *value)
422 {
423 	return zend_hash_index_update(Z_ARRVAL_P(arg), index, value) ? SUCCESS : FAILURE;
424 }
425 
426 ZEND_API int add_next_index_long(zval *arg, zend_long n);
427 ZEND_API int add_next_index_null(zval *arg);
428 ZEND_API int add_next_index_bool(zval *arg, int b);
429 ZEND_API int add_next_index_resource(zval *arg, zend_resource *r);
430 ZEND_API int add_next_index_double(zval *arg, double d);
431 ZEND_API int add_next_index_str(zval *arg, zend_string *str);
432 ZEND_API int add_next_index_string(zval *arg, const char *str);
433 ZEND_API int add_next_index_stringl(zval *arg, const char *str, size_t length);
434 
add_next_index_zval(zval *arg, zval *value)435 static zend_always_inline int add_next_index_zval(zval *arg, zval *value)
436 {
437 	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), value) ? SUCCESS : FAILURE;
438 }
439 
440 ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
441 
442 ZEND_API int add_property_long_ex(zval *arg, const char *key, size_t key_len, zend_long l);
443 ZEND_API int add_property_null_ex(zval *arg, const char *key, size_t key_len);
444 ZEND_API int add_property_bool_ex(zval *arg, const char *key, size_t key_len, zend_long b);
445 ZEND_API int add_property_resource_ex(zval *arg, const char *key, size_t key_len, zend_resource *r);
446 ZEND_API int add_property_double_ex(zval *arg, const char *key, size_t key_len, double d);
447 ZEND_API int add_property_str_ex(zval *arg, const char *key, size_t key_len, zend_string *str);
448 ZEND_API int add_property_string_ex(zval *arg, const char *key, size_t key_len, const char *str);
449 ZEND_API int add_property_stringl_ex(zval *arg, const char *key, size_t key_len,  const char *str, size_t length);
450 ZEND_API int add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
451 
452 #define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n)
453 #define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key))
454 #define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b)
455 #define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r)
456 #define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d)
457 #define add_property_str(__arg, __key, __str) add_property_str_ex(__arg, __key, strlen(__key), __str)
458 #define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str)
459 #define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length)
460 #define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value)
461 
462 
463 ZEND_API int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation);
464 
465 #define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \
466 	_call_user_function_ex(object, function_name, retval_ptr, param_count, params, 1)
467 #define call_user_function_ex(function_table, object, function_name, retval_ptr, param_count, params, no_separation, symbol_table) \
468 	_call_user_function_ex(object, function_name, retval_ptr, param_count, params, no_separation)
469 
470 ZEND_API extern const zend_fcall_info empty_fcall_info;
471 ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
472 
473 /** Build zend_call_info/cache from a zval*
474  *
475  * Caller is responsible to provide a return value (fci->retval), otherwise the we will crash.
476  * In order to pass parameters the following members need to be set:
477  * fci->param_count = 0;
478  * fci->params = NULL;
479  * The callable_name argument may be NULL.
480  * Set check_flags to IS_CALLABLE_STRICT for every new usage!
481  */
482 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);
483 
484 /** Clear arguments connected with zend_fcall_info *fci
485  * If free_mem is not zero then the params array gets free'd as well
486  */
487 ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
488 
489 /** Save current arguments from zend_fcall_info *fci
490  * params array will be set to NULL
491  */
492 ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval **params);
493 
494 /** Free arguments connected with zend_fcall_info *fci andset back saved ones.
495  */
496 ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval *params);
497 
498 /** Set or clear the arguments in the zend_call_info struct taking care of
499  * refcount. If args is NULL and arguments are set then those are cleared.
500  */
501 ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args);
502 ZEND_API int zend_fcall_info_args_ex(zend_fcall_info *fci, zend_function *func, zval *args);
503 
504 /** Set arguments in the zend_fcall_info struct taking care of refcount.
505  * If argc is 0 the arguments which are set will be cleared, else pass
506  * a variable amount of zval** arguments.
507  */
508 ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci, int argc, zval *argv);
509 
510 /** Set arguments in the zend_fcall_info struct taking care of refcount.
511  * If argc is 0 the arguments which are set will be cleared, else pass
512  * a variable amount of zval** arguments.
513  */
514 ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci, int argc, va_list *argv);
515 
516 /** Set arguments in the zend_fcall_info struct taking care of refcount.
517  * If argc is 0 the arguments which are set will be cleared, else pass
518  * a variable amount of zval** arguments.
519  */
520 ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci, int argc, ...);
521 
522 /** Call a function using information created by zend_fcall_info_init()/args().
523  * If args is given then those replace the argument info in fci is temporarily.
524  */
525 ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval *retval, zval *args);
526 
527 ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache);
528 
529 ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
530 
531 ZEND_API int zend_delete_global_variable(zend_string *name);
532 
533 ZEND_API zend_array *zend_rebuild_symbol_table(void);
534 ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data);
535 ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data);
536 ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force);
537 ZEND_API int zend_set_local_var_str(const char *name, size_t len, zval *value, int force);
538 
zend_forbid_dynamic_call(const char *func_name)539 static zend_always_inline int zend_forbid_dynamic_call(const char *func_name)
540 {
541 	zend_execute_data *ex = EG(current_execute_data);
542 	ZEND_ASSERT(ex != NULL && ex->func != NULL);
543 
544 	if (ZEND_CALL_INFO(ex) & ZEND_CALL_DYNAMIC) {
545 		zend_error(E_WARNING, "Cannot call %s dynamically", func_name);
546 		return FAILURE;
547 	}
548 
549 	return SUCCESS;
550 }
551 
552 ZEND_API zend_string *zend_find_alias_name(zend_class_entry *ce, zend_string *name);
553 ZEND_API zend_string *zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
554 
555 ZEND_API ZEND_COLD const char *zend_get_object_type(const zend_class_entry *ce);
556 
557 ZEND_API zend_bool zend_is_iterable(zval *iterable);
558 
559 ZEND_API zend_bool zend_is_countable(zval *countable);
560 
561 ZEND_API ZEND_FUNCTION(display_disabled_function);
562 END_EXTERN_C()
563 
564 #if ZEND_DEBUG
565 #define CHECK_ZVAL_STRING(str) \
566 	if (ZSTR_VAL(str)[ZSTR_LEN(str)] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", ZSTR_VAL(str)); }
567 #define CHECK_ZVAL_STRING_REL(str) \
568 	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); }
569 #else
570 #define CHECK_ZVAL_STRING(z)
571 #define CHECK_ZVAL_STRING_REL(z)
572 #endif
573 
574 #define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
575 #define CHECK_NULL_PATH(p, l) (strlen(p) != (size_t)(l))
576 
577 #define ZVAL_STRINGL(z, s, l) do {				\
578 		ZVAL_NEW_STR(z, zend_string_init(s, l, 0));		\
579 	} while (0)
580 
581 #define ZVAL_STRING(z, s) do {					\
582 		const char *_s = (s);					\
583 		ZVAL_STRINGL(z, _s, strlen(_s));		\
584 	} while (0)
585 
586 #define ZVAL_EMPTY_STRING(z) do {				\
587 		ZVAL_INTERNED_STR(z, ZSTR_EMPTY_ALLOC());		\
588 	} while (0)
589 
590 #define ZVAL_PSTRINGL(z, s, l) do {				\
591 		ZVAL_NEW_STR(z, zend_string_init(s, l, 1));		\
592 	} while (0)
593 
594 #define ZVAL_PSTRING(z, s) do {					\
595 		const char *_s = (s);					\
596 		ZVAL_PSTRINGL(z, _s, strlen(_s));		\
597 	} while (0)
598 
599 #define ZVAL_EMPTY_PSTRING(z) do {				\
600 		ZVAL_PSTRINGL(z, "", 0);				\
601 	} while (0)
602 
603 #define ZVAL_ZVAL(z, zv, copy, dtor) do {		\
604 		zval *__z = (z);						\
605 		zval *__zv = (zv);						\
606 		if (EXPECTED(!Z_ISREF_P(__zv))) {		\
607 			if (copy && !dtor) {				\
608 				ZVAL_COPY(__z, __zv);			\
609 			} else {							\
610 				ZVAL_COPY_VALUE(__z, __zv);		\
611 			}									\
612 		} else {								\
613 			ZVAL_COPY(__z, Z_REFVAL_P(__zv));	\
614 			if (dtor || !copy) {				\
615 				zval_ptr_dtor(__zv);			\
616 			}									\
617 		}										\
618 	} while (0)
619 
620 #define RETVAL_BOOL(b)					ZVAL_BOOL(return_value, b)
621 #define RETVAL_NULL() 					ZVAL_NULL(return_value)
622 #define RETVAL_LONG(l) 					ZVAL_LONG(return_value, l)
623 #define RETVAL_DOUBLE(d) 				ZVAL_DOUBLE(return_value, d)
624 #define RETVAL_STR(s)			 		ZVAL_STR(return_value, s)
625 #define RETVAL_INTERNED_STR(s)	 		ZVAL_INTERNED_STR(return_value, s)
626 #define RETVAL_NEW_STR(s)		 		ZVAL_NEW_STR(return_value, s)
627 #define RETVAL_STR_COPY(s)		 		ZVAL_STR_COPY(return_value, s)
628 #define RETVAL_STRING(s)		 		ZVAL_STRING(return_value, s)
629 #define RETVAL_STRINGL(s, l)		 	ZVAL_STRINGL(return_value, s, l)
630 #define RETVAL_EMPTY_STRING() 			ZVAL_EMPTY_STRING(return_value)
631 #define RETVAL_RES(r)			 		ZVAL_RES(return_value, r)
632 #define RETVAL_ARR(r)			 		ZVAL_ARR(return_value, r)
633 #define RETVAL_EMPTY_ARRAY()			ZVAL_EMPTY_ARRAY(return_value)
634 #define RETVAL_OBJ(r)			 		ZVAL_OBJ(return_value, r)
635 #define RETVAL_ZVAL(zv, copy, dtor)		ZVAL_ZVAL(return_value, zv, copy, dtor)
636 #define RETVAL_FALSE  					ZVAL_FALSE(return_value)
637 #define RETVAL_TRUE   					ZVAL_TRUE(return_value)
638 
639 #define RETURN_BOOL(b) 					{ RETVAL_BOOL(b); return; }
640 #define RETURN_NULL() 					{ RETVAL_NULL(); return;}
641 #define RETURN_LONG(l) 					{ RETVAL_LONG(l); return; }
642 #define RETURN_DOUBLE(d) 				{ RETVAL_DOUBLE(d); return; }
643 #define RETURN_STR(s) 					{ RETVAL_STR(s); return; }
644 #define RETURN_INTERNED_STR(s)			{ RETVAL_INTERNED_STR(s); return; }
645 #define RETURN_NEW_STR(s)				{ RETVAL_NEW_STR(s); return; }
646 #define RETURN_STR_COPY(s)				{ RETVAL_STR_COPY(s); return; }
647 #define RETURN_STRING(s) 				{ RETVAL_STRING(s); return; }
648 #define RETURN_STRINGL(s, l) 			{ RETVAL_STRINGL(s, l); return; }
649 #define RETURN_EMPTY_STRING() 			{ RETVAL_EMPTY_STRING(); return; }
650 #define RETURN_RES(r) 					{ RETVAL_RES(r); return; }
651 #define RETURN_ARR(r) 					{ RETVAL_ARR(r); return; }
652 #define RETURN_EMPTY_ARRAY()			{ RETVAL_EMPTY_ARRAY(); return; }
653 #define RETURN_OBJ(r) 					{ RETVAL_OBJ(r); return; }
654 #define RETURN_ZVAL(zv, copy, dtor)		{ RETVAL_ZVAL(zv, copy, dtor); return; }
655 #define RETURN_FALSE  					{ RETVAL_FALSE; return; }
656 #define RETURN_TRUE   					{ RETVAL_TRUE; return; }
657 
658 #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((p)) : NULL)))
659 #define ZVAL_IS_NULL(z) (Z_TYPE_P(z) == IS_NULL)
660 
661 /* For compatibility */
662 #define ZEND_MINIT			ZEND_MODULE_STARTUP_N
663 #define ZEND_MSHUTDOWN		ZEND_MODULE_SHUTDOWN_N
664 #define ZEND_RINIT			ZEND_MODULE_ACTIVATE_N
665 #define ZEND_RSHUTDOWN		ZEND_MODULE_DEACTIVATE_N
666 #define ZEND_MINFO			ZEND_MODULE_INFO_N
667 #define ZEND_GINIT(module)		((void (*)(void*))(ZEND_MODULE_GLOBALS_CTOR_N(module)))
668 #define ZEND_GSHUTDOWN(module)	((void (*)(void*))(ZEND_MODULE_GLOBALS_DTOR_N(module)))
669 
670 #define ZEND_MINIT_FUNCTION			ZEND_MODULE_STARTUP_D
671 #define ZEND_MSHUTDOWN_FUNCTION		ZEND_MODULE_SHUTDOWN_D
672 #define ZEND_RINIT_FUNCTION			ZEND_MODULE_ACTIVATE_D
673 #define ZEND_RSHUTDOWN_FUNCTION		ZEND_MODULE_DEACTIVATE_D
674 #define ZEND_MINFO_FUNCTION			ZEND_MODULE_INFO_D
675 #define ZEND_GINIT_FUNCTION			ZEND_MODULE_GLOBALS_CTOR_D
676 #define ZEND_GSHUTDOWN_FUNCTION		ZEND_MODULE_GLOBALS_DTOR_D
677 
678 /* May modify arg in-place. Will free arg in failure case (and take ownership in success case).
679  * Prefer using the ZEND_TRY_ASSIGN_* macros over these APIs. */
680 ZEND_API int zend_try_assign_typed_ref_ex(zend_reference *ref, zval *zv, zend_bool strict);
681 ZEND_API int zend_try_assign_typed_ref(zend_reference *ref, zval *zv);
682 
683 ZEND_API int zend_try_assign_typed_ref_null(zend_reference *ref);
684 ZEND_API int zend_try_assign_typed_ref_bool(zend_reference *ref, zend_bool val);
685 ZEND_API int zend_try_assign_typed_ref_long(zend_reference *ref, zend_long lval);
686 ZEND_API int zend_try_assign_typed_ref_double(zend_reference *ref, double dval);
687 ZEND_API int zend_try_assign_typed_ref_empty_string(zend_reference *ref);
688 ZEND_API int zend_try_assign_typed_ref_str(zend_reference *ref, zend_string *str);
689 ZEND_API int zend_try_assign_typed_ref_string(zend_reference *ref, const char *string);
690 ZEND_API int zend_try_assign_typed_ref_stringl(zend_reference *ref, const char *string, size_t len);
691 ZEND_API int zend_try_assign_typed_ref_arr(zend_reference *ref, zend_array *arr);
692 ZEND_API int zend_try_assign_typed_ref_res(zend_reference *ref, zend_resource *res);
693 ZEND_API int zend_try_assign_typed_ref_zval(zend_reference *ref, zval *zv);
694 ZEND_API int zend_try_assign_typed_ref_zval_ex(zend_reference *ref, zval *zv, zend_bool strict);
695 
696 #define _ZEND_TRY_ASSIGN_NULL(zv, is_ref) do { \
697 	zval *_zv = zv; \
698 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
699 		zend_reference *ref = Z_REF_P(_zv); \
700 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
701 			zend_try_assign_typed_ref_null(ref); \
702 			break; \
703 		} \
704 		_zv = &ref->val; \
705 	} \
706 	zval_ptr_dtor(_zv); \
707 	ZVAL_NULL(_zv); \
708 } while (0)
709 
710 #define ZEND_TRY_ASSIGN_NULL(zv) \
711 	_ZEND_TRY_ASSIGN_NULL(zv, 0)
712 
713 #define ZEND_TRY_ASSIGN_REF_NULL(zv) do { \
714 	ZEND_ASSERT(Z_ISREF_P(zv)); \
715 	_ZEND_TRY_ASSIGN_NULL(zv, 1); \
716 } while (0)
717 
718 #define _ZEND_TRY_ASSIGN_FALSE(zv, is_ref) do { \
719 	zval *_zv = zv; \
720 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
721 		zend_reference *ref = Z_REF_P(_zv); \
722 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
723 			zend_try_assign_typed_ref_bool(ref, 0); \
724 			break; \
725 		} \
726 		_zv = &ref->val; \
727 	} \
728 	zval_ptr_dtor(_zv); \
729 	ZVAL_FALSE(_zv); \
730 } while (0)
731 
732 #define ZEND_TRY_ASSIGN_FALSE(zv) \
733 	_ZEND_TRY_ASSIGN_FALSE(zv, 0)
734 
735 #define ZEND_TRY_ASSIGN_REF_FALSE(zv) do { \
736 	ZEND_ASSERT(Z_ISREF_P(zv)); \
737 	_ZEND_TRY_ASSIGN_FALSE(zv, 1); \
738 } while (0)
739 
740 #define _ZEND_TRY_ASSIGN_TRUE(zv, is_ref) do { \
741 	zval *_zv = zv; \
742 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
743 		zend_reference *ref = Z_REF_P(_zv); \
744 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
745 			zend_try_assign_typed_ref_bool(ref, 1); \
746 			break; \
747 		} \
748 		_zv = &ref->val; \
749 	} \
750 	zval_ptr_dtor(_zv); \
751 	ZVAL_TRUE(_zv); \
752 } while (0)
753 
754 #define ZEND_TRY_ASSIGN_TRUE(zv) \
755 	_ZEND_TRY_ASSIGN_TRUE(zv, 0)
756 
757 #define ZEND_TRY_ASSIGN_REF_TRUE(zv) do { \
758 	ZEND_ASSERT(Z_ISREF_P(zv)); \
759 	_ZEND_TRY_ASSIGN_TRUE(zv, 1); \
760 } while (0)
761 
762 #define _ZEND_TRY_ASSIGN_BOOL(zv, bval, is_ref) do { \
763 	zval *_zv = zv; \
764 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
765 		zend_reference *ref = Z_REF_P(_zv); \
766 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
767 			zend_try_assign_typed_ref_bool(ref, 1); \
768 			break; \
769 		} \
770 		_zv = &ref->val; \
771 	} \
772 	zval_ptr_dtor(_zv); \
773 	ZVAL_BOOL(_zv, bval); \
774 } while (0)
775 
776 #define ZEND_TRY_ASSIGN_BOOL(zv, bval) \
777 	_ZEND_TRY_ASSIGN_BOOL(zv, bval, 0)
778 
779 #define ZEND_TRY_ASSIGN_REF_BOOL(zv, bval) do { \
780 	ZEND_ASSERT(Z_ISREF_P(zv)); \
781 	_ZEND_TRY_ASSIGN_BOOL(zv, bval, 1); \
782 } while (0)
783 
784 #define _ZEND_TRY_ASSIGN_LONG(zv, lval, is_ref) do { \
785 	zval *_zv = zv; \
786 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
787 		zend_reference *ref = Z_REF_P(_zv); \
788 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
789 			zend_try_assign_typed_ref_long(ref, lval); \
790 			break; \
791 		} \
792 		_zv = &ref->val; \
793 	} \
794 	zval_ptr_dtor(_zv); \
795 	ZVAL_LONG(_zv, lval); \
796 } while (0)
797 
798 #define ZEND_TRY_ASSIGN_LONG(zv, lval) \
799 	_ZEND_TRY_ASSIGN_LONG(zv, lval, 0)
800 
801 #define ZEND_TRY_ASSIGN_REF_LONG(zv, lval) do { \
802 	ZEND_ASSERT(Z_ISREF_P(zv)); \
803 	_ZEND_TRY_ASSIGN_LONG(zv, lval, 1); \
804 } while (0)
805 
806 #define _ZEND_TRY_ASSIGN_DOUBLE(zv, dval, is_ref) do { \
807 	zval *_zv = zv; \
808 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
809 		zend_reference *ref = Z_REF_P(_zv); \
810 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
811 			zend_try_assign_typed_ref_double(ref, dval); \
812 			break; \
813 		} \
814 		_zv = &ref->val; \
815 	} \
816 	zval_ptr_dtor(_zv); \
817 	ZVAL_DOUBLE(_zv, dval); \
818 } while (0)
819 
820 #define ZEND_TRY_ASSIGN_DOUBLE(zv, dval) \
821 	_ZEND_TRY_ASSIGN_DOUBLE(zv, dval, 0)
822 
823 #define ZEND_TRY_ASSIGN_REF_DOUBLE(zv, dval) do { \
824 	ZEND_ASSERT(Z_ISREF_P(zv)); \
825 	_ZEND_TRY_ASSIGN_DOUBLE(zv, dval, 1); \
826 } while (0)
827 
828 #define _ZEND_TRY_ASSIGN_EMPTY_STRING(zv, is_ref) do { \
829 	zval *_zv = zv; \
830 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
831 		zend_reference *ref = Z_REF_P(_zv); \
832 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
833 			zend_try_assign_typed_ref_empty_string(ref); \
834 			break; \
835 		} \
836 		_zv = &ref->val; \
837 	} \
838 	zval_ptr_dtor(_zv); \
839 	ZVAL_EMPTY_STRING(_zv); \
840 } while (0)
841 
842 #define ZEND_TRY_ASSIGN_EMPTY_STRING(zv) \
843 	_ZEND_TRY_ASSIGN_EMPTY_STRING(zv, 0)
844 
845 #define ZEND_TRY_ASSIGN_REF_EMPTY_STRING(zv) do { \
846 	ZEND_ASSERT(Z_ISREF_P(zv)); \
847 	_ZEND_TRY_ASSIGN_EMPTY_STRING(zv, 1); \
848 } while (0)
849 
850 #define _ZEND_TRY_ASSIGN_STR(zv, str, is_ref) do { \
851 	zval *_zv = zv; \
852 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
853 		zend_reference *ref = Z_REF_P(_zv); \
854 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
855 			zend_try_assign_typed_ref_str(ref, str); \
856 			break; \
857 		} \
858 		_zv = &ref->val; \
859 	} \
860 	zval_ptr_dtor(_zv); \
861 	ZVAL_STR(_zv, str); \
862 } while (0)
863 
864 #define ZEND_TRY_ASSIGN_STR(zv, str) \
865 	_ZEND_TRY_ASSIGN_STR(zv, str, 0)
866 
867 #define ZEND_TRY_ASSIGN_REF_STR(zv, str) do { \
868 	ZEND_ASSERT(Z_ISREF_P(zv)); \
869 	_ZEND_TRY_ASSIGN_STR(zv, str, 1); \
870 } while (0)
871 
872 #define _ZEND_TRY_ASSIGN_NEW_STR(zv, str, is_str) do { \
873 	zval *_zv = zv; \
874 	if (is_str || UNEXPECTED(Z_ISREF_P(_zv))) { \
875 		zend_reference *ref = Z_REF_P(_zv); \
876 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
877 			zend_try_assign_typed_ref_str(ref, str); \
878 			break; \
879 		} \
880 		_zv = &ref->val; \
881 	} \
882 	zval_ptr_dtor(_zv); \
883 	ZVAL_NEW_STR(_zv, str); \
884 } while (0)
885 
886 #define ZEND_TRY_ASSIGN_NEW_STR(zv, str) \
887 	_ZEND_TRY_ASSIGN_NEW_STR(zv, str, 0)
888 
889 #define ZEND_TRY_ASSIGN_REF_NEW_STR(zv, str) do { \
890 	ZEND_ASSERT(Z_ISREF_P(zv)); \
891 	_ZEND_TRY_ASSIGN_NEW_STR(zv, str, 1); \
892 } while (0)
893 
894 #define _ZEND_TRY_ASSIGN_STRING(zv, string, is_ref) do { \
895 	zval *_zv = zv; \
896 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
897 		zend_reference *ref = Z_REF_P(_zv); \
898 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
899 			zend_try_assign_typed_ref_string(ref, string); \
900 			break; \
901 		} \
902 		_zv = &ref->val; \
903 	} \
904 	zval_ptr_dtor(_zv); \
905 	ZVAL_STRING(_zv, string); \
906 } while (0)
907 
908 #define ZEND_TRY_ASSIGN_STRING(zv, string) \
909 	_ZEND_TRY_ASSIGN_STRING(zv, string, 0)
910 
911 #define ZEND_TRY_ASSIGN_REF_STRING(zv, string) do { \
912 	ZEND_ASSERT(Z_ISREF_P(zv)); \
913 	_ZEND_TRY_ASSIGN_STRING(zv, string, 1); \
914 } while (0)
915 
916 #define _ZEND_TRY_ASSIGN_STRINGL(zv, string, len, is_ref) do { \
917 	zval *_zv = zv; \
918 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
919 		zend_reference *ref = Z_REF_P(_zv); \
920 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
921 			zend_try_assign_typed_ref_stringl(ref, string, len); \
922 			break; \
923 		} \
924 		_zv = &ref->val; \
925 	} \
926 	zval_ptr_dtor(_zv); \
927 	ZVAL_STRINGL(_zv, string, len); \
928 } while (0)
929 
930 #define ZEND_TRY_ASSIGN_STRINGL(zv, string, len) \
931 	_ZEND_TRY_ASSIGN_STRINGL(zv, string, len, 0)
932 
933 #define ZEND_TRY_ASSIGN_REF_STRINGL(zv, string, len) do { \
934 	ZEND_ASSERT(Z_ISREF_P(zv)); \
935 	_ZEND_TRY_ASSIGN_STRINGL(zv, string, len, 1); \
936 } while (0)
937 
938 #define _ZEND_TRY_ASSIGN_ARR(zv, arr, is_ref) do { \
939 	zval *_zv = zv; \
940 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
941 		zend_reference *ref = Z_REF_P(_zv); \
942 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
943 			zend_try_assign_typed_ref_arr(ref, arr); \
944 			break; \
945 		} \
946 		_zv = &ref->val; \
947 	} \
948 	zval_ptr_dtor(_zv); \
949 	ZVAL_ARR(_zv, arr); \
950 } while (0)
951 
952 #define ZEND_TRY_ASSIGN_ARR(zv, arr) \
953 	_ZEND_TRY_ASSIGN_ARR(zv, arr, 0)
954 
955 #define ZEND_TRY_ASSIGN_REF_ARR(zv, arr) do { \
956 	ZEND_ASSERT(Z_ISREF_P(zv)); \
957 	_ZEND_TRY_ASSIGN_ARR(zv, arr, 1); \
958 } while (0)
959 
960 #define _ZEND_TRY_ASSIGN_RES(zv, res, is_ref) do { \
961 	zval *_zv = zv; \
962 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
963 		zend_reference *ref = Z_REF_P(_zv); \
964 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
965 			zend_try_assign_typed_ref_res(ref, res); \
966 			break; \
967 		} \
968 		_zv = &ref->val; \
969 	} \
970 	zval_ptr_dtor(_zv); \
971 	ZVAL_RES(_zv, res); \
972 } while (0)
973 
974 #define ZEND_TRY_ASSIGN_RES(zv, res) \
975 	_ZEND_TRY_ASSIGN_RES(zv, res, 0)
976 
977 #define ZEND_TRY_ASSIGN_REF_RES(zv, res) do { \
978 	ZEND_ASSERT(Z_ISREF_P(zv)); \
979 	_ZEND_TRY_ASSIGN_RES(zv, res, 1); \
980 } while (0)
981 
982 #define _ZEND_TRY_ASSIGN_TMP(zv, other_zv, is_ref) do { \
983 	zval *_zv = zv; \
984 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
985 		zend_reference *ref = Z_REF_P(_zv); \
986 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
987 			zend_try_assign_typed_ref(ref, other_zv); \
988 			break; \
989 		} \
990 		_zv = &ref->val; \
991 	} \
992 	zval_ptr_dtor(_zv); \
993 	ZVAL_COPY_VALUE(_zv, other_zv); \
994 } while (0)
995 
996 #define ZEND_TRY_ASSIGN_TMP(zv, other_zv) \
997 	_ZEND_TRY_ASSIGN_TMP(zv, other_zv, 0)
998 
999 #define ZEND_TRY_ASSIGN_REF_TMP(zv, other_zv) do { \
1000 	ZEND_ASSERT(Z_ISREF_P(zv)); \
1001 	_ZEND_TRY_ASSIGN_TMP(zv, other_zv, 1); \
1002 } while (0)
1003 
1004 #define _ZEND_TRY_ASSIGN_VALUE(zv, other_zv, is_ref) do { \
1005 	zval *_zv = zv; \
1006 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
1007 		zend_reference *ref = Z_REF_P(_zv); \
1008 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
1009 			zend_try_assign_typed_ref_zval(ref, other_zv); \
1010 			break; \
1011 		} \
1012 		_zv = &ref->val; \
1013 	} \
1014 	zval_ptr_dtor(_zv); \
1015 	ZVAL_COPY_VALUE(_zv, other_zv); \
1016 } while (0)
1017 
1018 #define ZEND_TRY_ASSIGN_VALUE(zv, other_zv) \
1019 	_ZEND_TRY_ASSIGN_VALUE(zv, other_zv, 0)
1020 
1021 #define ZEND_TRY_ASSIGN_REF_VALUE(zv, other_zv) do { \
1022 	ZEND_ASSERT(Z_ISREF_P(zv)); \
1023 	_ZEND_TRY_ASSIGN_VALUE(zv, other_zv, 1); \
1024 } while (0)
1025 
1026 #define ZEND_TRY_ASSIGN_COPY(zv, other_zv) do { \
1027 	Z_TRY_ADDREF_P(other_zv); \
1028 	ZEND_TRY_ASSIGN_VALUE(zv, other_zv); \
1029 } while (0)
1030 
1031 #define ZEND_TRY_ASSIGN_REF_COPY(zv, other_zv) do { \
1032 	Z_TRY_ADDREF_P(other_zv); \
1033 	ZEND_TRY_ASSIGN_REF_VALUE(zv, other_zv); \
1034 } while (0)
1035 
1036 #define _ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, is_ref) do { \
1037 	zval *_zv = zv; \
1038 	if (is_ref || UNEXPECTED(Z_ISREF_P(_zv))) { \
1039 		zend_reference *ref = Z_REF_P(_zv); \
1040 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { \
1041 			zend_try_assign_typed_ref_zval_ex(ref, other_zv, strict); \
1042 			break; \
1043 		} \
1044 		_zv = &ref->val; \
1045 	} \
1046 	zval_ptr_dtor(_zv); \
1047 	ZVAL_COPY_VALUE(_zv, other_zv); \
1048 } while (0)
1049 
1050 #define ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict) \
1051 	_ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, 0)
1052 
1053 #define ZEND_TRY_ASSIGN_REF_VALUE_EX(zv, other_zv, strict) do { \
1054 	ZEND_ASSERT(Z_ISREF_P(zv)); \
1055 	_ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict, 1); \
1056 } while (0)
1057 
1058 #define ZEND_TRY_ASSIGN_COPY_EX(zv, other_zv, strict) do { \
1059 	Z_TRY_ADDREF_P(other_zv); \
1060 	ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict); \
1061 } while (0)
1062 
1063 #define ZEND_TRY_ASSIGN_REF_COPY_EX(zv, other_zv, strict) do { \
1064 	Z_TRY_ADDREF_P(other_zv); \
1065 	ZEND_TRY_ASSIGN_REF_VALUE_EX(zv, other_zv, strict); \
1066 } while (0)
1067 
1068 /* Initializes a reference to an empty array and returns dereferenced zval,
1069  * or NULL if the initialization failed. */
zend_try_array_init_size(zval *zv, uint32_t size)1070 static zend_always_inline zval *zend_try_array_init_size(zval *zv, uint32_t size)
1071 {
1072 	zend_array *arr = zend_new_array(size);
1073 
1074 	if (EXPECTED(Z_ISREF_P(zv))) {
1075 		zend_reference *ref = Z_REF_P(zv);
1076 		if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
1077 			if (zend_try_assign_typed_ref_arr(ref, arr) != SUCCESS) {
1078 				return NULL;
1079 			}
1080 			return &ref->val;
1081 		}
1082 		zv = &ref->val;
1083 	}
1084 	zval_ptr_dtor(zv);
1085 	ZVAL_ARR(zv, arr);
1086 	return zv;
1087 }
1088 
zend_try_array_init(zval *zv)1089 static zend_always_inline zval *zend_try_array_init(zval *zv)
1090 {
1091 	return zend_try_array_init_size(zv, 0);
1092 }
1093 
1094 /* Fast parameter parsing API */
1095 
1096 /* Fast ZPP is always enabled now; this define is left in for compatibility
1097  * with any existing conditional compilation blocks.
1098  */
1099 #define FAST_ZPP 1
1100 
1101 #define Z_EXPECTED_TYPES(_) \
1102 	_(Z_EXPECTED_LONG,		"int") \
1103 	_(Z_EXPECTED_BOOL,		"bool") \
1104 	_(Z_EXPECTED_STRING,	"string") \
1105 	_(Z_EXPECTED_ARRAY,		"array") \
1106 	_(Z_EXPECTED_FUNC,		"valid callback") \
1107 	_(Z_EXPECTED_RESOURCE,	"resource") \
1108 	_(Z_EXPECTED_PATH,		"a valid path") \
1109 	_(Z_EXPECTED_OBJECT,	"object") \
1110 	_(Z_EXPECTED_DOUBLE,	"float")
1111 
1112 #define Z_EXPECTED_TYPE_ENUM(id, str) id,
1113 #define Z_EXPECTED_TYPE_STR(id, str)  str,
1114 
1115 typedef enum _zend_expected_type {
1116 	Z_EXPECTED_TYPES(Z_EXPECTED_TYPE_ENUM)
1117 	Z_EXPECTED_LAST
1118 } zend_expected_type;
1119 
1120 ZEND_API ZEND_COLD int  ZEND_FASTCALL zend_wrong_parameters_none_error(void);
1121 ZEND_API ZEND_COLD int  ZEND_FASTCALL zend_wrong_parameters_none_exception(void);
1122 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_count_error(int min_num_args, int max_num_args);
1123 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_count_exception(int min_num_args, int max_num_args);
1124 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(int num, zend_expected_type expected_type, zval *arg);
1125 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_exception(int num, zend_expected_type expected_type, zval *arg);
1126 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_error(int num, char *name, zval *arg);
1127 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_exception(int num, char *name, zval *arg);
1128 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(int num, char *error);
1129 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_deprecated(int num, char *error);
1130 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_exception(int num, char *error);
1131 
1132 #define ZPP_ERROR_OK             0
1133 #define ZPP_ERROR_FAILURE        1
1134 #define ZPP_ERROR_WRONG_CALLBACK 2
1135 #define ZPP_ERROR_WRONG_CLASS    3
1136 #define ZPP_ERROR_WRONG_ARG      4
1137 #define ZPP_ERROR_WRONG_COUNT    5
1138 
1139 #define ZEND_PARSE_PARAMETERS_START_EX(flags, min_num_args, max_num_args) do { \
1140 		const int _flags = (flags); \
1141 		int _min_num_args = (min_num_args); \
1142 		int _max_num_args = (max_num_args); \
1143 		int _num_args = EX_NUM_ARGS(); \
1144 		int _i = 0; \
1145 		zval *_real_arg, *_arg = NULL; \
1146 		zend_expected_type _expected_type = Z_EXPECTED_LONG; \
1147 		char *_error = NULL; \
1148 		zend_bool _dummy; \
1149 		zend_bool _optional = 0; \
1150 		int _error_code = ZPP_ERROR_OK; \
1151 		((void)_i); \
1152 		((void)_real_arg); \
1153 		((void)_arg); \
1154 		((void)_expected_type); \
1155 		((void)_error); \
1156 		((void)_dummy); \
1157 		((void)_optional); \
1158 		\
1159 		do { \
1160 			if (UNEXPECTED(_num_args < _min_num_args) || \
1161 			    (UNEXPECTED(_num_args > _max_num_args) && \
1162 			     EXPECTED(_max_num_args >= 0))) { \
1163 				if (!(_flags & ZEND_PARSE_PARAMS_QUIET)) { \
1164 					if (_flags & ZEND_PARSE_PARAMS_THROW) { \
1165 						zend_wrong_parameters_count_exception(_min_num_args, _max_num_args); \
1166 					} else { \
1167 						zend_wrong_parameters_count_error(_min_num_args, _max_num_args); \
1168 					} \
1169 				} \
1170 				_error_code = ZPP_ERROR_FAILURE; \
1171 				break; \
1172 			} \
1173 			_real_arg = ZEND_CALL_ARG(execute_data, 0);
1174 
1175 #define ZEND_PARSE_PARAMETERS_START(min_num_args, max_num_args) \
1176 	ZEND_PARSE_PARAMETERS_START_EX(0, min_num_args, max_num_args)
1177 
1178 #define ZEND_PARSE_PARAMETERS_NONE() do { \
1179 		if (UNEXPECTED(ZEND_NUM_ARGS() != 0)) { \
1180 			zend_wrong_parameters_none_error(); \
1181 			return; \
1182 		} \
1183 	} while (0)
1184 
1185 #define ZEND_PARSE_PARAMETERS_END_EX(failure) \
1186 		} while (0); \
1187 		if (UNEXPECTED(_error_code != ZPP_ERROR_OK)) { \
1188 			if (!(_flags & ZEND_PARSE_PARAMS_QUIET)) { \
1189 				if (_error_code == ZPP_ERROR_WRONG_CALLBACK) { \
1190 					if (_flags & ZEND_PARSE_PARAMS_THROW) { \
1191 						zend_wrong_callback_exception(_i, _error); \
1192 					} else { \
1193 						zend_wrong_callback_error(_i, _error); \
1194 					} \
1195 				} else if (_error_code == ZPP_ERROR_WRONG_CLASS) { \
1196 					if (_flags & ZEND_PARSE_PARAMS_THROW) { \
1197 						zend_wrong_parameter_class_exception(_i, _error, _arg); \
1198 					} else { \
1199 						zend_wrong_parameter_class_error(_i, _error, _arg); \
1200 					} \
1201 				} else if (_error_code == ZPP_ERROR_WRONG_ARG) { \
1202 					if (_flags & ZEND_PARSE_PARAMS_THROW) { \
1203 						zend_wrong_parameter_type_exception(_i, _expected_type, _arg); \
1204 					} else { \
1205 						zend_wrong_parameter_type_error(_i, _expected_type, _arg); \
1206 					} \
1207 				} \
1208 			} \
1209 			failure; \
1210 		} \
1211 	} while (0)
1212 
1213 #define ZEND_PARSE_PARAMETERS_END() \
1214 	ZEND_PARSE_PARAMETERS_END_EX(return)
1215 
1216 #define Z_PARAM_PROLOGUE(deref, separate) \
1217 	++_i; \
1218 	ZEND_ASSERT(_i <= _min_num_args || _optional==1); \
1219 	ZEND_ASSERT(_i >  _min_num_args || _optional==0); \
1220 	if (_optional) { \
1221 		if (UNEXPECTED(_i >_num_args)) break; \
1222 	} \
1223 	_real_arg++; \
1224 	_arg = _real_arg; \
1225 	if (deref) { \
1226 		if (EXPECTED(Z_ISREF_P(_arg))) { \
1227 			_arg = Z_REFVAL_P(_arg); \
1228 		} \
1229 	} \
1230 	if (separate) { \
1231 		SEPARATE_ZVAL_NOREF(_arg); \
1232 	}
1233 
1234 /* old "|" */
1235 #define Z_PARAM_OPTIONAL \
1236 	_optional = 1;
1237 
1238 /* old "a" */
1239 #define Z_PARAM_ARRAY_EX2(dest, check_null, deref, separate) \
1240 		Z_PARAM_PROLOGUE(deref, separate); \
1241 		if (UNEXPECTED(!zend_parse_arg_array(_arg, &dest, check_null, 0))) { \
1242 			_expected_type = Z_EXPECTED_ARRAY; \
1243 			_error_code = ZPP_ERROR_WRONG_ARG; \
1244 			break; \
1245 		}
1246 
1247 #define Z_PARAM_ARRAY_EX(dest, check_null, separate) \
1248 	Z_PARAM_ARRAY_EX2(dest, check_null, separate, separate)
1249 
1250 #define Z_PARAM_ARRAY(dest) \
1251 	Z_PARAM_ARRAY_EX(dest, 0, 0)
1252 
1253 /* old "A" */
1254 #define Z_PARAM_ARRAY_OR_OBJECT_EX2(dest, check_null, deref, separate) \
1255 		Z_PARAM_PROLOGUE(deref, separate); \
1256 		if (UNEXPECTED(!zend_parse_arg_array(_arg, &dest, check_null, 1))) { \
1257 			_expected_type = Z_EXPECTED_ARRAY; \
1258 			_error_code = ZPP_ERROR_WRONG_ARG; \
1259 			break; \
1260 		}
1261 
1262 #define Z_PARAM_ARRAY_OR_OBJECT_EX(dest, check_null, separate) \
1263 	Z_PARAM_ARRAY_OR_OBJECT_EX2(dest, check_null, separate, separate)
1264 
1265 #define Z_PARAM_ARRAY_OR_OBJECT(dest) \
1266 	Z_PARAM_ARRAY_OR_OBJECT_EX(dest, 0, 0)
1267 
1268 /* old "b" */
1269 #define Z_PARAM_BOOL_EX2(dest, is_null, check_null, deref, separate) \
1270 		Z_PARAM_PROLOGUE(deref, separate); \
1271 		if (UNEXPECTED(!zend_parse_arg_bool(_arg, &dest, &is_null, check_null))) { \
1272 			_expected_type = Z_EXPECTED_BOOL; \
1273 			_error_code = ZPP_ERROR_WRONG_ARG; \
1274 			break; \
1275 		}
1276 
1277 #define Z_PARAM_BOOL_EX(dest, is_null, check_null, separate) \
1278 	Z_PARAM_BOOL_EX2(dest, is_null, check_null, separate, separate)
1279 
1280 #define Z_PARAM_BOOL(dest) \
1281 	Z_PARAM_BOOL_EX(dest, _dummy, 0, 0)
1282 
1283 /* old "C" */
1284 #define Z_PARAM_CLASS_EX2(dest, check_null, deref, separate) \
1285 		Z_PARAM_PROLOGUE(deref, separate); \
1286 		if (UNEXPECTED(!zend_parse_arg_class(_arg, &dest, _i, check_null))) { \
1287 			_error_code = ZPP_ERROR_FAILURE; \
1288 			break; \
1289 		}
1290 
1291 #define Z_PARAM_CLASS_EX(dest, check_null, separate) \
1292 	Z_PARAM_CLASS_EX2(dest, check_null, separate, separate)
1293 
1294 #define Z_PARAM_CLASS(dest) \
1295 	Z_PARAM_CLASS_EX(dest, 0, 0)
1296 
1297 /* old "d" */
1298 #define Z_PARAM_DOUBLE_EX2(dest, is_null, check_null, deref, separate) \
1299 		Z_PARAM_PROLOGUE(deref, separate); \
1300 		if (UNEXPECTED(!zend_parse_arg_double(_arg, &dest, &is_null, check_null))) { \
1301 			_expected_type = Z_EXPECTED_DOUBLE; \
1302 			_error_code = ZPP_ERROR_WRONG_ARG; \
1303 			break; \
1304 		}
1305 
1306 #define Z_PARAM_DOUBLE_EX(dest, is_null, check_null, separate) \
1307 	Z_PARAM_DOUBLE_EX2(dest, is_null, check_null, separate, separate)
1308 
1309 #define Z_PARAM_DOUBLE(dest) \
1310 	Z_PARAM_DOUBLE_EX(dest, _dummy, 0, 0)
1311 
1312 /* old "f" */
1313 #define Z_PARAM_FUNC_EX2(dest_fci, dest_fcc, check_null, deref, separate) \
1314 		Z_PARAM_PROLOGUE(deref, separate); \
1315 		if (UNEXPECTED(!zend_parse_arg_func(_arg, &dest_fci, &dest_fcc, check_null, &_error))) { \
1316 			if (!_error) { \
1317 				_expected_type = Z_EXPECTED_FUNC; \
1318 				_error_code = ZPP_ERROR_WRONG_ARG; \
1319 				break; \
1320 			} else { \
1321 				_error_code = ZPP_ERROR_WRONG_CALLBACK; \
1322 				break; \
1323 			} \
1324 		} else if (UNEXPECTED(_error != NULL)) { \
1325 			zend_wrong_callback_deprecated(_i, _error); \
1326 		}
1327 
1328 #define Z_PARAM_FUNC_EX(dest_fci, dest_fcc, check_null, separate) \
1329 	Z_PARAM_FUNC_EX2(dest_fci, dest_fcc, check_null, separate, separate)
1330 
1331 #define Z_PARAM_FUNC(dest_fci, dest_fcc) \
1332 	Z_PARAM_FUNC_EX(dest_fci, dest_fcc, 0, 0)
1333 
1334 /* old "h" */
1335 #define Z_PARAM_ARRAY_HT_EX2(dest, check_null, deref, separate) \
1336 		Z_PARAM_PROLOGUE(deref, separate); \
1337 		if (UNEXPECTED(!zend_parse_arg_array_ht(_arg, &dest, check_null, 0, separate))) { \
1338 			_expected_type = Z_EXPECTED_ARRAY; \
1339 			_error_code = ZPP_ERROR_WRONG_ARG; \
1340 			break; \
1341 		}
1342 
1343 #define Z_PARAM_ARRAY_HT_EX(dest, check_null, separate) \
1344 	Z_PARAM_ARRAY_HT_EX2(dest, check_null, separate, separate)
1345 
1346 #define Z_PARAM_ARRAY_HT(dest) \
1347 	Z_PARAM_ARRAY_HT_EX(dest, 0, 0)
1348 
1349 /* old "H" */
1350 #define Z_PARAM_ARRAY_OR_OBJECT_HT_EX2(dest, check_null, deref, separate) \
1351 		Z_PARAM_PROLOGUE(deref, separate); \
1352 		if (UNEXPECTED(!zend_parse_arg_array_ht(_arg, &dest, check_null, 1, separate))) { \
1353 			_expected_type = Z_EXPECTED_ARRAY; \
1354 			_error_code = ZPP_ERROR_WRONG_ARG; \
1355 			break; \
1356 		}
1357 
1358 #define Z_PARAM_ARRAY_OR_OBJECT_HT_EX(dest, check_null, separate) \
1359 	Z_PARAM_ARRAY_OR_OBJECT_HT_EX2(dest, check_null, separate, separate)
1360 
1361 #define Z_PARAM_ARRAY_OR_OBJECT_HT(dest) \
1362 	Z_PARAM_ARRAY_OR_OBJECT_HT_EX(dest, 0, 0)
1363 
1364 /* old "l" */
1365 #define Z_PARAM_LONG_EX2(dest, is_null, check_null, deref, separate) \
1366 		Z_PARAM_PROLOGUE(deref, separate); \
1367 		if (UNEXPECTED(!zend_parse_arg_long(_arg, &dest, &is_null, check_null, 0))) { \
1368 			_expected_type = Z_EXPECTED_LONG; \
1369 			_error_code = ZPP_ERROR_WRONG_ARG; \
1370 			break; \
1371 		}
1372 
1373 #define Z_PARAM_LONG_EX(dest, is_null, check_null, separate) \
1374 	Z_PARAM_LONG_EX2(dest, is_null, check_null, separate, separate)
1375 
1376 #define Z_PARAM_LONG(dest) \
1377 	Z_PARAM_LONG_EX(dest, _dummy, 0, 0)
1378 
1379 /* old "L" */
1380 #define Z_PARAM_STRICT_LONG_EX2(dest, is_null, check_null, deref, separate) \
1381 		Z_PARAM_PROLOGUE(deref, separate); \
1382 		if (UNEXPECTED(!zend_parse_arg_long(_arg, &dest, &is_null, check_null, 1))) { \
1383 			_expected_type = Z_EXPECTED_LONG; \
1384 			_error_code = ZPP_ERROR_WRONG_ARG; \
1385 			break; \
1386 		}
1387 
1388 #define Z_PARAM_STRICT_LONG_EX(dest, is_null, check_null, separate) \
1389 	Z_PARAM_STRICT_LONG_EX2(dest, is_null, check_null, separate, separate)
1390 
1391 #define Z_PARAM_STRICT_LONG(dest) \
1392 	Z_PARAM_STRICT_LONG_EX(dest, _dummy, 0, 0)
1393 
1394 /* old "o" */
1395 #define Z_PARAM_OBJECT_EX2(dest, check_null, deref, separate) \
1396 		Z_PARAM_PROLOGUE(deref, separate); \
1397 		if (UNEXPECTED(!zend_parse_arg_object(_arg, &dest, NULL, check_null))) { \
1398 			_expected_type = Z_EXPECTED_OBJECT; \
1399 			_error_code = ZPP_ERROR_WRONG_ARG; \
1400 			break; \
1401 		}
1402 
1403 #define Z_PARAM_OBJECT_EX(dest, check_null, separate) \
1404 	Z_PARAM_OBJECT_EX2(dest, check_null, separate, separate)
1405 
1406 #define Z_PARAM_OBJECT(dest) \
1407 	Z_PARAM_OBJECT_EX(dest, 0, 0)
1408 
1409 /* old "O" */
1410 #define Z_PARAM_OBJECT_OF_CLASS_EX2(dest, _ce, check_null, deref, separate) \
1411 		Z_PARAM_PROLOGUE(deref, separate); \
1412 		if (UNEXPECTED(!zend_parse_arg_object(_arg, &dest, _ce, check_null))) { \
1413 			if (_ce) { \
1414 				_error = ZSTR_VAL((_ce)->name); \
1415 				_error_code = ZPP_ERROR_WRONG_CLASS; \
1416 				break; \
1417 			} else { \
1418 				_expected_type = Z_EXPECTED_OBJECT; \
1419 				_error_code = ZPP_ERROR_WRONG_ARG; \
1420 				break; \
1421 			} \
1422 		}
1423 
1424 #define Z_PARAM_OBJECT_OF_CLASS_EX(dest, _ce, check_null, separate) \
1425 	Z_PARAM_OBJECT_OF_CLASS_EX2(dest, _ce, check_null, separate, separate)
1426 
1427 #define Z_PARAM_OBJECT_OF_CLASS(dest, _ce) \
1428 	Z_PARAM_OBJECT_OF_CLASS_EX(dest, _ce, 0, 0)
1429 
1430 /* old "p" */
1431 #define Z_PARAM_PATH_EX2(dest, dest_len, check_null, deref, separate) \
1432 		Z_PARAM_PROLOGUE(deref, separate); \
1433 		if (UNEXPECTED(!zend_parse_arg_path(_arg, &dest, &dest_len, check_null))) { \
1434 			_expected_type = Z_EXPECTED_PATH; \
1435 			_error_code = ZPP_ERROR_WRONG_ARG; \
1436 			break; \
1437 		}
1438 
1439 #define Z_PARAM_PATH_EX(dest, dest_len, check_null, separate) \
1440 	Z_PARAM_PATH_EX2(dest, dest_len, check_null, separate, separate)
1441 
1442 #define Z_PARAM_PATH(dest, dest_len) \
1443 	Z_PARAM_PATH_EX(dest, dest_len, 0, 0)
1444 
1445 /* old "P" */
1446 #define Z_PARAM_PATH_STR_EX2(dest, check_null, deref, separate) \
1447 		Z_PARAM_PROLOGUE(deref, separate); \
1448 		if (UNEXPECTED(!zend_parse_arg_path_str(_arg, &dest, check_null))) { \
1449 			_expected_type = Z_EXPECTED_PATH; \
1450 			_error_code = ZPP_ERROR_WRONG_ARG; \
1451 			break; \
1452 		}
1453 
1454 #define Z_PARAM_PATH_STR_EX(dest, check_null, separate) \
1455 	Z_PARAM_PATH_STR_EX2(dest, check_null, separate, separate)
1456 
1457 #define Z_PARAM_PATH_STR(dest) \
1458 	Z_PARAM_PATH_STR_EX(dest, 0, 0)
1459 
1460 /* old "r" */
1461 #define Z_PARAM_RESOURCE_EX2(dest, check_null, deref, separate) \
1462 		Z_PARAM_PROLOGUE(deref, separate); \
1463 		if (UNEXPECTED(!zend_parse_arg_resource(_arg, &dest, check_null))) { \
1464 			_expected_type = Z_EXPECTED_RESOURCE; \
1465 			_error_code = ZPP_ERROR_WRONG_ARG; \
1466 			break; \
1467 		}
1468 
1469 #define Z_PARAM_RESOURCE_EX(dest, check_null, separate) \
1470 	Z_PARAM_RESOURCE_EX2(dest, check_null, separate, separate)
1471 
1472 #define Z_PARAM_RESOURCE(dest) \
1473 	Z_PARAM_RESOURCE_EX(dest, 0, 0)
1474 
1475 /* old "s" */
1476 #define Z_PARAM_STRING_EX2(dest, dest_len, check_null, deref, separate) \
1477 		Z_PARAM_PROLOGUE(deref, separate); \
1478 		if (UNEXPECTED(!zend_parse_arg_string(_arg, &dest, &dest_len, check_null))) { \
1479 			_expected_type = Z_EXPECTED_STRING; \
1480 			_error_code = ZPP_ERROR_WRONG_ARG; \
1481 			break; \
1482 		}
1483 
1484 #define Z_PARAM_STRING_EX(dest, dest_len, check_null, separate) \
1485 	Z_PARAM_STRING_EX2(dest, dest_len, check_null, separate, separate)
1486 
1487 #define Z_PARAM_STRING(dest, dest_len) \
1488 	Z_PARAM_STRING_EX(dest, dest_len, 0, 0)
1489 
1490 /* old "S" */
1491 #define Z_PARAM_STR_EX2(dest, check_null, deref, separate) \
1492 		Z_PARAM_PROLOGUE(deref, separate); \
1493 		if (UNEXPECTED(!zend_parse_arg_str(_arg, &dest, check_null))) { \
1494 			_expected_type = Z_EXPECTED_STRING; \
1495 			_error_code = ZPP_ERROR_WRONG_ARG; \
1496 			break; \
1497 		}
1498 
1499 #define Z_PARAM_STR_EX(dest, check_null, separate) \
1500 	Z_PARAM_STR_EX2(dest, check_null, separate, separate)
1501 
1502 #define Z_PARAM_STR(dest) \
1503 	Z_PARAM_STR_EX(dest, 0, 0)
1504 
1505 /* old "z" */
1506 #define Z_PARAM_ZVAL_EX2(dest, check_null, deref, separate) \
1507 		Z_PARAM_PROLOGUE(deref, separate); \
1508 		zend_parse_arg_zval_deref(_arg, &dest, check_null);
1509 
1510 #define Z_PARAM_ZVAL_EX(dest, check_null, separate) \
1511 	Z_PARAM_ZVAL_EX2(dest, check_null, separate, separate)
1512 
1513 #define Z_PARAM_ZVAL(dest) \
1514 	Z_PARAM_ZVAL_EX(dest, 0, 0)
1515 
1516 /* old "z" (with dereference) */
1517 #define Z_PARAM_ZVAL_DEREF_EX(dest, check_null, separate) \
1518 		Z_PARAM_PROLOGUE(1, separate); \
1519 		zend_parse_arg_zval_deref(_arg, &dest, check_null);
1520 
1521 #define Z_PARAM_ZVAL_DEREF(dest) \
1522 	Z_PARAM_ZVAL_DEREF_EX(dest, 0, 0)
1523 
1524 /* old "+" and "*" */
1525 #define Z_PARAM_VARIADIC_EX(spec, dest, dest_num, post_varargs) do { \
1526 		int _num_varargs = _num_args - _i - (post_varargs); \
1527 		if (EXPECTED(_num_varargs > 0)) { \
1528 			dest = _real_arg + 1; \
1529 			dest_num = _num_varargs; \
1530 			_i += _num_varargs; \
1531 			_real_arg += _num_varargs; \
1532 		} else { \
1533 			dest = NULL; \
1534 			dest_num = 0; \
1535 		} \
1536 	} while (0);
1537 
1538 #define Z_PARAM_VARIADIC(spec, dest, dest_num) \
1539 	Z_PARAM_VARIADIC_EX(spec, dest, dest_num, 0)
1540 
1541 /* End of new parameter parsing API */
1542 
1543 /* Inlined implementations shared by new and old parameter parsing APIs */
1544 
1545 ZEND_API int ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **pce, int num, int check_null);
1546 ZEND_API int ZEND_FASTCALL zend_parse_arg_bool_slow(zval *arg, zend_bool *dest);
1547 ZEND_API int ZEND_FASTCALL zend_parse_arg_bool_weak(zval *arg, zend_bool *dest);
1548 ZEND_API int ZEND_FASTCALL zend_parse_arg_long_slow(zval *arg, zend_long *dest);
1549 ZEND_API int ZEND_FASTCALL zend_parse_arg_long_weak(zval *arg, zend_long *dest);
1550 ZEND_API int ZEND_FASTCALL zend_parse_arg_long_cap_slow(zval *arg, zend_long *dest);
1551 ZEND_API int ZEND_FASTCALL zend_parse_arg_long_cap_weak(zval *arg, zend_long *dest);
1552 ZEND_API int ZEND_FASTCALL zend_parse_arg_double_slow(zval *arg, double *dest);
1553 ZEND_API int ZEND_FASTCALL zend_parse_arg_double_weak(zval *arg, double *dest);
1554 ZEND_API int ZEND_FASTCALL zend_parse_arg_str_slow(zval *arg, zend_string **dest);
1555 ZEND_API int ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, zend_string **dest);
1556 
zend_parse_arg_bool(zval *arg, zend_bool *dest, zend_bool *is_null, int check_null)1557 static zend_always_inline int zend_parse_arg_bool(zval *arg, zend_bool *dest, zend_bool *is_null, int check_null)
1558 {
1559 	if (check_null) {
1560 		*is_null = 0;
1561 	}
1562 	if (EXPECTED(Z_TYPE_P(arg) == IS_TRUE)) {
1563 		*dest = 1;
1564 	} else if (EXPECTED(Z_TYPE_P(arg) == IS_FALSE)) {
1565 		*dest = 0;
1566 	} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
1567 		*is_null = 1;
1568 		*dest = 0;
1569 	} else {
1570 		return zend_parse_arg_bool_slow(arg, dest);
1571 	}
1572 	return 1;
1573 }
1574 
zend_parse_arg_long(zval *arg, zend_long *dest, zend_bool *is_null, int check_null, int cap)1575 static zend_always_inline int zend_parse_arg_long(zval *arg, zend_long *dest, zend_bool *is_null, int check_null, int cap)
1576 {
1577 	if (check_null) {
1578 		*is_null = 0;
1579 	}
1580 	if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
1581 		*dest = Z_LVAL_P(arg);
1582 	} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
1583 		*is_null = 1;
1584 		*dest = 0;
1585 	} else if (cap) {
1586 		return zend_parse_arg_long_cap_slow(arg, dest);
1587 	} else {
1588 		return zend_parse_arg_long_slow(arg, dest);
1589 	}
1590 	return 1;
1591 }
1592 
zend_parse_arg_double(zval *arg, double *dest, zend_bool *is_null, int check_null)1593 static zend_always_inline int zend_parse_arg_double(zval *arg, double *dest, zend_bool *is_null, int check_null)
1594 {
1595 	if (check_null) {
1596 		*is_null = 0;
1597 	}
1598 	if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) {
1599 		*dest = Z_DVAL_P(arg);
1600 	} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
1601 		*is_null = 1;
1602 		*dest = 0.0;
1603 	} else {
1604 		return zend_parse_arg_double_slow(arg, dest);
1605 	}
1606 	return 1;
1607 }
1608 
zend_parse_arg_str(zval *arg, zend_string **dest, int check_null)1609 static zend_always_inline int zend_parse_arg_str(zval *arg, zend_string **dest, int check_null)
1610 {
1611 	if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) {
1612 		*dest = Z_STR_P(arg);
1613 	} else if (check_null && Z_TYPE_P(arg) == IS_NULL) {
1614 		*dest = NULL;
1615 	} else {
1616 		return zend_parse_arg_str_slow(arg, dest);
1617 	}
1618 	return 1;
1619 }
1620 
zend_parse_arg_string(zval *arg, char **dest, size_t *dest_len, int check_null)1621 static zend_always_inline int zend_parse_arg_string(zval *arg, char **dest, size_t *dest_len, int check_null)
1622 {
1623 	zend_string *str;
1624 
1625 	if (!zend_parse_arg_str(arg, &str, check_null)) {
1626 		return 0;
1627 	}
1628 	if (check_null && UNEXPECTED(!str)) {
1629 		*dest = NULL;
1630 		*dest_len = 0;
1631 	} else {
1632 		*dest = ZSTR_VAL(str);
1633 		*dest_len = ZSTR_LEN(str);
1634 	}
1635 	return 1;
1636 }
1637 
zend_parse_arg_path_str(zval *arg, zend_string **dest, int check_null)1638 static zend_always_inline int zend_parse_arg_path_str(zval *arg, zend_string **dest, int check_null)
1639 {
1640 	if (!zend_parse_arg_str(arg, dest, check_null) ||
1641 	    (*dest && UNEXPECTED(CHECK_NULL_PATH(ZSTR_VAL(*dest), ZSTR_LEN(*dest))))) {
1642 		return 0;
1643 	}
1644 	return 1;
1645 }
1646 
zend_parse_arg_path(zval *arg, char **dest, size_t *dest_len, int check_null)1647 static zend_always_inline int zend_parse_arg_path(zval *arg, char **dest, size_t *dest_len, int check_null)
1648 {
1649 	zend_string *str;
1650 
1651 	if (!zend_parse_arg_path_str(arg, &str, check_null)) {
1652 		return 0;
1653 	}
1654 	if (check_null && UNEXPECTED(!str)) {
1655 		*dest = NULL;
1656 		*dest_len = 0;
1657 	} else {
1658 		*dest = ZSTR_VAL(str);
1659 		*dest_len = ZSTR_LEN(str);
1660 	}
1661 	return 1;
1662 }
1663 
zend_parse_arg_array(zval *arg, zval **dest, int check_null, int or_object)1664 static zend_always_inline int zend_parse_arg_array(zval *arg, zval **dest, int check_null, int or_object)
1665 {
1666 	if (EXPECTED(Z_TYPE_P(arg) == IS_ARRAY) ||
1667 		(or_object && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT))) {
1668 		*dest = arg;
1669 	} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
1670 		*dest = NULL;
1671 	} else {
1672 		return 0;
1673 	}
1674 	return 1;
1675 }
1676 
zend_parse_arg_array_ht(zval *arg, HashTable **dest, int check_null, int or_object, int separate)1677 static zend_always_inline int zend_parse_arg_array_ht(zval *arg, HashTable **dest, int check_null, int or_object, int separate)
1678 {
1679 	if (EXPECTED(Z_TYPE_P(arg) == IS_ARRAY)) {
1680 		*dest = Z_ARRVAL_P(arg);
1681 	} else if (or_object && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) {
1682 		if (separate
1683 		 && Z_OBJ_P(arg)->properties
1684 		 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(arg)->properties) > 1)) {
1685 			if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(arg)->properties) & IS_ARRAY_IMMUTABLE))) {
1686 				GC_DELREF(Z_OBJ_P(arg)->properties);
1687 			}
1688 			Z_OBJ_P(arg)->properties = zend_array_dup(Z_OBJ_P(arg)->properties);
1689 		}
1690 		*dest = Z_OBJ_HT_P(arg)->get_properties(arg);
1691 	} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
1692 		*dest = NULL;
1693 	} else {
1694 		return 0;
1695 	}
1696 	return 1;
1697 }
1698 
zend_parse_arg_object(zval *arg, zval **dest, zend_class_entry *ce, int check_null)1699 static zend_always_inline int zend_parse_arg_object(zval *arg, zval **dest, zend_class_entry *ce, int check_null)
1700 {
1701 	if (EXPECTED(Z_TYPE_P(arg) == IS_OBJECT) &&
1702 	    (!ce || EXPECTED(instanceof_function(Z_OBJCE_P(arg), ce) != 0))) {
1703 		*dest = arg;
1704 	} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
1705 		*dest = NULL;
1706 	} else {
1707 		return 0;
1708 	}
1709 	return 1;
1710 }
1711 
zend_parse_arg_resource(zval *arg, zval **dest, int check_null)1712 static zend_always_inline int zend_parse_arg_resource(zval *arg, zval **dest, int check_null)
1713 {
1714 	if (EXPECTED(Z_TYPE_P(arg) == IS_RESOURCE)) {
1715 		*dest = arg;
1716 	} else if (check_null && EXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
1717 		*dest = NULL;
1718 	} else {
1719 		return 0;
1720 	}
1721 	return 1;
1722 }
1723 
zend_parse_arg_func(zval *arg, zend_fcall_info *dest_fci, zend_fcall_info_cache *dest_fcc, int check_null, char **error)1724 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)
1725 {
1726 	if (check_null && UNEXPECTED(Z_TYPE_P(arg) == IS_NULL)) {
1727 		dest_fci->size = 0;
1728 		dest_fcc->function_handler = NULL;
1729 		*error = NULL;
1730 	} else if (UNEXPECTED(zend_fcall_info_init(arg, 0, dest_fci, dest_fcc, NULL, error) != SUCCESS)) {
1731 		return 0;
1732 	}
1733 	return 1;
1734 }
1735 
zend_parse_arg_zval(zval *arg, zval **dest, int check_null)1736 static zend_always_inline void zend_parse_arg_zval(zval *arg, zval **dest, int check_null)
1737 {
1738 	*dest = (check_null &&
1739 	    (UNEXPECTED(Z_TYPE_P(arg) == IS_NULL) ||
1740 	     (UNEXPECTED(Z_ISREF_P(arg)) &&
1741 	      UNEXPECTED(Z_TYPE_P(Z_REFVAL_P(arg)) == IS_NULL)))) ? NULL : arg;
1742 }
1743 
zend_parse_arg_zval_deref(zval *arg, zval **dest, int check_null)1744 static zend_always_inline void zend_parse_arg_zval_deref(zval *arg, zval **dest, int check_null)
1745 {
1746 	*dest = (check_null && UNEXPECTED(Z_TYPE_P(arg) == IS_NULL)) ? NULL : arg;
1747 }
1748 
1749 END_EXTERN_C()
1750 
1751 #endif /* ZEND_API_H */
1752