some type cleanup work

diff --git a/Zend/zend.h b/Zend/zend.h
index 7e8624949b1b4e1ec5ac58970f48198e9c5d0711..e4f5f90b263d292d87ee0218aa0e86f48ed80590 100644 (file)
--- 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 6efa0ff214690b664a08d0928dac4986469503da..67db62a218850352abf462e244b2cb4b513a87c5 100644 (file)
--- 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 be5e8b1861168d081905bee5f057936cc180b301..2d028b8529e23149cb350cd61b515fd379e9de74 100644 (file)
--- 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 a1a2797ca51ef6bcf8bca8fe95c2a8c6b9e0019d..42d5f77af457959220632a21f56acb15bfaf8755 100644 (file)
--- 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 64f4535d7f979630d6f0ee9c06f1bdbcfc05de22..acc1d20cbb8d85c54580dd37664a37ef4f971515 100644 (file)
--- 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 4dc3a1726198279bef19b220283bc430e2d3a13a..4c8e850f809dd49fe03a3f4ee4ba24be11da58e6 100644 (file)
--- 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 d1150f520cf4dd953ac9cf628f42ade7fba34300..400ad892b32042d5eb4b972232b3b40aefe7d488 100644 (file)
--- 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 f4ee73dbf635eefa6dfff5b676e03f97a66decce..888e6eb011e76c67b3d44ed7ea914cb42c145f85 100644 (file)
--- 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 7d878eb4ee4ee8a84389c66800e9b1e995618117..278745459010cd04def86eaa0df0d03bd799235e 100644 (file)
--- 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 d4c50560d42100d0fb29e3c0e3f976b79f326993..849e67e1fecc90746623807fe7e3adde3edbeb0d 100644 (file)
--- 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 5e5571e13442a21af51f4e721cf7f7739ad0e02a..c28b38d46b0cb63b4ed530ca1102c51f41e81514 100644 (file)
--- 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 221dee43ae52bcdfd384ee89d2fd04a878a7f760..62d80e29ef1ac9bcb12e3cfca5129d46ccbb2e0f 100644 (file)
--- 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 a74be6b6a33744e301454e7cdeec514b0d4ccab3..4309e78e3c18d0a442f761e932c15a1eca8a26ea 100644 (file)
--- 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 f7ce84423aeb3ca0c6dceedc1d8031aad675eafa..720aaf2e2145bdcfcf63c43a272a3739fb57f0a8 100644 (file)
--- 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 8fe36d32356bfb84fe6783a735612a2b138fb487..f455647da2ebc97083d7d00d624331b78c118a23 100644 (file)
--- 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 abd8e032dadee07a7c16cca383f1cd172cb71e84..a9d3a23d294693667c628e626310e0474b845741 100644 (file)
--- 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);