some type cleanup work

16 files changed, 49 insertions, 49 deletions

diff --git a/Zend/zend.h b/Zend/zend.h
index 7e8624949b..e4f5f90b26 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -221,7 +221,7 @@ typedef union _zvalue_value {
 	double dval;				/* double value */
 	struct {
 		char *val;
-		int len;
+		zend_uint len;
 	} str;
 	HashTable *ht;				/* hash table value */
 /*	struct {
@@ -272,7 +272,7 @@ union _zend_function;
 struct _zend_class_entry {
 	char type;
 	char *name;
-	uint name_length;
+	zend_uint name_length;
 	struct _zend_class_entry *parent; 
 	int refcount;
 	zend_bool constants_updated;
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 6efa0ff214..67db62a218 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1272,7 +1272,7 @@ ZEND_API zend_module_entry *zend_get_module(int module_number)
 }
 
 ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
-                                  int is_ref, int num_symbol_tables, ...)
+                                  zend_bool is_ref, int num_symbol_tables, ...)
 {
     HashTable  *symbol_table;
     va_list     symbol_table_list;
@@ -1320,7 +1320,7 @@ ZEND_API int zend_disable_function(char *function_name, uint function_name_lengt
 zend_bool zend_is_callable(zval *callable, zend_bool syntax_only, char **callable_name)
 {
 	char *lcname;
-	int retval = 0;
+	zend_bool retval = 0;
 	TSRMLS_FETCH();
 
 	switch (Z_TYPE_P(callable)) {
@@ -1343,7 +1343,7 @@ zend_bool zend_is_callable(zval *callable, zend_bool syntax_only, char **callabl
 				zval **method;
 				zval **obj;
 				zend_class_entry *ce = NULL, **pce;
-				char callable_name_len;
+				zend_uint callable_name_len;
 				
 				if (zend_hash_num_elements(Z_ARRVAL_P(callable)) == 2 &&
 					zend_hash_index_find(Z_ARRVAL_P(callable), 0, (void **) &obj) == SUCCESS &&
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index be5e8b1861..2d028b8529 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -252,7 +252,7 @@ ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zva
 ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_ptr, int param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);
 
 ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
-                                  int is_ref, int num_symbol_tables, ...);
+                                  zend_bool is_ref, int num_symbol_tables, ...);
 
 #define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
 
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index a1a2797ca5..42d5f77af4 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -492,7 +492,7 @@ ZEND_FUNCTION(get_class)
 {
 	zval **arg;
 	char *name;
-	int name_len;
+	zend_uint name_len;
 	
 	if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &arg)==FAILURE) {
 		ZEND_WRONG_PARAM_COUNT();
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 64f4535d7f..acc1d20cbb 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -156,7 +156,7 @@ static zend_uint get_temporary_variable(zend_op_array *op_array)
 }
 
 
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
+void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -169,7 +169,7 @@ void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
 }
 
 
-void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC)
+void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -200,7 +200,7 @@ static void zend_replace_object_fetch(zend_op *last_op, znode *value TSRMLS_DC)
 	}
 }
 
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
+void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
 	int last_op_number = get_next_op_number(CG(active_op_array))-1;
 	zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number];
@@ -264,7 +264,7 @@ void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRM
 }
 
 
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC)
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC)
 {
 	zend_op opline;
 	zend_op *opline_ptr;
@@ -518,7 +518,7 @@ void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC)
 }
 
 
-void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC)
+void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC)
 {
 	int last_op_number = get_next_op_number(CG(active_op_array))-1;
 	zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number];
@@ -543,7 +543,7 @@ void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC)
 }
 
 
-void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC)
+void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC)
 {
 	int last_op_number = get_next_op_number(CG(active_op_array))-1;
 	zend_op *last_op = &CG(active_op_array)->opcodes[last_op_number];
@@ -990,7 +990,7 @@ void zend_do_end_function_declaration(znode *function_token TSRMLS_DC)
 }
 
 
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC)
+void zend_do_receive_arg(zend_uchar op, znode *var, znode *offset, znode *initialization, zend_uchar pass_type TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -1224,7 +1224,7 @@ void zend_do_end_function_call(znode *function_name, znode *result, znode *argum
 }
 
 
-void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC)
+void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC)
 {
 	zend_op *opline;
 	unsigned char *arg_types;
@@ -1828,7 +1828,7 @@ void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr
 }
 
 
-void zend_do_brk_cont(int op, znode *expr TSRMLS_DC)
+void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -2363,7 +2363,7 @@ void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC)
 
 
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
+void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -2386,7 +2386,7 @@ void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TS
 }
 
 
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC)
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 4dc3a17261..4c8e850f80 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -223,13 +223,13 @@ int zend_get_zendleng(TSRMLS_D);
 
 
 /* parser-driven code generators */
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC);
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC);
+void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
 void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
 void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
 void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC);
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC);
 void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC);
 void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
 
