Convert some macros to inline functions

Zend/zend.h

@@ -298,8 +298,9 @@ ZEND_API zend_string *zend_print_zval_r_to_str(zval *expr, int indent);
 ZEND_API void zend_print_flat_zval_r(zval *expr);
 void zend_print_flat_zval_r_to_buf(smart_str *str, zval *expr);
 
-#define zend_print_variable(var) \
-	zend_print_zval((var), 0)
+static zend_always_inline size_t zend_print_variable(zval *var) {
+	return zend_print_zval(var, 0);
+}
 
 ZEND_API ZEND_COLD void zend_output_debug_string(bool trigger_break, const char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
 

Zend/zend_API.c

@@ -43,7 +43,7 @@ static zend_module_entry **module_post_deactivate_handlers;
 
 static zend_class_entry  **class_cleanup_handlers;
 
-ZEND_API zend_result _zend_get_parameters_array_ex(uint32_t param_count, zval *argument_array) /* {{{ */
+ZEND_API zend_result zend_get_parameters_array_ex(uint32_t param_count, zval *argument_array) /* {{{ */
 {
 	zval *param_ptr;
 	uint32_t arg_count;

Zend/zend_API.h

@@ -329,15 +329,13 @@ typedef struct _zend_fcall_info_cache {
 ZEND_API int zend_next_free_module(void);
 
 BEGIN_EXTERN_C()
-ZEND_API zend_result _zend_get_parameters_array_ex(uint32_t param_count, zval *argument_array);
+ZEND_API zend_result zend_get_parameters_array_ex(uint32_t param_count, zval *argument_array);
 
 /* internal function to efficiently copy parameters when executing __call() */
 ZEND_API zend_result zend_copy_parameters_array(uint32_t param_count, zval *argument_array);
 
 #define zend_get_parameters_array(ht, param_count, argument_array) \
-	_zend_get_parameters_array_ex(param_count, argument_array)
-#define zend_get_parameters_array_ex(param_count, argument_array) \
-	_zend_get_parameters_array_ex(param_count, argument_array)
+	zend_get_parameters_array_ex(param_count, argument_array)
 #define zend_parse_parameters_none() \
 	(EXPECTED(ZEND_NUM_ARGS() == 0) ? SUCCESS : (zend_wrong_parameters_none_error(), FAILURE))
 #define zend_parse_parameters_none_throw() \
@@ -382,8 +380,9 @@ ZEND_API void zend_class_implements(zend_class_entry *class_entry, int num_inter
 
 ZEND_API zend_result zend_register_class_alias_ex(const char *name, size_t name_len, zend_class_entry *ce, bool persistent);
 
-#define zend_register_class_alias(name, ce) \
-	zend_register_class_alias_ex(name, sizeof(name)-1, ce, 1)
+static zend_always_inline zend_result zend_register_class_alias(const char *name, zend_class_entry *ce) {
+	return zend_register_class_alias_ex(name, strlen(name), ce, 1);
+}
 #define zend_register_ns_class_alias(ns, name, ce) \
 	zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce, 1)
 
@@ -540,18 +539,42 @@ ZEND_API void add_assoc_object_ex(zval *arg, const char *key, size_t key_len, ze
 ZEND_API void add_assoc_reference_ex(zval *arg, const char *key, size_t key_len, zend_reference *ref);
 ZEND_API void add_assoc_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
 
-#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
-#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key))
-#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key), __b)
-#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key), __r)
-#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
-#define add_assoc_str(__arg, __key, __str) add_assoc_str_ex(__arg, __key, strlen(__key), __str)
-#define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
-#define add_assoc_stringl(__arg, __key, __str, __length) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
-#define add_assoc_array(__arg, __key, __arr) add_assoc_array_ex(__arg, __key, strlen(__key), __arr)
-#define add_assoc_object(__arg, __key, __obj) add_assoc_object_ex(__arg, __key, strlen(__key), __obj)
-#define add_assoc_reference(__arg, __key, __ref) add_assoc_object_ex(__arg, __key, strlen(__key), __ref)
-#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
+static zend_always_inline void add_assoc_long(zval *arg, const char *key, zend_long n) {
+	add_assoc_long_ex(arg, key, strlen(key), n);
+}
+static zend_always_inline void add_assoc_null(zval *arg, const char *key) {
+	add_assoc_null_ex(arg, key, strlen(key));
+}
+static zend_always_inline void add_assoc_bool(zval *arg, const char *key, bool b) {
+	add_assoc_bool_ex(arg, key, strlen(key), b);
+}
+static zend_always_inline void add_assoc_resource(zval *arg, const char *key, zend_resource *r) {
+	add_assoc_resource_ex(arg, key, strlen(key), r);
+}
+static zend_always_inline void add_assoc_double(zval *arg, const char *key, double d) {
+	add_assoc_double_ex(arg, key, strlen(key), d);
+}
+static zend_always_inline void add_assoc_str(zval *arg, const char *key, zend_string *str) {
+	add_assoc_str_ex(arg, key, strlen(key), str);
+}
+static zend_always_inline void add_assoc_string(zval *arg, const char *key, const char *str) {
+	add_assoc_string_ex(arg, key, strlen(key), str);
+}
+static zend_always_inline void add_assoc_stringl(zval *arg, const char *key, const char *str, size_t length) {
+	add_assoc_stringl_ex(arg, key, strlen(key), str, length);
+}
+static zend_always_inline void add_assoc_array(zval *arg, const char *key, zend_array *arr) {
+	add_assoc_array_ex(arg, key, strlen(key), arr);
+}
+static zend_always_inline void add_assoc_object(zval *arg, const char *key, zend_object *obj) {
+	add_assoc_object_ex(arg, key, strlen(key), obj);
+}
+static zend_always_inline void add_assoc_reference(zval *arg, const char *key, zend_reference *ref) {
+	add_assoc_reference_ex(arg, key, strlen(key), ref);
+}
+static zend_always_inline void add_assoc_zval(zval *arg, const char *key, zval *value) {
+	add_assoc_zval_ex(arg, key, strlen(key), value);
+}
 
 ZEND_API void add_index_long(zval *arg, zend_ulong index, zend_long n);
 ZEND_API void add_index_null(zval *arg, zend_ulong index);
@@ -602,19 +625,42 @@ ZEND_API void add_property_object_ex(zval *arg, const char *key, size_t key_len,
 ZEND_API void add_property_reference_ex(zval *arg, const char *key, size_t key_len, zend_reference *ref);
 ZEND_API void add_property_zval_ex(zval *arg, const char *key, size_t key_len, zval *value);
 
-#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n)
-#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key))
-#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b)
-#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r)
-#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d)
-#define add_property_str(__arg, __key, __str) add_property_str_ex(__arg, __key, strlen(__key), __str)
-#define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str)
-#define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length)
-#define add_property_array(__arg, __key, __arr) add_property_array_ex(__arg, __key, strlen(__key), __arr)
-#define add_property_object(__arg, __key, __obj) add_property_object_ex(__arg, __key, strlen(__key), __obj)
-#define add_property_reference(__arg, __key, __ref) add_property_reference_ex(__arg, __key, strlen(__key), __ref)
-#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value)
-
+static zend_always_inline void add_property_long(zval *arg, const char *key, zend_long n) {
+	add_property_long_ex(arg, key, strlen(key), n);
+}
+static zend_always_inline void add_property_null(zval *arg, const char *key) {
+	add_property_null_ex(arg, key, strlen(key));
+}
+static zend_always_inline void add_property_bool(zval *arg, const char *key, bool b) {
+	add_property_bool_ex(arg, key, strlen(key), b);
+}
+static zend_always_inline void add_property_resource(zval *arg, const char *key, zend_resource *r) {
+	add_property_resource_ex(arg, key, strlen(key), r);
+}
+static zend_always_inline void add_property_double(zval *arg, const char *key, double d) {
+	add_property_double_ex(arg, key, strlen(key), d);
+}
+static zend_always_inline void add_property_str(zval *arg, const char *key, zend_string *str) {
+	add_property_str_ex(arg, key, strlen(key), str);
+}
+static zend_always_inline void add_property_string(zval *arg, const char *key, const char *str) {
+	add_property_string_ex(arg, key, strlen(key), str);
+}
+static zend_always_inline void add_property_stringl(zval *arg, const char *key, const char *str, size_t length) {
+	add_property_stringl_ex(arg, key, strlen(key), str, length);
+}
+static zend_always_inline void add_property_array(zval *arg, const char *key, zend_array *arr) {
+	add_property_array_ex(arg, key, strlen(key), arr);
+}
+static zend_always_inline void add_property_object(zval *arg, const char *key, zend_object *obj) {
+	add_property_object_ex(arg, key, strlen(key), obj);
+}
+static zend_always_inline void add_property_reference(zval *arg, const char *key, zend_reference *ref) {
+	add_property_reference_ex(arg, key, strlen(key), ref);
+}
+static zend_always_inline void add_property_zval(zval *arg, const char *key, zval *value) {
+	add_property_zval_ex(arg, key, strlen(key), value);
+}
 
 ZEND_API zend_result _call_user_function_impl(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], HashTable *named_params);
 

Zend/zend_hash.c

@@ -2716,7 +2716,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_hash_move_backwards_ex(HashTable *ht, Ha
 
 
 /* This function should be made binary safe  */
-ZEND_API int ZEND_FASTCALL zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_ulong *num_index, HashPosition *pos)
+ZEND_API int ZEND_FASTCALL zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_ulong *num_index, const HashPosition *pos)
 {
 	uint32_t idx;
 	Bucket *p;
@@ -2740,7 +2740,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_get_current_key_ex(const HashTable *ht, zen
 	return HASH_KEY_NON_EXISTENT;
 }
 
-ZEND_API void ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos)
+ZEND_API void ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, const HashPosition *pos)
 {
 	uint32_t idx;
 	Bucket *p;

Zend/zend_hash.h

@@ -22,6 +22,7 @@
 #define ZEND_HASH_H
 
 #include "zend.h"
+#include "zend_sort.h"
 
 #define HASH_KEY_IS_STRING 1
 #define HASH_KEY_IS_LONG 2
@@ -244,35 +245,45 @@ static zend_always_inline bool zend_hash_index_exists(const HashTable *ht, zend_
 /* traversing */
 ZEND_API HashPosition ZEND_FASTCALL zend_hash_get_current_pos(const HashTable *ht);
 
-#define zend_hash_has_more_elements_ex(ht, pos) \
-	(zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS)
 ZEND_API zend_result   ZEND_FASTCALL zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
 ZEND_API zend_result   ZEND_FASTCALL zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int   ZEND_FASTCALL zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_ulong *num_index, HashPosition *pos);
-ZEND_API void  ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
+ZEND_API int   ZEND_FASTCALL zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_ulong *num_index, const HashPosition *pos);
+ZEND_API void  ZEND_FASTCALL zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, const HashPosition *pos);
 ZEND_API int   ZEND_FASTCALL zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
 ZEND_API zval* ZEND_FASTCALL zend_hash_get_current_data_ex(HashTable *ht, HashPosition *pos);
 ZEND_API void  ZEND_FASTCALL zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
 ZEND_API void  ZEND_FASTCALL zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
 
-#define zend_hash_has_more_elements(ht) \
-	zend_hash_has_more_elements_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_move_forward(ht) \
-	zend_hash_move_forward_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_move_backwards(ht) \
-	zend_hash_move_backwards_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_get_current_key(ht, str_index, num_index) \
-	zend_hash_get_current_key_ex(ht, str_index, num_index, &(ht)->nInternalPointer)
-#define zend_hash_get_current_key_zval(ht, key) \
-	zend_hash_get_current_key_zval_ex(ht, key, &(ht)->nInternalPointer)
-#define zend_hash_get_current_key_type(ht) \
-	zend_hash_get_current_key_type_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_get_current_data(ht) \
-	zend_hash_get_current_data_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_internal_pointer_reset(ht) \
-	zend_hash_internal_pointer_reset_ex(ht, &(ht)->nInternalPointer)
-#define zend_hash_internal_pointer_end(ht) \
-	zend_hash_internal_pointer_end_ex(ht, &(ht)->nInternalPointer)
+static zend_always_inline zend_result zend_hash_has_more_elements_ex(HashTable *ht, HashPosition *pos) {
+	return (zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS);
+}
+static zend_always_inline zend_result zend_hash_has_more_elements(HashTable *ht) {
+	return zend_hash_has_more_elements_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline zend_result zend_hash_move_forward(HashTable *ht) {
+	return zend_hash_move_forward_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline zend_result zend_hash_move_backwards(HashTable *ht) {
+	return zend_hash_move_backwards_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline int zend_hash_get_current_key(const HashTable *ht, zend_string **str_index, zend_ulong *num_index) {
+	return zend_hash_get_current_key_ex(ht, str_index, num_index, &ht->nInternalPointer);
+}
+static zend_always_inline void zend_hash_get_current_key_zval(const HashTable *ht, zval *key) {
+	zend_hash_get_current_key_zval_ex(ht, key, &ht->nInternalPointer);
+}
+static zend_always_inline int zend_hash_get_current_key_type(HashTable *ht) {
+	return zend_hash_get_current_key_type_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline zval* zend_hash_get_current_data(HashTable *ht) {
+	return zend_hash_get_current_data_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline void zend_hash_internal_pointer_reset(HashTable *ht) {
+	zend_hash_internal_pointer_reset_ex(ht, &ht->nInternalPointer);
+}
+static zend_always_inline void zend_hash_internal_pointer_end(HashTable *ht) {
+	zend_hash_internal_pointer_end_ex(ht, &ht->nInternalPointer);
+}
 
 /* Copying, merging and sorting */
 ZEND_API void  ZEND_FASTCALL zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor);
@@ -287,14 +298,17 @@ ZEND_API int   zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t
 ZEND_API void  ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, bucket_compare_func_t compare_func, bool renumber);
 ZEND_API zval* ZEND_FASTCALL zend_hash_minmax(const HashTable *ht, compare_func_t compar, uint32_t flag);
 
-#define zend_hash_sort(ht, compare_func, renumber) \
-	zend_hash_sort_ex(ht, zend_sort, compare_func, renumber)
+static zend_always_inline void ZEND_FASTCALL zend_hash_sort(HashTable *ht, bucket_compare_func_t compare_func, zend_bool renumber) {
+	zend_hash_sort_ex(ht, zend_sort, compare_func, renumber);
+}
 
-#define zend_hash_num_elements(ht) \
-	(ht)->nNumOfElements
+static zend_always_inline uint32_t zend_hash_num_elements(const HashTable *ht) {
+	return ht->nNumOfElements;
+}
 
-#define zend_hash_next_free_element(ht) \
-	(ht)->nNextFreeElement
+static zend_always_inline zend_long zend_hash_next_free_element(const HashTable *ht) {
+	return ht->nNextFreeElement;
+}
 
 ZEND_API void ZEND_FASTCALL zend_hash_rehash(HashTable *ht);
 

Zend/zend_inheritance.h

@@ -27,8 +27,9 @@ BEGIN_EXTERN_C()
 ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface);
 ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *parent_ce, bool checked);
 
-#define zend_do_inheritance(ce, parent_ce) \
-	zend_do_inheritance_ex(ce, parent_ce, 0)
+static zend_always_inline void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce) {
+	zend_do_inheritance_ex(ce, parent_ce, 0);
+}
 
 ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_name, zend_string *key);
 