@@ -257,8 +257,8 @@ void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
 void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC);
 void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC);
 
-void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC);
+void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
+void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
 
 void zend_do_begin_variable_parse(TSRMLS_D);
 void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC);
@@ -274,7 +274,7 @@ void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
 
 void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference TSRMLS_DC);
 void zend_do_end_function_declaration(znode *function_token TSRMLS_DC);
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC);
+void zend_do_receive_arg(zend_uchar op, znode *var, znode *offset, znode *initialization, zend_uchar pass_type TSRMLS_DC);
 int zend_do_begin_function_call(znode *function_name TSRMLS_DC);
 void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC);
 void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC);
@@ -293,7 +293,7 @@ ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_tabl
 void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
 void zend_do_early_binding(TSRMLS_D);
 
-void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC);
+void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC);
 
 
 void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
@@ -301,7 +301,7 @@ void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op
 void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);               
 void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
 
-void zend_do_brk_cont(int op, znode *expr TSRMLS_DC);
+void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC);
 
 void zend_do_switch_cond(znode *cond TSRMLS_DC);
 void zend_do_switch_end(znode *case_list TSRMLS_DC);
@@ -327,8 +327,8 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 
 void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
+void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
 void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
 void zend_do_list_init(TSRMLS_D);
 void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
@@ -382,7 +382,7 @@ ZEND_API zend_op_array *compile_string(zval *source_string, char *filename TSRML
 ZEND_API zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC);
 ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_count, ...);
 ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC);
-ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC);
+ZEND_API void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC);
 ZEND_API void destroy_op_array(zend_op_array *op_array);
 ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC);
 ZEND_API void zend_file_handle_dtor(zend_file_handle *fh);
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index d1150f520c..400ad892b3 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -427,7 +427,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
 							break;
 						}
 						if (T->EA.data.str_offset.offset >= T->EA.data.str_offset.str->value.str.len) {
-							int i;
+							zend_uint i;
 
 							if (T->EA.data.str_offset.str->value.str.len==0) {
 								STR_FREE(T->EA.data.str_offset.str->value.str.val);
@@ -493,7 +493,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
 	
 	if (PZVAL_IS_REF(variable_ptr)) {
 		if (variable_ptr!=value) {
-			short refcount=variable_ptr->refcount;
+			zend_uint refcount = variable_ptr->refcount;
 			zval garbage;
 	
 			if (type!=IS_TMP_VAR) {
@@ -1814,7 +1814,7 @@ binary_assign_op_addr_obj:
 						zval *class_name;
 						zend_bool is_const;
 						char *class_name_strval;
-						int class_name_strlen;
+						zend_uint class_name_strlen;
 						
 						if (EX(opline)->extended_value == ZEND_FETCH_CLASS_SELF) {
 							if (!EG(scope)) {
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index f4ee73dbf6..888e6eb011 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -38,7 +38,7 @@ typedef union _temp_variable {
 		union {
 			struct {
 				zval *str;
-				int offset;
+				zend_uint offset;
 			} str_offset;
 			zend_property_reference overloaded_element;
 		} data;
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 7d878eb4ee..2787454590 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -642,7 +642,7 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSR
 	zend_op_array *new_op_array;
 	zend_op_array *original_active_op_array = EG(active_op_array);
 	zend_function_state *original_function_state_ptr = EG(function_state_ptr);
-	int original_handle_op_arrays;
+	zend_uchar original_handle_op_arrays;
 	int retval;
 
 	if (retval_ptr) {
diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index d4c50560d4..849e67e1fe 100644
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -161,7 +161,7 @@ ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength)
 	}
 
 
-ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent)
+ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent)
 {
 	uint i = 3;
 
@@ -194,7 +194,7 @@ ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction
 }
 
 
-ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection)
+ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection)
 {
 	int retval = zend_hash_init(ht, nSize, pHashFunction, pDestructor, persistent);
 
diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 5e5571e134..c28b38d46b 100644
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -76,8 +76,8 @@ typedef Bucket* HashPosition;
 BEGIN_EXTERN_C()
 
 /* startup/shutdown */
-ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent);
-ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection);
+ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent);
+ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection);
 ZEND_API void zend_hash_destroy(HashTable *ht);
 ZEND_API void zend_hash_clean(HashTable *ht);
 
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 221dee43ae..62d80e29ef 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -50,7 +50,7 @@ static void op_array_alloc_ops(zend_op_array *op_array)
 
 
 