Zend/zend_interfaces.h

@@ -40,14 +40,23 @@ typedef struct _zend_user_iterator {
 
 ZEND_API zval* zend_call_method(zend_object *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval, uint32_t param_count, zval* arg1, zval* arg2);
 
-#define zend_call_method_with_0_params(obj, obj_ce, fn_proxy, function_name, retval) \
-	zend_call_method(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 0, NULL, NULL)
-
-#define zend_call_method_with_1_params(obj, obj_ce, fn_proxy, function_name, retval, arg1) \
-	zend_call_method(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 1, arg1, NULL)
-
-#define zend_call_method_with_2_params(obj, obj_ce, fn_proxy, function_name, retval, arg1, arg2) \
-	zend_call_method(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 2, arg1, arg2)
+static zend_always_inline zval* zend_call_method_with_0_params(zend_object *object, zend_class_entry *obj_ce,
+		zend_function **fn_proxy, const char *function_name, zval *retval)
+{
+	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 0, NULL, NULL);
+}
+
+static zend_always_inline zval* zend_call_method_with_1_params(zend_object *object, zend_class_entry *obj_ce,
+		zend_function **fn_proxy, const char *function_name, zval *retval, zval* arg1)
+{
+	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 1, arg1, NULL);
+}
+
+static zend_always_inline zval* zend_call_method_with_2_params(zend_object *object, zend_class_entry *obj_ce,
+		zend_function **fn_proxy, const char *function_name, zval *retval, zval* arg1, zval* arg2)
+{
+	return zend_call_method(object, obj_ce, fn_proxy, function_name, strlen(function_name), retval, 2, arg1, arg2);
+}
 
 ZEND_API void zend_user_it_rewind(zend_object_iterator *_iter);
 ZEND_API zend_result zend_user_it_valid(zend_object_iterator *_iter);

Zend/zend_llist.h

@@ -66,10 +66,25 @@ ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos);
 ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos);
 ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos);
 
-#define zend_llist_get_first(l) zend_llist_get_first_ex(l, NULL)
-#define zend_llist_get_last(l) zend_llist_get_last_ex(l, NULL)
-#define zend_llist_get_next(l) zend_llist_get_next_ex(l, NULL)
-#define zend_llist_get_prev(l) zend_llist_get_prev_ex(l, NULL)
+static zend_always_inline void *zend_llist_get_first(zend_llist *l)
+{
+	return zend_llist_get_first_ex(l, NULL);
+}
+
+static zend_always_inline void *zend_llist_get_last(zend_llist *l)
+{
+	return zend_llist_get_last_ex(l, NULL);
+}
+
+static zend_always_inline void *zend_llist_get_next(zend_llist *l)
+{
+	return zend_llist_get_next_ex(l, NULL);
+}
+
+static zend_always_inline void *zend_llist_get_prev(zend_llist *l)
+{
+	return zend_llist_get_prev_ex(l, NULL);
+}
 
 END_EXTERN_C()
 

Zend/zend_operators.h

@@ -450,8 +450,12 @@ ZEND_API char*        ZEND_FASTCALL zend_str_toupper_dup_ex(const char *source,
 ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower_ex(zend_string *str, bool persistent);
 ZEND_API zend_string* ZEND_FASTCALL zend_string_toupper_ex(zend_string *str, bool persistent);
 
-#define zend_string_tolower(str) zend_string_tolower_ex(str, 0)
-#define zend_string_toupper(str) zend_string_toupper_ex(str, 0)
+static zend_always_inline zend_string* zend_string_tolower(zend_string *str) {
+	return zend_string_tolower_ex(str, false);
+}
+static zend_always_inline zend_string* zend_string_toupper(zend_string *str) {
+	return zend_string_toupper_ex(str, false);
+}
 
 ZEND_API int ZEND_FASTCALL zend_binary_zval_strcmp(zval *s1, zval *s2);
 ZEND_API int ZEND_FASTCALL zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3);