-void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC)
+void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC)
 {
 	op_array->type = type;
 
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index a74be6b6a3..4309e78e3c 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -839,7 +839,7 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC)
 		return SUCCESS;
 	}
 	if (op1->type == IS_STRING) {
-		int i;
+		zend_uint i;
 
 		result->type = IS_STRING;
 		result->value.str.val = estrndup(op1->value.str.val, op1->value.str.len);
@@ -861,7 +861,7 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 	if (op1->type == IS_STRING && op2->type == IS_STRING) {
 		zval *longer, *shorter;
 		char *result_str;
-		int i, result_len;
+		zend_uint i, result_len;
 
 		if (op1->value.str.len >= op2->value.str.len) {
 			longer = op1;
@@ -900,7 +900,7 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 	if (op1->type == IS_STRING && op2->type == IS_STRING) {
 		zval *longer, *shorter;
 		char *result_str;
-		int i, result_len;
+		zend_uint i, result_len;
 
 		if (op1->value.str.len >= op2->value.str.len) {
 			longer = op1;
@@ -941,7 +941,7 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 	if (op1->type == IS_STRING && op2->type == IS_STRING) {
 		zval *longer, *shorter;
 		char *result_str;
-		int i, result_len;
+		zend_uint i, result_len;
 
 		if (op1->value.str.len >= op2->value.str.len) {
 			longer = op1;
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index f7ce84423a..720aaf2e21 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -58,7 +58,7 @@ ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
 ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
 
-static inline int is_numeric_string(char *str, int length, long *lval, double *dval, zend_bool allow_errors)
+static inline zend_bool is_numeric_string(char *str, int length, long *lval, double *dval, zend_bool allow_errors)
 {
 	long local_lval;
 	double local_dval;
diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c
index 8fe36d3235..f455647da2 100644
--- a/Zend/zend_ts_hash.c
+++ b/Zend/zend_ts_hash.c
@@ -50,7 +50,7 @@ static void end_write(TsHashTable *ht)
 }
 
 /* delegates */
-ZEND_API int zend_ts_hash_init(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent)
+ZEND_API int zend_ts_hash_init(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent)
 {
 	ht->mx_reader = tsrm_mutex_alloc();
 	ht->mx_writer = tsrm_mutex_alloc();
@@ -58,7 +58,7 @@ ZEND_API int zend_ts_hash_init(TsHashTable *ht, uint nSize, hash_func_t pHashFun
 	return zend_hash_init(&(ht->hash), nSize, pHashFunction, pDestructor, persistent);
 }
 
-ZEND_API int zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection)
+ZEND_API int zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection)
 {
 	ht->mx_reader = tsrm_mutex_alloc();
 	ht->mx_writer = tsrm_mutex_alloc();
diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h
index abd8e032da..a9d3a23d29 100644
--- a/Zend/zend_ts_hash.h
+++ b/Zend/zend_ts_hash.h
@@ -33,8 +33,8 @@ typedef struct _zend_ts_hashtable {
 BEGIN_EXTERN_C()
 
 /* startup/shutdown */
-ZEND_API int zend_ts_hash_init(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent);
-ZEND_API int zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection);
+ZEND_API int zend_ts_hash_init(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent);
+ZEND_API int zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection);
 ZEND_API void zend_ts_hash_destroy(TsHashTable *ht);
 ZEND_API void zend_ts_hash_clean(TsHashTable *ht);