diff options
172 files changed, 4452 insertions, 4332 deletions
diff --git a/TSRM/TSRM.h b/TSRM/TSRM.h index b232429d4d..82e272db5b 100644 --- a/TSRM/TSRM.h +++ b/TSRM/TSRM.h @@ -64,7 +64,7 @@ typedef int ts_rsrc_id; /* Define THREAD_T and MUTEX_T */ #ifdef TSRM_WIN32 -# define THREAD_T DWORD +# define THREAD_T UINT_PTR # define MUTEX_T CRITICAL_SECTION * #elif defined(GNUPTH) # define THREAD_T pth_t diff --git a/Zend/Zend.m4 b/Zend/Zend.m4 index 945409eb1e..8a676cba15 100644 --- a/Zend/Zend.m4 +++ b/Zend/Zend.m4 @@ -130,7 +130,7 @@ int main() exit(1); } ], [ - AC_DEFINE([ZEND_DVAL_TO_LVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits]) + AC_DEFINE([ZEND_DVAL_TO_IVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits]) AC_MSG_RESULT(yes) ], [ AC_MSG_RESULT(no) diff --git a/Zend/zend.c b/Zend/zend.c index 913462bec7..d571bdbaaf 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -46,7 +46,7 @@ /* true multithread-shared globals */ ZEND_API zend_class_entry *zend_standard_class_def = NULL; -ZEND_API int (*zend_printf)(const char *format, ...); +ZEND_API zend_size_t (*zend_printf)(const char *format, ...); ZEND_API zend_write_func_t zend_write; ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC); ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC); @@ -54,14 +54,14 @@ ZEND_API void (*zend_block_interruptions)(void); ZEND_API void (*zend_unblock_interruptions)(void); ZEND_API void (*zend_ticks_function)(int ticks TSRMLS_DC); ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args); -int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap); +zend_size_t (*zend_vspprintf)(char **pbuf, zend_size_t max_len, const char *format, va_list ap); zend_string *(*zend_vstrpprintf)(size_t max_len, const char *format, va_list ap); ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC); ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC); void (*zend_on_timeout)(int seconds TSRMLS_DC); -static void (*zend_message_dispatcher_p)(long message, const void *data TSRMLS_DC); +static void (*zend_message_dispatcher_p)(zend_int_t message, const void *data TSRMLS_DC); static int (*zend_get_configuration_directive_p)(const char *name, uint name_length, zval *contents); static ZEND_INI_MH(OnUpdateErrorReporting) /* {{{ */ @@ -134,7 +134,7 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent, { zval *tmp; zend_string *string_key; - ulong num_key; + zend_uint_t num_key; int i; for (i = 0; i < indent; i++) { @@ -193,7 +193,7 @@ static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */ { zval *tmp; zend_string *string_key; - ulong num_key; + zend_uint_t num_key; int i = 0; ZEND_HASH_FOREACH_KEY_VAL_IND(ht, num_key, string_key, tmp) { @@ -204,7 +204,7 @@ static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */ if (string_key) { ZEND_WRITE(string_key->val, string_key->len); } else { - zend_printf("%ld", num_key); + zend_printf(ZEND_UINT_FMT, num_key); } ZEND_PUTS("] => "); zend_print_flat_zval_r(tmp TSRMLS_CC); @@ -232,7 +232,7 @@ again: } break; case IS_RESOURCE: { - char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG]; + char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT]; int len; len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(expr)); @@ -1158,7 +1158,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */ va_end(usr_copy); #endif - ZVAL_LONG(¶ms[0], type); + ZVAL_INT(¶ms[0], type); if (error_filename) { ZVAL_STRING(¶ms[2], error_filename); @@ -1166,7 +1166,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */ ZVAL_NULL(¶ms[2]); } - ZVAL_LONG(¶ms[3], error_lineno); + ZVAL_INT(¶ms[3], error_lineno); symbol_table = zend_rebuild_symbol_table(TSRMLS_C); @@ -1293,7 +1293,7 @@ ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval *retval, int file_cou int i; zend_file_handle *file_handle; zend_op_array *op_array; - long orig_interactive = CG(interactive); + zend_int_t orig_interactive = CG(interactive); va_start(files, file_count); for (i = 0; i < file_count; i++) { diff --git a/Zend/zend.h b/Zend/zend.h index 0718edba12..731a8e5a81 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -273,14 +273,14 @@ char *alloca (); #define LONG_MIN (- LONG_MAX - 1) #endif -#if SIZEOF_LONG == 4 -#define MAX_LENGTH_OF_LONG 11 -static const char long_min_digits[] = "2147483648"; -#elif SIZEOF_LONG == 8 -#define MAX_LENGTH_OF_LONG 20 -static const char long_min_digits[] = "9223372036854775808"; +#if SIZEOF_ZEND_INT == 4 +#define MAX_LENGTH_OF_ZEND_INT 11 +static const char int_min_digits[] = "2147483648"; +#elif SIZEOF_ZEND_INT == 8 +#define MAX_LENGTH_OF_ZEND_INT 20 +static const char int_min_digits[] = "9223372036854775808"; #else -#error "Unknown SIZEOF_LONG" +#error "Unknown SIZEOF_ZEND_INT" #endif #define MAX_LENGTH_OF_DOUBLE 32 @@ -388,7 +388,7 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore # else /* ! (CRAY || __arm) */ # define XtOffset(p_type, field) \ - ((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL))) + ((zend_int_t) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL))) # endif /* !CRAY */ @@ -534,8 +534,8 @@ struct _zend_class_entry { #include "zend_stream.h" typedef struct _zend_utility_functions { void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0); - int (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); - int (*write_function)(const char *str, uint str_length); + zend_size_t (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); + zend_size_t (*write_function)(const char *str, zend_size_t str_length); FILE *(*fopen_function)(const char *filename, char **opened_path TSRMLS_DC); void (*message_handler)(long message, const void *data TSRMLS_DC); void (*block_interruptions)(void); @@ -544,7 +544,7 @@ typedef struct _zend_utility_functions { void (*ticks_function)(int ticks TSRMLS_DC); void (*on_timeout)(int seconds TSRMLS_DC); int (*stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC); - int (*vspprintf_function)(char **pbuf, size_t max_len, const char *format, va_list ap); + zend_size_t (*vspprintf_function)(char **pbuf, size_t max_len, const char *format, va_list ap); zend_string *(*vstrpprintf_function)(size_t max_len, const char *format, va_list ap); char *(*getenv_function)(char *name, size_t name_len TSRMLS_DC); char *(*resolve_path_function)(const char *filename, int filename_len TSRMLS_DC); @@ -646,7 +646,7 @@ END_EXTERN_C() #define ZEND_PUTC(c) zend_write(&(c), 1) BEGIN_EXTERN_C() -extern ZEND_API int (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); +extern ZEND_API zend_size_t (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); extern ZEND_API zend_write_func_t zend_write; extern ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC); extern ZEND_API void (*zend_block_interruptions)(void); @@ -655,8 +655,8 @@ extern ZEND_API void (*zend_ticks_function)(int ticks TSRMLS_DC); extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0); extern ZEND_API void (*zend_on_timeout)(int seconds TSRMLS_DC); extern ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC); -extern int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap); -extern zend_string *(*zend_vstrpprintf)(size_t max_len, const char *format, va_list ap); +extern zend_size_t (*zend_vspprintf)(char **pbuf, zend_size_t max_len, const char *format, va_list ap); +extern zend_string *(*zend_vstrpprintf)(zend_size_t max_len, const char *format, va_list ap); extern ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC); extern ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC); @@ -685,7 +685,7 @@ END_EXTERN_C() #endif BEGIN_EXTERN_C() -ZEND_API void zend_message_dispatcher(long message, const void *data TSRMLS_DC); +ZEND_API void zend_message_dispatcher(zend_int_t message, const void *data TSRMLS_DC); ZEND_API int zend_get_configuration_directive(const char *name, uint name_length, zval *contents); END_EXTERN_C() diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 9881740c06..4bd8760e6a 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -166,7 +166,7 @@ ZEND_API char *zend_get_type_by_const(int type) /* {{{ */ case IS_FALSE: case IS_TRUE: return "boolean"; - case IS_LONG: + case IS_INT: return "integer"; case IS_DOUBLE: return "double"; @@ -228,7 +228,7 @@ static int parse_arg_object_to_string(zval *arg, char **p, int *pl, int type TSR if (Z_OBJ_HANDLER_P(arg, cast_object)(arg, &obj, type TSRMLS_CC) == SUCCESS) { zval_ptr_dtor(arg); ZVAL_COPY_VALUE(arg, &obj); - *pl = Z_STRLEN_P(arg); + *pl = Z_STRSIZE_P(arg); *p = Z_STRVAL_P(arg); return SUCCESS; } @@ -237,7 +237,7 @@ static int parse_arg_object_to_string(zval *arg, char **p, int *pl, int type TSR if (Z_OBJ_HT_P(arg) == &std_object_handlers || !Z_OBJ_HANDLER_P(arg, cast_object)) { SEPARATE_ZVAL_NOREF(arg); if (zend_std_cast_object_tostring(arg, arg, type TSRMLS_CC) == SUCCESS) { - *pl = Z_STRLEN_P(arg); + *pl = Z_STRSIZE_P(arg); *p = Z_STRVAL_P(arg); return SUCCESS; } @@ -252,7 +252,7 @@ static int parse_arg_object_to_string(zval *arg, char **p, int *pl, int type TSR if (!zend_make_printable_zval(z, arg TSRMLS_CC)) { ZVAL_ZVAL(arg, z, 1, 1); } - *pl = Z_STRLEN_P(arg); + *pl = Z_STRSIZE_P(arg); *p = Z_STRVAL_P(arg); return SUCCESS; } @@ -426,7 +426,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons double d; int type; - if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), p, &d, -1)) == 0) { + if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), (zend_int_t *)p, &d, -1)) == 0) { return "long"; } else if (type == IS_DOUBLE) { if (c == 'L') { @@ -439,7 +439,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons } } - *p = zend_dval_to_lval(d); + *p = zend_dval_to_ival(d); } } break; @@ -457,9 +457,70 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons case IS_NULL: case IS_FALSE: case IS_TRUE: - case IS_LONG: - convert_to_long_ex(arg); - *p = Z_LVAL_P(arg); + case IS_INT: + convert_to_int_ex(arg); + *p = Z_IVAL_P(arg); + break; + + case IS_ARRAY: + case IS_OBJECT: + case IS_RESOURCE: + default: + return "long"; + } + } + break; + + case 'i': + case 'I': + { + zend_int_t *p = va_arg(*va, zend_int_t *); + + if (check_null) { + zend_bool *p = va_arg(*va, zend_bool *); + *p = (Z_TYPE_P(arg) == IS_NULL); + } + + switch (Z_TYPE_P(arg)) { + case IS_STRING: + { + double d; + int type; + + if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), p, &d, -1)) == 0) { + return "long"; + } else if (type == IS_DOUBLE) { + if (c == 'I') { + if (d > ZEND_INT_MAX) { + *p = ZEND_INT_MAX; + break; + } else if (d < ZEND_INT_MIN) { + *p = ZEND_INT_MIN; + break; + } + } + + *p = zend_dval_to_ival(d); + } + } + break; + + case IS_DOUBLE: + if (c == 'I') { + if (Z_DVAL_P(arg) > ZEND_INT_MAX) { + *p = ZEND_INT_MAX; + break; + } else if (Z_DVAL_P(arg) < ZEND_INT_MIN) { + *p = ZEND_INT_MIN; + break; + } + } + case IS_NULL: + case IS_FALSE: + case IS_TRUE: + case IS_INT: + convert_to_int_ex(arg); + *p = Z_IVAL_P(arg); break; case IS_ARRAY: @@ -483,12 +544,12 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons switch (Z_TYPE_P(arg)) { case IS_STRING: { - long l; + zend_int_t l; int type; - if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &l, p, -1)) == 0) { + if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), &l, p, -1)) == 0) { return "double"; - } else if (type == IS_LONG) { + } else if (type == IS_INT) { *p = (double) l; } } @@ -497,7 +558,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons case IS_NULL: case IS_FALSE: case IS_TRUE: - case IS_LONG: + case IS_INT: case IS_DOUBLE: convert_to_double_ex(arg); *p = Z_DVAL_P(arg); @@ -526,14 +587,14 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons } /* break omitted intentionally */ - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: convert_to_string_ex(arg); case IS_STRING: *p = Z_STRVAL_P(arg); - *pl = Z_STRLEN_P(arg); + *pl = Z_STRSIZE_P(arg); if (c == 'p' && CHECK_ZVAL_NULL_PATH(arg)) { return "a valid path"; } @@ -567,7 +628,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons } /* break omitted intentionally */ - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: @@ -607,7 +668,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons switch (Z_TYPE_P(arg)) { case IS_NULL: case IS_STRING: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: @@ -871,6 +932,7 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va, case 'f': case 'A': case 'H': case 'p': case 'S': case 'P': + case 'i': max_num_args++; break; @@ -1363,11 +1425,11 @@ ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr) } /* }}} */ -ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n) /* {{{ */ +ZEND_API int add_assoc_int_ex(zval *arg, const char *key, uint key_len, zend_int_t n) /* {{{ */ { zval *ret, tmp; - ZVAL_LONG(&tmp, n); + ZVAL_INT(&tmp, n); ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp); return ret ? SUCCESS : FAILURE; } @@ -1452,16 +1514,16 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *v } /* }}} */ -ZEND_API int add_index_long(zval *arg, ulong index, long n) /* {{{ */ +ZEND_API int add_index_int(zval *arg, zend_uint_t index, zend_int_t n) /* {{{ */ { zval tmp; - ZVAL_LONG(&tmp, n); + ZVAL_INT(&tmp, n); return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE; } /* }}} */ -ZEND_API int add_index_null(zval *arg, ulong index) /* {{{ */ +ZEND_API int add_index_null(zval *arg, zend_uint_t index) /* {{{ */ { zval tmp; @@ -1470,7 +1532,7 @@ ZEND_API int add_index_null(zval *arg, ulong index) /* {{{ */ } /* }}} */ -ZEND_API int add_index_bool(zval *arg, ulong index, int b) /* {{{ */ +ZEND_API int add_index_bool(zval *arg, zend_uint_t index, int b) /* {{{ */ { zval tmp; @@ -1479,7 +1541,7 @@ ZEND_API int add_index_bool(zval *arg, ulong index, int b) /* {{{ */ } /* }}} */ -ZEND_API int add_index_resource(zval *arg, ulong index, zend_resource *r) /* {{{ */ +ZEND_API int add_index_resource(zval *arg, zend_uint_t index, zend_resource *r) /* {{{ */ { zval tmp; @@ -1488,7 +1550,7 @@ ZEND_API int add_index_resource(zval *arg, ulong index, zend_resource *r) /* {{{ } /* }}} */ -ZEND_API int add_index_double(zval *arg, ulong index, double d) /* {{{ */ +ZEND_API int add_index_double(zval *arg, zend_uint_t index, double d) /* {{{ */ { zval tmp; @@ -1497,7 +1559,7 @@ ZEND_API int add_index_double(zval *arg, ulong index, double d) /* {{{ */ } /* }}} */ -ZEND_API int add_index_str(zval *arg, ulong index, zend_string *str) /* {{{ */ +ZEND_API int add_index_str(zval *arg, zend_uint_t index, zend_string *str) /* {{{ */ { zval tmp; @@ -1506,7 +1568,7 @@ ZEND_API int add_index_str(zval *arg, ulong index, zend_string *str) /* {{{ */ } /* }}} */ -ZEND_API int add_index_string(zval *arg, ulong index, const char *str) /* {{{ */ +ZEND_API int add_index_string(zval *arg, zend_uint_t index, const char *str) /* {{{ */ { zval tmp; @@ -1515,7 +1577,7 @@ ZEND_API int add_index_string(zval *arg, ulong index, const char *str) /* {{{ */ } /* }}} */ -ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */ +ZEND_API int add_index_stringl(zval *arg, zend_uint_t index, const char *str, uint length) /* {{{ */ { zval tmp; @@ -1524,17 +1586,17 @@ ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint len } /* }}} */ -ZEND_API int add_index_zval(zval *arg, ulong index, zval *value) /* {{{ */ +ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value) /* {{{ */ { return zend_hash_index_update(Z_ARRVAL_P(arg), index, value) ? SUCCESS : FAILURE; } /* }}} */ -ZEND_API int add_next_index_long(zval *arg, long n) /* {{{ */ +ZEND_API int add_next_index_int(zval *arg, zend_int_t n) /* {{{ */ { zval tmp; - ZVAL_LONG(&tmp, n); + ZVAL_INT(&tmp, n); return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE; } /* }}} */ @@ -1628,16 +1690,16 @@ ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len } /* }}} */ -ZEND_API zval *add_get_index_long(zval *arg, ulong index, long l) /* {{{ */ +ZEND_API zval *add_get_index_int(zval *arg, zend_uint_t index, zend_int_t l) /* {{{ */ { zval tmp; - ZVAL_LONG(&tmp, l); + ZVAL_INT(&tmp, l); return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp); } /* }}} */ -ZEND_API zval *add_get_index_double(zval *arg, ulong index, double d) /* {{{ */ +ZEND_API zval *add_get_index_double(zval *arg, zend_uint_t index, double d) /* {{{ */ { zval tmp; @@ -1646,7 +1708,7 @@ ZEND_API zval *add_get_index_double(zval *arg, ulong index, double d) /* {{{ */ } /* }}} */ -ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str) /* {{{ */ +ZEND_API zval *add_get_index_str(zval *arg, zend_uint_t index, zend_string *str) /* {{{ */ { zval tmp; @@ -1655,7 +1717,7 @@ ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str) /* {{ } /* }}} */ -ZEND_API zval *add_get_index_string(zval *arg, ulong index, const char *str) /* {{{ */ +ZEND_API zval *add_get_index_string(zval *arg, zend_uint_t index, const char *str) /* {{{ */ { zval tmp; @@ -1664,7 +1726,7 @@ ZEND_API zval *add_get_index_string(zval *arg, ulong index, const char *str) /* } /* }}} */ -ZEND_API zval *add_get_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */ +ZEND_API zval *add_get_index_stringl(zval *arg, zend_uint_t index, const char *str, uint length) /* {{{ */ { zval tmp; @@ -1694,11 +1756,11 @@ ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC) case IS_TRUE: result = zend_hash_index_update(ht, 1, value); break; - case IS_LONG: - result = zend_hash_index_update(ht, Z_LVAL_P(key), value); + case IS_INT: + result = zend_hash_index_update(ht, Z_IVAL_P(key), value); break; case IS_DOUBLE: - result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), value); + result = zend_hash_index_update(ht, zend_dval_to_ival(Z_DVAL_P(key)), value); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -1716,12 +1778,12 @@ ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC) } /* }}} */ -ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long n TSRMLS_DC) /* {{{ */ +ZEND_API int add_property_int_ex(zval *arg, const char *key, uint key_len, zend_int_t n TSRMLS_DC) /* {{{ */ { zval tmp; zval z_key; - ZVAL_LONG(&tmp, n); + ZVAL_INT(&tmp, n); ZVAL_STRINGL(&z_key, key, key_len); Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, NULL TSRMLS_CC); zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */ @@ -1730,7 +1792,7 @@ ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long } /* }}} */ -ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC) /* {{{ */ +ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, zend_int_t b TSRMLS_DC) /* {{{ */ { zval tmp; zval z_key; @@ -2941,7 +3003,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca /* Skip leading \ */ if (UNEXPECTED(Z_STRVAL_P(callable)[0] == '\\')) { - STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable) + 1, Z_STRLEN_P(callable) - 1, use_heap); + STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable) + 1, Z_STRSIZE_P(callable) - 1, use_heap); } else { lmname = Z_STR_P(callable); } @@ -2954,7 +3016,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca return 1; } else { if (lmname == Z_STR_P(callable)) { - STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable), Z_STRLEN_P(callable), use_heap); + STR_ALLOCA_INIT(lmname, Z_STRVAL_P(callable), Z_STRSIZE_P(callable), use_heap); } else { STR_FORGET_HASH_VAL(lmname); } @@ -2970,13 +3032,13 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca } /* Split name into class/namespace and method/function names */ - if ((colon = zend_memrchr(Z_STRVAL_P(callable), ':', Z_STRLEN_P(callable))) != NULL && + if ((colon = zend_memrchr(Z_STRVAL_P(callable), ':', Z_STRSIZE_P(callable))) != NULL && colon > Z_STRVAL_P(callable) && *(colon-1) == ':' ) { colon--; clen = colon - Z_STRVAL_P(callable); - mlen = Z_STRLEN_P(callable) - clen - 2; + mlen = Z_STRSIZE_P(callable) - clen - 2; if (colon == Z_STRVAL_P(callable)) { if (error) zend_spprintf(error, 0, "invalid function name"); @@ -3007,7 +3069,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca mname = STR_INIT(Z_STRVAL_P(callable) + clen + 2, mlen, 0); } else if (ce_org) { /* Try to fetch find static method of given class. */ - mlen = Z_STRLEN_P(callable); + mlen = Z_STRSIZE_P(callable); mname = Z_STR_P(callable); STR_ADDREF(mname); ftable = &ce_org->function_table; @@ -3237,13 +3299,13 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint if (callable_name) { char *ptr; - *callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRLEN_P(callable) + sizeof("::") - 1, 0); + *callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRSIZE_P(callable) + sizeof("::") - 1, 0); ptr = (*callable_name)->val; memcpy(ptr, fcc->calling_scope->name->val, fcc->calling_scope->name->len); ptr += fcc->calling_scope->name->len; memcpy(ptr, "::", sizeof("::") - 1); ptr += sizeof("::") - 1; - memcpy(ptr, Z_STRVAL_P(callable), Z_STRLEN_P(callable) + 1); + memcpy(ptr, Z_STRVAL_P(callable), Z_STRSIZE_P(callable) + 1); } } else if (callable_name) { *callable_name = STR_COPY(Z_STR_P(callable)); @@ -3294,13 +3356,13 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint char *ptr; - *callable_name = STR_ALLOC(Z_STRLEN_P(obj) + Z_STRLEN_P(method) + sizeof("::") - 1, 0); + *callable_name = STR_ALLOC(Z_STRSIZE_P(obj) + Z_STRSIZE_P(method) + sizeof("::") - 1, 0); ptr = (*callable_name)->val; - memcpy(ptr, Z_STRVAL_P(obj), Z_STRLEN_P(obj)); - ptr += Z_STRLEN_P(obj); + memcpy(ptr, Z_STRVAL_P(obj), Z_STRSIZE_P(obj)); + ptr += Z_STRSIZE_P(obj); memcpy(ptr, "::", sizeof("::") - 1); ptr += sizeof("::") - 1; - memcpy(ptr, Z_STRVAL_P(method), Z_STRLEN_P(method) + 1); + memcpy(ptr, Z_STRVAL_P(method), Z_STRSIZE_P(method) + 1); } if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) { @@ -3324,13 +3386,13 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint if (callable_name) { char *ptr; - *callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRLEN_P(method) + sizeof("::") - 1, 0); + *callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRSIZE_P(method) + sizeof("::") - 1, 0); ptr = (*callable_name)->val; memcpy(ptr, fcc->calling_scope->name->val, fcc->calling_scope->name->len); ptr += fcc->calling_scope->name->len; memcpy(ptr, "::", sizeof("::") - 1); ptr += sizeof("::") - 1; - memcpy(ptr, Z_STRVAL_P(method), Z_STRLEN_P(method) + 1); + memcpy(ptr, Z_STRVAL_P(method), Z_STRSIZE_P(method) + 1); } if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) { @@ -3702,7 +3764,7 @@ ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, } /* }}} */ -ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC) /* {{{ */ +ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, zend_int_t value, int access_type TSRMLS_DC) /* {{{ */ { zval property; @@ -3711,11 +3773,11 @@ ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, } /* }}} */ -ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC) /* {{{ */ +ZEND_API int zend_declare_property_int(zend_class_entry *ce, const char *name, int name_length, zend_int_t value, int access_type TSRMLS_DC) /* {{{ */ { zval property; - ZVAL_LONG(&property, value); + ZVAL_INT(&property, value); return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC); } /* }}} */ @@ -3766,11 +3828,11 @@ ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char * } /* }}} */ -ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC) /* {{{ */ +ZEND_API int zend_declare_class_constant_int(zend_class_entry *ce, const char *name, size_t name_length, zend_int_t value TSRMLS_DC) /* {{{ */ { zval constant; - ZVAL_LONG(&constant, value); + ZVAL_INT(&constant, value); return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC); } /* }}} */ @@ -3836,7 +3898,7 @@ ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, c } /* }}} */ -ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */ +ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_int_t value TSRMLS_DC) /* {{{ */ { zval tmp; @@ -3845,11 +3907,11 @@ ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, c } /* }}} */ -ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */ +ZEND_API void zend_update_property_int(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_int_t value TSRMLS_DC) /* {{{ */ { zval tmp; - ZVAL_LONG(&tmp, value); + ZVAL_INT(&tmp, value); zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC); } /* }}} */ @@ -3938,7 +4000,7 @@ ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const cha } /* }}} */ -ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */ +ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, zend_int_t value TSRMLS_DC) /* {{{ */ { zval tmp; @@ -3947,11 +4009,11 @@ ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const cha } /* }}} */ -ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */ +ZEND_API int zend_update_static_property_int(zend_class_entry *scope, const char *name, int name_length, zend_int_t value TSRMLS_DC) /* {{{ */ { zval tmp; - ZVAL_LONG(&tmp, value); + ZVAL_INT(&tmp, value); return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC); } /* }}} */ @@ -4055,10 +4117,10 @@ static int same_zval(zval *zv1, zval *zv2) /* {{{ */ case IS_FALSE: case IS_TRUE: return 1; - case IS_LONG: - return Z_LVAL_P(zv1) == Z_LVAL_P(zv2); + case IS_INT: + return Z_IVAL_P(zv1) == Z_IVAL_P(zv2); case IS_DOUBLE: - return Z_LVAL_P(zv1) == Z_LVAL_P(zv2); + return Z_IVAL_P(zv1) == Z_IVAL_P(zv2); case IS_STRING: case IS_ARRAY: case IS_OBJECT: diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 0268374fc4..ec23dde796 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -303,15 +303,15 @@ ZEND_API int zend_get_module_started(const char *module_name); ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment TSRMLS_DC); ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC); ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC); -ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC); -ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC); +ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, zend_int_t value, int access_type TSRMLS_DC); +ZEND_API int zend_declare_property_int(zend_class_entry *ce, const char *name, int name_length, zend_int_t value, int access_type TSRMLS_DC); ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, int name_length, double value, int access_type TSRMLS_DC); ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, int name_length, const char *value, int access_type TSRMLS_DC); ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, int name_length, const char *value, int value_len, int access_type TSRMLS_DC); ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC); ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC); -ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC); +ZEND_API int zend_declare_class_constant_int(zend_class_entry *ce, const char *name, size_t name_length, zend_int_t value TSRMLS_DC); ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value TSRMLS_DC); ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value TSRMLS_DC); 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 TSRMLS_DC); @@ -320,8 +320,8 @@ ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC); ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zval *value TSRMLS_DC); ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, int name_length TSRMLS_DC); -ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC); -ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC); +ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_int_t value TSRMLS_DC); +ZEND_API void zend_update_property_int(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_int_t value TSRMLS_DC); ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC); ZEND_API void zend_update_property_str(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_string *value TSRMLS_DC); ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC); @@ -329,8 +329,8 @@ ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, int name_length, zval *value TSRMLS_DC); ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, int name_length TSRMLS_DC); -ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC); -ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC); +ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, zend_int_t value TSRMLS_DC); +ZEND_API int zend_update_static_property_int(zend_class_entry *scope, const char *name, int name_length, zend_int_t value TSRMLS_DC); ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, int name_length, double value TSRMLS_DC); ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, int name_length, const char *value TSRMLS_DC); ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, int name_length, const char *value, int value_length TSRMLS_DC); @@ -374,7 +374,7 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties TSRMLS_DC); /* no longer supported */ ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS)); -ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n); +ZEND_API int add_assoc_int_ex(zval *arg, const char *key, uint key_len, zend_int_t n); ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len); ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b); ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r); @@ -384,7 +384,7 @@ ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length); ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value); -#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n) +#define add_assoc_int(__arg, __key, __n) add_assoc_int_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) @@ -400,17 +400,17 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *v #define add_next_index_unset(__arg) add_next_index_null(__arg) #define add_property_unset(__arg, __key) add_property_null(__arg, __key) -ZEND_API int add_index_long(zval *arg, ulong idx, long n); -ZEND_API int add_index_null(zval *arg, ulong idx); -ZEND_API int add_index_bool(zval *arg, ulong idx, int b); -ZEND_API int add_index_resource(zval *arg, ulong idx, zend_resource *r); -ZEND_API int add_index_double(zval *arg, ulong idx, double d); -ZEND_API int add_index_str(zval *arg, ulong idx, zend_string *str); -ZEND_API int add_index_string(zval *arg, ulong idx, const char *str); -ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length); -ZEND_API int add_index_zval(zval *arg, ulong index, zval *value); - -ZEND_API int add_next_index_long(zval *arg, long n); +ZEND_API int add_index_int(zval *arg, zend_uint_t idx, zend_int_t n); +ZEND_API int add_index_null(zval *arg, zend_uint_t idx); +ZEND_API int add_index_bool(zval *arg, zend_uint_t idx, int b); +ZEND_API int add_index_resource(zval *arg, zend_uint_t idx, zend_resource *r); +ZEND_API int add_index_double(zval *arg, zend_uint_t idx, double d); +ZEND_API int add_index_str(zval *arg, zend_uint_t idx, zend_string *str); +ZEND_API int add_index_string(zval *arg, zend_uint_t idx, const char *str); +ZEND_API int add_index_stringl(zval *arg, zend_uint_t idx, const char *str, uint length); +ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value); + +ZEND_API int add_next_index_int(zval *arg, zend_int_t n); ZEND_API int add_next_index_null(zval *arg); ZEND_API int add_next_index_bool(zval *arg, int b); ZEND_API int add_next_index_resource(zval *arg, zend_resource *r); @@ -426,17 +426,17 @@ ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len #define add_get_assoc_string(__arg, __key, __str) add_get_assoc_string_ex(__arg, __key, strlen(__key), __str) #define add_get_assoc_stringl(__arg, __key, __str, __length) add_get_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length) -ZEND_API zval *add_get_index_long(zval *arg, ulong idx, long l); -ZEND_API zval *add_get_index_double(zval *arg, ulong idx, double d); -ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str); -ZEND_API zval *add_get_index_string(zval *arg, ulong idx, const char *str); -ZEND_API zval *add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length); +ZEND_API zval *add_get_index_int(zval *arg, zend_uint_t idx, zend_int_t l); +ZEND_API zval *add_get_index_double(zval *arg, zend_uint_t idx, double d); +ZEND_API zval *add_get_index_str(zval *arg, zend_uint_t index, zend_string *str); +ZEND_API zval *add_get_index_string(zval *arg, zend_uint_t idx, const char *str); +ZEND_API zval *add_get_index_stringl(zval *arg, zend_uint_t idx, const char *str, uint length); ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC); -ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC); +ZEND_API int add_property_int_ex(zval *arg, const char *key, uint key_len, zend_int_t l TSRMLS_DC); ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC); -ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC); +ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, zend_int_t b TSRMLS_DC); ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r TSRMLS_DC); ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC); ZEND_API int add_property_str_ex(zval *arg, const char *key, uint key_len, zend_string *str TSRMLS_DC); @@ -444,7 +444,7 @@ ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, co ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length TSRMLS_DC); ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC); -#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n TSRMLS_CC) +#define add_property_int(__arg, __key, __n) add_property_int_ex(__arg, __key, strlen(__key), __n TSRMLS_CC) #define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) TSRMLS_CC) #define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b TSRMLS_CC) #define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r TSRMLS_CC) @@ -546,7 +546,7 @@ END_EXTERN_C() #define CHECK_ZVAL_STRING_REL(z) #endif -#define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p))) +#define CHECK_ZVAL_NULL_PATH(p) (Z_STRSIZE_P(p) != strlen(Z_STRVAL_P(p))) #define CHECK_NULL_PATH(p, l) (strlen(p) != l) #define ZVAL_STRINGL(z, s, l) do { \ @@ -597,7 +597,7 @@ END_EXTERN_C() #define RETVAL_BOOL(b) ZVAL_BOOL(return_value, b) #define RETVAL_NULL() ZVAL_NULL(return_value) -#define RETVAL_LONG(l) ZVAL_LONG(return_value, l) +#define RETVAL_INT(l) ZVAL_INT(return_value, l) #define RETVAL_DOUBLE(d) ZVAL_DOUBLE(return_value, d) #define RETVAL_STR(s) ZVAL_STR(return_value, s) #define RETVAL_INT_STR(s) ZVAL_INT_STR(return_value, s) @@ -613,7 +613,7 @@ END_EXTERN_C() #define RETURN_BOOL(b) { RETVAL_BOOL(b); return; } #define RETURN_NULL() { RETVAL_NULL(); return;} -#define RETURN_LONG(l) { RETVAL_LONG(l); return; } +#define RETURN_INT(l) { RETVAL_INT(l); return; } #define RETURN_DOUBLE(d) { RETVAL_DOUBLE(d); return; } #define RETURN_STR(s) { RETVAL_STR(s); return; } #define RETURN_INT_STR(s) { RETVAL_INT_STR(s); return; } @@ -898,7 +898,7 @@ ZEND_API int _z_param_class(zval *arg, zend_class_entry **pce, int num, int chec Z_PARAM_ARRAY_OR_OBJECT_HT_EX(dest, 0, 0) /* old "l" */ -#define Z_PARAM_LONG_EX(dest, is_null, check_null, separate) \ +#define Z_PARAM_INT_EX(dest, is_null, check_null, separate) \ Z_PARAM_PROLOGUE(separate); \ if (UNEXPECTED(!_z_param_long(_arg, &dest, &is_null, check_null, 0))) { \ _expected_type = Z_EXPECTED_LONG; \ @@ -906,11 +906,11 @@ ZEND_API int _z_param_class(zval *arg, zend_class_entry **pce, int num, int chec break; \ } -#define Z_PARAM_LONG(dest) \ - Z_PARAM_LONG_EX(dest, _dummy, 0, 0) +#define Z_PARAM_INT(dest) \ + Z_PARAM_INT_EX(dest, _dummy, 0, 0) /* old "L" */ -#define Z_PARAM_STRICT_LONG_EX(dest, is_null, check_null, separate) \ +#define Z_PARAM_STRICT_INT_EX(dest, is_null, check_null, separate) \ Z_PARAM_PROLOGUE(separate); \ if (UNEXPECTED(!_z_param_long(_arg, &dest, &is_null, check_null, 1))) { \ _expected_type = Z_EXPECTED_LONG; \ @@ -918,8 +918,8 @@ ZEND_API int _z_param_class(zval *arg, zend_class_entry **pce, int num, int chec break; \ } -#define Z_PARAM_STRICT_LONG(dest) \ - Z_PARAM_STRICT_LONG_EX(dest, _dummy, 0, 0) +#define Z_PARAM_STRICT_INT(dest) \ + Z_PARAM_STRICT_INT_EX(dest, _dummy, 0, 0) /* old "o" */ #define Z_PARAM_OBJECT_EX(dest, check_null, separate) \ @@ -1072,33 +1072,33 @@ static zend_always_inline int _z_param_bool(zval *arg, zend_bool *dest, zend_boo return 1; } -static zend_always_inline int _z_param_long(zval *arg, long *dest, zend_bool *is_null, int check_null, int strict) +static zend_always_inline int _z_param_long(zval *arg, zend_int_t *dest, zend_bool *is_null, int check_null, int strict) { if (check_null) { *is_null = 0; } - if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) { - *dest = Z_LVAL_P(arg); + if (EXPECTED(Z_TYPE_P(arg) == IS_INT)) { + *dest = Z_IVAL_P(arg); } else if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) { - if (strict && UNEXPECTED(Z_DVAL_P(arg) > LONG_MAX)) { - *dest = LONG_MAX; - } else if (strict && UNEXPECTED(Z_DVAL_P(arg) < LONG_MIN)) { - *dest = LONG_MIN; + if (strict && UNEXPECTED(Z_DVAL_P(arg) > ZEND_INT_MAX)) { + *dest = ZEND_INT__MAX; + } else if (strict && UNEXPECTED(Z_DVAL_P(arg) < ZEND_INT_MIN)) { + *dest = ZEND_INT_MIN; } else { - *dest = zend_dval_to_lval(Z_DVAL_P(arg)); + *dest = zend_dval_to_ival(Z_DVAL_P(arg)); } } else if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) { double d; int type; - if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), dest, &d)) != IS_LONG)) { + if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), dest, &d)) != IS_INT)) { if (EXPECTED(type != 0)) { - if (strict && UNEXPECTED(d > LONG_MAX)) { - *dest = LONG_MAX; - } else if (strict && UNEXPECTED(d < LONG_MIN)) { - *dest = LONG_MIN; + if (strict && UNEXPECTED(d > ZEND_INT_MAX)) { + *dest = ZEND_INT_MAX; + } else if (strict && UNEXPECTED(d < ZEND_INT_MIN)) { + *dest = ZEND_INT_MIN; } else { - *dest = zend_dval_to_lval(d); + *dest = zend_dval_to_ival(d); } } else { return 0; @@ -1124,10 +1124,10 @@ static zend_always_inline int _z_param_double(zval *arg, double *dest, zend_bool } if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) { *dest = Z_DVAL_P(arg); - } else if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) { - *dest = (double)Z_LVAL_P(arg); + } else if (EXPECTED(Z_TYPE_P(arg) == IS_INT)) { + *dest = (double)Z_IVAL_P(arg); } else if (EXPECTED(Z_TYPE_P(arg) == IS_STRING)) { - long l; + zend_int_t l; int type; if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), &l, dest)) != IS_DOUBLE)) { diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c index bb3e66c989..195235ffd9 100644 --- a/Zend/zend_alloc.c +++ b/Zend/zend_alloc.c @@ -488,16 +488,16 @@ static unsigned int _zend_mm_cookie = 0; #define ZEND_MM_RESERVE_SIZE (8*1024) #ifdef _WIN64 -# define ZEND_MM_LONG_CONST(x) (x##i64) +# define ZEND_MM_INT_CONST(x) (x##i64) #else -# define ZEND_MM_LONG_CONST(x) (x##L) +# define ZEND_MM_INT_CONST(x) (x##L) #endif -#define ZEND_MM_TYPE_MASK ZEND_MM_LONG_CONST(0x3) +#define ZEND_MM_TYPE_MASK ZEND_MM_INT_CONST(0x3) -#define ZEND_MM_FREE_BLOCK ZEND_MM_LONG_CONST(0x0) -#define ZEND_MM_USED_BLOCK ZEND_MM_LONG_CONST(0x1) -#define ZEND_MM_GUARD_BLOCK ZEND_MM_LONG_CONST(0x3) +#define ZEND_MM_FREE_BLOCK ZEND_MM_INT_CONST(0x0) +#define ZEND_MM_USED_BLOCK ZEND_MM_INT_CONST(0x1) +#define ZEND_MM_GUARD_BLOCK ZEND_MM_INT_CONST(0x3) #define ZEND_MM_BLOCK(b, type, size) do { \ size_t _size = (size); \ @@ -742,7 +742,7 @@ static inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_blo *p = mm_block; mm_block->parent = p; mm_block->prev_free_block = mm_block->next_free_block = mm_block; - heap->large_free_bitmap |= (ZEND_MM_LONG_CONST(1) << index); + heap->large_free_bitmap |= (ZEND_MM_INT_CONST(1) << index); } else { size_t m; @@ -775,7 +775,7 @@ static inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_blo prev = ZEND_MM_SMALL_FREE_BUCKET(heap, index); if (prev->prev_free_block == prev) { - heap->free_bitmap |= (ZEND_MM_LONG_CONST(1) << index); + heap->free_bitmap |= (ZEND_MM_INT_CONST(1) << index); } next = prev->next_free_block; @@ -809,7 +809,7 @@ static inline void zend_mm_remove_from_free_list(zend_mm_heap *heap, zend_mm_fre ZEND_MM_CHECK_TREE(mm_block); *mm_block->parent = NULL; if (mm_block->parent == &heap->large_free_buckets[index]) { - heap->large_free_bitmap &= ~(ZEND_MM_LONG_CONST(1) << index); + heap->large_free_bitmap &= ~(ZEND_MM_INT_CONST(1) << index); } } else { while (*(cp = &(prev->child[prev->child[1] != NULL])) != NULL) { @@ -847,7 +847,7 @@ subst_block: size_t index = ZEND_MM_BUCKET_INDEX(ZEND_MM_FREE_BLOCK_SIZE(mm_block)); if (EXPECTED(heap->free_buckets[index*2] == heap->free_buckets[index*2+1])) { - heap->free_bitmap &= ~(ZEND_MM_LONG_CONST(1) << index); + heap->free_bitmap &= ~(ZEND_MM_INT_CONST(1) << index); } } } else if (UNEXPECTED(mm_block->parent == ZEND_MM_REST_BLOCK)) { @@ -1116,7 +1116,7 @@ ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_mem_handlers *handlers, heap->real_size = 0; heap->overflow = 0; heap->real_peak = 0; - heap->limit = ZEND_MM_LONG_CONST(1)<<(ZEND_MM_NUM_BUCKETS-2); + heap->limit = ZEND_MM_INT_CONST(1)<<(ZEND_MM_NUM_BUCKETS-2); heap->size = 0; heap->peak = 0; heap->internal = internal; @@ -1231,9 +1231,9 @@ ZEND_API zend_mm_heap *zend_mm_startup(void) } #if ZEND_DEBUG -static long zend_mm_find_leaks(zend_mm_segment *segment, zend_mm_block *b) +static zend_int_t zend_mm_find_leaks(zend_mm_segment *segment, zend_mm_block *b) { - long leaks = 0; + zend_int_t leaks = 0; zend_mm_block *p, *q; p = ZEND_MM_NEXT_BLOCK(b); @@ -1291,7 +1291,7 @@ static void zend_mm_check_leaks(zend_mm_heap *heap TSRMLS_DC) } if (!ZEND_MM_IS_FREE_BLOCK(p)) { if (p->magic == MEM_BLOCK_VALID) { - long repeated; + zend_int_t repeated; zend_leak_info leak; ZEND_MM_SET_MAGIC(p, MEM_BLOCK_LEAK); @@ -1373,7 +1373,7 @@ static int zend_mm_check_ptr(zend_mm_heap *heap, void *ptr, int silent ZEND_FILE #ifdef ZTS if (ZEND_MM_BAD_THREAD_ID(p)) { if (!silent) { - zend_debug_alloc_output("Invalid pointer: ((thread_id=0x%0.8X) != (expected=0x%0.8X))\n", (long)p->thread_id, (long)tsrm_thread_id()); + zend_debug_alloc_output("Invalid pointer: ((thread_id=0x%0.8X) != (expected=0x%0.8X))\n", (zend_int_t)p->thread_id, (zend_int_t)tsrm_thread_id()); had_problems = 1; } else { return zend_mm_check_ptr(heap, ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); @@ -1842,7 +1842,7 @@ static zend_mm_free_block *zend_mm_search_large_block(zend_mm_heap *heap, size_t best_size = ZEND_MM_FREE_BLOCK_SIZE(p); best_fit = p; } - if ((m & (ZEND_MM_LONG_CONST(1) << (ZEND_MM_NUM_BUCKETS-1))) == 0) { + if ((m & (ZEND_MM_INT_CONST(1) << (ZEND_MM_NUM_BUCKETS-1))) == 0) { if (p->child[1]) { rst = p->child[1]; } @@ -1984,9 +1984,9 @@ static void *_zend_mm_alloc_int(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D #endif HANDLE_UNBLOCK_INTERRUPTIONS(); #if ZEND_DEBUG - zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %lu bytes)", heap->limit, __zend_filename, __zend_lineno, size); + zend_mm_safe_error(heap, "Allowed memory size of " ZEND_UINT_FMT " bytes exhausted at %s:%d (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, __zend_filename, __zend_lineno, size); #else - zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %lu bytes)", heap->limit, size); + zend_mm_safe_error(heap, "Allowed memory size of " ZEND_UINT_FMT " bytes exhausted (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, size); #endif } @@ -2297,9 +2297,9 @@ realloc_segment: #endif HANDLE_UNBLOCK_INTERRUPTIONS(); #if ZEND_DEBUG - zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %ld bytes)", heap->limit, __zend_filename, __zend_lineno, size); + zend_mm_safe_error(heap, "Allowed memory size of " ZEND_UINT_FMT " bytes exhausted at %s:%d (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, __zend_filename, __zend_lineno, size); #else - zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %ld bytes)", heap->limit, size); + zend_mm_safe_error(heap, "Allowed memory size of " ZEND_UINT_FMT " bytes exhausted (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, size); #endif return NULL; } @@ -2474,7 +2474,7 @@ ZEND_API size_t _zend_mem_block_size(void *ptr TSRMLS_DC ZEND_FILE_LINE_DC ZEND_ static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) { size_t res = nmemb; - unsigned long overflow = 0; + zend_uint_t overflow = 0; __asm__ ("mull %3\n\taddl %4,%0\n\tadcl $0,%1" : "=&a"(res), "=&d" (overflow) @@ -2494,7 +2494,7 @@ static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) { size_t res = nmemb; - unsigned long overflow = 0; + zend_uint_t overflow = 0; #ifdef __ILP32__ /* x32 */ # define LP_SUFF "l" @@ -2523,7 +2523,7 @@ static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) { size_t res; - unsigned long overflow; + zend_uint_t overflow; __asm__ ("umlal %0,%1,%2,%3" : "=r"(res), "=r"(overflow) @@ -2544,7 +2544,7 @@ static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) static inline size_t safe_address(size_t nmemb, size_t size, size_t offset) { size_t res; - unsigned long overflow; + zend_uint_t overflow; __asm__ ("mul %0,%2,%3\n\tumulh %1,%2,%3\n\tadds %0,%0,%4\n\tadc %1,%1,xzr" : "=&r"(res), "=&r"(overflow) @@ -2630,7 +2630,7 @@ ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) { - int length; + zend_size_t length; char *p; #ifdef ZEND_SIGNALS TSRMLS_FETCH(); @@ -2649,7 +2649,7 @@ ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) return p; } -ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) +ZEND_API char *_estrndup(const char *s, zend_size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) { char *p; #ifdef ZEND_SIGNALS @@ -2670,7 +2670,7 @@ ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_ } -ZEND_API char *zend_strndup(const char *s, uint length) +ZEND_API char *zend_strndup(const char *s, zend_size_t length) { char *p; #ifdef ZEND_SIGNALS diff --git a/Zend/zend_alloc.h b/Zend/zend_alloc.h index 609db22dac..3c143419ae 100644 --- a/Zend/zend_alloc.h +++ b/Zend/zend_alloc.h @@ -26,20 +26,21 @@ #include "../TSRM/TSRM.h" #include "zend.h" +#include "zend_types.h" #ifndef ZEND_MM_ALIGNMENT -# define ZEND_MM_ALIGNMENT 8 -# define ZEND_MM_ALIGNMENT_LOG2 3 -#elif ZEND_MM_ALIGNMENT < 4 +# define ZEND_MM_ALIGNMENT Z_I(8) +# define ZEND_MM_ALIGNMENT_LOG2 Z_I(3) +#elif ZEND_MM_ALIGNMENT < Z_I(4) # undef ZEND_MM_ALIGNMENT # undef ZEND_MM_ALIGNMENT_LOG2 -# define ZEND_MM_ALIGNMENT 4 -# define ZEND_MM_ALIGNMENT_LOG2 2 +# define ZEND_MM_ALIGNMENT Z_I(4) +# define ZEND_MM_ALIGNMENT_LOG2 Z_I(2) #endif -#define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT-1) +#define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT-Z_I(1)) -#define ZEND_MM_ALIGNED_SIZE(size) (((size) + ZEND_MM_ALIGNMENT - 1) & ZEND_MM_ALIGNMENT_MASK) +#define ZEND_MM_ALIGNED_SIZE(size) (((size) + ZEND_MM_ALIGNMENT - Z_I(1)) & ZEND_MM_ALIGNMENT_MASK) typedef struct _zend_leak_info { void *addr; @@ -52,7 +53,7 @@ typedef struct _zend_leak_info { BEGIN_EXTERN_C() -ZEND_API char *zend_strndup(const char *s, unsigned int length) ZEND_ATTRIBUTE_MALLOC; +ZEND_API char *zend_strndup(const char *s, zend_size_t length) ZEND_ATTRIBUTE_MALLOC; ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1); ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; @@ -63,7 +64,7 @@ ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LIN ZEND_API void *_safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); ZEND_API void *_safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset); ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; -ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; +ZEND_API char *_estrndup(const char *s, zend_size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC; ZEND_API size_t _zend_mem_block_size(void *ptr TSRMLS_DC ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); /* Standard wrapper macros */ diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 810b9b1fe8..dd7574ba3c 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -114,8 +114,8 @@ static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr TS case IS_NULL: zend_symtable_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), expr); break; - case IS_LONG: - zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), expr); + case IS_INT: + zend_hash_index_update(Z_ARRVAL_P(result), Z_IVAL_P(offset), expr); break; case IS_FALSE: zend_hash_index_update(Z_ARRVAL_P(result), 0, expr); @@ -124,7 +124,7 @@ static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr TS zend_hash_index_update(Z_ARRVAL_P(result), 1, expr); break; case IS_DOUBLE: - zend_hash_index_update(Z_ARRVAL_P(result), zend_dval_to_lval(Z_DVAL_P(offset)), expr); + zend_hash_index_update(Z_ARRVAL_P(result), zend_dval_to_ival(Z_DVAL_P(offset)), expr); break; default: zend_error(E_ERROR, "Illegal offset type"); @@ -331,13 +331,13 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s } break; case ZEND_UNARY_PLUS: - ZVAL_LONG(&op1, 0); + ZVAL_INT(&op1, 0); zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC); add_function(result, &op1, &op2 TSRMLS_CC); zval_dtor(&op2); break; case ZEND_UNARY_MINUS: - ZVAL_LONG(&op1, 0); + ZVAL_INT(&op1, 0); zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC); sub_function(result, &op1, &op2 TSRMLS_CC); zval_dtor(&op2); diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 1e29ea4db1..a479bdba6f 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -358,7 +358,7 @@ ZEND_FUNCTION(zend_version) Returns number of freed zvals */ ZEND_FUNCTION(gc_collect_cycles) { - RETURN_LONG(gc_collect_cycles(TSRMLS_C)); + RETURN_INT(gc_collect_cycles(TSRMLS_C)); } /* }}} */ @@ -397,10 +397,10 @@ ZEND_FUNCTION(func_num_args) zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; if (ex->frame_kind == VM_FRAME_NESTED_FUNCTION || ex->frame_kind == VM_FRAME_TOP_FUNCTION) { - RETURN_LONG(ex->num_args); + RETURN_INT(ex->num_args); } else { zend_error(E_WARNING, "func_num_args(): Called from the global scope - no function context"); - RETURN_LONG(-1); + RETURN_INT(-1); } } /* }}} */ @@ -411,10 +411,10 @@ ZEND_FUNCTION(func_get_arg) { int arg_count, first_extra_arg; zval *arg; - long requested_offset; + zend_int_t requested_offset; zend_execute_data *ex; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &requested_offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &requested_offset) == FAILURE) { return; } @@ -528,7 +528,7 @@ ZEND_FUNCTION(strlen) ZEND_PARSE_PARAMETERS_END(); #endif - RETVAL_LONG(s->len); + RETVAL_INT(s->len); } /* }}} */ @@ -537,14 +537,13 @@ ZEND_FUNCTION(strlen) Binary safe string comparison */ ZEND_FUNCTION(strcmp) { - char *s1, *s2; - int s1_len, s2_len; + zend_string *s1, *s2; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &s1, &s2) == FAILURE) { return; } - RETURN_LONG(zend_binary_strcmp(s1, s1_len, s2, s2_len)); + RETURN_INT(zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len)); } /* }}} */ @@ -553,11 +552,10 @@ ZEND_FUNCTION(strcmp) Binary safe string comparison */ ZEND_FUNCTION(strncmp) { - char *s1, *s2; - int s1_len, s2_len; - long len; + zend_string *s1, *s2; + zend_int_t len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s2, &len) == FAILURE) { return; } @@ -566,7 +564,7 @@ ZEND_FUNCTION(strncmp) RETURN_FALSE; } - RETURN_LONG(zend_binary_strncmp(s1, s1_len, s2, s2_len, len)); + RETURN_INT(zend_binary_strncmp(s1->val, s1->len, s2->val, s2->len, len)); } /* }}} */ @@ -575,14 +573,13 @@ ZEND_FUNCTION(strncmp) Binary safe case-insensitive string comparison */ ZEND_FUNCTION(strcasecmp) { - char *s1, *s2; - int s1_len, s2_len; + zend_string *s1, *s2; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &s1, &s2) == FAILURE) { return; } - RETURN_LONG(zend_binary_strcasecmp(s1, s1_len, s2, s2_len)); + RETURN_INT(zend_binary_strcasecmp(s1->val, s1->len, s2->val, s2->len)); } /* }}} */ @@ -591,11 +588,10 @@ ZEND_FUNCTION(strcasecmp) Binary safe string comparison */ ZEND_FUNCTION(strncasecmp) { - char *s1, *s2; - int s1_len, s2_len; - long len; + zend_string *s1, *s2; + zend_int_t len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s2, &len) == FAILURE) { return; } @@ -604,7 +600,7 @@ ZEND_FUNCTION(strncasecmp) RETURN_FALSE; } - RETURN_LONG(zend_binary_strncasecmp(s1, s1_len, s2, s2_len, len)); + RETURN_INT(zend_binary_strncasecmp(s1->val, s1->len, s2->val, s2->len, len)); } /* }}} */ @@ -614,7 +610,7 @@ ZEND_FUNCTION(strncasecmp) ZEND_FUNCTION(each) { zval *array, *entry, tmp; - ulong num_key; + zend_uint_t num_key; HashTable *target_hash; zend_string *key; @@ -660,7 +656,7 @@ ZEND_FUNCTION(each) ZVAL_STR(&tmp, STR_COPY(key)); if (Z_REFCOUNTED(tmp)) Z_ADDREF(tmp); } else { - ZVAL_LONG(&tmp, num_key); + ZVAL_INT(&tmp, num_key); } zend_hash_index_add_new(Z_ARRVAL_P(return_value), 0, &tmp); zend_hash_str_add_new(Z_ARRVAL_P(return_value), "key", sizeof("key")-1, &tmp); @@ -688,7 +684,7 @@ ZEND_FUNCTION(error_reporting) STR_RELEASE(key); } - RETVAL_LONG(old_error_reporting); + RETVAL_INT(old_error_reporting); } /* }}} */ @@ -730,7 +726,7 @@ ZEND_FUNCTION(define) repeat: switch (Z_TYPE_P(val)) { - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_FALSE: @@ -1472,7 +1468,7 @@ ZEND_FUNCTION(class_alias) Cause an intentional memory leak, for testing/debugging purposes */ ZEND_FUNCTION(leak) { - long leakbytes=3; + zend_int_t leakbytes=3; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) { return; @@ -1540,7 +1536,7 @@ ZEND_FUNCTION(get_included_files) Generates a user-level error/warning/notice message */ ZEND_FUNCTION(trigger_error) { - long error_type = E_USER_NOTICE; + zend_int_t error_type = E_USER_NOTICE; char *message; int message_len; @@ -1572,7 +1568,7 @@ ZEND_FUNCTION(set_error_handler) { zval *error_handler; zend_string *error_handler_name = NULL; - long error_type = E_ALL; + zend_int_t error_type = E_ALL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) { return; @@ -1880,11 +1876,11 @@ ZEND_FUNCTION(create_function) } (*func->refcount)++; - function_name = STR_ALLOC(sizeof("0lambda_")+MAX_LENGTH_OF_LONG, 0); + function_name = STR_ALLOC(sizeof("0lambda_")+MAX_LENGTH_OF_ZEND_INT, 0); function_name->val[0] = '\0'; do { - function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count)) + 1; + function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_ZEND_INT, "lambda_%d", ++EG(lambda_count)) + 1; } while (zend_hash_add_ptr(EG(function_table), function_name, func) == NULL); static_variables = func->static_variables; func->static_variables = NULL; @@ -1911,7 +1907,7 @@ ZEND_FUNCTION(zend_test_func) #ifdef ZTS ZEND_FUNCTION(zend_thread_id) { - RETURN_LONG((long)tsrm_thread_id()); + RETURN_INT((zend_int_t)tsrm_thread_id()); } #endif #endif @@ -2115,10 +2111,10 @@ ZEND_FUNCTION(debug_print_backtrace) const char *include_filename = NULL; zval arg_array; int indent = 0; - long options = 0; - long limit = 0; + zend_int_t options = 0; + zend_int_t limit = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) { return; } @@ -2356,7 +2352,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int lineno = skip->opline->lineno; } add_assoc_string_ex(&stack_frame, "file", sizeof("file")-1, (char*)filename); - add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, lineno); + add_assoc_int_ex(&stack_frame, "line", sizeof("line")-1, lineno); /* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function * and debug_baktrace() might have been called by the error_handler. in this case we don't @@ -2375,7 +2371,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int } if (prev->func && ZEND_USER_CODE(prev->func->common.type)) { add_assoc_str_ex(&stack_frame, "file", sizeof("file")-1, STR_COPY(prev->func->op_array.filename)); - add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, prev->opline->lineno); + add_assoc_int_ex(&stack_frame, "line", sizeof("line")-1, prev->opline->lineno); break; } prev_call = prev; @@ -2503,10 +2499,10 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int Return backtrace as array */ ZEND_FUNCTION(debug_backtrace) { - long options = DEBUG_BACKTRACE_PROVIDE_OBJECT; - long limit = 0; + zend_int_t options = DEBUG_BACKTRACE_PROVIDE_OBJECT; + zend_int_t limit = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) { return; } diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ae26733a7b..120cc98da5 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -171,7 +171,7 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i static void init_compiler_declarables(TSRMLS_D) /* {{{ */ { - ZVAL_LONG(&CG(declarables).ticks, 0); + ZVAL_INT(&CG(declarables).ticks, 0); } /* }}} */ @@ -300,7 +300,7 @@ static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */ static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{{ */{ int i = 0; - ulong hash_value = STR_HASH_VAL(name); + zend_uint_t hash_value = STR_HASH_VAL(name); while (i < op_array->last_var) { if (op_array->vars[i]->val == name->val || @@ -383,8 +383,8 @@ static int zend_add_func_name_literal(zend_op_array *op_array, zval *zv TSRMLS_D ret = zend_add_literal(op_array, zv TSRMLS_CC); } - lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); + lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv)); ZVAL_NEW_STR(&c, lc_name); zend_add_literal(CG(active_op_array), &c TSRMLS_CC); @@ -409,16 +409,16 @@ static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRML ret = zend_add_literal(op_array, zv TSRMLS_CC); } - lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); + lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv)); ZVAL_NEW_STR(&c, lc_name); zend_add_literal(CG(active_op_array), &c TSRMLS_CC); - ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv)); + ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRSIZE_P(zv)); if (ns_separator != NULL) { ns_separator += 1; - lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv)); + lc_len = Z_STRSIZE_P(zv) - (ns_separator - Z_STRVAL_P(zv)); lc_name = STR_ALLOC(lc_len, 0); zend_str_tolower_copy(lc_name->val, ns_separator, lc_len); ZVAL_NEW_STR(&c, lc_name); @@ -445,11 +445,11 @@ static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_ } if (Z_STRVAL_P(zv)[0] == '\\') { - lc_name = STR_ALLOC(Z_STRLEN_P(zv) - 1, 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1); + lc_name = STR_ALLOC(Z_STRSIZE_P(zv) - 1, 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRSIZE_P(zv) - 1); } else { - lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); + lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv)); } ZVAL_NEW_STR(&c, lc_name); zend_add_literal(CG(active_op_array), &c TSRMLS_CC); @@ -480,10 +480,10 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int un /* skip leading '\\' */ if (Z_STRVAL_P(zv)[0] == '\\') { - name_len = Z_STRLEN_P(zv) - 1; + name_len = Z_STRSIZE_P(zv) - 1; name = Z_STRVAL_P(zv) + 1; } else { - name_len = Z_STRLEN_P(zv); + name_len = Z_STRSIZE_P(zv); name = Z_STRVAL_P(zv); } ns_separator = zend_memrchr(name, '\\', name_len); @@ -543,15 +543,15 @@ static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int un op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ } while (0) -#define LITERAL_LONG(op, val) do { \ +#define LITERAL_INT(op, val) do { \ zval _c; \ - ZVAL_LONG(&_c, val); \ + ZVAL_INT(&_c, val); \ op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \ } while (0) -#define LITERAL_LONG_EX(op_array, op, val) do { \ +#define LITERAL_INT_EX(op_array, op, val) do { \ zval _c; \ - ZVAL_LONG(&_c, val); \ + ZVAL_INT(&_c, val); \ op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \ } while (0) @@ -657,7 +657,7 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar } if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && + !(Z_STRSIZE(varname->u.constant) == (sizeof("this")-1) && !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) && (CG(active_op_array)->last == 0 || CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) { @@ -713,7 +713,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /* zend_op opline; if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { + ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) { zend_resolve_class_name(class_name TSRMLS_CC); class_node = *class_name; } else { @@ -811,11 +811,11 @@ void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ SET_NODE(opline.op1, parent); SET_NODE(opline.op2, dim); if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) { - ulong index; + zend_uint_t index; if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) { zval_dtor(&CONSTANT(opline.op2.constant)); - ZVAL_LONG(&CONSTANT(opline.op2.constant), index); + ZVAL_INT(&CONSTANT(opline.op2.constant), index); } } @@ -859,17 +859,17 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const char *method_type; if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT; + Z_IVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT; method_type = "Interface"; } else { method_type = "Abstract"; } - if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) { - if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) { + if (Z_IVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) { + if(Z_IVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) { zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); } - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { + if (Z_IVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); opline->opcode = ZEND_RAISE_ABSTRACT_ERROR; @@ -880,7 +880,7 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); } } else { - if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { + if (Z_IVAL(body->u.constant) == ZEND_ACC_ABSTRACT) { zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); } } @@ -893,7 +893,7 @@ static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */ && (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) && ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER) && (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL) - && (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1)) + && (Z_STRSIZE(CONSTANT(opline->op1.constant)) == (sizeof("this")-1)) && !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) { return 1; } else { @@ -1369,15 +1369,15 @@ void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ { zend_op *opline; - if (Z_STRLEN(op2->u.constant) > 1) { + if (Z_STRSIZE(op2->u.constant) > 1) { opline = get_next_op(CG(active_op_array) TSRMLS_CC); opline->opcode = ZEND_ADD_STRING; - } else if (Z_STRLEN(op2->u.constant) == 1) { + } else if (Z_STRSIZE(op2->u.constant) == 1) { int ch = *Z_STRVAL(op2->u.constant); /* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */ STR_FREE(Z_STR(op2->u.constant)); - ZVAL_LONG(&op2->u.constant, ch); + ZVAL_INT(&op2->u.constant, ch); opline = get_next_op(CG(active_op_array) TSRMLS_CC); opline->opcode = ZEND_ADD_CHAR; } else { /* String can be empty after a variable at the end of a heredoc */ @@ -1480,26 +1480,26 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */ int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */ { - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) { + if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK) + && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) { + if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT) + && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) { + if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_STATIC) + && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed"); } - if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL) - && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) { + if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_FINAL) + && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) { zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed"); } - if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) { + if (((Z_IVAL(current_access_type->u.constant) | Z_IVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member"); } - return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)); + return (Z_IVAL(current_access_type->u.constant) | Z_IVAL(new_modifier->u.constant)); } /* }}} */ @@ -1515,12 +1515,12 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n if (is_method) { if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) { - if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) { + if ((Z_IVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) { zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant)); } - Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */ + Z_IVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */ } - fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */ + fn_flags = Z_IVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */ } else { fn_flags = 0; } @@ -1689,8 +1689,8 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n ZVAL_DUP(&tmp.u.constant, &CG(current_namespace)); zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC); op_array.function_name = Z_STR(tmp.u.constant); - lcname = STR_ALLOC(Z_STRLEN(tmp.u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant)); + lcname = STR_ALLOC(Z_STRSIZE(tmp.u.constant), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRSIZE(tmp.u.constant)); } else { lcname = STR_ALLOC(name->len, 0); zend_str_tolower_copy(lcname->val, name->val, name->len); @@ -1700,10 +1700,10 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n if (CG(current_import_function) && (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) { - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); + char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name)); - if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) || - memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) { + if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(function_name->u.constant) || + memcmp(tmp, lcname->val, Z_STRSIZE(function_name->u.constant))) { zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant)); } efree(tmp); @@ -1847,7 +1847,7 @@ void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) { zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter %s", Z_STRVAL(varname->u.constant)); } else if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL && - Z_STRLEN(varname->u.constant) == sizeof("this")-1 && + Z_STRSIZE(varname->u.constant) == sizeof("this")-1 && !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) { if (CG(active_op_array)->scope && (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) { @@ -1886,8 +1886,8 @@ void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, } CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args)); cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1]; - cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)); - cur_arg_info->name_len = Z_STRLEN(varname->u.constant); + cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRSIZE(varname->u.constant)); + cur_arg_info->name_len = Z_STRSIZE(varname->u.constant); cur_arg_info->type_hint = 0; cur_arg_info->pass_by_reference = pass_by_reference; cur_arg_info->allow_null = 1; @@ -1919,7 +1919,7 @@ void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, } } else { cur_arg_info->type_hint = IS_OBJECT; - if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) { + if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRSIZE(class_type->u.constant))) { zend_resolve_class_name(class_type TSRMLS_CC); } Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC); @@ -1928,12 +1928,12 @@ void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, } // TODO: for now we have to copy it ??? #if 1 - cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant)); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); + cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRSIZE(class_type->u.constant)); + cur_arg_info->class_name_len = Z_STRSIZE(class_type->u.constant); STR_RELEASE(Z_STR(class_type->u.constant)); #else cur_arg_info->class_name = Z_STRVAL(class_type->u.constant); - cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant); + cur_arg_info->class_name_len = Z_STRSIZE(class_type->u.constant); #endif if (op == ZEND_RECV_INIT) { if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) { @@ -1958,7 +1958,7 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace zend_uint op_number; zend_function *function; zend_string *lcname; - char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant)); + char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRSIZE(function_name->u.constant)); zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC); @@ -1972,8 +1972,8 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace return 1; } - lcname = STR_ALLOC(Z_STRLEN(function_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant)); + lcname = STR_ALLOC(Z_STRSIZE(function_name->u.constant), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRSIZE(function_name->u.constant)); if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && (function->type == ZEND_INTERNAL_FUNCTION))) { @@ -2008,8 +2008,8 @@ void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ last_op_number = get_next_op_number(CG(active_op_array))-1; last_op = &CG(active_op_array)->opcodes[last_op_number]; - if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1) - && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) { + if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRSIZE(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1) + && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRSIZE(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead"); } @@ -2028,7 +2028,7 @@ void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */ } last_op->opcode = ZEND_INIT_METHOD_CALL; last_op->result_type = IS_UNUSED; - Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; + Z_IVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME; } else { zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC); opline->opcode = ZEND_INIT_FCALL_BY_NAME; @@ -2098,12 +2098,12 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace int len; zval *ns; zend_string *lookup_name; - char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant)); + char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRSIZE(element_name->u.constant)); if (Z_STRVAL(element_name->u.constant)[0] == '\\') { /* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */ - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant)); - --Z_STRLEN(element_name->u.constant); + memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRSIZE(element_name->u.constant)); + --Z_STRSIZE(element_name->u.constant); return; } @@ -2112,7 +2112,7 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace } if (current_import_sub) { - len = Z_STRLEN(element_name->u.constant); + len = Z_STRSIZE(element_name->u.constant); if (case_sensitive) { lookup_name = STR_INIT(Z_STRVAL(element_name->u.constant), len, 0); } else { @@ -2141,8 +2141,8 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace tmp.op_type = IS_CONST; ZVAL_DUP(&tmp.u.constant, ns); len += 1; - Z_STRLEN(element_name->u.constant) -= len; - memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1); + Z_STRSIZE(element_name->u.constant) -= len; + memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRSIZE(element_name->u.constant)+1); zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC); *element_name = tmp; STR_FREE(lookup_name); @@ -2154,11 +2154,11 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { tmp = *element_name; - Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0); + Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRSIZE(element_name->u.constant) + Z_STRSIZE(CG(current_namespace)), 0); Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1); - memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1); + memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace))); + memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRSIZE(CG(current_namespace))]), "\\", sizeof("\\")-1); + memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRSIZE(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRSIZE(element_name->u.constant)+1); STR_RELEASE(Z_STR(element_name->u.constant)); *element_name = tmp; } @@ -2183,7 +2183,7 @@ void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static int lctype; znode constant_name; - lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant)); lctype = zend_get_class_fetch_type(lcname, strlen(lcname)); switch (lctype) { case ZEND_FETCH_CLASS_SELF: @@ -2232,18 +2232,18 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ znode tmp; int len; - compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant)); + compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRSIZE(class_name->u.constant)); if (compound) { /* This is a compound class name that contains namespace prefix */ if (Z_STRVAL(class_name->u.constant)[0] == '\\') { /* The STRING name has "\" prefix */ - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)); + memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRSIZE(class_name->u.constant)); Z_STR(class_name->u.constant) = STR_REALLOC( Z_STR(class_name->u.constant), - Z_STRLEN(class_name->u.constant) - 1, 0); + Z_STRSIZE(class_name->u.constant) - 1, 0); Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; - if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { + if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) { zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant)); } } else { @@ -2257,8 +2257,8 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ tmp.op_type = IS_CONST; ZVAL_DUP(&tmp.u.constant, ns); len += 1; - Z_STRLEN(class_name->u.constant) -= len; - memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1); + Z_STRSIZE(class_name->u.constant) -= len; + memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRSIZE(class_name->u.constant)+1); zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); *class_name = tmp; STR_FREE(lcname); @@ -2276,8 +2276,8 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ } } else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) { /* this is a plain name (without \) */ - lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant)); if (CG(current_import) && (ns = zend_hash_find(CG(current_import), lcname)) != NULL) { @@ -2298,7 +2298,7 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ { - long fetch_class_op_number; + zend_int_t fetch_class_op_number; zend_op *opline; fetch_class_op_number = get_next_op_number(CG(active_op_array)); @@ -2311,7 +2311,7 @@ void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */ if (class_name->op_type == IS_CONST) { int fetch_type; - fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant)); switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: case ZEND_FETCH_CLASS_PARENT: @@ -2367,7 +2367,7 @@ void zend_do_label(znode *label TSRMLS_DC) /* {{{ */ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */ { zend_label *dest; - long current, distance; + zend_int_t current, distance; zval *label; if (pass2) { @@ -2415,7 +2415,7 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 SET_UNUSED(opline->op2); } else { /* Set real break distance */ - ZVAL_LONG(label, distance); + ZVAL_INT(label, distance); } if (pass2) { @@ -2462,20 +2462,20 @@ void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_c } if (is_class_member) { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant); + int old_len = Z_STRSIZE(result->u.constant); + length = sizeof("::")-1 + old_len + Z_STRSIZE(name->u.constant); Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0); Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); + memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant)+1); STR_RELEASE(Z_STR(name->u.constant)); } else { - int old_len = Z_STRLEN(result->u.constant); - length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant); + int old_len = Z_STRSIZE(result->u.constant); + length = sizeof("\\")-1 + old_len + Z_STRSIZE(name->u.constant); Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0); Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE; memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1); - memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); + memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant)+1); STR_RELEASE(Z_STR(name->u.constant)); } } @@ -2492,8 +2492,8 @@ int zend_do_begin_class_member_function_call(znode *class_name, znode *method_na if (Z_TYPE(method_name->u.constant) != IS_STRING) { zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string"); } - lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant)); - if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) && + lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRSIZE(method_name->u.constant)); + if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRSIZE(method_name->u.constant) && memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) { zval_dtor(&method_name->u.constant); method_name->op_type = IS_UNUSED; @@ -2502,7 +2502,7 @@ int zend_do_begin_class_member_function_call(znode *class_name, znode *method_na } if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { + ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) { zend_resolve_class_name(class_name TSRMLS_CC); class_node = *class_name; op_number = get_next_op_number(CG(active_op_array)); @@ -2539,7 +2539,7 @@ int zend_do_begin_class_member_function_call(znode *class_name, znode *method_na } /* }}} */ -static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, long num_args, zend_function **func_ptr TSRMLS_DC) /* {{{ */ +static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, zend_int_t num_args, zend_function **func_ptr TSRMLS_DC) /* {{{ */ { zval *function_name; zend_string *lcname; @@ -2548,8 +2548,8 @@ static int zend_do_convert_call(zend_op *init_opline, zend_op *opline, long num_ *func_ptr = NULL; if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) { function_name = &CONSTANT(opline->op1.constant); - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) || ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) && (function->type == ZEND_INTERNAL_FUNCTION))) { @@ -2808,8 +2808,8 @@ static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC if (opline->opcode != ZEND_SEND_VAL || opline->op1_type != IS_CONST || Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL - || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) { + || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRSIZE(CONSTANT(opline->op1.constant))) != NULL + || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRSIZE(CONSTANT(opline->op1.constant))) != NULL) { return 0; } @@ -2818,8 +2818,8 @@ static int zend_do_convert_defined(zend_op *init_opline, znode *result TSRMLS_DC opline->extended_value = 0; GET_CACHE_SLOT(opline->op1.constant); /* lowcase constant name */ - lc_name = STR_ALLOC(Z_STRLEN(CONSTANT(opline->op1.constant)), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant))); + lc_name = STR_ALLOC(Z_STRSIZE(CONSTANT(opline->op1.constant)), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRSIZE(CONSTANT(opline->op1.constant))); ZVAL_NEW_STR(&c, lc_name); zend_add_literal(CG(active_op_array), &c TSRMLS_CC); opline->result.var = get_temporary_variable(CG(active_op_array)); @@ -2839,7 +2839,7 @@ void zend_do_end_function_call(znode *function_name, znode *result, int is_metho if (fcall->arg_num != 0) { zend_error(E_WARNING, "Clone method does not require arguments"); } - opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)]; + opline = &CG(active_op_array)->opcodes[Z_IVAL(function_name->u.constant)]; } else { zend_uint call_flags = 0; @@ -2902,7 +2902,7 @@ void zend_do_end_function_call(znode *function_name, znode *result, int is_metho } else if (func->common.function_name->len == sizeof("is_long")-1 && memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) { if (fcall->arg_num == 1) { - if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) { + if (zend_do_convert_type_check(opline, result, IS_INT TSRMLS_CC)) { zend_stack_del_top(&CG(function_call_stack)); return; } @@ -3337,12 +3337,12 @@ void zend_do_finally(znode *finally_token TSRMLS_DC) /* {{{ */ void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */ { - long catch_op_number; + zend_int_t catch_op_number; zend_op *opline; znode catch_class; if (class_name->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { + ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) { zend_resolve_class_name(class_name TSRMLS_CC); catch_class = *class_name; } else { @@ -3825,7 +3825,7 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ ++idx; while (op < end) { if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT) - && op->op1.num == (long)idx) + && op->op1.num == (zend_int_t)idx) { precv = op; } @@ -3836,9 +3836,9 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ zval *zv = precv->op2.zv; if (Z_TYPE_P(zv) == IS_CONSTANT) { - REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv)); - memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); - offset += Z_STRLEN_P(zv); + REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRSIZE_P(zv)); + memcpy(offset, Z_STRVAL_P(zv), Z_STRSIZE_P(zv)); + offset += Z_STRSIZE_P(zv); } else if (Z_TYPE_P(zv) == IS_FALSE) { memcpy(offset, "false", 5); offset += 5; @@ -3850,10 +3850,10 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{ offset += 4; } else if (Z_TYPE_P(zv) == IS_STRING) { *(offset++) = '\''; - REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10)); - memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10)); - offset += MIN(Z_STRLEN_P(zv), 10); - if (Z_STRLEN_P(zv) > 10) { + REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRSIZE_P(zv), 10)); + memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRSIZE_P(zv), 10)); + offset += MIN(Z_STRSIZE_P(zv), 10); + if (Z_STRSIZE_P(zv) > 10) { *(offset++) = '.'; *(offset++) = '.'; *(offset++) = '.'; @@ -4837,12 +4837,12 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* { not_compatible = (FAILURE == compare_function(&compare_result, &ce->default_static_members_table[coliding_prop->offset], &ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC)) - || (Z_LVAL(compare_result) != 0); + || (Z_IVAL(compare_result) != 0); } else { not_compatible = (FAILURE == compare_function(&compare_result, &ce->default_properties_table[coliding_prop->offset], &ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC)) - || (Z_LVAL(compare_result) != 0); + || (Z_IVAL(compare_result) != 0); } } else { /* the flags are not identical, thus, we assume properties are not compatible */ @@ -5035,20 +5035,20 @@ void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alia zend_class_entry *ce = CG(active_class_entry); zend_trait_alias *trait_alias; - if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) { + if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_STATIC) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier"); return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) { + } else if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier"); return; - } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) { + } else if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_FINAL) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier"); return; } trait_alias = emalloc(sizeof(zend_trait_alias)); trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr; - trait_alias->modifiers = Z_LVAL(modifiers->u.constant); + trait_alias->modifiers = Z_IVAL(modifiers->u.constant); if (alias) { trait_alias->alias = Z_STR(alias->u.constant); } else { @@ -5347,12 +5347,12 @@ void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */ if (expr) { if (expr->op_type != IS_CONST) { zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue"); - } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) { + } else if (Z_TYPE(expr->u.constant) != IS_INT || Z_IVAL(expr->u.constant) < 1) { zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue"); } SET_NODE(opline->op2, expr); } else { - LITERAL_LONG(opline->op2, 1); + LITERAL_INT(opline->op2, 1); opline->op2_type = IS_CONST; } } @@ -5505,8 +5505,8 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name return; } - lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant)); if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) { STR_FREE(lcname); @@ -5528,15 +5528,15 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC); *class_name = tmp; STR_FREE(lcname); - lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant)); + lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant)); } if (error) { - char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); + char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name)); - if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) || - memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) { + if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(class_name->u.constant) || + memcmp(tmp, lcname->val, Z_STRSIZE(class_name->u.constant))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant)); } efree(tmp); @@ -5686,7 +5686,7 @@ void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */ CG(active_class_entry)->name->val); } - switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) { + switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRSIZE(interface_name->u.constant))) { case ZEND_FETCH_CLASS_SELF: case ZEND_FETCH_CLASS_PARENT: case ZEND_FETCH_CLASS_STATIC: @@ -5718,7 +5718,7 @@ void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */ } - switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) { + switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRSIZE(trait_name->u.constant))) { case ZEND_FETCH_CLASS_SELF: case ZEND_FETCH_CLASS_PARENT: case ZEND_FETCH_CLASS_STATIC: @@ -5953,7 +5953,7 @@ void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ cfilename = zend_get_compiled_filename(TSRMLS_C); name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0); - zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); + zend_register_int_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); STR_FREE(name); if (CG(in_namespace)) { @@ -6012,9 +6012,9 @@ static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal char *lookup_name; if (Z_STRVAL_P(const_name)[0] == '\\') { - if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) { + if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRSIZE_P(const_name)-1)) == NULL) { + lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRSIZE_P(const_name)-1); + if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRSIZE_P(const_name)-1)) != NULL) { if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { efree(lookup_name); return c; @@ -6024,8 +6024,8 @@ static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal return NULL; } } else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) { - lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)); - if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) { + lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRSIZE_P(const_name)); + if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRSIZE_P(const_name))) != NULL) { if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) { efree(lookup_name); return c; @@ -6068,13 +6068,13 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con zend_op *opline; int type; char *compound; - ulong fetch_type = 0; + zend_uint_t fetch_type = 0; if (constant_container) { switch (mode) { case ZEND_CT: /* this is a class constant */ - type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant)); + type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRSIZE(constant_container->u.constant)); if (ZEND_FETCH_CLASS_STATIC == type) { zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants"); @@ -6091,7 +6091,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con break; case ZEND_RT: if (constant_container->op_type == IS_CONST && - ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) { + ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRSIZE(constant_container->u.constant))) { zend_resolve_class_name(constant_container TSRMLS_CC); } else { zend_do_fetch_class(&tmp, constant_container TSRMLS_CC); @@ -6122,7 +6122,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con /* only one that did not contain \ from the start can be converted to string if unknown */ switch (mode) { case ZEND_CT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); + compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRSIZE(constant_name->u.constant)); /* this is a namespace constant, or an unprefixed constant */ if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) { @@ -6143,7 +6143,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con Z_CONST_FLAGS(result->u.constant) = fetch_type; break; case ZEND_RT: - compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant)); + compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRSIZE(constant_name->u.constant)); zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC); @@ -6232,12 +6232,12 @@ void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ if (offset) { SET_NODE(opline->op2, offset); if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - ulong index; + zend_uint_t index; opline->extended_value |= ZEND_ARRAY_NOT_PACKED; if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); + ZVAL_INT(&CONSTANT(opline->op2.constant), index); } } } else { @@ -6262,12 +6262,12 @@ void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_b if (offset) { SET_NODE(opline->op2, offset); if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) { - ulong index; + zend_uint_t index; init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED; if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) { zval_dtor(&CONSTANT(opline->op2.constant)); - ZVAL_LONG(&CONSTANT(opline->op2.constant), index); + ZVAL_INT(&CONSTANT(opline->op2.constant), index); } } } else { @@ -6312,7 +6312,7 @@ void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ if (constant_array) { /* try to construct constant array */ zend_uint size; - long num; + zend_int_t num; zend_string *str; if (init_opline->op1_type != IS_UNUSED) { @@ -6334,8 +6334,8 @@ void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ while (i > 0 && constant_array) { if (opline->op2_type == IS_CONST) { switch (Z_TYPE(CONSTANT(opline->op2.constant))) { - case IS_LONG: - num = Z_LVAL(CONSTANT(opline->op2.constant)); + case IS_INT: + num = Z_IVAL(CONSTANT(opline->op2.constant)); num_index: zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant)); if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); @@ -6347,7 +6347,7 @@ str_index: if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant)); break; case IS_DOUBLE: - num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant))); + num = zend_dval_to_ival(Z_DVAL(CONSTANT(opline->op2.constant))); goto num_index; case IS_FALSE: num = 0; @@ -6483,7 +6483,7 @@ void zend_do_list_end(znode *result, znode *expr TSRMLS_DC) /* {{{ */ opline->result.var = get_temporary_variable(CG(active_op_array)); SET_NODE(opline->op1, &last_container); opline->op2_type = IS_CONST; - LITERAL_LONG(opline->op2, *((int *) dimension->data)); + LITERAL_INT(opline->op2, *((int *) dimension->data)); GET_NODE(&last_container, opline->result); dimension = dimension->next; } @@ -6600,7 +6600,7 @@ void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC) { znode value; - if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 && + if (Z_STRSIZE(varname->u.constant) == sizeof("this") - 1 && memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable"); return; @@ -6629,7 +6629,7 @@ void zend_do_fetch_global_variable(znode *varname, const znode *static_assignmen if (varname->op_type == IS_CONST && !zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) && - !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) && + !(Z_STRSIZE(varname->u.constant) == (sizeof("this")-1) && !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) { opline->opcode = ZEND_BIND_GLOBAL; SET_NODE(opline->op2, varname); @@ -6693,7 +6693,7 @@ void zend_do_indirect_references(znode *result, const znode *num_references, zno int i; zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC); - for (i=1; i<Z_LVAL(num_references->u.constant); i++) { + for (i=1; i<Z_IVAL(num_references->u.constant); i++) { fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC); *variable = *result; } @@ -6997,10 +6997,10 @@ void zend_do_declare_begin(TSRMLS_D) /* {{{ */ void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */ { - if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) { - convert_to_long(&val->u.constant); + if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRSIZE(var->u.constant), "ticks", sizeof("ticks")-1)) { + convert_to_int(&val->u.constant); CG(declarables).ticks = val->u.constant; - } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) { + } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRSIZE(var->u.constant), "encoding", sizeof("encoding")-1)) { if (Z_TYPE(val->u.constant) == IS_CONSTANT) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding"); } @@ -7062,7 +7062,7 @@ void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */ { zend_declarables *declarables = zend_stack_top(&CG(declare_stack)); /* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */ - if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) { + if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_IVAL(CG(declarables).ticks))?1:0)) { CG(declarables) = *declarables; } } @@ -7284,7 +7284,7 @@ void zend_do_ticks(TSRMLS_D) /* {{{ */ opline->opcode = ZEND_TICKS; SET_UNUSED(opline->op1); SET_UNUSED(opline->op2); - opline->extended_value = Z_LVAL(CG(declarables).ticks); + opline->extended_value = Z_IVAL(CG(declarables).ticks); } /* }}} */ @@ -7344,7 +7344,7 @@ int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */ } again: - Z_TYPE_INFO(zendlval->u.constant) = IS_LONG; + Z_TYPE_INFO(zendlval->u.constant) = IS_INT; retval = lex_scan(&zendlval->u.constant TSRMLS_CC); switch (retval) { case T_COMMENT: @@ -7472,7 +7472,7 @@ void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRM if (prefix) { *result = *prefix; if (Z_TYPE(result->u.constant) == IS_STRING && - Z_STRLEN(result->u.constant) == 0) { + Z_STRSIZE(result->u.constant) == 0) { /* namespace\ */ if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { znode tmp; @@ -7532,10 +7532,10 @@ void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* { } if (name) { - lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)); - if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) && + lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant)); + if (((Z_STRSIZE(name->u.constant) == sizeof("self")-1) && !memcmp(lcname, "self", sizeof("self")-1)) || - ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) && + ((Z_STRSIZE(name->u.constant) == sizeof("parent")-1) && !memcmp(lcname, "parent", sizeof("parent")-1))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant)); } @@ -7598,7 +7598,7 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{ /* The form "use A\B" is eqivalent to "use A\B as B". So we extract the last part of compound name to use as a new_name */ name = &tmp; - p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns)); + p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRSIZE(ns)); if (p) { ZVAL_STRING(name, p+1); } else { @@ -7607,28 +7607,28 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{ } } - lcname = STR_ALLOC(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + lcname = STR_ALLOC(Z_STRSIZE_P(name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRSIZE_P(name)); - if (((Z_STRLEN_P(name) == sizeof("self")-1) && + if (((Z_STRSIZE_P(name) == sizeof("self")-1) && !memcmp(lcname->val, "self", sizeof("self")-1)) || - ((Z_STRLEN_P(name) == sizeof("parent")-1) && + ((Z_STRSIZE_P(name) == sizeof("parent")-1) && !memcmp(lcname->val, "parent", sizeof("parent")-1))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name)); } if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { /* Prefix import name with current namespace name to avoid conflicts with classes */ - zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_string *c_ns_name = STR_ALLOC(Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name), 0); - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1); + zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace))); + c_ns_name->val[Z_STRSIZE(CG(current_namespace))] = '\\'; + memcpy(c_ns_name->val+Z_STRSIZE(CG(current_namespace))+1, lcname->val, Z_STRSIZE_P(name)+1); if (zend_hash_exists(CG(class_table), c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns)); - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) { + if (Z_STRSIZE(ns) != Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name) || + memcmp(tmp2, c_ns_name->val, Z_STRSIZE(ns))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); } efree(tmp2); @@ -7637,10 +7637,10 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{ } else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL && ce->type == ZEND_USER_CLASS && ce->info.user.filename == CG(compiled_filename)) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns)); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) { + if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) || + memcmp(c_tmp, lcname->val, Z_STRSIZE(ns))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); } efree(c_tmp); @@ -7675,7 +7675,7 @@ void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int i /* The form "use A\B" is eqivalent to "use A\B as B". So we extract the last part of compound name to use as a new_name */ name = &tmp; - p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns)); + p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRSIZE(ns)); if (p) { ZVAL_STRING(name, p+1); } else { @@ -7687,22 +7687,22 @@ void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int i if (case_sensitive) { lookup_name = STR_COPY(Z_STR_P(name)); } else { - lookup_name = STR_ALLOC(Z_STRLEN_P(name), 0); - zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name)); + lookup_name = STR_ALLOC(Z_STRSIZE_P(name), 0); + zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRSIZE_P(name)); } if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) { /* Prefix import name with current namespace name to avoid conflicts with functions/consts */ - zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0); + zend_string *c_ns_name = STR_ALLOC(Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name), 0); - zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); - c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\'; - memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1); + zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace))); + c_ns_name->val[Z_STRSIZE(CG(current_namespace))] = '\\'; + memcpy(c_ns_name->val+Z_STRSIZE(CG(current_namespace))+1, lookup_name, Z_STRSIZE_P(name)+1); if (zend_hash_exists(lookup_table, c_ns_name)) { - char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns)); - if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) || - memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) { + if (Z_STRSIZE(ns) != Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name) || + memcmp(tmp2, c_ns_name->val, Z_STRSIZE(ns))) { zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name)); } efree(tmp2); @@ -7712,10 +7712,10 @@ void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int i zend_function *function; if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns)); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { + if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) || + memcmp(c_tmp, lookup_name->val, Z_STRSIZE(ns))) { zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); } efree(c_tmp); @@ -7724,10 +7724,10 @@ void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int i zend_string *filename; if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) { - char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns)); + char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns)); - if (Z_STRLEN(ns) != Z_STRLEN_P(name) || - memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) { + if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) || + memcmp(c_tmp, lookup_name->val, Z_STRSIZE(ns))) { zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name)); } efree(c_tmp); @@ -7781,8 +7781,8 @@ void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */ znode tmp; tmp.op_type = IS_CONST; - ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRLEN(CG(current_namespace)), 0)); - zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace))); + ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRSIZE(CG(current_namespace)), 0)); + zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace))); zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC); *name = tmp; } @@ -7791,10 +7791,10 @@ void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */ if (CG(current_import_const) && (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) { - char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name)); + char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name)); - if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) || - memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) { + if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(name->u.constant) || + memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant))) { zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant)); } efree(tmp); diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index fa333545f4..6317ceb7cb 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -40,7 +40,7 @@ #define INC_BPC(op_array) if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count++); } #define DEC_BPC(op_array) if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count--); } #define HANDLE_INTERACTIVE() if (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) { execute_new_code(TSRMLS_C); } -#define DO_TICKS() if (Z_LVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); } +#define DO_TICKS() if (Z_IVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); } #define RESET_DOC_COMMENT() \ { \ @@ -67,7 +67,7 @@ typedef union _znode_op { zend_uint constant; zend_uint var; zend_uint num; - zend_ulong hash; + zend_uint_t hash; zend_uint opline_num; /* Needs to be signed */ zend_op *jmp_addr; zval *zv; @@ -100,7 +100,7 @@ struct _zend_op { znode_op op1; znode_op op2; znode_op result; - ulong extended_value; + zend_uint_t extended_value; uint lineno; zend_uchar opcode; zend_uchar op1_type; @@ -128,8 +128,12 @@ typedef struct _zend_try_catch_element { zend_uint finally_end; } zend_try_catch_element; -#if SIZEOF_LONG == 8 -#define THIS_HASHVAL 6385726429UL +#if SIZEOF_ZEND_INT == 8 +# ifdef _WIN32 +# define THIS_HASHVAL 6385726429Ui64 +# else +# define THIS_HASHVAL 6385726429ULL +# endif #else #define THIS_HASHVAL 2090759133UL #endif @@ -210,7 +214,7 @@ char *zend_visibility_string(zend_uint fn_flags); typedef struct _zend_property_info { zend_uint flags; zend_string *name; - ulong h; + zend_uint_t h; int offset; zend_string *doc_comment; zend_class_entry *ce; diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c index 64ea7060fa..9c52056d10 100644 --- a/Zend/zend_constants.c +++ b/Zend/zend_constants.c @@ -113,26 +113,26 @@ int zend_startup_constants(TSRMLS_D) void zend_register_standard_constants(TSRMLS_D) { - REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS); - - REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS); - - REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS); + + REGISTER_MAIN_INT_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS); + + REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS); /* true/false constants */ { REGISTER_MAIN_BOOL_CONSTANT("TRUE", 1, CONST_PERSISTENT | CONST_CT_SUBST); @@ -183,11 +183,11 @@ ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_ zend_register_constant(&c TSRMLS_CC); } -ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC) +ZEND_API void zend_register_int_constant(const char *name, uint name_len, zend_int_t lval, int flags, int module_number TSRMLS_DC) { zend_constant c; - ZVAL_LONG(&c.value, lval); + ZVAL_INT(&c.value, lval); c.flags = flags; c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; @@ -323,7 +323,7 @@ ZEND_API zval *zend_get_constant(zend_string *name TSRMLS_DC) return c ? &c->value : NULL; } -ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, ulong flags TSRMLS_DC) +ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, zend_uint_t flags TSRMLS_DC) { zend_constant *c; const char *colon; @@ -449,7 +449,7 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, } } -zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC) +zend_constant *zend_quick_get_constant(const zval *key, zend_uint_t flags TSRMLS_DC) { zend_constant *c; @@ -465,12 +465,12 @@ zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC) (c->flags & CONST_CS) != 0) { key--; - c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC); + c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRSIZE_P(key) TSRMLS_CC); } } } else { key--; - c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC); + c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRSIZE_P(key) TSRMLS_CC); } } } diff --git a/Zend/zend_constants.h b/Zend/zend_constants.h index 09a5dac63d..d36584d20f 100644 --- a/Zend/zend_constants.h +++ b/Zend/zend_constants.h @@ -39,21 +39,21 @@ typedef struct _zend_constant { #define REGISTER_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name)-1, (flags), module_number TSRMLS_CC) #define REGISTER_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name)-1, (bval), (flags), module_number TSRMLS_CC) -#define REGISTER_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name)-1, (lval), (flags), module_number TSRMLS_CC) +#define REGISTER_INT_CONSTANT(name, lval, flags) zend_register_int_constant((name), sizeof(name)-1, (lval), (flags), module_number TSRMLS_CC) #define REGISTER_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name)-1, (dval), (flags), module_number TSRMLS_CC) #define REGISTER_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), module_number TSRMLS_CC) #define REGISTER_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), module_number TSRMLS_CC) #define REGISTER_NS_NULL_CONSTANT(ns, name, flags) zend_register_null_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (flags), module_number TSRMLS_CC) #define REGISTER_NS_BOOL_CONSTANT(ns, name, bval, flags) zend_register_bool_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (bval), (flags), module_number TSRMLS_CC) -#define REGISTER_NS_LONG_CONSTANT(ns, name, lval, flags) zend_register_long_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (lval), (flags), module_number TSRMLS_CC) +#define REGISTER_NS_INT_CONSTANT(ns, name, lval, flags) zend_register_int_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (lval), (flags), module_number TSRMLS_CC) #define REGISTER_NS_DOUBLE_CONSTANT(ns, name, dval, flags) zend_register_double_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (dval), (flags), module_number TSRMLS_CC) #define REGISTER_NS_STRING_CONSTANT(ns, name, str, flags) zend_register_string_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (flags), module_number TSRMLS_CC) #define REGISTER_NS_STRINGL_CONSTANT(ns, name, str, len, flags) zend_register_stringl_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (len), (flags), module_number TSRMLS_CC) #define REGISTER_MAIN_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name)-1, (flags), 0 TSRMLS_CC) #define REGISTER_MAIN_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name)-1, (bval), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name)-1, (lval), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_INT_CONSTANT(name, lval, flags) zend_register_int_constant((name), sizeof(name)-1, (lval), (flags), 0 TSRMLS_CC) #define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name)-1, (dval), (flags), 0 TSRMLS_CC) #define REGISTER_MAIN_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), 0 TSRMLS_CC) #define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), 0 TSRMLS_CC) @@ -67,16 +67,16 @@ void zend_register_standard_constants(TSRMLS_D); void clean_non_persistent_constants(TSRMLS_D); ZEND_API zval *zend_get_constant(zend_string *name TSRMLS_DC); ZEND_API zval *zend_get_constant_str(const char *name, uint name_len TSRMLS_DC); -ZEND_API zval *zend_get_constant_ex(zend_string *name, zend_class_entry *scope, ulong flags TSRMLS_DC); +ZEND_API zval *zend_get_constant_ex(zend_string *name, zend_class_entry *scope, zend_uint_t flags TSRMLS_DC); ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_bool bval, int flags, int module_number TSRMLS_DC); ZEND_API void zend_register_null_constant(const char *name, uint name_len, int flags, int module_number TSRMLS_DC); -ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC); +ZEND_API void zend_register_int_constant(const char *name, uint name_len, zend_int_t lval, int flags, int module_number TSRMLS_DC); ZEND_API void zend_register_double_constant(const char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC); ZEND_API void zend_register_string_constant(const char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC); ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC); ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC); void zend_copy_constants(HashTable *target, HashTable *sourc); -zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC); +zend_constant *zend_quick_get_constant(const zval *key, zend_uint_t flags TSRMLS_DC); END_EXTERN_C() #define ZEND_CONSTANT_DTOR free_zend_constant diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 754927b577..9fda5d4289 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -163,7 +163,7 @@ static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, Z_SET_REFCOUNT(trace, 0); zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC); - zend_update_property_long(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC); + zend_update_property_int(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC); zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, &trace TSRMLS_CC); return object; @@ -211,7 +211,7 @@ ZEND_METHOD(exception, __construct) } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); } if (previous) { @@ -240,21 +240,21 @@ ZEND_METHOD(error_exception, __construct) } if (code) { - zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC); } if (previous) { zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous TSRMLS_CC); } - zend_update_property_long(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC); if (argc >= 4) { zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename TSRMLS_CC); if (argc < 5) { lineno = 0; /* invalidate lineno */ } - zend_update_property_long(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC); + zend_update_property_int(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC); } } /* }}} */ @@ -354,7 +354,7 @@ ZEND_METHOD(error_exception, getSeverity) zend_error(E_WARNING, "Value for %s is no string", key); \ TRACE_APPEND_STR("[unknown]"); \ } else { \ - TRACE_APPEND_STRL(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)); \ + TRACE_APPEND_STRL(Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); \ } \ } \ } while (0) @@ -386,12 +386,12 @@ static void _build_trace_args(zval *arg, zend_string **str_ptr TSRMLS_DC) /* {{{ case IS_STRING: { int l_added; TRACE_APPEND_CHR('\''); - if (Z_STRLEN_P(arg) > 15) { + if (Z_STRSIZE_P(arg) > 15) { TRACE_APPEND_STRL(Z_STRVAL_P(arg), 15); TRACE_APPEND_STR("...', "); l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */ } else { - l_added = Z_STRLEN_P(arg); + l_added = Z_STRSIZE_P(arg); TRACE_APPEND_STRL(Z_STRVAL_P(arg), l_added); TRACE_APPEND_STR("', "); l_added += 3 + 1; @@ -459,17 +459,17 @@ static void _build_trace_args(zval *arg, zend_string **str_ptr TSRMLS_DC) /* {{{ TRACE_APPEND_STR("true, "); break; case IS_RESOURCE: { - long lval = Z_RES_HANDLE_P(arg); - char s_tmp[MAX_LENGTH_OF_LONG + 1]; + zend_int_t lval = Z_RES_HANDLE_P(arg); + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 1]; int l_tmp = zend_sprintf(s_tmp, "%ld", lval); /* SAFE */ TRACE_APPEND_STR("Resource id #"); TRACE_APPEND_STRL(s_tmp, l_tmp); TRACE_APPEND_STR(", "); break; } - case IS_LONG: { - long lval = Z_LVAL_P(arg); - char s_tmp[MAX_LENGTH_OF_LONG + 1]; + case IS_INT: { + zend_int_t lval = Z_IVAL_P(arg); + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 1]; int l_tmp = zend_sprintf(s_tmp, "%ld", lval); /* SAFE */ TRACE_APPEND_STRL(s_tmp, l_tmp); TRACE_APPEND_STR(", "); @@ -509,7 +509,7 @@ static void _build_trace_args(zval *arg, zend_string **str_ptr TSRMLS_DC) /* {{{ } /* }}} */ -static void _build_trace_string(zval *frame, ulong index, zend_string **str_ptr, int *num TSRMLS_DC) /* {{{ */ +static void _build_trace_string(zval *frame, zend_uint_t index, zend_string **str_ptr, int *num TSRMLS_DC) /* {{{ */ { char *s_tmp; int len; @@ -524,7 +524,7 @@ static void _build_trace_string(zval *frame, ulong index, zend_string **str_ptr, } ht = Z_ARRVAL_P(frame); - s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 1 + 1); + s_tmp = emalloc(1 + MAX_LENGTH_OF_ZEND_INT + 1 + 1); len = sprintf(s_tmp, "#%d ", (*num)++); TRACE_APPEND_STRL(s_tmp, len); efree(s_tmp); @@ -536,8 +536,8 @@ static void _build_trace_string(zval *frame, ulong index, zend_string **str_ptr, } else{ tmp = zend_hash_str_find(ht, "line", sizeof("line")-1); if (tmp) { - if (Z_TYPE_P(tmp) == IS_LONG) { - line = Z_LVAL_P(tmp); + if (Z_TYPE_P(tmp) == IS_INT) { + line = Z_IVAL_P(tmp); } else { zend_error(E_WARNING, "Line is no long"); line = 0; @@ -545,7 +545,7 @@ static void _build_trace_string(zval *frame, ulong index, zend_string **str_ptr, } else { line = 0; } - s_tmp = emalloc(Z_STRLEN_P(file) + MAX_LENGTH_OF_LONG + 4 + 1); + s_tmp = emalloc(Z_STRSIZE_P(file) + MAX_LENGTH_OF_ZEND_INT + 4 + 1); len = sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_P(file), line); TRACE_APPEND_STRL(s_tmp, len); efree(s_tmp); @@ -584,10 +584,10 @@ static void _build_trace_string(zval *frame, ulong index, zend_string **str_ptr, ZEND_METHOD(exception, getTraceAsString) { zval *trace, *frame; - ulong index; + zend_uint_t index; zend_string *str, *key; int num = 0, len; - char s_tmp[MAX_LENGTH_OF_LONG + 7 + 1 + 1]; + char s_tmp[MAX_LENGTH_OF_ZEND_INT + 7 + 1 + 1]; DEFAULT_0_PARAMS; @@ -667,7 +667,7 @@ ZEND_METHOD(exception, __toString) convert_to_string(&message); convert_to_string(&file); - convert_to_long(&line); + convert_to_int(&line); fci.size = sizeof(fci); fci.function_table = &Z_OBJCE_P(exception)->function_table; @@ -686,15 +686,15 @@ ZEND_METHOD(exception, __toString) ZVAL_UNDEF(&trace); } - if (Z_STRLEN(message) > 0) { + if (Z_STRSIZE(message) > 0) { str = zend_strpprintf(0, "exception '%s' with message '%s' in %s:%ld\nStack trace:\n%s%s%s", - Z_OBJCE_P(exception)->name->val, Z_STRVAL(message), Z_STRVAL(file), Z_LVAL(line), - (Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", + Z_OBJCE_P(exception)->name->val, Z_STRVAL(message), Z_STRVAL(file), Z_IVAL(line), + (Z_TYPE(trace) == IS_STRING && Z_STRSIZE(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", prev_str->len ? "\n\nNext " : "", prev_str->val); } else { str = zend_strpprintf(0, "exception '%s' in %s:%ld\nStack trace:\n%s%s%s", - Z_OBJCE_P(exception)->name->val, Z_STRVAL(file), Z_LVAL(line), - (Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", + Z_OBJCE_P(exception)->name->val, Z_STRVAL(file), Z_IVAL(line), + (Z_TYPE(trace) == IS_STRING && Z_STRSIZE(trace)) ? Z_STRVAL(trace) : "#0 {main}\n", prev_str->len ? "\n\nNext " : "", prev_str->val); } STR_RELEASE(prev_str); @@ -775,7 +775,7 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */ zend_declare_property_string(default_exception_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC); zend_declare_property_string(default_exception_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC); - zend_declare_property_long(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC); + zend_declare_property_int(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC); zend_declare_property_null(default_exception_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED TSRMLS_CC); zend_declare_property_null(default_exception_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED TSRMLS_CC); zend_declare_property_null(default_exception_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE TSRMLS_CC); @@ -784,7 +784,7 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */ INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions); error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce TSRMLS_CC); error_exception_ce->create_object = zend_error_exception_new; - zend_declare_property_long(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC); + zend_declare_property_int(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC); } /* }}} */ @@ -819,7 +819,7 @@ ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const zend_update_property_string(default_exception_ce, &ex, "message", sizeof("message")-1, message TSRMLS_CC); } if (code) { - zend_update_property_long(default_exception_ce, &ex, "code", sizeof("code")-1, code TSRMLS_CC); + zend_update_property_int(default_exception_ce, &ex, "code", sizeof("code")-1, code TSRMLS_CC); } zend_throw_exception_internal(&ex TSRMLS_CC); @@ -847,7 +847,7 @@ ZEND_API zend_object *zend_throw_error_exception(zend_class_entry *exception_ce, zval ex; zend_object *obj = zend_throw_exception(exception_ce, message, code TSRMLS_CC); ZVAL_OBJ(&ex, obj); - zend_update_property_long(default_exception_ce, &ex, "severity", sizeof("severity")-1, severity TSRMLS_CC); + zend_update_property_int(default_exception_ce, &ex, "severity", sizeof("severity")-1, severity TSRMLS_CC); return obj; } /* }}} */ @@ -895,13 +895,13 @@ ZEND_API void zend_exception_error(zend_object *ex, int severity TSRMLS_DC) /* { line = zend_read_property(default_exception_ce, &zv, "line", sizeof("line")-1, 1 TSRMLS_CC); convert_to_string(file); - file = (Z_STRLEN_P(file) > 0) ? file : NULL; - line = (Z_TYPE_P(line) == IS_LONG) ? line : NULL; + file = (Z_STRSIZE_P(file) > 0) ? file : NULL; + line = (Z_TYPE_P(line) == IS_INT) ? line : NULL; } else { file = NULL; line = NULL; } - zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val); + zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_IVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val); } str = zend_read_property(default_exception_ce, &exception, "string", sizeof("string")-1, 1 TSRMLS_CC); @@ -910,9 +910,9 @@ ZEND_API void zend_exception_error(zend_object *ex, int severity TSRMLS_DC) /* { convert_to_string(str); convert_to_string(file); - convert_to_long(line); + convert_to_int(line); - zend_error_va(severity, (Z_STRLEN_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_LVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str)); + zend_error_va(severity, (Z_STRSIZE_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_IVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str)); } else { zend_error(severity, "Uncaught exception '%s'", ce_exception->name->val); } diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index f3e97d71d0..54397153c1 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -516,7 +516,7 @@ static inline zval* make_real_object(zval *object_ptr TSRMLS_DC) if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_TYPE_P(object) == IS_NULL || Z_TYPE_P(object) == IS_FALSE - || (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) { + || (Z_TYPE_P(object) == IS_STRING && Z_STRSIZE_P(object) == 0)) { zval_ptr_dtor_nogc(object); object_init(object); zend_error(E_WARNING, "Creating default object from empty value"); @@ -525,7 +525,7 @@ static inline zval* make_real_object(zval *object_ptr TSRMLS_DC) return object; } -ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC) +ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, zend_uint_t fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC) { zend_string *key; ALLOCA_FLAG(use_heap); @@ -574,7 +574,7 @@ ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, zen } } -static void zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC) +static void zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, zend_uint_t fetch_type TSRMLS_DC) { zend_arg_info *cur_arg_info; char *need_msg; @@ -623,7 +623,7 @@ static void zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg } } -static inline int zend_verify_missing_arg_type(zend_function *zf, zend_uint arg_num, ulong fetch_type TSRMLS_DC) +static inline int zend_verify_missing_arg_type(zend_function *zf, zend_uint arg_num, zend_uint_t fetch_type TSRMLS_DC) { zend_arg_info *cur_arg_info; char *need_msg; @@ -695,7 +695,7 @@ static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *p } if (Z_TYPE_P(object) == IS_NULL || Z_TYPE_P(object) == IS_FALSE || - (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) { + (Z_TYPE_P(object) == IS_STRING && Z_STRSIZE_P(object) == 0)) { zend_object *obj; zval_ptr_dtor(object); @@ -781,14 +781,14 @@ static void zend_assign_to_string_offset(zval *str_offset, zval *value, int valu } old_str = Z_STR_P(str); - if (offset >= Z_STRLEN_P(str)) { - int old_len = Z_STRLEN_P(str); + if (offset >= Z_STRSIZE_P(str)) { + int old_len = Z_STRSIZE_P(str); Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), offset + 1, 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len); Z_STRVAL_P(str)[offset+1] = 0; } else if (IS_INTERNED(Z_STR_P(str))) { - Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); + Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; } @@ -1015,23 +1015,23 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht { zval *retval; zend_string *offset_key; - ulong hval; + zend_uint_t hval; - if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - hval = Z_LVAL_P(dim); + if (EXPECTED(Z_TYPE_P(dim) == IS_INT)) { + hval = Z_IVAL_P(dim); num_index: retval = zend_hash_index_find(ht, hval); if (retval == NULL) { switch (type) { case BP_VAR_R: - zend_error(E_NOTICE,"Undefined offset: %ld", hval); + zend_error(E_NOTICE,"Undefined offset: " ZEND_UINT_FMT, hval); /* break missing intentionally */ case BP_VAR_UNSET: case BP_VAR_IS: retval = &EG(uninitialized_zval); break; case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined offset: %ld", hval); + zend_error(E_NOTICE,"Undefined offset: " ZEND_UINT_FMT, hval); /* break missing intentionally */ case BP_VAR_W: retval = zend_hash_index_add_new(ht, hval, &EG(uninitialized_zval)); @@ -1092,7 +1092,7 @@ str_index: offset_key = STR_EMPTY_ALLOC(); goto str_index; case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(dim)); + hval = zend_dval_to_ival(Z_DVAL_P(dim)); goto num_index; case IS_RESOURCE: zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim)); @@ -1139,9 +1139,9 @@ fetch_from_array: ZVAL_INDIRECT(result, retval); } } else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { - long offset; + zend_int_t offset; - if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRLEN_P(container) == 0)) { + if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRSIZE_P(container) == 0)) { zval_dtor(container); convert_to_array: ZVAL_NEW_ARR(container); @@ -1156,10 +1156,10 @@ convert_to_array: SEPARATE_STRING(container); } - if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(dim) != IS_INT)) { switch(Z_TYPE_P(dim)) { case IS_STRING: - if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { + if (IS_INT == is_numeric_string(Z_STRVAL_P(dim), Z_STRSIZE_P(dim), NULL, NULL, -1)) { break; } if (type != BP_VAR_UNSET) { @@ -1177,9 +1177,9 @@ convert_to_array: break; } - offset = zval_get_long(dim); + offset = zval_get_int(dim); } else { - offset = Z_LVAL_P(dim); + offset = Z_IVAL_P(dim); } if (!IS_INTERNED(Z_STR_P(container))) STR_ADDREF(Z_STR_P(container)); @@ -1279,13 +1279,13 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC); ZVAL_COPY(result, retval); } else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) { - long offset; + zend_int_t offset; - if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(dim) != IS_INT)) { switch(Z_TYPE_P(dim)) { - /* case IS_LONG: */ + /* case IS_INT: */ case IS_STRING: - if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { + if (IS_INT == is_numeric_string(Z_STRVAL_P(dim), Z_STRSIZE_P(dim), NULL, NULL, -1)) { break; } if (type != BP_VAR_IS) { @@ -1305,12 +1305,12 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z break; } - offset = zval_get_long(dim); + offset = zval_get_int(dim); } else { - offset = Z_LVAL_P(dim); + offset = Z_IVAL_P(dim); } - if (UNEXPECTED(offset < 0) || UNEXPECTED(Z_STRLEN_P(container) <= offset)) { + if (UNEXPECTED(offset < 0) || UNEXPECTED(Z_STRSIZE_P(container) <= offset)) { if (type != BP_VAR_IS) { zend_error(E_NOTICE, "Uninitialized string offset: %ld", offset); } @@ -1375,7 +1375,7 @@ static void zend_fetch_property_address(zval *result, zval *container_ptr, zval if (type != BP_VAR_UNSET && ((Z_TYPE_P(container) == IS_NULL || Z_TYPE_P(container) == IS_FALSE || - (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) { + (Z_TYPE_P(container) == IS_STRING && Z_STRSIZE_P(container)==0)))) { zval_ptr_dtor_nogc(container); object_init(container); } else { diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index cb7ca70ef3..8ef2cb2f81 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -48,7 +48,7 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC); ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC); -ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC); +ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, zend_uint_t fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC); ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind, zval *arg TSRMLS_DC); static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_DC) @@ -87,8 +87,8 @@ again: case IS_TRUE: result = 1; break; - case IS_LONG: - result = (Z_LVAL_P(op)?1:0); + case IS_INT: + result = (Z_IVAL_P(op)?1:0); break; case IS_RESOURCE: result = (Z_RES_HANDLE_P(op)?1:0); @@ -97,8 +97,8 @@ again: result = (Z_DVAL_P(op) ? 1 : 0); break; case IS_STRING: - if (Z_STRLEN_P(op) == 0 - || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { + if (Z_STRSIZE_P(op) == 0 + || (Z_STRSIZE_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { result = 0; } else { result = 1; @@ -279,7 +279,7 @@ ZEND_API const char *zend_get_executed_filename(TSRMLS_D); ZEND_API uint zend_get_executed_lineno(TSRMLS_D); ZEND_API zend_bool zend_is_executing(TSRMLS_D); -ZEND_API void zend_set_timeout(long seconds, int reset_signals); +ZEND_API void zend_set_timeout(zend_int_t seconds, int reset_signals); ZEND_API void zend_unset_timeout(TSRMLS_D); ZEND_API void zend_timeout(int dummy); ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type TSRMLS_DC); diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 8af877215c..eba2d39c5f 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -531,11 +531,11 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas if (!const_value) { char *actual = Z_STRVAL_P(p); - if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p)))) { + if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRSIZE_P(p)))) { int len; zend_error(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(p)); - len = Z_STRLEN_P(p) - ((colon - Z_STRVAL_P(p)) + 1); + len = Z_STRSIZE_P(p) - ((colon - Z_STRVAL_P(p)) + 1); if (inline_change) { zend_string *tmp = STR_INIT(colon + 1, len, 0); STR_RELEASE(Z_STR_P(p)); @@ -547,7 +547,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas } else { zend_string *save = Z_STR_P(p); char *slash; - int actual_len = Z_STRLEN_P(p); + int actual_len = Z_STRSIZE_P(p); if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) { actual = slash + 1; actual_len -= (actual - Z_STRVAL_P(p)); @@ -559,8 +559,8 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas } if (actual[0] == '\\') { if (inline_change) { - memmove(Z_STRVAL_P(p), Z_STRVAL_P(p)+1, Z_STRLEN_P(p)); - --Z_STRLEN_P(p); + memmove(Z_STRVAL_P(p), Z_STRVAL_P(p)+1, Z_STRSIZE_P(p)); + --Z_STRSIZE_P(p); } else { ++actual; } @@ -1069,8 +1069,8 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s ZVAL_NEW_STR(&pv, STR_ALLOC(str_len + sizeof("return ;")-1, 1)); memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1); memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, str, str_len); - Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';'; - Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0'; + Z_STRVAL(pv)[Z_STRSIZE(pv) - 1] = ';'; + Z_STRVAL(pv)[Z_STRSIZE(pv)] = '\0'; } else { ZVAL_STRINGL(&pv, str, str_len); } @@ -1183,7 +1183,7 @@ void execute_new_code(TSRMLS_D) /* {{{ */ } switch (opline->opcode) { case ZEND_GOTO: - if (Z_TYPE_P(opline->op2.zv) != IS_LONG) { + if (Z_TYPE_P(opline->op2.zv) != IS_INT) { zend_resolve_goto_label(CG(active_op_array), opline, 1 TSRMLS_CC); } /* break omitted intentionally */ @@ -1360,7 +1360,7 @@ void zend_shutdown_timeout_thread(void) /* {{{ */ #define SIGPROF 27 #endif -void zend_set_timeout(long seconds, int reset_signals) /* {{{ */ +void zend_set_timeout(zend_int_t seconds, int reset_signals) /* {{{ */ { TSRMLS_FETCH(); @@ -1680,7 +1680,7 @@ ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force TSRMLS if (execute_data) { if (!execute_data->symbol_table) { - zend_ulong h = STR_HASH_VAL(name); + zend_uint_t h = STR_HASH_VAL(name); zend_op_array *op_array = &execute_data->func->op_array; int i; @@ -1716,7 +1716,7 @@ ZEND_API int zend_set_local_var_str(const char *name, int len, zval *value, int if (execute_data) { if (!execute_data->symbol_table) { - zend_ulong h = zend_hash_func(name, len); + zend_uint_t h = zend_hash_func(name, len); zend_op_array *op_array = &execute_data->func->op_array; int i; diff --git a/Zend/zend_generators.h b/Zend/zend_generators.h index 5d1264cc4f..ba6fe1b8ca 100644 --- a/Zend/zend_generators.h +++ b/Zend/zend_generators.h @@ -43,7 +43,7 @@ typedef struct _zend_generator { /* Variable to put sent value into */ zval *send_target; /* Largest used integer key for auto-incrementing keys */ - long largest_used_integer_key; + zend_int_t largest_used_integer_key; /* ZEND_GENERATOR_* flags */ zend_uchar flags; diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 082e733844..81ddfb9396 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -112,7 +112,7 @@ struct _zend_compiler_globals { zend_llist open_files; - long catch_begin; + zend_int_t catch_begin; struct _zend_ini_parser_param *ini_parser_param; @@ -188,7 +188,7 @@ struct _zend_executor_globals { zval This; - long precision; + zend_int_t precision; int ticks_count; @@ -220,7 +220,7 @@ struct _zend_executor_globals { zend_class_entry *exception_class; /* timeout support */ - int timeout_seconds; + zend_int_t timeout_seconds; int lambda_count; diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 78b38f7ea2..3fe499c0c4 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -183,7 +183,7 @@ ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProt static zend_always_inline Bucket *zend_hash_find_bucket(const HashTable *ht, zend_string *key) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -205,7 +205,7 @@ static zend_always_inline Bucket *zend_hash_find_bucket(const HashTable *ht, zen return NULL; } -static zend_always_inline Bucket *zend_hash_str_find_bucket(const HashTable *ht, const char *str, int len, ulong h) +static zend_always_inline Bucket *zend_hash_str_find_bucket(const HashTable *ht, const char *str, int len, zend_uint_t h) { uint nIndex; uint idx; @@ -227,7 +227,7 @@ static zend_always_inline Bucket *zend_hash_str_find_bucket(const HashTable *ht, return NULL; } -static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *ht, ulong h) +static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *ht, zend_uint_t h) { uint nIndex; uint idx; @@ -248,7 +248,7 @@ static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *h static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -375,7 +375,7 @@ ZEND_API zval *_zend_hash_str_add_new(HashTable *ht, const char *str, int len, z return ret; } -ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, ulong h) +ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, zend_uint_t h) { zval dummy; @@ -402,7 +402,7 @@ ZEND_API zval *zend_hash_str_add_empty_element(HashTable *ht, const char *str, i return zend_hash_str_add(ht, str, len, &dummy); } -static zend_always_inline zval *_zend_hash_index_update_or_next_insert_i(HashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC) +static zend_always_inline zval *_zend_hash_index_update_or_next_insert_i(HashTable *ht, zend_uint_t h, zval *pData, int flag ZEND_FILE_LINE_DC) { uint nIndex; uint idx; @@ -430,8 +430,8 @@ static zend_always_inline zval *_zend_hash_index_update_or_next_insert_i(HashTab ht->pDestructor(&p->val); } ZVAL_COPY_VALUE(&p->val, pData); - if ((long)h >= (long)ht->nNextFreeElement) { - ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX; + if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) { + ht->nNextFreeElement = h < ZEND_INT_MAX ? h + 1 : ZEND_INT_MAX; } return &p->val; } else { /* we have to keep the order :( */ @@ -460,8 +460,8 @@ static zend_always_inline zval *_zend_hash_index_update_or_next_insert_i(HashTab if (ht->nInternalPointer == INVALID_IDX) { ht->nInternalPointer = h; } - if ((long)h >= (long)ht->nNextFreeElement) { - ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX; + if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) { + ht->nNextFreeElement = h < ZEND_INT_MAX ? h + 1 : ZEND_INT_MAX; } p->h = h; p->key = NULL; @@ -490,8 +490,8 @@ convert_to_hash: } ZVAL_COPY_VALUE(&p->val, pData); HANDLE_UNBLOCK_INTERRUPTIONS(); - if ((long)h >= (long)ht->nNextFreeElement) { - ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX; + if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) { + ht->nNextFreeElement = h < ZEND_INT_MAX ? h + 1 : ZEND_INT_MAX; } return &p->val; } @@ -505,8 +505,8 @@ convert_to_hash: if (ht->nInternalPointer == INVALID_IDX) { ht->nInternalPointer = idx; } - if ((long)h >= (long)ht->nNextFreeElement) { - ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX; + if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) { + ht->nNextFreeElement = h < ZEND_INT_MAX ? h + 1 : ZEND_INT_MAX; } p = ht->arData + idx; p->h = h; @@ -520,22 +520,22 @@ convert_to_hash: return &p->val; } -ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC) +ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, zval *pData, int flag ZEND_FILE_LINE_DC) { return _zend_hash_index_update_or_next_insert_i(ht, h, pData, flag ZEND_FILE_LINE_RELAY_CC); } -ZEND_API zval *_zend_hash_index_add(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC) +ZEND_API zval *_zend_hash_index_add(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC) { return _zend_hash_index_update_or_next_insert_i(ht, h, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC); } -ZEND_API zval *_zend_hash_index_add_new(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC) +ZEND_API zval *_zend_hash_index_add_new(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC) { return _zend_hash_index_update_or_next_insert_i(ht, h, pData, HASH_ADD | HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC); } -ZEND_API zval *_zend_hash_index_update(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC) +ZEND_API zval *_zend_hash_index_update(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC) { return _zend_hash_index_update_or_next_insert_i(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC); } @@ -669,7 +669,7 @@ static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint idx, Bucket ZEND_API int zend_hash_del(HashTable *ht, zend_string *key) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -708,7 +708,7 @@ ZEND_API int zend_hash_del(HashTable *ht, zend_string *key) ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -760,7 +760,7 @@ ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key) ZEND_API int zend_hash_str_del(HashTable *ht, const char *str, int len) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -811,7 +811,7 @@ ZEND_API int zend_hash_str_del(HashTable *ht, const char *str, int len) ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *str, int len) { - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; @@ -843,7 +843,7 @@ ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *str, int len) return FAILURE; } -ZEND_API int zend_hash_index_del(HashTable *ht, ulong h) +ZEND_API int zend_hash_index_del(HashTable *ht, zend_uint_t h) { uint nIndex; uint idx; @@ -1383,7 +1383,7 @@ ZEND_API zval *zend_hash_find(const HashTable *ht, zend_string *key) ZEND_API zval *zend_hash_str_find(const HashTable *ht, const char *str, int len) { - ulong h; + zend_uint_t h; Bucket *p; IS_CONSISTENT(ht); @@ -1413,7 +1413,7 @@ ZEND_API int zend_hash_exists(const HashTable *ht, zend_string *key) ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len) { - ulong h; + zend_uint_t h; Bucket *p; IS_CONSISTENT(ht); @@ -1427,7 +1427,7 @@ ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len) return p ? 1 : 0; } -ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h) +ZEND_API zval *zend_hash_index_find(const HashTable *ht, zend_uint_t h) { Bucket *p; @@ -1448,7 +1448,7 @@ ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h) } -ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h) +ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h) { Bucket *p; @@ -1602,7 +1602,7 @@ ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos) /* This function should be made binary safe */ -ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, ulong *num_index, zend_bool duplicate, HashPosition *pos) +ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos) { uint idx = *pos; Bucket *p; @@ -1619,7 +1619,7 @@ ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str return HASH_KEY_IS_STRING; } else { *num_index = p->h; - return HASH_KEY_IS_LONG; + return HASH_KEY_IS_INT; } } return HASH_KEY_NON_EXISTENT; @@ -1639,7 +1639,7 @@ ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, ZVAL_STR(key, p->key); STR_ADDREF(p->key); } else { - ZVAL_LONG(key, p->h); + ZVAL_INT(key, p->h); } } } @@ -1655,7 +1655,7 @@ ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos) if (p->key) { return HASH_KEY_IS_STRING; } else { - return HASH_KEY_IS_LONG; + return HASH_KEY_IS_INT; } } return HASH_KEY_NON_EXISTENT; diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h index d7b419225e..f9c7f02efe 100644 --- a/Zend/zend_hash.h +++ b/Zend/zend_hash.h @@ -26,7 +26,7 @@ #include "zend.h" #define HASH_KEY_IS_STRING 1 -#define HASH_KEY_IS_LONG 2 +#define HASH_KEY_IS_INT 2 #define HASH_KEY_NON_EXISTENT 3 #define HASH_KEY_NON_EXISTANT HASH_KEY_NON_EXISTENT /* Keeping old define (with typo) for backward compatibility */ @@ -45,7 +45,7 @@ #define HASH_MASK_CONSISTENCY 0x60 typedef struct _zend_hash_key { - ulong h; + zend_uint_t h; zend_string *key; } zend_hash_key; @@ -98,10 +98,10 @@ ZEND_API zval *_zend_hash_str_add_new(HashTable *ht, const char *key, int len, z #define zend_hash_str_add_new(ht, key, len, pData) \ _zend_hash_str_add_new(ht, key, len, pData ZEND_FILE_LINE_CC) -ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC); -ZEND_API zval *_zend_hash_index_add(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC); -ZEND_API zval *_zend_hash_index_add_new(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC); -ZEND_API zval *_zend_hash_index_update(HashTable *ht, ulong h, zval *pData ZEND_FILE_LINE_DC); +ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, zval *pData, int flag ZEND_FILE_LINE_DC); +ZEND_API zval *_zend_hash_index_add(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC); +ZEND_API zval *_zend_hash_index_add_new(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC); +ZEND_API zval *_zend_hash_index_update(HashTable *ht, zend_uint_t h, zval *pData ZEND_FILE_LINE_DC); ZEND_API zval *_zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC); ZEND_API zval *_zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_FILE_LINE_DC); @@ -116,7 +116,7 @@ ZEND_API zval *_zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_ #define zend_hash_next_index_insert_new(ht, pData) \ _zend_hash_next_index_insert_new(ht, pData ZEND_FILE_LINE_CC) -ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, ulong h); +ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, zend_uint_t h); ZEND_API zval *zend_hash_add_empty_element(HashTable *ht, zend_string *key); ZEND_API zval *zend_hash_str_add_empty_element(HashTable *ht, const char *key, int len); @@ -148,24 +148,24 @@ ZEND_API int zend_hash_del(HashTable *ht, zend_string *key); ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key); ZEND_API int zend_hash_str_del(HashTable *ht, const char *key, int len); ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *key, int len); -ZEND_API int zend_hash_index_del(HashTable *ht, ulong h); +ZEND_API int zend_hash_index_del(HashTable *ht, zend_uint_t h); /* Data retreival */ ZEND_API zval *zend_hash_find(const HashTable *ht, zend_string *key); ZEND_API zval *zend_hash_str_find(const HashTable *ht, const char *key, int len); -ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h); +ZEND_API zval *zend_hash_index_find(const HashTable *ht, zend_uint_t h); /* Misc */ ZEND_API int zend_hash_exists(const HashTable *ht, zend_string *key); ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len); -ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h); +ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h); /* traversing */ #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 int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos); ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos); -ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, ulong *num_index, zend_bool duplicate, HashPosition *pos); +ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos); ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos); ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos); ZEND_API zval *zend_hash_get_current_data_ex(HashTable *ht, HashPosition *pos); @@ -175,7 +175,7 @@ ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos typedef struct _HashPointer { HashPosition pos; HashTable *ht; - ulong h; + zend_uint_t h; } HashPointer; ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr); @@ -235,7 +235,7 @@ END_EXTERN_C() #define ZEND_INIT_SYMTABLE_EX(ht, n, persistent) \ zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent) -static inline int _zend_handle_numeric_str(const char *key, int length, ulong *idx) +static inline int _zend_handle_numeric_str(const char *key, zend_size_t length, zend_uint_t *idx) { register const char *tmp = key; const char *end; @@ -257,9 +257,9 @@ static inline int _zend_handle_numeric_str(const char *key, int length, ulong *i if ((*end != '\0') /* not a null terminated string */ || (*tmp == '0' && length > 1) /* numbers with leading zeros */ - || (end - tmp > MAX_LENGTH_OF_LONG - 1) /* number too long */ - || (SIZEOF_LONG == 4 && - end - tmp == MAX_LENGTH_OF_LONG - 1 && + || (end - tmp > MAX_LENGTH_OF_ZEND_INT - 1) /* number too long */ + || (SIZEOF_ZEND_INT == 4 && + end - tmp == MAX_LENGTH_OF_ZEND_INT - 1 && *tmp > '2')) { /* overflow */ return 0; } @@ -268,11 +268,11 @@ static inline int _zend_handle_numeric_str(const char *key, int length, ulong *i ++tmp; if (tmp == end) { if (*key == '-') { - if (*idx-1 > LONG_MAX) { /* overflow */ + if (*idx-1 > ZEND_INT_MAX) { /* overflow */ return 0; } *idx = 0 - *idx; - } else if (*idx > LONG_MAX) { /* overflow */ + } else if (*idx > ZEND_INT_MAX) { /* overflow */ return 0; } return 1; @@ -322,7 +322,7 @@ static inline zval *zend_hash_str_find_ind(const HashTable *ht, const char *str, static inline zval *zend_symtable_update(HashTable *ht, zend_string *key, zval *pData) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_update(ht, idx, pData); @@ -334,7 +334,7 @@ static inline zval *zend_symtable_update(HashTable *ht, zend_string *key, zval * static inline zval *zend_symtable_update_ind(HashTable *ht, zend_string *key, zval *pData) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_update(ht, idx, pData); @@ -346,7 +346,7 @@ static inline zval *zend_symtable_update_ind(HashTable *ht, zend_string *key, zv static inline int zend_symtable_del(HashTable *ht, zend_string *key) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_del(ht, idx); @@ -358,7 +358,7 @@ static inline int zend_symtable_del(HashTable *ht, zend_string *key) static inline int zend_symtable_del_ind(HashTable *ht, zend_string *key) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_del(ht, idx); @@ -370,7 +370,7 @@ static inline int zend_symtable_del_ind(HashTable *ht, zend_string *key) static inline zval *zend_symtable_find(const HashTable *ht, zend_string *key) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_find(ht, idx); @@ -382,7 +382,7 @@ static inline zval *zend_symtable_find(const HashTable *ht, zend_string *key) static inline zval *zend_symtable_find_ind(const HashTable *ht, zend_string *key) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_find(ht, idx); @@ -394,7 +394,7 @@ static inline zval *zend_symtable_find_ind(const HashTable *ht, zend_string *key static inline int zend_symtable_exists(HashTable *ht, zend_string *key) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC(key, idx)) { return zend_hash_index_exists(ht, idx); @@ -406,7 +406,7 @@ static inline int zend_symtable_exists(HashTable *ht, zend_string *key) static inline zval *zend_symtable_str_update(HashTable *ht, const char *str, int len, zval *pData) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_update(ht, idx, pData); @@ -418,7 +418,7 @@ static inline zval *zend_symtable_str_update(HashTable *ht, const char *str, int static inline zval *zend_symtable_str_update_ind(HashTable *ht, const char *str, int len, zval *pData) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_update(ht, idx, pData); @@ -430,7 +430,7 @@ static inline zval *zend_symtable_str_update_ind(HashTable *ht, const char *str, static inline int zend_symtable_str_del(HashTable *ht, const char *str, int len) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_del(ht, idx); @@ -442,7 +442,7 @@ static inline int zend_symtable_str_del(HashTable *ht, const char *str, int len) static inline int zend_symtable_str_del_ind(HashTable *ht, const char *str, int len) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_del(ht, idx); @@ -454,7 +454,7 @@ static inline int zend_symtable_str_del_ind(HashTable *ht, const char *str, int static inline zval *zend_symtable_str_find(HashTable *ht, const char *str, int len) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_find(ht, idx); @@ -466,7 +466,7 @@ static inline zval *zend_symtable_str_find(HashTable *ht, const char *str, int l static inline int zend_symtable_str_exists(HashTable *ht, const char *str, int len) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_exists(ht, idx); @@ -564,7 +564,7 @@ static inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, int return zend_hash_str_update_ptr(ht, str, len, p); } -static inline void *zend_hash_index_update_ptr(HashTable *ht, ulong h, void *pData) +static inline void *zend_hash_index_update_ptr(HashTable *ht, zend_uint_t h, void *pData) { zval tmp, *zv; @@ -582,7 +582,7 @@ static inline void *zend_hash_next_index_insert_ptr(HashTable *ht, void *pData) return zv ? Z_PTR_P(zv) : NULL; } -static inline void *zend_hash_index_update_mem(HashTable *ht, ulong h, void *pData, size_t size) +static inline void *zend_hash_index_update_mem(HashTable *ht, zend_uint_t h, void *pData, size_t size) { void *p; @@ -620,7 +620,7 @@ static inline void *zend_hash_str_find_ptr(const HashTable *ht, const char *str, return zv ? Z_PTR_P(zv) : NULL; } -static inline void *zend_hash_index_find_ptr(const HashTable *ht, ulong h) +static inline void *zend_hash_index_find_ptr(const HashTable *ht, zend_uint_t h) { zval *zv; @@ -630,7 +630,7 @@ static inline void *zend_hash_index_find_ptr(const HashTable *ht, ulong h) static inline void *zend_symtable_str_find_ptr(HashTable *ht, const char *str, int len) { - ulong idx; + zend_uint_t idx; if (ZEND_HANDLE_NUMERIC_STR(str, len, idx)) { return zend_hash_index_find_ptr(ht, idx); diff --git a/Zend/zend_ini.c b/Zend/zend_ini.c index c3a02d53a3..52585005b9 100644 --- a/Zend/zend_ini.c +++ b/Zend/zend_ini.c @@ -208,9 +208,9 @@ ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int modu hashed_ini_entry->module_number = module_number; if ((zend_get_configuration_directive(p->name, p->name_length, &default_value)) == SUCCESS) { if (!hashed_ini_entry->on_modify - || hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRLEN(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) { + || hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRSIZE(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) { hashed_ini_entry->value = Z_STRVAL(default_value); - hashed_ini_entry->value_length = Z_STRLEN(default_value); + hashed_ini_entry->value_length = Z_STRSIZE(default_value); config_directive_success = 1; } } @@ -352,7 +352,7 @@ ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*di * Data retrieval */ -ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */ +ZEND_API zend_int_t zend_ini_int(char *name, uint name_length, int orig) /* {{{ */ { zend_ini_entry *ini_entry; TSRMLS_FETCH(); @@ -360,9 +360,9 @@ ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */ ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length); if (ini_entry) { if (orig && ini_entry->modified) { - return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0); + return (ini_entry->orig_value ? ZEND_STRTOI(ini_entry->orig_value, NULL, 0) : 0); } else { - return (ini_entry->value ? strtol(ini_entry->value, NULL, 0) : 0); + return (ini_entry->value ? ZEND_STRTOI(ini_entry->value, NULL, 0) : 0); } } @@ -587,7 +587,7 @@ ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */ ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */ { - long *p; + zend_int_t *p; #ifndef ZTS char *base = (char *) mh_arg2; #else @@ -596,7 +596,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */ base = (char *) ts_resource(*((int *) mh_arg2)); #endif - p = (long *) (base+(size_t) mh_arg1); + p = (zend_int_t *) (base+(size_t) mh_arg1); *p = zend_atol(new_value, new_value_length); return SUCCESS; @@ -605,7 +605,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */ ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */ { - long *p, tmp; + zend_int_t *p, tmp; #ifndef ZTS char *base = (char *) mh_arg2; #else @@ -619,7 +619,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */ return FAILURE; } - p = (long *) (base+(size_t) mh_arg1); + p = (zend_int_t *) (base+(size_t) mh_arg1); *p = tmp; return SUCCESS; diff --git a/Zend/zend_ini.h b/Zend/zend_ini.h index 0a0c1137e1..4ed2b99387 100644 --- a/Zend/zend_ini.h +++ b/Zend/zend_ini.h @@ -69,7 +69,7 @@ ZEND_API int zend_alter_ini_entry_ex(zend_string *name, char *new_value, uint ne ZEND_API int zend_restore_ini_entry(zend_string *name, int stage); ZEND_API void display_ini_entries(zend_module_entry *module); -ZEND_API long zend_ini_long(char *name, uint name_length, int orig); +ZEND_API zend_int_t zend_ini_int(char *name, uint name_length, int orig); ZEND_API double zend_ini_double(char *name, uint name_length, int orig); ZEND_API char *zend_ini_string(char *name, uint name_length, int orig); ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists); @@ -124,12 +124,12 @@ END_EXTERN_C() ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb) #endif -#define INI_INT(name) zend_ini_long((name), sizeof(name)-1, 0) +#define INI_INT(name) zend_ini_int((name), sizeof(name)-1, 0) #define INI_FLT(name) zend_ini_double((name), sizeof(name)-1, 0) #define INI_STR(name) zend_ini_string_ex((name), sizeof(name)-1, 0, NULL) #define INI_BOOL(name) ((zend_bool) INI_INT(name)) -#define INI_ORIG_INT(name) zend_ini_long((name), sizeof(name)-1, 1) +#define INI_ORIG_INT(name) zend_ini_int((name), sizeof(name)-1, 1) #define INI_ORIG_FLT(name) zend_ini_double((name), sizeof(name)-1, 1) #define INI_ORIG_STR(name) zend_ini_string((name), sizeof(name)-1, 1) #define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name)) diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y index eaf451a3a1..7981cff3d4 100644 --- a/Zend/zend_ini_parser.y +++ b/Zend/zend_ini_parser.y @@ -50,7 +50,7 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2) int i_result; int i_op1, i_op2; int str_len; - char str_result[MAX_LENGTH_OF_LONG]; + char str_result[MAX_LENGTH_OF_ZEND_INT]; i_op1 = atoi(Z_STRVAL_P(op1)); STR_FREE(Z_STR_P(op1)); @@ -99,11 +99,11 @@ static void zend_ini_init_string(zval *result) */ static void zend_ini_add_string(zval *result, zval *op1, zval *op2) { - int op1_len = Z_STRLEN_P(op1); - int length = op1_len + Z_STRLEN_P(op2); + int op1_len = Z_STRSIZE_P(op1); + int length = op1_len + Z_STRSIZE_P(op2); ZVAL_NEW_STR(result, STR_REALLOC(Z_STR_P(op1), length, 1)); - memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRSIZE_P(op2)); Z_STRVAL_P(result)[length] = 0; } /* }}} */ @@ -115,7 +115,7 @@ static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC) zval *c, tmp; /* If name contains ':' it is not a constant. Bug #26893. */ - if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name)) + if (!memchr(Z_STRVAL_P(name), ':', Z_STRSIZE_P(name)) && (c = zend_get_constant(Z_STR_P(name) TSRMLS_CC)) != 0) { if (Z_TYPE_P(c) != IS_STRING) { ZVAL_COPY_VALUE(&tmp, c); @@ -126,7 +126,7 @@ static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC) convert_to_string(&tmp); c = &tmp; } - ZVAL_PSTRINGL(result, Z_STRVAL_P(c), Z_STRLEN_P(c)); + ZVAL_PSTRINGL(result, Z_STRVAL_P(c), Z_STRSIZE_P(c)); if (c == &tmp) { zval_dtor(&tmp); } @@ -145,10 +145,10 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC) char *envvar; /* Fetch configuration option value */ - if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name), &curval) == SUCCESS) { - ZVAL_PSTRINGL(result, Z_STRVAL(curval), Z_STRLEN(curval)); + if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRSIZE_P(name), &curval) == SUCCESS) { + ZVAL_PSTRINGL(result, Z_STRVAL(curval), Z_STRSIZE(curval)); /* ..or if not found, try ENV */ - } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL || + } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRSIZE_P(name) TSRMLS_CC)) != NULL || (envvar = getenv(Z_STRVAL_P(name))) != NULL) { ZVAL_PSTRING(result, envvar); } else { diff --git a/Zend/zend_ini_scanner.c b/Zend/zend_ini_scanner.c index b71f1ccb3c..981ab50100 100644 --- a/Zend/zend_ini_scanner.c +++ b/Zend/zend_ini_scanner.c @@ -269,7 +269,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty /* convert escape sequences */ s = t = Z_STRVAL_P(lval); - end = s + Z_STRLEN_P(lval); + end = s + Z_STRSIZE_P(lval); while (s < end) { if (*s == '\\') { @@ -288,7 +288,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty case '\\': case '$': *t++ = *s; - Z_STRLEN_P(lval)--; + Z_STRSIZE_P(lval)--; break; default: *t++ = '\\'; diff --git a/Zend/zend_ini_scanner.l b/Zend/zend_ini_scanner.l index bbc48d1fc1..0bd303f54a 100644 --- a/Zend/zend_ini_scanner.l +++ b/Zend/zend_ini_scanner.l @@ -267,7 +267,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty /* convert escape sequences */ s = t = Z_STRVAL_P(lval); - end = s + Z_STRLEN_P(lval); + end = s + Z_STRSIZE_P(lval); while (s < end) { if (*s == '\\') { @@ -286,7 +286,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty case '\\': case '$': *t++ = *s; - Z_STRLEN_P(lval)--; + Z_STRSIZE_P(lval)--; break; default: *t++ = '\\'; diff --git a/Zend/zend_int.h b/Zend/zend_int.h new file mode 100644 index 0000000000..de48718365 --- /dev/null +++ b/Zend/zend_int.h @@ -0,0 +1,145 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Anatol Belski <ab@php.net> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + + +#ifndef ZEND_INT_H +#define ZEND_INT_H + +#ifndef ZEND_WIN32 +/* this probably needs more on non windows, like for C++ and C99*/ +# include <stdint.h> +# include <inttypes.h> +#endif + +/* This is the heart of the whole int64 enablement in zval. Based on this + macros the zend_size_t datatype is handled, see zend_types.h */ +#if defined(__X86_64__) || defined(__LP64__) || defined(_LP64) || defined(_WIN64) +# define ZEND_ENABLE_INT64 1 +#endif + +/* Integer types or the old bad long. */ +#ifdef ZEND_ENABLE_INT64 +# ifdef ZEND_WIN32 +# ifdef _WIN64 +typedef __int64 zend_int_t; +typedef unsigned __int64 zend_uint_t; +typedef __int64 zend_off_t; +# define ZEND_INT_MAX _I64_MAX +# define ZEND_INT_MIN _I64_MIN +# define ZEND_UINT_MAX _UI64_MAX +# define Z_I(i) i##i64 +# define Z_UI(i) i##Ui64 +# else +# error Cant enable 64 bit integers on non 64 bit platform +# endif +# else +# if defined(__X86_64__) || defined(__LP64__) || defined(_LP64) +typedef int64_t zend_int_t; +typedef uint64_t zend_uint_t; +typedef off_t zend_off_t; +# define ZEND_INT_MAX INT64_MAX +# define ZEND_INT_MIN INT64_MIN +# define ZEND_UINT_MAX UINT64_MAX +# define Z_I(i) i##LL +# define Z_UI(i) i##ULL +# else +# error Cant enable 64 bit integers on non 64 bit platform +# endif +# endif +# define SIZEOF_ZEND_INT 8 +#else +typedef long zend_int_t; +typedef unsigned long zend_uint_t; +typedef long zend_off_t; +# define ZEND_INT_MAX LONG_MAX +# define ZEND_INT_MIN LONG_MIN +# define ZEND_UINT_MAX ULONG_MAX +# define Z_I(i) i##L +# define Z_UI(i) i##UL +# define SIZEOF_ZEND_INT SIZEOF_LONG +#endif + + +/* conversion macros */ +#define ZEND_ITOA_BUF_LEN 65 + +#ifdef ZEND_ENABLE_INT64 +# ifdef PHP_WIN32 +# define ZEND_ITOA(i, s, len) _i64toa_s((i), (s), (len), 10) +# define ZEND_ATOI(i, s) i = _atoi64((s)) +# define ZEND_STRTOI(s0, s1, base) _strtoi64((s0), (s1), (base)) +# define ZEND_STRTOUI(s0, s1, base) _strtoui64((s0), (s1), (base)) +# define ZEND_INT_FMT "%I64d" +# define ZEND_UINT_FMT "%I64u" +# define ZEND_INT_FMT_SPEC "I64d" +# define ZEND_UINT_FMT_SPEC "I64u" +# define ZEND_STRTOI_PTR _strtoi64 +# define ZEND_STRTOUI_PTR _strtoui64 +# define ZEND_ABS _abs64 +# else +# define ZEND_ITOA(i, s, len) \ + do { \ + int st = snprintf((s), (len), "%lld", (i)); \ + (s)[st] = '\0'; \ + } while (0) +# define ZEND_ATOI(i, s) (i) = atoll((s)) +# define ZEND_STRTOI(s0, s1, base) strtoll((s0), (s1), (base)) +# define ZEND_STRTOUI(s0, s1, base) strtoull((s0), (s1), (base)) +# define ZEND_INT_FMT "%" PRId64 +# define ZEND_UINT_FMT "%" PRIu64 +# define ZEND_INT_FMT_SPEC PRId64 +# define ZEND_UINT_FMT_SPEC PRIu64 +# define ZEND_STRTOI_PTR strtoll +# define ZEND_STRTOUI_PTR strtoull +# define ZEND_ABS llabs +# endif +#else +# define ZEND_STRTOI(s0, s1, base) strtol((s0), (s1), (base)) +# define ZEND_STRTOUI(s0, s1, base) strtoul((s0), (s1), (base)) +# ifdef PHP_WIN32 +# define ZEND_ITOA(i, s, len) _ltoa_s((i), (s), (len), 10) +# define ZEND_ATOI(i, s) i = atol((s)) +# else +# define ZEND_ITOA(i, s, len) \ + do { \ + int st = snprintf((s), (len), "%ld", (i)); \ + (s)[st] = '\0'; \ + } while (0) +# define ZEND_ATOI(i, s) (i) = atol((s)) +# endif +# define ZEND_INT_FMT "%ld" +# define ZEND_UINT_FMT "%lu" +# define ZEND_INT_FMT_SPEC "ld" +# define ZEND_UINT_FMT_SPEC "lu" +# define ZEND_STRTOI_PTR strtol +# define ZEND_STRTOUI_PTR strtoul +# define ZEND_ABS abs +#endif + + +#endif /* ZEND_INT_H */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * indent-tabs-mode: t + * End: + */ diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c index d5420dae76..8d1b2e3652 100644 --- a/Zend/zend_interfaces.c +++ b/Zend/zend_interfaces.c @@ -195,7 +195,7 @@ ZEND_API zval *zend_user_it_get_current_data(zend_object_iterator *_iter TSRMLS_ static int zend_user_it_get_current_key_default(zend_object_iterator *_iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC) { *int_key = _iter->index; - return HASH_KEY_IS_LONG; + return HASH_KEY_IS_INT; } #endif /* }}} */ @@ -216,7 +216,7 @@ ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *ke zend_error(E_WARNING, "Nothing returned from %s::key()", iter->ce->name->val); } - ZVAL_LONG(key, 0); + ZVAL_INT(key, 0); } } /* }}} */ @@ -424,8 +424,8 @@ ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, zend_uint zval_ptr_dtor(&retval); return FAILURE; case IS_STRING: - *buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRLEN(retval)); - *buf_len = Z_STRLEN(retval); + *buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRSIZE(retval)); + *buf_len = Z_STRSIZE(retval); result = SUCCESS; break; default: /* failure */ diff --git a/Zend/zend_iterators.h b/Zend/zend_iterators.h index 09346aee90..468223d47c 100644 --- a/Zend/zend_iterators.h +++ b/Zend/zend_iterators.h @@ -58,7 +58,7 @@ struct _zend_object_iterator { zend_object std; zval data; zend_object_iterator_funcs *funcs; - ulong index; /* private to fe_reset/fe_fetch opcodes */ + zend_uint_t index; /* private to fe_reset/fe_fetch opcodes */ }; typedef struct _zend_class_iterator_funcs { diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 38b1bcc2b4..0d40b73e4d 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -578,7 +578,7 @@ optional_class_type: function_call_parameter_list: - '(' ')' { Z_LVAL($$.u.constant) = 0; } + '(' ')' { Z_IVAL($$.u.constant) = 0; } | '(' non_empty_function_call_parameter_list ')' { $$ = $2; } | '(' yield_expr ')' { zend_do_pass_param(&$2, ZEND_SEND_VAL TSRMLS_CC); } ; @@ -625,7 +625,7 @@ class_statement_list: class_statement: - variable_modifiers { CG(access_type) = Z_LVAL($1.u.constant); } class_variable_declaration ';' + variable_modifiers { CG(access_type) = Z_IVAL($1.u.constant); } class_variable_declaration ';' | class_constant_declaration ';' | trait_use_statement | method_modifiers function is_reference T_STRING { zend_do_begin_function_declaration(&$2, &$4, 1, $3.op_type, &$1 TSRMLS_CC); } @@ -686,37 +686,37 @@ trait_alias: ; trait_modifiers: - /* empty */ { Z_LVAL($$.u.constant) = 0x0; } /* No change of methods visibility */ + /* empty */ { Z_IVAL($$.u.constant) = 0x0; } /* No change of methods visibility */ | member_modifier { $$ = $1; } /* REM: Keep in mind, there are not only visibility modifiers */ ; method_body: - ';' /* abstract method */ { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } - | '{' inner_statement_list '}' { Z_LVAL($$.u.constant) = 0; } + ';' /* abstract method */ { Z_IVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } + | '{' inner_statement_list '}' { Z_IVAL($$.u.constant) = 0; } ; variable_modifiers: non_empty_member_modifiers { $$ = $1; } - | T_VAR { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } + | T_VAR { Z_IVAL($$.u.constant) = ZEND_ACC_PUBLIC; } ; method_modifiers: - /* empty */ { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } - | non_empty_member_modifiers { $$ = $1; if (!(Z_LVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_LVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } } + /* empty */ { Z_IVAL($$.u.constant) = ZEND_ACC_PUBLIC; } + | non_empty_member_modifiers { $$ = $1; if (!(Z_IVAL($$.u.constant) & ZEND_ACC_PPP_MASK)) { Z_IVAL($$.u.constant) |= ZEND_ACC_PUBLIC; } } ; non_empty_member_modifiers: member_modifier { $$ = $1; } - | non_empty_member_modifiers member_modifier { Z_LVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); } + | non_empty_member_modifiers member_modifier { Z_IVAL($$.u.constant) = zend_do_verify_access_types(&$1, &$2); } ; member_modifier: - T_PUBLIC { Z_LVAL($$.u.constant) = ZEND_ACC_PUBLIC; } - | T_PROTECTED { Z_LVAL($$.u.constant) = ZEND_ACC_PROTECTED; } - | T_PRIVATE { Z_LVAL($$.u.constant) = ZEND_ACC_PRIVATE; } - | T_STATIC { Z_LVAL($$.u.constant) = ZEND_ACC_STATIC; } - | T_ABSTRACT { Z_LVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } - | T_FINAL { Z_LVAL($$.u.constant) = ZEND_ACC_FINAL; } + T_PUBLIC { Z_IVAL($$.u.constant) = ZEND_ACC_PUBLIC; } + | T_PROTECTED { Z_IVAL($$.u.constant) = ZEND_ACC_PROTECTED; } + | T_PRIVATE { Z_IVAL($$.u.constant) = ZEND_ACC_PRIVATE; } + | T_STATIC { Z_IVAL($$.u.constant) = ZEND_ACC_STATIC; } + | T_ABSTRACT { Z_IVAL($$.u.constant) = ZEND_ACC_ABSTRACT; } + | T_FINAL { Z_IVAL($$.u.constant) = ZEND_ACC_FINAL; } ; class_variable_declaration: @@ -812,8 +812,8 @@ expr_without_variable: | expr '%' expr { zend_do_binary_op(ZEND_MOD, &$$, &$1, &$3 TSRMLS_CC); } | expr T_SL expr { zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); } | expr T_SR expr { zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); } - | '+' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } } - | '-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } } + | '+' expr %prec T_INC { ZVAL_INT(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } } + | '-' expr %prec T_INC { ZVAL_INT(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } } | '!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); } | '~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); } | expr T_IS_IDENTICAL expr { zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); } @@ -834,7 +834,7 @@ expr_without_variable: | expr '?' ':' { zend_do_jmp_set(&$1, &$2, &$3 TSRMLS_CC); } expr { zend_do_jmp_set_else(&$$, &$5, &$2, &$3 TSRMLS_CC); } | internal_functions_in_yacc { $$ = $1; } - | T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); } + | T_INT_CAST expr { zend_do_cast(&$$, &$2, IS_INT TSRMLS_CC); } | T_DOUBLE_CAST expr { zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); } | T_STRING_CAST expr { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); } | T_ARRAY_CAST expr { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); } @@ -915,13 +915,13 @@ class_name: T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1);} | namespace_name { $$ = $1; } | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } + | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRSIZE($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRSIZE($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } ; fully_qualified_class_name: namespace_name { $$ = $1; } | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } + | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRSIZE($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRSIZE($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; } ; @@ -964,7 +964,7 @@ backticks_expr: ctor_arguments: - /* empty */ { Z_LVAL($$.u.constant) = 0; } + /* empty */ { Z_IVAL($$.u.constant) = 0; } | function_call_parameter_list { $$ = $1; } ; @@ -997,7 +997,7 @@ static_scalar_value: | static_class_name_scalar { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } | namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } + | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRSIZE($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRSIZE($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); } | T_ARRAY '(' static_array_pair_list ')' { $$ = $3; } | '[' static_array_pair_list ']' { $$ = $2; } | static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); } @@ -1045,7 +1045,7 @@ general_constant: class_constant { $$ = $1; } | namespace_name { zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC); } | T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant); zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); } - | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); } + | T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRSIZE($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRSIZE($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); } ; scalar: @@ -1203,8 +1203,8 @@ variable_name: ; simple_indirect_reference: - '$' { Z_LVAL($$.u.constant) = 1; } - | simple_indirect_reference '$' { Z_LVAL($$.u.constant)++; } + '$' { Z_IVAL($$.u.constant) = 1; } + | simple_indirect_reference '$' { Z_IVAL($$.u.constant)++; } ; assignment_list: diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c index 8858e8be9e..ffde058e0b 100644 --- a/Zend/zend_language_scanner.c +++ b/Zend/zend_language_scanner.c @@ -565,7 +565,7 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR zend_bool original_in_compilation = CG(in_compilation); retval_znode.op_type = IS_CONST; - ZVAL_LONG(&retval_znode.u.constant, 1); + ZVAL_INT(&retval_znode.u.constant, 1); zend_save_lexical_state(&original_lex_state TSRMLS_CC); @@ -631,7 +631,7 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC) retval = zend_compile_file(&file_handle, type TSRMLS_CC); if (retval && file_handle.handle.stream.handle) { if (!file_handle.opened_path) { - file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename)); + file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRSIZE_P(filename)); } zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)); @@ -655,7 +655,7 @@ ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_D zend_string *new_compiled_filename; /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */ - old_len = Z_STRLEN_P(str); + old_len = Z_STRSIZE_P(str); Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1); @@ -727,7 +727,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) int compiler_result; zend_bool original_in_compilation = CG(in_compilation); - if (Z_STRLEN_P(source_string)==0) { + if (Z_STRSIZE_P(source_string)==0) { efree(op_array); return NULL; } @@ -894,7 +894,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo /* convert escape sequences */ s = t = Z_STRVAL_P(zendlval); - end = s+Z_STRLEN_P(zendlval); + end = s+Z_STRSIZE_P(zendlval); while (s<end) { if (*s=='\\') { s++; @@ -906,23 +906,23 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo switch(*s) { case 'n': *t++ = '\n'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'r': *t++ = '\r'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 't': *t++ = '\t'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'f': *t++ = '\f'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'v': *t++ = '\v'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'e': #ifdef PHP_WIN32 @@ -930,7 +930,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo #else *t++ = '\e'; #endif - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case '"': case '`': @@ -942,22 +942,22 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo case '\\': case '$': *t++ = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'x': case 'X': if (ZEND_IS_HEX(*(s+1))) { char hex_buf[3] = { 0, 0, 0 }; - Z_STRLEN_P(zendlval)--; /* for the 'x' */ + Z_STRSIZE_P(zendlval)--; /* for the 'x' */ hex_buf[0] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_HEX(*(s+1))) { hex_buf[1] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; } - *t++ = (char) strtol(hex_buf, NULL, 16); + *t++ = (char) ZEND_STRTOI(hex_buf, NULL, 16); } else { *t++ = '\\'; *t++ = *s; @@ -969,16 +969,16 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo char octal_buf[4] = { 0, 0, 0, 0 }; octal_buf[0] = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_OCT(*(s+1))) { octal_buf[1] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_OCT(*(s+1))) { octal_buf[2] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; } } - *t++ = (char) strtol(octal_buf, NULL, 8); + *t++ = (char) ZEND_STRTOI(octal_buf, NULL, 8); } else { *t++ = '\\'; *t++ = *s; @@ -1000,7 +1000,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo unsigned char *str; // TODO: avoid realocation ??? s = Z_STRVAL_P(zendlval); - SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC); + SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRSIZE_P(zendlval) TSRMLS_CC); zval_ptr_dtor(zendlval); ZVAL_STRINGL(zendlval, str, sz); efree(str); @@ -1645,7 +1645,7 @@ yy61: yyleng = YYCURSOR - SCNG(yy_text); #line 2153 "Zend/zend_language_scanner.l" { - Z_LVAL_P(zendlval) = (long) '{'; + Z_IVAL_P(zendlval) = (zend_int_t) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; @@ -1873,7 +1873,7 @@ yy83: yyleng = YYCURSOR - SCNG(yy_text); #line 2153 "Zend/zend_language_scanner.l" { - Z_LVAL_P(zendlval) = (long) '{'; + Z_IVAL_P(zendlval) = (zend_int_t) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; @@ -2132,7 +2132,7 @@ yy107: yyleng = YYCURSOR - SCNG(yy_text); #line 2153 "Zend/zend_language_scanner.l" { - Z_LVAL_P(zendlval) = (long) '{'; + Z_IVAL_P(zendlval) = (zend_int_t) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; @@ -2952,11 +2952,11 @@ yy173: yyleng = YYCURSOR - SCNG(yy_text); #line 1537 "Zend/zend_language_scanner.l" { - if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */ - ZVAL_LONG(zendlval, strtol(yytext, NULL, 0)); + if (yyleng < MAX_LENGTH_OF_ZEND_INT - 1) { /* Won't overflow */ + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 0)); } else { errno = 0; - ZVAL_LONG(zendlval, strtol(yytext, NULL, 0)); + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 0)); if (errno == ERANGE) { /* Overflow */ if (yytext[0] == '0') { /* octal overflow */ ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL)); @@ -3067,7 +3067,7 @@ yy179: /* convert escape sequences */ s = t = Z_STRVAL_P(zendlval); - end = s+Z_STRLEN_P(zendlval); + end = s+Z_STRSIZE_P(zendlval); while (s<end) { if (*s=='\\') { s++; @@ -3076,7 +3076,7 @@ yy179: case '\\': case '\'': *t++ = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; default: *t++ = '\\'; @@ -3099,7 +3099,7 @@ yy179: char *str = NULL; s = Z_STRVAL_P(zendlval); // TODO: avoid reallocation ??? - SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC); + SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRSIZE_P(zendlval) TSRMLS_CC); ZVAL_STRINGL(zendlval, str, sz); efree(s); } @@ -3314,11 +3314,11 @@ yy200: --len; } - if (len < SIZEOF_LONG * 8) { + if (len < SIZEOF_ZEND_INT * 8) { if (len == 0) { - ZVAL_LONG(zendlval, 0); + ZVAL_INT(zendlval, 0); } else { - ZVAL_LONG(zendlval, strtol(bin, NULL, 2)); + ZVAL_INT(zendlval, ZEND_STRTOI(bin, NULL, 2)); } return T_LNUMBER; } else { @@ -3349,11 +3349,11 @@ yy203: len--; } - if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) { + if (len < SIZEOF_ZEND_INT * 2 || (len == SIZEOF_ZEND_INT * 2 && *hex <= '7')) { if (len == 0) { - ZVAL_LONG(zendlval, 0); + ZVAL_INT(zendlval, 0); } else { - ZVAL_LONG(zendlval, strtol(hex, NULL, 16)); + ZVAL_INT(zendlval, ZEND_STRTOI(hex, NULL, 16)); } return T_LNUMBER; } else { @@ -4248,7 +4248,7 @@ yy328: yyleng = YYCURSOR - SCNG(yy_text); #line 1666 "Zend/zend_language_scanner.l" { - ZVAL_LONG(zendlval, CG(zend_lineno)); + ZVAL_INT(zendlval, CG(zend_lineno)); return T_LINE; } #line 4255 "Zend/zend_language_scanner.c" @@ -7672,8 +7672,8 @@ yy839: yyleng = YYCURSOR - SCNG(yy_text); #line 1578 "Zend/zend_language_scanner.l" { /* Offset could be treated as a long */ - if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) { - ZVAL_LONG(zendlval, strtol(yytext, NULL, 10)); + if (yyleng < MAX_LENGTH_OF_ZEND_INT - 1 || (yyleng == MAX_LENGTH_OF_ZEND_INT - 1 && strcmp(yytext, int_min_digits) < 0)) { + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 10)); } else { ZVAL_STRINGL(zendlval, yytext, yyleng); } diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index b5100860c1..b6cad8f217 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -563,7 +563,7 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR zend_bool original_in_compilation = CG(in_compilation); retval_znode.op_type = IS_CONST; - ZVAL_LONG(&retval_znode.u.constant, 1); + ZVAL_INT(&retval_znode.u.constant, 1); zend_save_lexical_state(&original_lex_state TSRMLS_CC); @@ -629,7 +629,7 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC) retval = zend_compile_file(&file_handle, type TSRMLS_CC); if (retval && file_handle.handle.stream.handle) { if (!file_handle.opened_path) { - file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename)); + file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRSIZE_P(filename)); } zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)); @@ -653,7 +653,7 @@ ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_D zend_string *new_compiled_filename; /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */ - old_len = Z_STRLEN_P(str); + old_len = Z_STRSIZE_P(str); Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1); @@ -725,7 +725,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC) int compiler_result; zend_bool original_in_compilation = CG(in_compilation); - if (Z_STRLEN_P(source_string)==0) { + if (Z_STRSIZE_P(source_string)==0) { efree(op_array); return NULL; } @@ -892,7 +892,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo /* convert escape sequences */ s = t = Z_STRVAL_P(zendlval); - end = s+Z_STRLEN_P(zendlval); + end = s+Z_STRSIZE_P(zendlval); while (s<end) { if (*s=='\\') { s++; @@ -904,23 +904,23 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo switch(*s) { case 'n': *t++ = '\n'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'r': *t++ = '\r'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 't': *t++ = '\t'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'f': *t++ = '\f'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'v': *t++ = '\v'; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'e': #ifdef PHP_WIN32 @@ -928,7 +928,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo #else *t++ = '\e'; #endif - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case '"': case '`': @@ -940,22 +940,22 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo case '\\': case '$': *t++ = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; case 'x': case 'X': if (ZEND_IS_HEX(*(s+1))) { char hex_buf[3] = { 0, 0, 0 }; - Z_STRLEN_P(zendlval)--; /* for the 'x' */ + Z_STRSIZE_P(zendlval)--; /* for the 'x' */ hex_buf[0] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_HEX(*(s+1))) { hex_buf[1] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; } - *t++ = (char) strtol(hex_buf, NULL, 16); + *t++ = (char) ZEND_STRTOI(hex_buf, NULL, 16); } else { *t++ = '\\'; *t++ = *s; @@ -967,16 +967,16 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo char octal_buf[4] = { 0, 0, 0, 0 }; octal_buf[0] = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_OCT(*(s+1))) { octal_buf[1] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; if (ZEND_IS_OCT(*(s+1))) { octal_buf[2] = *(++s); - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; } } - *t++ = (char) strtol(octal_buf, NULL, 8); + *t++ = (char) ZEND_STRTOI(octal_buf, NULL, 8); } else { *t++ = '\\'; *t++ = *s; @@ -998,7 +998,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo unsigned char *str; // TODO: avoid realocation ??? s = Z_STRVAL_P(zendlval); - SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC); + SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRSIZE_P(zendlval) TSRMLS_CC); zval_ptr_dtor(zendlval); ZVAL_STRINGL(zendlval, str, sz); efree(str); @@ -1521,11 +1521,11 @@ NEWLINE ("\r"|"\n"|"\r\n") --len; } - if (len < SIZEOF_LONG * 8) { + if (len < SIZEOF_ZEND_INT * 8) { if (len == 0) { - ZVAL_LONG(zendlval, 0); + ZVAL_INT(zendlval, 0); } else { - ZVAL_LONG(zendlval, strtol(bin, NULL, 2)); + ZVAL_INT(zendlval, ZEND_STRTOI(bin, NULL, 2)); } return T_LNUMBER; } else { @@ -1535,11 +1535,11 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING>{LNUM} { - if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */ - ZVAL_LONG(zendlval, strtol(yytext, NULL, 0)); + if (yyleng < MAX_LENGTH_OF_ZEND_INT - 1) { /* Won't overflow */ + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 0)); } else { errno = 0; - ZVAL_LONG(zendlval, strtol(yytext, NULL, 0)); + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 0)); if (errno == ERANGE) { /* Overflow */ if (yytext[0] == '0') { /* octal overflow */ ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL)); @@ -1562,11 +1562,11 @@ NEWLINE ("\r"|"\n"|"\r\n") len--; } - if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) { + if (len < SIZEOF_ZEND_INT * 2 || (len == SIZEOF_ZEND_INT * 2 && *hex <= '7')) { if (len == 0) { - ZVAL_LONG(zendlval, 0); + ZVAL_INT(zendlval, 0); } else { - ZVAL_LONG(zendlval, strtol(hex, NULL, 16)); + ZVAL_INT(zendlval, ZEND_STRTOI(hex, NULL, 16)); } return T_LNUMBER; } else { @@ -1576,8 +1576,8 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_VAR_OFFSET>[0]|([1-9][0-9]*) { /* Offset could be treated as a long */ - if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) { - ZVAL_LONG(zendlval, strtol(yytext, NULL, 10)); + if (yyleng < MAX_LENGTH_OF_ZEND_INT - 1 || (yyleng == MAX_LENGTH_OF_ZEND_INT - 1 && strcmp(yytext, int_min_digits) < 0)) { + ZVAL_INT(zendlval, ZEND_STRTOI(yytext, NULL, 10)); } else { ZVAL_STRINGL(zendlval, yytext, yyleng); } @@ -1664,7 +1664,7 @@ NEWLINE ("\r"|"\n"|"\r\n") } <ST_IN_SCRIPTING>"__LINE__" { - ZVAL_LONG(zendlval, CG(zend_lineno)); + ZVAL_INT(zendlval, CG(zend_lineno)); return T_LINE; } @@ -2000,7 +2000,7 @@ inline_html: /* convert escape sequences */ s = t = Z_STRVAL_P(zendlval); - end = s+Z_STRLEN_P(zendlval); + end = s+Z_STRSIZE_P(zendlval); while (s<end) { if (*s=='\\') { s++; @@ -2009,7 +2009,7 @@ inline_html: case '\\': case '\'': *t++ = *s; - Z_STRLEN_P(zendlval)--; + Z_STRSIZE_P(zendlval)--; break; default: *t++ = '\\'; @@ -2032,7 +2032,7 @@ inline_html: char *str = NULL; s = Z_STRVAL_P(zendlval); // TODO: avoid reallocation ??? - SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC); + SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRSIZE_P(zendlval) TSRMLS_CC); ZVAL_STRINGL(zendlval, str, sz); efree(s); } @@ -2151,7 +2151,7 @@ inline_html: <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" { - Z_LVAL_P(zendlval) = (long) '{'; + Z_IVAL_P(zendlval) = (zend_int_t) '{'; yy_push_state(ST_IN_SCRIPTING TSRMLS_CC); yyless(1); return T_CURLY_OPEN; diff --git a/Zend/zend_multiply.h b/Zend/zend_multiply.h index 74dc7d1452..7f1c6c18ec 100644 --- a/Zend/zend_multiply.h +++ b/Zend/zend_multiply.h @@ -21,8 +21,8 @@ #if defined(__i386__) && defined(__GNUC__) -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ - long __tmpvar; \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ + zend_int_t __tmpvar; \ __asm__ ("imul %3,%0\n" \ "adc $0,%1" \ : "=r"(__tmpvar),"=r"(usedval) \ @@ -33,8 +33,8 @@ #elif defined(__x86_64__) && defined(__GNUC__) -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ - long __tmpvar; \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ + zend_int_t __tmpvar; \ __asm__ ("imul %3,%0\n" \ "adc $0,%1" \ : "=r"(__tmpvar),"=r"(usedval) \ @@ -45,8 +45,8 @@ #elif defined(__arm__) && defined(__GNUC__) -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ - long __tmpvar; \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ + zend_int_t __tmpvar; \ __asm__("smull %0, %1, %2, %3\n" \ "sub %1, %1, %0, asr #31" \ : "=r"(__tmpvar), "=r"(usedval) \ @@ -57,8 +57,8 @@ #elif defined(__aarch64__) && defined(__GNUC__) -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ - long __tmpvar; \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ + zend_int_t __tmpvar; \ __asm__("mul %0, %2, %3\n" \ "smulh %1, %2, %3\n" \ "sub %1, %1, %0, asr #63\n" \ @@ -68,11 +68,24 @@ else (lval) = __tmpvar; \ } while (0) -#elif SIZEOF_LONG == 4 && defined(HAVE_ZEND_LONG64) +#elif defined(ZEND_WIN32) -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ + zend_int_t __lres = (a) * (b); \ + long double __dres = (long double)(a) * (long double)(b); \ + long double __delta = (long double) __lres - __dres; \ + if ( ((usedval) = (( __dres + __delta ) != __dres))) { \ + (dval) = __dres; \ + } else { \ + (lval) = __lres; \ + } \ +} while (0) + +#elif SIZEOF_ZEND_INT == 4 && defined(HAVE_ZEND_LONG64) + +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ zend_long64 __result = (zend_long64) (a) * (zend_long64) (b); \ - if (__result > LONG_MAX || __result < LONG_MIN) { \ + if (__result > ZEND_INT_MAX || __result < ZEND_INT_MIN) { \ (dval) = (double) __result; \ (usedval) = 1; \ } else { \ @@ -83,7 +96,7 @@ #else -#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \ +#define ZEND_SIGNED_MULTIPLY_INT(a, b, lval, dval, usedval) do { \ long __lres = (a) * (b); \ long double __dres = (long double)(a) * (long double)(b); \ long double __delta = (long double) __lres - __dres; \ diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index d7d8bf0a52..a0ff59b292 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -423,7 +423,7 @@ ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_inf } /* }}} */ -static long *zend_get_property_guard(zend_object *zobj, zend_property_info *property_info, zval *member) /* {{{ */ +static zend_int_t *zend_get_property_guard(zend_object *zobj, zend_property_info *property_info, zval *member) /* {{{ */ { zend_property_info info; zval stub, *guard; @@ -448,15 +448,15 @@ static long *zend_get_property_guard(zend_object *zobj, zend_property_info *prop if (str) { STR_RELEASE(str); } - return &Z_LVAL_P(guard); + return &Z_IVAL_P(guard); } - ZVAL_LONG(&stub, 0); + ZVAL_INT(&stub, 0); guard = zend_hash_add_new(zobj->guards, property_info->name, &stub); if (str) { STR_RELEASE(str); } - return &Z_LVAL_P(guard); + return &Z_IVAL_P(guard); } /* }}} */ @@ -501,7 +501,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_ /* magic get */ if (zobj->ce->__get) { - long *guard = zend_get_property_guard(zobj, property_info, member); + zend_int_t *guard = zend_get_property_guard(zobj, property_info, member); if (!((*guard) & IN_GET)) { zval tmp_object; @@ -526,7 +526,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_ zval_ptr_dtor(&tmp_object); } else { if (Z_STRVAL_P(member)[0] == '\0') { - if (Z_STRLEN_P(member) == 0) { + if (Z_STRSIZE_P(member) == 0) { zend_error(E_ERROR, "Cannot access empty property"); } else { zend_error(E_ERROR, "Cannot access property started with '\\0'"); @@ -635,7 +635,7 @@ found: /* magic set */ if (zobj->ce->__set) { - long *guard = zend_get_property_guard(zobj, property_info, member); + zend_int_t *guard = zend_get_property_guard(zobj, property_info, member); if (!((*guard) & IN_SET)) { zval tmp_object; @@ -651,7 +651,7 @@ found: goto write_std_property; } else { if (Z_STRVAL_P(member)[0] == '\0') { - if (Z_STRLEN_P(member) == 0) { + if (Z_STRSIZE_P(member) == 0) { zend_error(E_ERROR, "Cannot access empty property"); } else { zend_error(E_ERROR, "Cannot access property started with '\\0'"); @@ -778,7 +778,7 @@ static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, zval tmp_member; zval *retval, tmp; zend_property_info *property_info; - long *guard; + zend_int_t *guard; zobj = Z_OBJ_P(object); @@ -875,7 +875,7 @@ static void zend_std_unset_property(zval *object, zval *member, void **cache_slo /* magic unset */ if (zobj->ce->__unset) { - long *guard = zend_get_property_guard(zobj, property_info, member); + zend_int_t *guard = zend_get_property_guard(zobj, property_info, member); if (!((*guard) & IN_UNSET)) { zval tmp_object; @@ -887,7 +887,7 @@ static void zend_std_unset_property(zval *object, zval *member, void **cache_slo zval_ptr_dtor(&tmp_object); } else { if (Z_STRVAL_P(member)[0] == '\0') { - if (Z_STRLEN_P(member) == 0) { + if (Z_STRSIZE_P(member) == 0) { zend_error(E_ERROR, "Cannot access empty property"); } else { zend_error(E_ERROR, "Cannot access property started with '\\0'"); @@ -1404,10 +1404,10 @@ static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ Z_OBJ_UNPROTECT_RECURSION(o2); return 1; } - if (Z_LVAL(result) != 0) { + if (Z_IVAL(result) != 0) { Z_OBJ_UNPROTECT_RECURSION(o1); Z_OBJ_UNPROTECT_RECURSION(o2); - return Z_LVAL(result); + return Z_IVAL(result); } } else { Z_OBJ_UNPROTECT_RECURSION(o1); @@ -1485,7 +1485,7 @@ found: result = 0; if ((has_set_exists != 2) && zobj->ce->__isset) { - long *guard = zend_get_property_guard(zobj, property_info, member); + zend_int_t *guard = zend_get_property_guard(zobj, property_info, member); if (!((*guard) & IN_ISSET)) { zval rv; @@ -1586,13 +1586,13 @@ ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int ty case _IS_BOOL: ZVAL_BOOL(writeobj, 1); return SUCCESS; - case IS_LONG: + case IS_INT: ce = Z_OBJCE_P(readobj); zend_error(E_NOTICE, "Object of class %s could not be converted to int", ce->name->val); if (readobj == writeobj) { zval_dtor(readobj); } - ZVAL_LONG(writeobj, 1); + ZVAL_INT(writeobj, 1); return SUCCESS; case IS_DOUBLE: ce = Z_OBJCE_P(readobj); diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h index ac3d962071..a11269c925 100644 --- a/Zend/zend_object_handlers.h +++ b/Zend/zend_object_handlers.h @@ -106,7 +106,7 @@ typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_D /* updates *count to hold the number of elements present and returns SUCCESS. * Returns FAILURE if the object does not have any sense of overloaded dimensions */ -typedef int (*zend_object_count_elements_t)(zval *object, long *count TSRMLS_DC); +typedef int (*zend_object_count_elements_t)(zval *object, zend_int_t *count TSRMLS_DC); typedef int (*zend_object_get_closure_t)(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC); diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index af0070c5fb..c254b33fb2 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -149,7 +149,7 @@ ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object *o } if (old_object->properties) { zval *prop, new_prop; - ulong num_key; + zend_uint_t num_key; zend_string *key; if (!new_object->properties) { diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 8309599521..1c0b06fa8c 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -648,7 +648,7 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC) int nest_levels, array_offset; zend_brk_cont_element *jmp_to; - nest_levels = Z_LVAL(op_array->literals[opline->op2.constant]); + nest_levels = Z_IVAL(op_array->literals[opline->op2.constant]); if ((array_offset = opline->op1.opline_num) != -1) { do { jmp_to = &op_array->brk_cont_array[array_offset]; @@ -661,7 +661,7 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC) } } case ZEND_GOTO: - if (Z_TYPE(op_array->literals[opline->op2.constant]) != IS_LONG) { + if (Z_TYPE(op_array->literals[opline->op2.constant]) != IS_INT) { zend_uint num = opline->op2.constant; opline->op2.zv = &op_array->literals[opline->op2.constant]; zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC); @@ -734,7 +734,7 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC) opline->extended_value = (zend_uint)(zend_intptr_t)EX_VAR_NUM_2(NULL, op_array->last_var + opline->extended_value); break; case ZEND_GOTO: - if (Z_TYPE_P(opline->op2.zv) != IS_LONG) { + if (Z_TYPE_P(opline->op2.zv) != IS_INT) { zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC); } /* break omitted intentionally */ diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 921d71b685..6a81999495 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -86,7 +86,7 @@ ZEND_API int zend_atoi(const char *str, int str_len) /* {{{ */ if (!str_len) { str_len = strlen(str); } - retval = strtol(str, NULL, 0); + retval = ZEND_STRTOI(str, NULL, 0); if (str_len>0) { switch (str[str_len-1]) { case 'g': @@ -107,14 +107,14 @@ ZEND_API int zend_atoi(const char *str, int str_len) /* {{{ */ } /* }}} */ -ZEND_API long zend_atol(const char *str, int str_len) /* {{{ */ +ZEND_API zend_int_t zend_atol(const char *str, int str_len) /* {{{ */ { - long retval; + zend_int_t retval; if (!str_len) { str_len = strlen(str); } - retval = strtol(str, NULL, 0); + retval = ZEND_STRTOI(str, NULL, 0); if (str_len>0) { switch (str[str_len-1]) { case 'g': @@ -198,28 +198,28 @@ try_again: zend_string *str; str = Z_STR_P(op); - if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) { - ZVAL_LONG(op, 0); + if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_IVAL_P(op), &Z_DVAL_P(op), 1)) == 0) { + ZVAL_INT(op, 0); } STR_RELEASE(str); break; } case IS_NULL: case IS_FALSE: - ZVAL_LONG(op, 0); + ZVAL_INT(op, 0); break; case IS_TRUE: - ZVAL_LONG(op, 1); + ZVAL_INT(op, 1); break; case IS_RESOURCE: { - long l = Z_RES_HANDLE_P(op); + zend_int_t l = Z_RES_HANDLE_P(op); zval_ptr_dtor(op); - ZVAL_LONG(op, l); + ZVAL_INT(op, l); } break; case IS_OBJECT: - convert_to_long_base(op, 10); + convert_to_int_base(op, 10); break; } } @@ -228,36 +228,36 @@ try_again: /* {{{ zendi_convert_scalar_to_number */ #define zendi_convert_scalar_to_number(op, holder, result) \ if (op==result) { \ - if (Z_TYPE_P(op) != IS_LONG) { \ + if (Z_TYPE_P(op) != IS_INT) { \ convert_scalar_to_number(op TSRMLS_CC); \ } \ } else { \ switch (Z_TYPE_P(op)) { \ case IS_STRING: \ { \ - if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) { \ - ZVAL_LONG(&(holder), 0); \ + if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRSIZE_P(op), &Z_IVAL(holder), &Z_DVAL(holder), 1)) == 0) { \ + ZVAL_INT(&(holder), 0); \ } \ (op) = &(holder); \ break; \ } \ case IS_NULL: \ case IS_FALSE: \ - ZVAL_LONG(&(holder), 0); \ + ZVAL_INT(&(holder), 0); \ (op) = &(holder); \ break; \ case IS_TRUE: \ - ZVAL_LONG(&(holder), 1); \ + ZVAL_INT(&(holder), 1); \ (op) = &(holder); \ break; \ case IS_RESOURCE: \ - ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op)); \ + ZVAL_INT(&(holder), Z_RES_HANDLE_P(op)); \ (op) = &(holder); \ break; \ case IS_OBJECT: \ ZVAL_DUP(&(holder), op); \ - convert_to_long_base(&(holder), 10); \ - if (Z_TYPE(holder) == IS_LONG) { \ + convert_to_int_base(&(holder), 10); \ + if (Z_TYPE(holder) == IS_INT) { \ (op) = &(holder); \ } \ break; \ @@ -266,38 +266,38 @@ try_again: /* }}} */ -/* {{{ zendi_convert_to_long */ -#define zendi_convert_to_long(op, holder, result) \ +/* {{{ zendi_convert_to_int */ +#define zendi_convert_to_int(op, holder, result) \ if (op == result) { \ - convert_to_long(op); \ - } else if (Z_TYPE_P(op) != IS_LONG) { \ + convert_to_int(op); \ + } else if (Z_TYPE_P(op) != IS_INT) { \ switch (Z_TYPE_P(op)) { \ case IS_NULL: \ case IS_FALSE: \ - ZVAL_LONG(&(holder), 0); \ + ZVAL_INT(&(holder), 0); \ break; \ case IS_TRUE: \ - ZVAL_LONG(&(holder), 1); \ + ZVAL_INT(&(holder), 1); \ break; \ case IS_DOUBLE: \ - ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\ + ZVAL_INT(&holder, zend_dval_to_ival(Z_DVAL_P(op)));\ break; \ case IS_STRING: \ - ZVAL_LONG(&holder, strtol(Z_STRVAL_P(op), NULL, 10));\ + ZVAL_INT(&holder, ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10));\ break; \ case IS_ARRAY: \ - ZVAL_LONG(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ + ZVAL_INT(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ break; \ case IS_OBJECT: \ ZVAL_DUP(&(holder), (op)); \ - convert_to_long_base(&(holder), 10); \ + convert_to_int_base(&(holder), 10); \ break; \ case IS_RESOURCE: \ - ZVAL_LONG(&holder, Z_RES_HANDLE_P(op)); \ + ZVAL_INT(&holder, Z_RES_HANDLE_P(op)); \ break; \ default: \ zend_error(E_WARNING, "Cannot convert to ordinal value"); \ - ZVAL_LONG(&holder, 0); \ + ZVAL_INT(&holder, 0); \ break; \ } \ (op) = &(holder); \ @@ -318,15 +318,15 @@ try_again: case IS_RESOURCE: \ ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0); \ break; \ - case IS_LONG: \ - ZVAL_BOOL(&holder, Z_LVAL_P(op) ? 1 : 0); \ + case IS_INT: \ + ZVAL_BOOL(&holder, Z_IVAL_P(op) ? 1 : 0); \ break; \ case IS_DOUBLE: \ ZVAL_BOOL(&holder, Z_DVAL_P(op) ? 1 : 0); \ break; \ case IS_STRING: \ - if (Z_STRLEN_P(op) == 0 \ - || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \ + if (Z_STRSIZE_P(op) == 0 \ + || (Z_STRSIZE_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \ ZVAL_BOOL(&holder, 0); \ } else { \ ZVAL_BOOL(&holder, 1); \ @@ -368,66 +368,66 @@ try_again: /* }}} */ -ZEND_API void convert_to_long(zval *op) /* {{{ */ +ZEND_API void convert_to_int(zval *op) /* {{{ */ { - if (Z_TYPE_P(op) != IS_LONG) { - convert_to_long_base(op, 10); + if (Z_TYPE_P(op) != IS_INT) { + convert_to_int_base(op, 10); } } /* }}} */ -ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */ +ZEND_API void convert_to_int_base(zval *op, int base) /* {{{ */ { - long tmp; + zend_int_t tmp; switch (Z_TYPE_P(op)) { case IS_NULL: case IS_FALSE: - ZVAL_LONG(op, 0); + ZVAL_INT(op, 0); break; case IS_TRUE: - ZVAL_LONG(op, 1); + ZVAL_INT(op, 1); break; case IS_RESOURCE: { - long l = Z_RES_HANDLE_P(op); + zend_int_t l = Z_RES_HANDLE_P(op); zval_ptr_dtor(op); - ZVAL_LONG(op, l); + ZVAL_INT(op, l); } /* break missing intentionally */ - Z_TYPE_INFO_P(op) = IS_LONG; + Z_TYPE_INFO_P(op) = IS_INT; break; - case IS_LONG: + case IS_INT: break; case IS_DOUBLE: - ZVAL_LONG(op, zend_dval_to_lval(Z_DVAL_P(op))); + ZVAL_INT(op, zend_dval_to_ival(Z_DVAL_P(op))); break; case IS_STRING: { zend_string *str = Z_STR_P(op); - ZVAL_LONG(op, strtol(str->val, NULL, base)); + ZVAL_INT(op, strtol(str->val, NULL, base)); STR_RELEASE(str); } break; case IS_ARRAY: tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); zval_dtor(op); - ZVAL_LONG(op, tmp); + ZVAL_INT(op, tmp); break; case IS_OBJECT: { zval dst; TSRMLS_FETCH(); - convert_object_to_type(op, &dst, IS_LONG, convert_to_long); + convert_object_to_type(op, &dst, IS_INT, convert_to_int); zval_dtor(op); - if (Z_TYPE(dst) == IS_LONG) { + if (Z_TYPE(dst) == IS_INT) { ZVAL_COPY_VALUE(op, &dst); } else { zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val); - ZVAL_LONG(op, 1); + ZVAL_INT(op, 1); } return; } @@ -454,8 +454,8 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */ ZVAL_DOUBLE(op, d); } break; - case IS_LONG: - ZVAL_DOUBLE(op, (double) Z_LVAL_P(op)); + case IS_INT: + ZVAL_DOUBLE(op, (double) Z_IVAL_P(op)); break; case IS_DOUBLE: break; @@ -527,14 +527,14 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */ ZVAL_BOOL(op, 0); break; case IS_RESOURCE: { - long l = (Z_RES_HANDLE_P(op) ? 1 : 0); + zend_int_t l = (Z_RES_HANDLE_P(op) ? 1 : 0); zval_ptr_dtor(op); ZVAL_BOOL(op, l); } break; - case IS_LONG: - ZVAL_BOOL(op, Z_LVAL_P(op) ? 1 : 0); + case IS_INT: + ZVAL_BOOL(op, Z_IVAL_P(op) ? 1 : 0); break; case IS_DOUBLE: ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0); @@ -598,13 +598,13 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */ case IS_STRING: break; case IS_RESOURCE: { - char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG]; + char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT]; int len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op)); ZVAL_NEW_STR(op, STR_INIT(buf, len, 0)); break; } - case IS_LONG: { - ZVAL_NEW_STR(op, zend_long_to_str(Z_LVAL_P(op))); + case IS_INT: { + ZVAL_NEW_STR(op, zend_int_to_str(Z_IVAL_P(op))); break; } case IS_DOUBLE: { @@ -736,7 +736,7 @@ ZEND_API void convert_to_object(zval *op) /* {{{ */ } /* }}} */ -ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */ +ZEND_API void multi_convert_to_int_ex(int argc, ...) /* {{{ */ { zval *arg; va_list ap; @@ -745,7 +745,7 @@ ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */ while (argc--) { arg = va_arg(ap, zval *); - convert_to_long_ex(arg); + convert_to_int_ex(arg); } va_end(ap); @@ -784,7 +784,7 @@ ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */ } /* }}} */ -ZEND_API long _zval_get_long_func(zval *op TSRMLS_DC) /* {{{ */ +ZEND_API zend_int_t _zval_get_int_func(zval *op TSRMLS_DC) /* {{{ */ { try_again: switch (Z_TYPE_P(op)) { @@ -795,20 +795,20 @@ try_again: return 1; case IS_RESOURCE: return Z_RES_HANDLE_P(op); - case IS_LONG: - return Z_LVAL_P(op); + case IS_INT: + return Z_IVAL_P(op); case IS_DOUBLE: - return zend_dval_to_lval(Z_DVAL_P(op)); + return zend_dval_to_ival(Z_DVAL_P(op)); case IS_STRING: - return strtol(Z_STRVAL_P(op), NULL, 10); + return ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10); case IS_ARRAY: return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0; case IS_OBJECT: { zval dst; - convert_object_to_type(op, &dst, IS_LONG, convert_to_long); - if (Z_TYPE(dst) == IS_LONG) { - return Z_LVAL(dst); + convert_object_to_type(op, &dst, IS_INT, convert_to_int); + if (Z_TYPE(dst) == IS_INT) { + return Z_IVAL(dst); } else { zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val); return 1; @@ -834,8 +834,8 @@ try_again: return 1.0; case IS_RESOURCE: return (double) Z_RES_HANDLE_P(op); - case IS_LONG: - return (double) Z_LVAL_P(op); + case IS_INT: + return (double) Z_IVAL_P(op); case IS_DOUBLE: return Z_DVAL_P(op); case IS_STRING: @@ -876,14 +876,14 @@ try_again: case IS_TRUE: return STR_INIT("1", 1, 0); case IS_RESOURCE: { - char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG]; + char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT]; int len; len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op)); return STR_INIT(buf, len, 0); } - case IS_LONG: { - return zend_long_to_str(Z_LVAL_P(op)); + case IS_INT: { + return zend_int_to_str(Z_IVAL_P(op)); } case IS_DOUBLE: { return zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(op)); @@ -925,26 +925,26 @@ ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): { - long lval = Z_LVAL_P(op1) + Z_LVAL_P(op2); + case TYPE_PAIR(IS_INT, IS_INT): { + zend_int_t lval = Z_IVAL_P(op1) + Z_IVAL_P(op2); /* check for overflow by comparing sign bits */ - if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK) - && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { + if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) == (Z_IVAL_P(op2) & LONG_SIGN_MASK) + && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { - ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2)); + ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) + (double) Z_IVAL_P(op2)); } else { - ZVAL_LONG(result, lval); + ZVAL_INT(result, lval); } return SUCCESS; } - case TYPE_PAIR(IS_LONG, IS_DOUBLE): - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2)); + case TYPE_PAIR(IS_INT, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) + Z_DVAL_P(op2)); return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2))); + case TYPE_PAIR(IS_DOUBLE, IS_INT): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_IVAL_P(op2))); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): @@ -989,26 +989,26 @@ ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): { - long lval = Z_LVAL_P(op1) - Z_LVAL_P(op2); + case TYPE_PAIR(IS_INT, IS_INT): { + zend_int_t lval = Z_IVAL_P(op1) - Z_IVAL_P(op2); /* check for overflow by comparing sign bits */ - if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK) - && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { + if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) != (Z_IVAL_P(op2) & LONG_SIGN_MASK) + && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) { - ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2)); + ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) - (double) Z_IVAL_P(op2)); } else { - ZVAL_LONG(result, lval); + ZVAL_INT(result, lval); } return SUCCESS; } - case TYPE_PAIR(IS_LONG, IS_DOUBLE): - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2)); + case TYPE_PAIR(IS_INT, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) - Z_DVAL_P(op2)); return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2))); + case TYPE_PAIR(IS_DOUBLE, IS_INT): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_IVAL_P(op2))); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): @@ -1042,20 +1042,20 @@ ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): { - long overflow; + case TYPE_PAIR(IS_INT, IS_INT): { + zend_int_t overflow; - ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow); - Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG; + ZEND_SIGNED_MULTIPLY_INT(Z_IVAL_P(op1),Z_IVAL_P(op2), Z_IVAL_P(result),Z_DVAL_P(result),overflow); + Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_INT; return SUCCESS; } - case TYPE_PAIR(IS_LONG, IS_DOUBLE): - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2)); + case TYPE_PAIR(IS_INT, IS_DOUBLE): + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) * Z_DVAL_P(op2)); return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2))); + case TYPE_PAIR(IS_DOUBLE, IS_INT): + ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_IVAL_P(op2))); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): @@ -1089,32 +1089,32 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): - if (Z_LVAL_P(op2) >= 0) { - long l1 = 1, l2 = Z_LVAL_P(op1), i = Z_LVAL_P(op2); + case TYPE_PAIR(IS_INT, IS_INT): + if (Z_IVAL_P(op2) >= 0) { + zend_int_t l1 = 1, l2 = Z_IVAL_P(op1), i = Z_IVAL_P(op2); if (i == 0) { - ZVAL_LONG(result, 1L); + ZVAL_INT(result, 1L); return SUCCESS; } else if (l2 == 0) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; } while (i >= 1) { - long overflow; + zend_int_t overflow; double dval = 0.0; if (i % 2) { --i; - ZEND_SIGNED_MULTIPLY_LONG(l1, l2, l1, dval, overflow); + ZEND_SIGNED_MULTIPLY_INT(l1, l2, l1, dval, overflow); if (overflow) { ZVAL_DOUBLE(result, dval * pow(l2, i)); return SUCCESS; } } else { i /= 2; - ZEND_SIGNED_MULTIPLY_LONG(l2, l2, l2, dval, overflow); + ZEND_SIGNED_MULTIPLY_INT(l2, l2, l2, dval, overflow); if (overflow) { ZVAL_DOUBLE(result, (double)l1 * pow(dval, i)); return SUCCESS; @@ -1122,18 +1122,18 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * } } /* i == 0 */ - ZVAL_LONG(result, l1); + ZVAL_INT(result, l1); } else { - ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), (double)Z_LVAL_P(op2))); + ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), (double)Z_IVAL_P(op2))); } return SUCCESS; - case TYPE_PAIR(IS_LONG, IS_DOUBLE): - ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), Z_DVAL_P(op2))); + case TYPE_PAIR(IS_INT, IS_DOUBLE): + ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), Z_DVAL_P(op2))); return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_LVAL_P(op2))); + case TYPE_PAIR(IS_DOUBLE, IS_INT): + ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_IVAL_P(op2))); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): @@ -1149,13 +1149,13 @@ ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_POW); if (Z_TYPE_P(op1) == IS_ARRAY) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; } else { zendi_convert_scalar_to_number(op1, op1_copy, result); } if (Z_TYPE_P(op2) == IS_ARRAY) { - ZVAL_LONG(result, 1L); + ZVAL_INT(result, 1L); return SUCCESS; } else { zendi_convert_scalar_to_number(op2, op2_copy, result); @@ -1177,39 +1177,39 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): - if (Z_LVAL_P(op2) == 0) { + case TYPE_PAIR(IS_INT, IS_INT): + if (Z_IVAL_P(op2) == 0) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; /* division by zero */ - } else if (Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN) { + } else if (Z_IVAL_P(op2) == -1 && Z_IVAL_P(op1) == ZEND_INT_MIN) { /* Prevent overflow error/crash */ - ZVAL_DOUBLE(result, (double) LONG_MIN / -1); + ZVAL_DOUBLE(result, (double) ZEND_INT_MIN / -1); return SUCCESS; } - if (Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0) { /* integer */ - ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2)); + if (Z_IVAL_P(op1) % Z_IVAL_P(op2) == 0) { /* integer */ + ZVAL_INT(result, Z_IVAL_P(op1) / Z_IVAL_P(op2)); } else { - ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / Z_LVAL_P(op2)); + ZVAL_DOUBLE(result, ((double) Z_IVAL_P(op1)) / Z_IVAL_P(op2)); } return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - if (Z_LVAL_P(op2) == 0) { + case TYPE_PAIR(IS_DOUBLE, IS_INT): + if (Z_IVAL_P(op2) == 0) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; /* division by zero */ } - ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_LVAL_P(op2)); + ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_IVAL_P(op2)); return SUCCESS; - case TYPE_PAIR(IS_LONG, IS_DOUBLE): + case TYPE_PAIR(IS_INT, IS_DOUBLE): if (Z_DVAL_P(op2) == 0) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; /* division by zero */ } - ZVAL_DOUBLE(result, (double)Z_LVAL_P(op1) / Z_DVAL_P(op2)); + ZVAL_DOUBLE(result, (double)Z_IVAL_P(op1) / Z_DVAL_P(op2)); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): @@ -1244,31 +1244,31 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MOD); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - if (Z_LVAL_P(op2) == 0) { + if (Z_IVAL_P(op2) == 0) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; /* modulus by zero */ } - if (Z_LVAL_P(op2) == -1) { + if (Z_IVAL_P(op2) == -1) { /* Prevent overflow error/crash if op1==LONG_MIN */ - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; } - ZVAL_LONG(result, op1_lval % Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval % Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1276,7 +1276,7 @@ ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; if ((Z_TYPE_P(op1) != IS_FALSE && Z_TYPE_P(op1) != IS_TRUE) || (Z_TYPE_P(op2) != IS_FALSE && Z_TYPE_P(op2) != IS_TRUE)) { @@ -1317,18 +1317,18 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ { switch (Z_TYPE_P(op1)) { - case IS_LONG: - ZVAL_LONG(result, ~Z_LVAL_P(op1)); + case IS_INT: + ZVAL_INT(result, ~Z_IVAL_P(op1)); return SUCCESS; case IS_DOUBLE: - ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1))); + ZVAL_INT(result, ~zend_dval_to_ival(Z_DVAL_P(op1))); return SUCCESS; case IS_STRING: { - int i; + zend_size_t i; zval op1_copy = *op1; - ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN(op1_copy), 0)); - for (i = 0; i < Z_STRLEN(op1_copy); i++) { + ZVAL_NEW_STR(result, STR_ALLOC(Z_STRSIZE(op1_copy), 0)); + for (i = 0; i < Z_STRSIZE(op1_copy); i++) { Z_STRVAL_P(result)[i] = ~Z_STRVAL(op1_copy)[i]; } Z_STRVAL_P(result)[i] = 0; @@ -1346,14 +1346,14 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { zval *longer, *shorter; zend_string *str; - int i; + zend_size_t i; - if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) { longer = op1; shorter = op2; } else { @@ -1361,11 +1361,11 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / shorter = op1; } - str = STR_ALLOC(Z_STRLEN_P(longer), 0); - for (i = 0; i < Z_STRLEN_P(shorter); i++) { + str = STR_ALLOC(Z_STRSIZE_P(longer), 0); + for (i = 0; i < Z_STRSIZE_P(shorter); i++) { str->val[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i]; } - memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1); + memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRSIZE_P(longer) - i + 1); if (result==op1) { STR_RELEASE(Z_STR_P(result)); } @@ -1373,17 +1373,17 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / return SUCCESS; } - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_OR); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - ZVAL_LONG(result, op1_lval | Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval | Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1391,14 +1391,14 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { zval *longer, *shorter; zend_string *str; - int i; + zend_size_t i; - if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) { longer = op1; shorter = op2; } else { @@ -1406,8 +1406,8 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) shorter = op1; } - str = STR_ALLOC(Z_STRLEN_P(shorter), 0); - for (i = 0; i < Z_STRLEN_P(shorter); i++) { + str = STR_ALLOC(Z_STRSIZE_P(shorter), 0); + for (i = 0; i < Z_STRSIZE_P(shorter); i++) { str->val[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i]; } str->val[i] = 0; @@ -1418,17 +1418,17 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) return SUCCESS; } - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_AND); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - ZVAL_LONG(result, op1_lval & Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval & Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1436,14 +1436,14 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) { zval *longer, *shorter; zend_string *str; - int i; + zend_size_t i; - if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) { longer = op1; shorter = op2; } else { @@ -1451,8 +1451,8 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) shorter = op1; } - str = STR_ALLOC(Z_STRLEN_P(shorter), 0); - for (i = 0; i < Z_STRLEN_P(shorter); i++) { + str = STR_ALLOC(Z_STRSIZE_P(shorter), 0); + for (i = 0; i < Z_STRSIZE_P(shorter); i++) { str->val[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i]; } str->val[i] = 0; @@ -1463,17 +1463,17 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) return SUCCESS; } - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_XOR); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - ZVAL_LONG(result, op1_lval ^ Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval ^ Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1481,19 +1481,19 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SL); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - ZVAL_LONG(result, op1_lval << Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval << Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1501,19 +1501,19 @@ ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { zval op1_copy, op2_copy; - long op1_lval; + zend_int_t op1_lval; - if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) { + if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) { ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SR); - zendi_convert_to_long(op1, op1_copy, result); - op1_lval = Z_LVAL_P(op1); - zendi_convert_to_long(op2, op2_copy, result); + zendi_convert_to_int(op1, op1_copy, result); + op1_lval = Z_IVAL_P(op1); + zendi_convert_to_int(op2, op2_copy, result); } else { - op1_lval = Z_LVAL_P(op1); + op1_lval = Z_IVAL_P(op1); } - ZVAL_LONG(result, op1_lval >> Z_LVAL_P(op2)); + ZVAL_INT(result, op1_lval >> Z_IVAL_P(op2)); return SUCCESS; } /* }}} */ @@ -1521,10 +1521,10 @@ ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* must support result==op1 */ ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ { - int length = Z_STRLEN_P(op1) + 1; + zend_size_t length = Z_STRSIZE_P(op1) + 1; zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0); - buf->val[length - 1] = (char) Z_LVAL_P(op2); + buf->val[length - 1] = (char) Z_IVAL_P(op2); buf->val[length] = 0; ZVAL_NEW_STR(result, buf); return SUCCESS; @@ -1534,11 +1534,11 @@ ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) /* must support result==op1 */ ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ { - int op1_len = Z_STRLEN_P(op1); - int length = op1_len + Z_STRLEN_P(op2); + zend_size_t op1_len = Z_STRSIZE_P(op1); + zend_size_t length = op1_len + Z_STRSIZE_P(op2); zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0); - memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRSIZE_P(op2)); buf->val[length] = 0; ZVAL_NEW_STR(result, buf); return SUCCESS; @@ -1576,11 +1576,11 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{ } if (result==op1 && !IS_INTERNED(Z_STR_P(op1))) { /* special case, perform operations on result */ - uint op1_len = Z_STRLEN_P(op1); - uint op2_len = Z_STRLEN_P(op2); - uint res_len = op1_len + op2_len; + zend_size_t op1_len = Z_STRSIZE_P(op1); + zend_size_t op2_len = Z_STRSIZE_P(op2); + zend_size_t res_len = op1_len + op2_len; - if (Z_STRLEN_P(result) < 0 || (int) (op1_len + op2_len) < 0) { + if (Z_STRSIZE_P(result) < 0 || (zend_size_t) (op1_len + op2_len) < 0) { ZVAL_EMPTY_STRING(result); zend_error(E_ERROR, "String size overflow"); } @@ -1590,11 +1590,11 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{ memcpy(Z_STRVAL_P(result) + op1_len, Z_STRVAL_P(op2), op2_len); Z_STRVAL_P(result)[res_len]=0; } else { - int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); + zend_size_t length = Z_STRSIZE_P(op1) + Z_STRSIZE_P(op2); zend_string *buf = STR_ALLOC(length, 0); - memcpy(buf->val, Z_STRVAL_P(op1), Z_STRLEN_P(op1)); - memcpy(buf->val + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + memcpy(buf->val, Z_STRVAL_P(op1), Z_STRSIZE_P(op1)); + memcpy(buf->val + Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2)); buf->val[length] = 0; ZVAL_NEW_STR(result, buf); } @@ -1614,9 +1614,9 @@ ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend zend_string *str2 = zval_get_string(op2); if (case_insensitive) { - ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len)); + ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len)); } else { - ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len)); + ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len)); } STR_RELEASE(str1); @@ -1630,15 +1630,15 @@ ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_D if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) && EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { if (Z_STR_P(op1) == Z_STR_P(op2)) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); } else { - ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2))); + ZVAL_INT(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2))); } } else { zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len)); + ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len)); STR_RELEASE(str1); STR_RELEASE(str2); @@ -1652,15 +1652,15 @@ ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSR if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) && EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { if (Z_STR_P(op1) == Z_STR_P(op2)) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); } else { - ZVAL_LONG(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2))); + ZVAL_INT(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2))); } } else { zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len)); + ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len)); STR_RELEASE(str1); STR_RELEASE(str2); @@ -1675,7 +1675,7 @@ ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 T zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_LONG(result, strcoll(str1->val, str2->val)); + ZVAL_INT(result, strcoll(str1->val, str2->val)); STR_RELEASE(str1); STR_RELEASE(str2); @@ -1691,7 +1691,7 @@ ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_ d1 = zval_get_double(op1); d2 = zval_get_double(op2); - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(d1 - d2)); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(d1 - d2)); return SUCCESS; } @@ -1718,26 +1718,26 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { while (1) { switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) { - case TYPE_PAIR(IS_LONG, IS_LONG): - ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0)); + case TYPE_PAIR(IS_INT, IS_INT): + ZVAL_INT(result, Z_IVAL_P(op1)>Z_IVAL_P(op2)?1:(Z_IVAL_P(op1)<Z_IVAL_P(op2)?-1:0)); return SUCCESS; - case TYPE_PAIR(IS_DOUBLE, IS_LONG): - Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2); - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + case TYPE_PAIR(IS_DOUBLE, IS_INT): + Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_IVAL_P(op2); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); return SUCCESS; - case TYPE_PAIR(IS_LONG, IS_DOUBLE): - Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2); - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + case TYPE_PAIR(IS_INT, IS_DOUBLE): + Z_DVAL_P(result) = (double)Z_IVAL_P(op1) - Z_DVAL_P(op2); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); return SUCCESS; case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE): if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); } else { Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2); - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); } return SUCCESS; @@ -1750,39 +1750,39 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { case TYPE_PAIR(IS_FALSE, IS_NULL): case TYPE_PAIR(IS_FALSE, IS_FALSE): case TYPE_PAIR(IS_TRUE, IS_TRUE): - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; case TYPE_PAIR(IS_NULL, IS_TRUE): - ZVAL_LONG(result, -1); + ZVAL_INT(result, -1); return SUCCESS; case TYPE_PAIR(IS_TRUE, IS_NULL): - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); return SUCCESS; case TYPE_PAIR(IS_STRING, IS_STRING): if (Z_STR_P(op1) == Z_STR_P(op2)) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; } zendi_smart_strcmp(result, op1, op2); return SUCCESS; case TYPE_PAIR(IS_NULL, IS_STRING): - ZVAL_LONG(result, Z_STRLEN_P(op2) == 0 ? 0 : -1); + ZVAL_INT(result, Z_STRSIZE_P(op2) == 0 ? 0 : -1); return SUCCESS; case TYPE_PAIR(IS_STRING, IS_NULL): - ZVAL_LONG(result, Z_STRLEN_P(op1) == 0 ? 0 : 1); + ZVAL_INT(result, Z_STRSIZE_P(op1) == 0 ? 0 : 1); return SUCCESS; case TYPE_PAIR(IS_OBJECT, IS_NULL): - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); return SUCCESS; case TYPE_PAIR(IS_NULL, IS_OBJECT): - ZVAL_LONG(result, -1); + ZVAL_INT(result, -1); return SUCCESS; default: @@ -1803,11 +1803,11 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) { if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) { /* object handles are identical, apparently this is the same object */ - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return SUCCESS; } if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) { - ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC)); + ZVAL_INT(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC)); return SUCCESS; } } @@ -1821,7 +1821,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { } else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) { ZVAL_UNDEF(&tmp_free); if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2)) TSRMLS_CC) == FAILURE) { - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); zend_free_obj_get_result(&tmp_free TSRMLS_CC); return SUCCESS; } @@ -1840,7 +1840,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { } else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) { ZVAL_UNDEF(&tmp_free); if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1)) TSRMLS_CC) == FAILURE) { - ZVAL_LONG(result, -1); + ZVAL_INT(result, -1); zend_free_obj_get_result(&tmp_free TSRMLS_CC); return SUCCESS; } @@ -1848,26 +1848,26 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { zend_free_obj_get_result(&tmp_free TSRMLS_CC); return ret; } else if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); return SUCCESS; } } if (!converted) { if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) { zendi_convert_to_boolean(op2, op2_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0); + ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0); return SUCCESS; } else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) { zendi_convert_to_boolean(op1, op1_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0); + ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0); return SUCCESS; } else if (Z_TYPE_P(op1) == IS_TRUE) { zendi_convert_to_boolean(op2, op2_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1); + ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1); return SUCCESS; } else if (Z_TYPE_P(op2) == IS_TRUE) { zendi_convert_to_boolean(op1, op1_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1); + ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1); return SUCCESS; } else { zendi_convert_scalar_to_number(op1, op1_copy, result); @@ -1875,19 +1875,19 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { converted = 1; } } else if (Z_TYPE_P(op1)==IS_ARRAY) { - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); return SUCCESS; } else if (Z_TYPE_P(op2)==IS_ARRAY) { - ZVAL_LONG(result, -1); + ZVAL_INT(result, -1); return SUCCESS; } else if (Z_TYPE_P(op1)==IS_OBJECT) { - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); return SUCCESS; } else if (Z_TYPE_P(op2)==IS_OBJECT) { - ZVAL_LONG(result, -1); + ZVAL_INT(result, -1); return SUCCESS; } else { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return FAILURE; } } @@ -1925,8 +1925,8 @@ ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) case IS_TRUE: ZVAL_BOOL(result, 1); break; - case IS_LONG: - ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2)); + case IS_INT: + ZVAL_BOOL(result, Z_IVAL_P(op1) == Z_IVAL_P(op2)); break; case IS_RESOURCE: ZVAL_BOOL(result, Z_RES_P(op1) == Z_RES_P(op2)); @@ -1938,8 +1938,8 @@ ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) if (Z_STR_P(op1) == Z_STR_P(op2)) { ZVAL_BOOL(result, 1); } else { - ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) - && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)))); + ZVAL_BOOL(result, (Z_STRSIZE_P(op1) == Z_STRSIZE_P(op2)) + && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1)))); } break; case IS_ARRAY: @@ -1976,7 +1976,7 @@ ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { return FAILURE; } - ZVAL_BOOL(result, (Z_LVAL_P(result) == 0)); + ZVAL_BOOL(result, (Z_IVAL_P(result) == 0)); return SUCCESS; } /* }}} */ @@ -1986,7 +1986,7 @@ ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { return FAILURE; } - ZVAL_BOOL(result, (Z_LVAL_P(result) != 0)); + ZVAL_BOOL(result, (Z_IVAL_P(result) != 0)); return SUCCESS; } /* }}} */ @@ -1996,7 +1996,7 @@ ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { return FAILURE; } - ZVAL_BOOL(result, (Z_LVAL_P(result) < 0)); + ZVAL_BOOL(result, (Z_IVAL_P(result) < 0)); return SUCCESS; } /* }}} */ @@ -2006,7 +2006,7 @@ ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSR if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) { return FAILURE; } - ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0)); + ZVAL_BOOL(result, (Z_IVAL_P(result) <= 0)); return SUCCESS; } /* }}} */ @@ -2046,13 +2046,13 @@ ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, cons static void increment_string(zval *str) /* {{{ */ { int carry=0; - int pos=Z_STRLEN_P(str)-1; + zend_size_t pos=Z_STRSIZE_P(str)-1; char *s; zend_string *t; int last=0; /* Shut up the compiler warning */ int ch; - if (Z_STRLEN_P(str) == 0) { + if (Z_STRSIZE_P(str) == 0) { STR_RELEASE(Z_STR_P(str)); Z_STR_P(str) = STR_INIT("1", sizeof("1")-1, 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; @@ -2060,11 +2060,11 @@ static void increment_string(zval *str) /* {{{ */ } if (IS_INTERNED(Z_STR_P(str))) { - Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); + Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; } else if (Z_REFCOUNT_P(str) > 1) { Z_DELREF_P(str); - Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); + Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0); } else { STR_FORGET_HASH_VAL(Z_STR_P(str)); } @@ -2110,9 +2110,9 @@ static void increment_string(zval *str) /* {{{ */ } if (carry) { - t = STR_ALLOC(Z_STRLEN_P(str)+1, 0); - memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRLEN_P(str)); - t->val[Z_STRLEN_P(str) + 1] = '\0'; + t = STR_ALLOC(Z_STRSIZE_P(str)+1, 0); + memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRSIZE_P(str)); + t->val[Z_STRSIZE_P(str) + 1] = '\0'; switch (last) { case NUMERIC: t->val[0] = '1'; @@ -2134,34 +2134,34 @@ ZEND_API int increment_function(zval *op1) /* {{{ */ { try_again: switch (Z_TYPE_P(op1)) { - case IS_LONG: - if (Z_LVAL_P(op1) == LONG_MAX) { + case IS_INT: + if (Z_IVAL_P(op1) == ZEND_INT_MAX) { /* switch to double */ - double d = (double)Z_LVAL_P(op1); + double d = (double)Z_IVAL_P(op1); ZVAL_DOUBLE(op1, d+1); } else { - Z_LVAL_P(op1)++; + Z_IVAL_P(op1)++; } break; case IS_DOUBLE: Z_DVAL_P(op1) = Z_DVAL_P(op1) + 1; break; case IS_NULL: - ZVAL_LONG(op1, 1); + ZVAL_INT(op1, 1); break; case IS_STRING: { - long lval; + zend_int_t lval; double dval; - switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) { - case IS_LONG: + switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) { + case IS_INT: STR_RELEASE(Z_STR_P(op1)); - if (lval == LONG_MAX) { + if (lval == ZEND_INT_MAX) { /* switch to double */ double d = (double)lval; ZVAL_DOUBLE(op1, d+1); } else { - ZVAL_LONG(op1, lval+1); + ZVAL_INT(op1, lval+1); } break; case IS_DOUBLE: @@ -2181,7 +2181,7 @@ try_again: int res; TSRMLS_FETCH(); - ZVAL_LONG(&op2, 1); + ZVAL_INT(&op2, 1); res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, &op2 TSRMLS_CC); zval_ptr_dtor(&op2); @@ -2200,36 +2200,36 @@ try_again: ZEND_API int decrement_function(zval *op1) /* {{{ */ { - long lval; + zend_int_t lval; double dval; try_again: switch (Z_TYPE_P(op1)) { - case IS_LONG: - if (Z_LVAL_P(op1) == LONG_MIN) { - double d = (double)Z_LVAL_P(op1); + case IS_INT: + if (Z_IVAL_P(op1) == ZEND_INT_MIN) { + double d = (double)Z_IVAL_P(op1); ZVAL_DOUBLE(op1, d-1); } else { - Z_LVAL_P(op1)--; + Z_IVAL_P(op1)--; } break; case IS_DOUBLE: Z_DVAL_P(op1) = Z_DVAL_P(op1) - 1; break; case IS_STRING: /* Like perl we only support string increment */ - if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */ + if (Z_STRSIZE_P(op1) == 0) { /* consider as 0 */ STR_RELEASE(Z_STR_P(op1)); - ZVAL_LONG(op1, -1); + ZVAL_INT(op1, -1); break; } - switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) { - case IS_LONG: + switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) { + case IS_INT: STR_RELEASE(Z_STR_P(op1)); - if (lval == LONG_MIN) { + if (lval == ZEND_INT_MIN) { double d = (double)lval; ZVAL_DOUBLE(op1, d-1); } else { - ZVAL_LONG(op1, lval-1); + ZVAL_INT(op1, lval-1); } break; case IS_DOUBLE: @@ -2244,7 +2244,7 @@ try_again: int res; TSRMLS_FETCH(); - ZVAL_LONG(&op2, 1); + ZVAL_INT(&op2, 1); res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, &op2 TSRMLS_CC); zval_ptr_dtor(&op2); @@ -2277,7 +2277,7 @@ ZEND_API void zend_update_current_locale(void) /* {{{ */ /* }}} */ #endif -ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length) /* {{{ */ +ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, zend_size_t length) /* {{{ */ { register unsigned char *str = (unsigned char*)source; register unsigned char *result = (unsigned char*)dest; @@ -2292,13 +2292,13 @@ ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned in } /* }}} */ -ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length) /* {{{ */ +ZEND_API char *zend_str_tolower_dup(const char *source, zend_size_t length) /* {{{ */ { return zend_str_tolower_copy((char *)emalloc(length+1), source, length); } /* }}} */ -ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */ +ZEND_API void zend_str_tolower(char *str, zend_size_t length) /* {{{ */ { register unsigned char *p = (unsigned char*)str; register unsigned char *end = p + length; @@ -2310,7 +2310,7 @@ ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */ } /* }}} */ -ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */ +ZEND_API int zend_binary_strcmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */ { int retval; @@ -2319,14 +2319,14 @@ ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint } retval = memcmp(s1, s2, MIN(len1, len2)); if (!retval) { - return (len1 - len2); + return (int)(len1 - len2); } else { return retval; } } /* }}} */ -ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */ +ZEND_API int zend_binary_strncmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */ { int retval; @@ -2335,16 +2335,16 @@ ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint } retval = memcmp(s1, s2, MIN(length, MIN(len1, len2))); if (!retval) { - return (MIN(length, len1) - MIN(length, len2)); + return (int)(MIN(length, len1) - MIN(length, len2)); } else { return retval; } } /* }}} */ -ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */ +ZEND_API int zend_binary_strcasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */ { - int len; + zend_size_t len; int c1, c2; if (s1 == s2) { @@ -2360,13 +2360,13 @@ ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, u } } - return len1 - len2; + return (int)(len1 - len2); } /* }}} */ -ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */ +ZEND_API int zend_binary_strncasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */ { - int len; + zend_size_t len; int c1, c2; if (s1 == s2) { @@ -2381,13 +2381,13 @@ ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, } } - return MIN(length, len1) - MIN(length, len2); + return (int)(MIN(length, len1) - MIN(length, len2)); } /* }}} */ -ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */ +ZEND_API int zend_binary_strcasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */ { - int len; + zend_size_t len; int c1, c2; if (s1 == s2) { @@ -2403,13 +2403,13 @@ ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, } } - return len1 - len2; + return (int)(len1 - len2); } /* }}} */ -ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */ +ZEND_API int zend_binary_strncasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */ { - int len; + zend_size_t len; int c1, c2; if (s1 == s2) { @@ -2424,31 +2424,31 @@ ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2 } } - return MIN(length, len1) - MIN(length, len2); + return (int)(MIN(length, len1) - MIN(length, len2)); } /* }}} */ ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2) /* {{{ */ { - return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); + return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2)); } /* }}} */ ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3) /* {{{ */ { - return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3)); + return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3)); } /* }}} */ ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2) /* {{{ */ { - return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); + return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2)); } /* }}} */ ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3) /* {{{ */ { - return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3)); + return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3)); } /* }}} */ @@ -2456,12 +2456,12 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */ { int ret1, ret2; int oflow1, oflow2; - long lval1 = 0, lval2 = 0; + zend_int_t lval1 = 0, lval2 = 0; double dval1 = 0.0, dval2 = 0.0; - if ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRLEN_P(s1), &lval1, &dval1, 0, &oflow1)) && - (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRLEN_P(s2), &lval2, &dval2, 0, &oflow2))) { -#if ULONG_MAX == 0xFFFFFFFF + if ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), &lval1, &dval1, 0, &oflow1)) && + (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRSIZE_P(s2), &lval2, &dval2, 0, &oflow2))) { +#if ZEND_UINT_MAX == 0xFFFFFFFF if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. && ((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/) || (oflow1 == -1 && dval1 < -9007199254740991.))) { @@ -2476,13 +2476,13 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */ if (ret1!=IS_DOUBLE) { if (oflow2) { /* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */ - ZVAL_LONG(result, -1 * oflow2); + ZVAL_INT(result, -1 * oflow2); return; } dval1 = (double) lval1; } else if (ret2!=IS_DOUBLE) { if (oflow1) { - ZVAL_LONG(result, oflow1); + ZVAL_INT(result, oflow1); return; } dval2 = (double) lval2; @@ -2492,14 +2492,14 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */ goto string_cmp; } Z_DVAL_P(result) = dval1 - dval2; - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result))); } else { /* they both have to be long's */ - ZVAL_LONG(result, lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0)); + ZVAL_INT(result, lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0)); } } else { string_cmp: - Z_LVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2)); - ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result))); + Z_IVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2)); + ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_IVAL_P(result))); } } /* }}} */ @@ -2511,7 +2511,7 @@ static int hash_zval_compare_function(zval *z1, zval *z2 TSRMLS_DC) /* {{{ */ if (compare_function(&result, z1, z2 TSRMLS_CC)==FAILURE) { return 1; } - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -2523,7 +2523,7 @@ ZEND_API int zend_compare_symbol_tables_i(HashTable *ht1, HashTable *ht2 TSRMLS_ ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC) /* {{{ */ { - ZVAL_LONG(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC)); + ZVAL_INT(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC)); } /* }}} */ @@ -2536,14 +2536,14 @@ ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC) /* ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ { if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) { - ZVAL_LONG(result, 0); + ZVAL_INT(result, 0); return; } if (Z_OBJ_HT_P(o1)->compare_objects == NULL) { - ZVAL_LONG(result, 1); + ZVAL_INT(result, 1); } else { - ZVAL_LONG(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC)); + ZVAL_INT(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC)); } } /* }}} */ @@ -2558,16 +2558,16 @@ ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC) /* {{{ */ } /* }}} */ -ZEND_API zend_string *zend_long_to_str(long num) /* {{{ */ +ZEND_API zend_string *zend_int_to_str(zend_int_t num) /* {{{ */ { - char buf[MAX_LENGTH_OF_LONG + 1]; + char buf[MAX_LENGTH_OF_ZEND_INT + 1]; char *res; - _zend_print_signed_to_buf(buf + sizeof(buf) - 1, num, unsigned long, res); + _zend_print_signed_to_buf(buf + sizeof(buf) - 1, num, zend_uint_t, res); return STR_INIT(res, buf + sizeof(buf) - 1 - res, 0); } /* }}} */ -ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, long *lval, double *dval) { +ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, zend_int_t *lval, double *dval) { return is_numeric_string_ex(str->val, str->len, lval, dval, -1, NULL); } diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index 1ab9518b9a..3ed9b9fb4d 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -41,7 +41,7 @@ #include "ext/bcmath/libbcmath/src/bcmath.h" #endif -#define LONG_SIGN_MASK (1L << (8*sizeof(long)-1)) +#define LONG_SIGN_MASK (((zend_int_t)1) << (8*sizeof(zend_int_t)-1)) BEGIN_EXTERN_C() ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC); @@ -71,12 +71,12 @@ ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, c ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce TSRMLS_DC); END_EXTERN_C() -#if ZEND_DVAL_TO_LVAL_CAST_OK -# define zend_dval_to_lval(d) ((long) (d)) -#elif SIZEOF_LONG == 4 -static zend_always_inline long zend_dval_to_lval(double d) +#if ZEND_DVAL_TO_IVAL_CAST_OK +# define zend_dval_to_ival(d) ((zend_int_t) (d)) +#elif SIZEOF_ZEND_INT == 4 +static zend_always_inline zend_int_t zend_dval_to_ival(double d) { - if (d > LONG_MAX || d < LONG_MIN) { + if (d > ZEND_INT_MAX || d < ZEND_INT_MIN) { double two_pow_32 = pow(2., 32.), dmod; @@ -86,15 +86,15 @@ static zend_always_inline long zend_dval_to_lval(double d) * to simulate rounding towards 0 of the negative number */ dmod = ceil(dmod) + two_pow_32; } - return (long)(unsigned long)dmod; + return (zend_int_t)(zend_uint_t)dmod; } - return (long)d; + return (zend_int_t)d; } #else -static zend_always_inline long zend_dval_to_lval(double d) +static zend_always_inline zend_int_t zend_dval_to_ival(double d) { - /* >= as (double)LONG_MAX is outside signed range */ - if (d >= LONG_MAX || d < LONG_MIN) { + /* >= as (double)ZEND_INT_MAX is outside signed range */ + if (d >= ZEND_INT_MAX || d < ZEND_INT_MIN) { double two_pow_64 = pow(2., 64.), dmod; @@ -104,9 +104,9 @@ static zend_always_inline long zend_dval_to_lval(double d) * fractional part, hence dmod does not have one either */ dmod += two_pow_64; } - return (long)(unsigned long)dmod; + return (zend_int_t)(zend_uint_t)dmod; } - return (long)d; + return (zend_int_t)d; } #endif /* }}} */ @@ -119,7 +119,7 @@ static zend_always_inline long zend_dval_to_lval(double d) * of allow_errors determines whether it's required to be entirely numeric, or * just its prefix. Leading whitespace is allowed. * - * The function returns 0 if the string did not contain a valid number; IS_LONG + * The function returns 0 if the string did not contain a valid number; IS_INT * if it contained a number that fits within the range of a long; or IS_DOUBLE * if the number was out of long range or contained a decimal point/exponent. * The number's value is returned into the respective pointer, *lval or *dval, @@ -127,9 +127,9 @@ static zend_always_inline long zend_dval_to_lval(double d) * * This variant also gives information if a string that represents an integer * could not be represented as such due to overflow. It writes 1 to oflow_info - * if the integer is larger than LONG_MAX and -1 if it's smaller than LONG_MIN. + * if the integer is larger than ZEND_INT_MAX and -1 if it's smaller than ZEND_INT_MIN. */ -static inline zend_uchar is_numeric_string_ex(const char *str, int length, long *lval, double *dval, int allow_errors, int *oflow_info) +static inline zend_uchar is_numeric_string_ex(const char *str, zend_size_t length, zend_int_t *lval, double *dval, int allow_errors, int *oflow_info) { const char *ptr; int base = 10, digits = 0, dp_or_e = 0; @@ -172,7 +172,7 @@ static inline zend_uchar is_numeric_string_ex(const char *str, int length, long /* Count the number of digits. If a decimal point/exponent is found, * it's a double. Otherwise, if there's a dval or no need to check for * a full match, stop when there are too many digits for a long */ - for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) { + for (type = IS_INT; !(digits >= MAX_LENGTH_OF_ZEND_INT && (dval || allow_errors == 1)); digits++, ptr++) { check_digits: if (ZEND_IS_DIGIT(*ptr) || (base == 16 && ZEND_IS_XDIGIT(*ptr))) { continue; @@ -195,14 +195,14 @@ check_digits: } if (base == 10) { - if (digits >= MAX_LENGTH_OF_LONG) { + if (digits >= MAX_LENGTH_OF_ZEND_INT) { if (oflow_info != NULL) { *oflow_info = *str == '-' ? -1 : 1; } dp_or_e = -1; goto process_double; } - } else if (!(digits < SIZEOF_LONG * 2 || (digits == SIZEOF_LONG * 2 && ptr[-digits] <= '7'))) { + } else if (!(digits < SIZEOF_ZEND_INT * 2 || (digits == SIZEOF_ZEND_INT * 2 && ptr[-digits] <= '7'))) { if (dval) { local_dval = zend_hex_strtod(str, &ptr); } @@ -236,9 +236,9 @@ process_double: } } - if (type == IS_LONG) { - if (digits == MAX_LENGTH_OF_LONG - 1) { - int cmp = strcmp(&ptr[-digits], long_min_digits); + if (type == IS_INT) { + if (digits == MAX_LENGTH_OF_ZEND_INT - 1) { + int cmp = strcmp(&ptr[-digits], int_min_digits); if (!(cmp < 0 || (cmp == 0 && *str == '-'))) { if (dval) { @@ -253,10 +253,10 @@ process_double: } if (lval) { - *lval = strtol(str, NULL, base); + *lval = ZEND_STRTOI(str, NULL, base); } - return IS_LONG; + return IS_INT; } else { if (dval) { *dval = local_dval; @@ -266,23 +266,27 @@ process_double: } } -static inline zend_uchar is_numeric_string(const char *str, int length, long *lval, double *dval, int allow_errors) { +static inline zend_uchar is_numeric_string(const char *str, zend_size_t length, zend_int_t *lval, double *dval, int allow_errors) { return is_numeric_string_ex(str, length, lval, dval, allow_errors, NULL); } -ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, long *lval, double *dval); +ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, zend_int_t *lval, double *dval); static inline const char * -zend_memnstr(const char *haystack, const char *needle, int needle_len, char *end) +zend_memnstr(const char *haystack, const char *needle, zend_size_t needle_len, char *end) { const char *p = haystack; const char ne = needle[needle_len-1]; + ptrdiff_t off_p; + zend_size_t off_s; if (needle_len == 1) { return (char *)memchr(p, *needle, (end-p)); } - if (needle_len > end-haystack) { + off_p = end - haystack; + off_s = (off_p > 0) ? (zend_size_t)off_p : 0; + if (needle_len > off_s) { return NULL; } @@ -305,7 +309,7 @@ zend_memnstr(const char *haystack, const char *needle, int needle_len, char *end return NULL; } -static inline const void *zend_memrchr(const void *s, int c, size_t n) +static inline const void *zend_memrchr(const void *s, int c, zend_size_t n) { register const unsigned char *e; @@ -329,23 +333,23 @@ ZEND_API int decrement_function(zval *op2); ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC); ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC); ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC); -ZEND_API void convert_to_long(zval *op); +ZEND_API void convert_to_int(zval *op); ZEND_API void convert_to_double(zval *op); -ZEND_API void convert_to_long_base(zval *op, int base); +ZEND_API void convert_to_int_base(zval *op, int base); ZEND_API void convert_to_null(zval *op); ZEND_API void convert_to_boolean(zval *op); ZEND_API void convert_to_array(zval *op); ZEND_API void convert_to_object(zval *op); -ZEND_API void multi_convert_to_long_ex(int argc, ...); +ZEND_API void multi_convert_to_int_ex(int argc, ...); ZEND_API void multi_convert_to_double_ex(int argc, ...); ZEND_API void multi_convert_to_string_ex(int argc, ...); -ZEND_API long _zval_get_long_func(zval *op TSRMLS_DC); +ZEND_API zend_int_t _zval_get_int_func(zval *op TSRMLS_DC); ZEND_API double _zval_get_double_func(zval *op TSRMLS_DC); ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC); -static zend_always_inline long _zval_get_long(zval *op TSRMLS_DC) { - return Z_TYPE_P(op) == IS_LONG ? Z_LVAL_P(op) : _zval_get_long_func(op TSRMLS_CC); +static zend_always_inline zend_int_t _zval_get_int(zval *op TSRMLS_DC) { + return Z_TYPE_P(op) == IS_INT ? Z_IVAL_P(op) : _zval_get_int_func(op TSRMLS_CC); } static zend_always_inline double _zval_get_double(zval *op TSRMLS_DC) { return Z_TYPE_P(op) == IS_DOUBLE ? Z_DVAL_P(op) : _zval_get_double_func(op TSRMLS_CC); @@ -354,7 +358,7 @@ static zend_always_inline zend_string *_zval_get_string(zval *op TSRMLS_DC) { return Z_TYPE_P(op) == IS_STRING ? STR_COPY(Z_STR_P(op)) : _zval_get_string_func(op TSRMLS_CC); } -#define zval_get_long(op) _zval_get_long((op) TSRMLS_CC) +#define zval_get_int(op) _zval_get_int((op) TSRMLS_CC) #define zval_get_double(op) _zval_get_double((op) TSRMLS_CC) #define zval_get_string(op) _zval_get_string((op) TSRMLS_CC) @@ -375,20 +379,20 @@ ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSR ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC); #endif -ZEND_API void zend_str_tolower(char *str, unsigned int length); -ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length); -ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length); +ZEND_API void zend_str_tolower(char *str, zend_size_t length); +ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, zend_size_t length); +ZEND_API char *zend_str_tolower_dup(const char *source, zend_size_t length); ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2); ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3); ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2); ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3); -ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2); -ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length); -ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2); -ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length); -ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2); -ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length); +ZEND_API int zend_binary_strcmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2); +ZEND_API int zend_binary_strncmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length); +ZEND_API int zend_binary_strcasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2); +ZEND_API int zend_binary_strncasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length); +ZEND_API int zend_binary_strcasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2); +ZEND_API int zend_binary_strncasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length); ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2); ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC); @@ -396,7 +400,7 @@ ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC); ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC); ZEND_API int zend_atoi(const char *str, int str_len); -ZEND_API long zend_atol(const char *str, int str_len); +ZEND_API zend_int_t zend_atol(const char *str, int str_len); ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC); END_EXTERN_C() @@ -413,8 +417,8 @@ END_EXTERN_C() case IS_NULL: \ convert_to_null(pzv); \ break; \ - case IS_LONG: \ - convert_to_long(pzv); \ + case IS_INT: \ + convert_to_int(pzv); \ break; \ case IS_DOUBLE: \ convert_to_double(pzv); \ @@ -444,7 +448,7 @@ END_EXTERN_C() } #define convert_to_boolean_ex(pzv) convert_to_ex_master(pzv, boolean, _IS_BOOL) -#define convert_to_long_ex(pzv) convert_to_ex_master(pzv, long, IS_LONG) +#define convert_to_int_ex(pzv) convert_to_ex_master(pzv, int, IS_INT) #define convert_to_double_ex(pzv) convert_to_ex_master(pzv, double, IS_DOUBLE) #define convert_to_string_ex(pzv) convert_to_ex_master(pzv, string, IS_STRING) #define convert_to_array_ex(pzv) convert_to_ex_master(pzv, array, IS_ARRAY) @@ -452,7 +456,7 @@ END_EXTERN_C() #define convert_to_null_ex(pzv) convert_to_ex_master(pzv, null, IS_NULL) #define convert_scalar_to_number_ex(pzv) \ - if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) { \ + if (Z_TYPE_P(pzv)!=IS_INT && Z_TYPE_P(pzv)!=IS_DOUBLE) { \ SEPARATE_ZVAL_IF_NOT_REF(pzv); \ convert_scalar_to_number(pzv TSRMLS_CC); \ } @@ -476,7 +480,7 @@ ZEND_API void zend_update_current_locale(void); static zend_always_inline int fast_increment_function(zval *op1) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { #if defined(__GNUC__) && defined(__i386__) __asm__( "incl (%0)\n\t" @@ -504,11 +508,11 @@ static zend_always_inline int fast_increment_function(zval *op1) "n"(ZVAL_OFFSETOF_TYPE) : "cc"); #else - if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MAX)) { + if (UNEXPECTED(Z_IVAL_P(op1) == ZEND_INT_MAX)) { /* switch to double */ - ZVAL_DOUBLE(op1, (double)LONG_MAX + 1.0); + ZVAL_DOUBLE(op1, (double)ZEND_INT_MAX + 1.0); } else { - Z_LVAL_P(op1)++; + Z_IVAL_P(op1)++; } #endif return SUCCESS; @@ -518,7 +522,7 @@ static zend_always_inline int fast_increment_function(zval *op1) static zend_always_inline int fast_decrement_function(zval *op1) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { #if defined(__GNUC__) && defined(__i386__) __asm__( "decl (%0)\n\t" @@ -546,11 +550,11 @@ static zend_always_inline int fast_decrement_function(zval *op1) "n"(ZVAL_OFFSETOF_TYPE) : "cc"); #else - if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MIN)) { + if (UNEXPECTED(Z_IVAL_P(op1) == ZEND_INT_MIN)) { /* switch to double */ - ZVAL_DOUBLE(op1, (double)LONG_MIN - 1.0); + ZVAL_DOUBLE(op1, (double)ZEND_INT_MIN - 1.0); } else { - Z_LVAL_P(op1)--; + Z_IVAL_P(op1)--; } #endif return SUCCESS; @@ -560,8 +564,8 @@ static zend_always_inline int fast_decrement_function(zval *op1) static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { #if defined(__GNUC__) && defined(__i386__) __asm__( "movl (%1), %%eax\n\t" @@ -581,7 +585,7 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o : "r"(&result->value), "r"(&op1->value), "r"(&op2->value), - "n"(IS_LONG), + "n"(IS_INT), "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "eax","cc"); @@ -604,7 +608,7 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o : "r"(&result->value), "r"(&op1->value), "r"(&op2->value), - "n"(IS_LONG), + "n"(IS_INT), "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "rax","cc"); @@ -615,24 +619,24 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o * have read the values of op1 and op2. */ - if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK) - && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != ((Z_LVAL_P(op1) + Z_LVAL_P(op2)) & LONG_SIGN_MASK))) { - ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2)); + if (UNEXPECTED((Z_IVAL_P(op1) & LONG_SIGN_MASK) == (Z_IVAL_P(op2) & LONG_SIGN_MASK) + && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != ((Z_IVAL_P(op1) + Z_IVAL_P(op2)) & LONG_SIGN_MASK))) { + ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) + (double) Z_IVAL_P(op2)); } else { - ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2)); + ZVAL_INT(result, Z_IVAL_P(op1) + Z_IVAL_P(op2)); } #endif return SUCCESS; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2)); + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) + Z_DVAL_P(op2)); return SUCCESS; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2)); return SUCCESS; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_IVAL_P(op2))); return SUCCESS; } } @@ -641,8 +645,8 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { #if defined(__GNUC__) && defined(__i386__) __asm__( "movl (%1), %%eax\n\t" @@ -666,7 +670,7 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o : "r"(&result->value), "r"(&op1->value), "r"(&op2->value), - "n"(IS_LONG), + "n"(IS_INT), "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "eax","cc"); @@ -693,29 +697,29 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o : "r"(&result->value), "r"(&op1->value), "r"(&op2->value), - "n"(IS_LONG), + "n"(IS_INT), "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "rax","cc"); #else - ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2)); + ZVAL_INT(result, Z_IVAL_P(op1) - Z_IVAL_P(op2)); - if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK) - && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(result) & LONG_SIGN_MASK))) { - ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2)); + if (UNEXPECTED((Z_IVAL_P(op1) & LONG_SIGN_MASK) != (Z_IVAL_P(op2) & LONG_SIGN_MASK) + && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (Z_IVAL_P(result) & LONG_SIGN_MASK))) { + ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) - (double) Z_IVAL_P(op2)); } #endif return SUCCESS; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2)); + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) - Z_DVAL_P(op2)); return SUCCESS; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2)); return SUCCESS; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_IVAL_P(op2))); return SUCCESS; } } @@ -724,23 +728,23 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - long overflow; + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + zend_int_t overflow; - ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow); - Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG; + ZEND_SIGNED_MULTIPLY_INT(Z_IVAL_P(op1), Z_IVAL_P(op2), Z_IVAL_P(result), Z_DVAL_P(result), overflow); + Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_INT; return SUCCESS; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2)); + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) * Z_DVAL_P(op2)); return SUCCESS; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2)); return SUCCESS; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_IVAL_P(op2))); return SUCCESS; } } @@ -750,20 +754,20 @@ static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *o static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { #if 0 - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && 0) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT) && 0) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + if (UNEXPECTED(Z_IVAL_P(op2) == 0)) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; - } else if (UNEXPECTED(Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN)) { + } else if (UNEXPECTED(Z_IVAL_P(op2) == -1 && Z_IVAL_P(op1) == ZEND_INT_MIN)) { /* Prevent overflow error/crash */ - ZVAL_DOUBLE(result, (double) LONG_MIN / -1); - } else if (EXPECTED(Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0)) { + ZVAL_DOUBLE(result, (double) ZEND_INT_MIN / -1); + } else if (EXPECTED(Z_IVAL_P(op1) % Z_IVAL_P(op2) == 0)) { /* integer */ - ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2)); + ZVAL_INT(result, Z_IVAL_P(op1) / Z_IVAL_P(op2)); } else { - ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / ((double)Z_LVAL_P(op2))); + ZVAL_DOUBLE(result, ((double) Z_IVAL_P(op1)) / ((double)Z_IVAL_P(op2))); } return SUCCESS; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { @@ -772,7 +776,7 @@ static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *o ZVAL_BOOL(result, 0); return FAILURE; } - ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) / Z_DVAL_P(op2)); + ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) / Z_DVAL_P(op2)); return SUCCESS; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE) && 0) { @@ -784,13 +788,13 @@ static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *o } ZVAL_DOUBLE(result, Z_DVAL_P(op1) / Z_DVAL_P(op2)); return SUCCESS; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + if (UNEXPECTED(Z_IVAL_P(op2) == 0)) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; } - ZVAL_DOUBLE(result, Z_DVAL_P(op1) / ((double)Z_LVAL_P(op2))); + ZVAL_DOUBLE(result, Z_DVAL_P(op1) / ((double)Z_IVAL_P(op2))); return SUCCESS; } } @@ -800,18 +804,18 @@ static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *o static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + if (UNEXPECTED(Z_IVAL_P(op2) == 0)) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; - } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { - /* Prevent overflow error/crash if op1==LONG_MIN */ - ZVAL_LONG(result, 0); + } else if (UNEXPECTED(Z_IVAL_P(op2) == -1)) { + /* Prevent overflow error/crash if op1==ZEND_INT_MIN */ + ZVAL_INT(result, 0); return SUCCESS; } - ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2)); + ZVAL_INT(result, Z_IVAL_P(op1) % Z_IVAL_P(op2)); return SUCCESS; } } @@ -820,54 +824,54 @@ static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *o static zend_always_inline int fast_equal_check_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - return Z_LVAL_P(op1) == Z_LVAL_P(op2); + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + return Z_IVAL_P(op1) == Z_IVAL_P(op2); } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - return ((double)Z_LVAL_P(op1)) == Z_DVAL_P(op2); + return ((double)Z_IVAL_P(op1)) == Z_DVAL_P(op2); } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { return Z_DVAL_P(op1) == Z_DVAL_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - return Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + return Z_DVAL_P(op1) == ((double)Z_IVAL_P(op2)); } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { if (Z_STR_P(op1) == Z_STR_P(op2)) { return 1; } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') { - if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) != Z_STRSIZE_P(op2)) { return 0; } else { - return memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0; + return memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1)) == 0; } } else { zendi_smart_strcmp(result, op1, op2); - return Z_LVAL_P(result) == 0; + return Z_IVAL_P(result) == 0; } } } compare_function(result, op1, op2 TSRMLS_CC); - return Z_LVAL_P(result) == 0; + return Z_IVAL_P(result) == 0; } static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2)); + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_IVAL_P(op1) == Z_IVAL_P(op2)); return; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_BOOL(result, (double)Z_LVAL_P(op1) == Z_DVAL_P(op2)); + ZVAL_BOOL(result, (double)Z_IVAL_P(op1) == Z_DVAL_P(op2)); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2)); return; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_DVAL_P(op1) == ((double)Z_IVAL_P(op2))); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { @@ -876,40 +880,40 @@ static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval ZVAL_TRUE(result); return; } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') { - if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) != Z_STRSIZE_P(op2)) { ZVAL_FALSE(result); return; } else { - ZVAL_BOOL(result, memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) == 0); + ZVAL_BOOL(result, memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1)) == 0); return; } } else { zendi_smart_strcmp(result, op1, op2); - ZVAL_BOOL(result, Z_LVAL_P(result) == 0); + ZVAL_BOOL(result, Z_IVAL_P(result) == 0); return; } } } compare_function(result, op1, op2 TSRMLS_CC); - ZVAL_BOOL(result, Z_LVAL_P(result) == 0); + ZVAL_BOOL(result, Z_IVAL_P(result) == 0); } static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_LVAL_P(op1) != Z_LVAL_P(op2)); + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_IVAL_P(op1) != Z_IVAL_P(op2)); return; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_BOOL(result, (double)Z_LVAL_P(op1) != Z_DVAL_P(op2)); + ZVAL_BOOL(result, (double)Z_IVAL_P(op1) != Z_DVAL_P(op2)); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_BOOL(result, Z_DVAL_P(op1) != Z_DVAL_P(op2)); return; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_DVAL_P(op1) != ((double)Z_IVAL_P(op2))); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { @@ -918,68 +922,68 @@ static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, ZVAL_FALSE(result); return; } else if (Z_STRVAL_P(op1)[0] > '9' || Z_STRVAL_P(op2)[0] > '9') { - if (Z_STRLEN_P(op1) != Z_STRLEN_P(op2)) { + if (Z_STRSIZE_P(op1) != Z_STRSIZE_P(op2)) { ZVAL_TRUE(result); return; } else { - ZVAL_BOOL(result, memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1)) != 0); + ZVAL_BOOL(result, memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1)) != 0); return; } } else { zendi_smart_strcmp(result, op1, op2); - ZVAL_BOOL(result, Z_LVAL_P(result) != 0); + ZVAL_BOOL(result, Z_IVAL_P(result) != 0); return; } } } compare_function(result, op1, op2 TSRMLS_CC); - ZVAL_BOOL(result, Z_LVAL_P(result) != 0); + ZVAL_BOOL(result, Z_IVAL_P(result) != 0); } static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_LVAL_P(op1) < Z_LVAL_P(op2)); + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_IVAL_P(op1) < Z_IVAL_P(op2)); return; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_BOOL(result, (double)Z_LVAL_P(op1) < Z_DVAL_P(op2)); + ZVAL_BOOL(result, (double)Z_IVAL_P(op1) < Z_DVAL_P(op2)); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_BOOL(result, Z_DVAL_P(op1) < Z_DVAL_P(op2)); return; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_DVAL_P(op1) < ((double)Z_IVAL_P(op2))); return; } } compare_function(result, op1, op2 TSRMLS_CC); - ZVAL_BOOL(result, Z_LVAL_P(result) < 0); + ZVAL_BOOL(result, Z_IVAL_P(result) < 0); } static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_LVAL_P(op1) <= Z_LVAL_P(op2)); + if (EXPECTED(Z_TYPE_P(op1) == IS_INT)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_IVAL_P(op1) <= Z_IVAL_P(op2)); return; } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - ZVAL_BOOL(result, (double)Z_LVAL_P(op1) <= Z_DVAL_P(op2)); + ZVAL_BOOL(result, (double)Z_IVAL_P(op1) <= Z_DVAL_P(op2)); return; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { ZVAL_BOOL(result, Z_DVAL_P(op1) <= Z_DVAL_P(op2)); return; - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - ZVAL_BOOL(result, Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2))); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_INT)) { + ZVAL_BOOL(result, Z_DVAL_P(op1) <= ((double)Z_IVAL_P(op2))); return; } } compare_function(result, op1, op2 TSRMLS_CC); - ZVAL_BOOL(result, Z_LVAL_P(result) <= 0); + ZVAL_BOOL(result, Z_IVAL_P(result) <= 0); } static zend_always_inline void fast_is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) @@ -1041,7 +1045,7 @@ static zend_always_inline void fast_is_not_identical_function(zval *result, zval } \ } while (0) -ZEND_API zend_string *zend_long_to_str(long num); +ZEND_API zend_string *zend_int_to_str(zend_int_t num); #endif diff --git a/Zend/zend_qsort.c b/Zend/zend_qsort.c index ea577e1c07..16d513e93c 100644 --- a/Zend/zend_qsort.c +++ b/Zend/zend_qsort.c @@ -74,7 +74,7 @@ ZEND_API void zend_qsort_r(void *base, size_t nmemb, size_t siz, compare_r_func_ end = end_stack[loop]; while (begin < end) { - offset = (end - begin) >> 1; + offset = (end - begin) >> Z_I(1); _zend_qsort_swap(begin, begin + (offset - (offset % siz)), siz); seg1 = begin + siz; diff --git a/Zend/zend_stream.c b/Zend/zend_stream.c index 6d306b337e..b144432db9 100644 --- a/Zend/zend_stream.c +++ b/Zend/zend_stream.c @@ -24,9 +24,8 @@ #include "zend.h" #include "zend_compile.h" +#include "zend_stream.h" -#include <sys/types.h> -#include <sys/stat.h> #if HAVE_MMAP # if HAVE_UNISTD_H # include <unistd.h> @@ -64,8 +63,8 @@ static void zend_stream_stdio_closer(void *handle TSRMLS_DC) /* {{{ */ static size_t zend_stream_stdio_fsizer(void *handle TSRMLS_DC) /* {{{ */ { - struct stat buf; - if (handle && fstat(fileno((FILE*)handle), &buf) == 0) { + zend_stat_t buf; + if (handle && zend_fstat(fileno((FILE*)handle), &buf) == 0) { #ifdef S_ISREG if (!S_ISREG(buf.st_mode)) { return 0; @@ -237,7 +236,7 @@ ZEND_API int zend_stream_fixup(zend_file_handle *file_handle, char **buf, size_t /* *buf[size] is zeroed automatically by the kernel */ *buf = mmap(0, size + ZEND_MMAP_AHEAD, PROT_READ, MAP_PRIVATE, fileno(file_handle->handle.fp), 0); if (*buf != MAP_FAILED) { - long offset = ftell(file_handle->handle.fp); + zend_int_t offset = ftell(file_handle->handle.fp); file_handle->handle.stream.mmap.map = *buf; if (offset != -1) { diff --git a/Zend/zend_stream.h b/Zend/zend_stream.h index 5306b496f9..10fa8d8a60 100644 --- a/Zend/zend_stream.h +++ b/Zend/zend_stream.h @@ -24,6 +24,9 @@ #ifndef ZEND_STREAM_H #define ZEND_STREAM_H +#include <sys/types.h> +#include <sys/stat.h> + /* Lightweight stream implementation for the ZE scanners. * These functions are private to the engine. * */ @@ -78,4 +81,20 @@ ZEND_API void zend_file_handle_dtor(zend_file_handle *fh TSRMLS_DC); ZEND_API int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2); END_EXTERN_C() +#ifdef _WIN64 +# define zend_fseek _fseeki64 +# define zend_ftell _ftelli64 +# define zend_lseek _lseeki64 +# define zend_fstat _fstat64 +# define zend_stat _stat64 +typedef struct __stat64 zend_stat_t; +#else +# define zend_fseek fseek +# define zend_ftell ftell +# define zend_lseek lseek +# define zend_fstat fstat +# define zend_stat stat +typedef struct stat zend_stat_t; +#endif + #endif diff --git a/Zend/zend_string.c b/Zend/zend_string.c index 2a415454ce..5a4f4e1fc5 100644 --- a/Zend/zend_string.c +++ b/Zend/zend_string.c @@ -29,7 +29,7 @@ static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC); static void zend_interned_strings_snapshot_int(TSRMLS_D); static void zend_interned_strings_restore_int(TSRMLS_D); -ZEND_API zend_ulong zend_hash_func(const char *str, uint len) +ZEND_API zend_uint_t zend_hash_func(const char *str, zend_size_t len) { return zend_inline_hash_func(str, len); } @@ -85,7 +85,7 @@ void zend_interned_strings_dtor(TSRMLS_D) static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC) { #ifndef ZTS - ulong h; + zend_uint_t h; uint nIndex; uint idx; Bucket *p; diff --git a/Zend/zend_string.h b/Zend/zend_string.h index ef0116b938..f30ae29941 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -29,7 +29,7 @@ ZEND_API extern zend_string *(*zend_new_interned_string)(zend_string *str TSRMLS ZEND_API extern void (*zend_interned_strings_snapshot)(TSRMLS_D); ZEND_API extern void (*zend_interned_strings_restore)(TSRMLS_D); -ZEND_API zend_ulong zend_hash_func(const char *str, uint len); +ZEND_API zend_uint_t zend_hash_func(const char *str, zend_size_t len); void zend_interned_strings_init(TSRMLS_D); void zend_interned_strings_dtor(TSRMLS_D); @@ -70,7 +70,7 @@ END_EXTERN_C() #define STR_ALLOCA_FREE(str, use_heap) free_alloca(str, use_heap) -static zend_always_inline zend_ulong zend_str_hash_val(zend_string *s) +static zend_always_inline zend_uint_t zend_str_hash_val(zend_string *s) { if (!s->h) { s->h = zend_hash_func(s->val, s->len); @@ -107,7 +107,7 @@ static zend_always_inline zend_uint zend_str_delref(zend_string *s) return 1; } -static zend_always_inline zend_string *zend_str_alloc(int len, int persistent) +static zend_always_inline zend_string *zend_str_alloc(zend_size_t len, int persistent) { zend_string *ret = (zend_string *)pemalloc(ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + len + 1), persistent); @@ -143,7 +143,7 @@ static zend_always_inline zend_string *zend_str_safe_alloc(size_t n, size_t m, s return ret; } -static zend_always_inline zend_string *zend_str_init(const char *str, int len, int persistent) +static zend_always_inline zend_string *zend_str_init(const char *str, zend_size_t len, int persistent) { zend_string *ret = STR_ALLOC(len, persistent); @@ -169,7 +169,7 @@ static zend_always_inline zend_string *zend_str_dup(zend_string *s, int persiste } } -static zend_always_inline zend_string *zend_str_realloc(zend_string *s, int len, int persistent) +static zend_always_inline zend_string *zend_str_realloc(zend_string *s, zend_size_t len, int persistent) { zend_string *ret; @@ -257,9 +257,9 @@ static zend_always_inline void zend_str_release(zend_string *s) * -- Ralf S. Engelschall <rse@engelschall.com> */ -static inline ulong zend_inline_hash_func(const char *str, uint len) +static inline zend_uint_t zend_inline_hash_func(const char *str, zend_size_t len) { - register ulong hash = 5381; + register zend_uint_t hash = Z_UI(5381); /* variant with the hash unrolled eight times */ for (; len >= 8; len -= 8) { diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c index f6523574ae..9d55933e0a 100644 --- a/Zend/zend_ts_hash.c +++ b/Zend/zend_ts_hash.c @@ -110,7 +110,7 @@ ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zv return retval; } -ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC) +ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, zend_uint_t h, zval *pData, int flag ZEND_FILE_LINE_DC) { zval *retval; @@ -187,7 +187,7 @@ ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key) return retval; } -ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, ulong h) +ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, zend_uint_t h) { int retval; @@ -209,7 +209,7 @@ ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key) return retval; } -ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, ulong h) +ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, zend_uint_t h) { zval *retval; @@ -231,7 +231,7 @@ ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key) return retval; } -ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, ulong h) +ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, zend_uint_t h) { int retval; diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h index fcf8c3cda1..ceb7cbf1fe 100644 --- a/Zend/zend_ts_hash.h +++ b/Zend/zend_ts_hash.h @@ -55,7 +55,7 @@ ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zv #define zend_ts_hash_add(ht, key, pData) \ _zend_ts_hash_add_or_update(ht, key, pData, HASH_ADD ZEND_FILE_LINE_CC) -ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC); +ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, zend_uint_t h, zval *pData, int flag ZEND_FILE_LINE_DC); #define zend_ts_hash_index_update(ht, h, pData) \ _zend_ts_hash_index_update_or_next_insert(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_CC) #define zend_ts_hash_next_index_insert(ht, pData) \ @@ -73,15 +73,15 @@ ZEND_API void zend_ts_hash_reverse_apply(TsHashTable *ht, apply_func_t apply_fun /* Deletes */ ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key); -ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, ulong h); +ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, zend_uint_t h); /* Data retreival */ ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key); -ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, ulong); +ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, zend_uint_t); /* Misc */ ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key); -ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, ulong h); +ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, zend_uint_t h); /* Copying, merging and sorting */ ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor); diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 232fcbadc1..f5d7a6ea7d 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -22,6 +22,8 @@ #ifndef ZEND_TYPES_H #define ZEND_TYPES_H +#include "zend_int.h" + #ifdef WORDS_BIGENDIAN # define ZEND_ENDIAN_LOHI(lo, hi) hi; lo; # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) hi; mi; lo; @@ -44,6 +46,21 @@ typedef unsigned int zend_uint; typedef unsigned long zend_ulong; typedef unsigned short zend_ushort; +#ifdef ZEND_ENABLE_INT64 +# ifdef ZEND_WIN32 +# define ZEND_SIZE_MAX _UI64_MAX +# else +# define ZEND_SIZE_MAX SIZE_MAX +# endif +#else +# if defined(ZEND_WIN32) +# define ZEND_SIZE_MAX _UI32_MAX +# else +# define ZEND_SIZE_MAX SIZE_MAX +# endif +#endif +typedef size_t zend_size_t; + #define HAVE_ZEND_LONG64 #ifdef ZEND_WIN32 typedef __int64 zend_long64; @@ -87,7 +104,7 @@ typedef void (*dtor_func_t)(zval *pDest); typedef void (*copy_ctor_func_t)(zval *pElement); typedef union _zend_value { - long lval; /* long value */ + zend_int_t lval; /* long value */ double dval; /* double value */ zend_refcounted *counted; zend_string *str; @@ -137,13 +154,13 @@ struct _zend_refcounted { struct _zend_string { zend_refcounted gc; - zend_ulong h; /* hash value */ - int len; + zend_uint_t h; /* hash value */ + zend_size_t len; char val[1]; }; typedef struct _Bucket { - zend_ulong h; /* hash value (or numeric index) */ + zend_uint_t h; /* hash value (or numeric index) */ zend_string *key; /* string key or NULL for numerics */ zval val; } Bucket; @@ -153,7 +170,7 @@ typedef struct _HashTable { zend_uint nTableMask; zend_uint nNumUsed; zend_uint nNumOfElements; - long nNextFreeElement; + zend_int_t nNextFreeElement; Bucket *arData; zend_uint *arHash; dtor_func_t pDestructor; @@ -186,7 +203,7 @@ struct _zend_object { struct _zend_resource { zend_refcounted gc; - long handle; // TODO: may be removed ??? + zend_int_t handle; // TODO: may be removed ??? int type; void *ptr; }; @@ -206,7 +223,7 @@ struct _zend_ast_ref { #define IS_NULL 1 #define IS_FALSE 2 #define IS_TRUE 3 -#define IS_LONG 4 +#define IS_INT 4 #define IS_DOUBLE 5 #define IS_STRING 6 #define IS_ARRAY 7 @@ -381,8 +398,8 @@ static inline zend_uchar zval_get_type(const zval* pz) { #define Z_ISNULL(zval) (Z_TYPE(zval) == IS_NULL) #define Z_ISNULL_P(zval_p) Z_ISNULL(*(zval_p)) -#define Z_LVAL(zval) (zval).value.lval -#define Z_LVAL_P(zval_p) Z_LVAL(*(zval_p)) +#define Z_IVAL(zval) (zval).value.lval +#define Z_IVAL_P(zval_p) Z_IVAL(*(zval_p)) #define Z_DVAL(zval) (zval).value.dval #define Z_DVAL_P(zval_p) Z_DVAL(*(zval_p)) @@ -393,8 +410,8 @@ static inline zend_uchar zval_get_type(const zval* pz) { #define Z_STRVAL(zval) Z_STR(zval)->val #define Z_STRVAL_P(zval_p) Z_STRVAL(*(zval_p)) -#define Z_STRLEN(zval) Z_STR(zval)->len -#define Z_STRLEN_P(zval_p) Z_STRLEN(*(zval_p)) +#define Z_STRSIZE(zval) Z_STR(zval)->len +#define Z_STRSIZE_P(zval_p) Z_STRSIZE(*(zval_p)) #define Z_STRHASH(zval) Z_STR(zval)->h #define Z_STRHASH_P(zval_p) Z_STRHASH(*(zval_p)) @@ -483,10 +500,10 @@ static inline zend_uchar zval_get_type(const zval* pz) { (b) ? IS_TRUE : IS_FALSE; \ } while (0) -#define ZVAL_LONG(z, l) { \ +#define ZVAL_INT(z, l) { \ zval *__z = (z); \ - Z_LVAL_P(__z) = l; \ - Z_TYPE_INFO_P(__z) = IS_LONG; \ + Z_IVAL_P(__z) = l; \ + Z_TYPE_INFO_P(__z) = IS_INT; \ } #define ZVAL_DOUBLE(z, d) { \ diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c index 9f76d9f812..1c10a1451f 100644 --- a/Zend/zend_variables.c +++ b/Zend/zend_variables.c @@ -165,7 +165,7 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC) free(ref); break; } - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: @@ -196,7 +196,7 @@ ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC) free(ref); break; } - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: diff --git a/Zend/zend_virtual_cwd.c b/Zend/zend_virtual_cwd.c index ab3d0d7c49..92613c7420 100644 --- a/Zend/zend_virtual_cwd.c +++ b/Zend/zend_virtual_cwd.c @@ -178,7 +178,7 @@ static int php_check_dots(const char *element, int n) #define MAXIMUM_REPARSE_DATA_BUFFER_SIZE ( 16 * 1024 ) typedef struct { - unsigned long ReparseTag; + zend_uint_t ReparseTag; unsigned short ReparseDataLength; unsigned short Reserved; union { @@ -187,7 +187,7 @@ typedef struct { unsigned short SubstituteNameLength; unsigned short PrintNameOffset; unsigned short PrintNameLength; - unsigned long Flags; + zend_uint_t Flags; wchar_t ReparseTarget[1]; } SymbolicLinkReparseBuffer; struct { @@ -291,7 +291,7 @@ CWD_API int php_sys_readlink(const char *link, char *target, size_t target_len){ } /* }}} */ -CWD_API int php_sys_stat_ex(const char *path, struct stat *buf, int lstat) /* {{{ */ +CWD_API int php_sys_stat_ex(const char *path, zend_stat_t *buf, int lstat) /* {{{ */ { WIN32_FILE_ATTRIBUTE_DATA data; __int64 t; @@ -299,7 +299,7 @@ CWD_API int php_sys_stat_ex(const char *path, struct stat *buf, int lstat) /* {{ ALLOCA_FLAG(use_heap_large); if (!GetFileAttributesEx(path, GetFileExInfoStandard, &data)) { - return stat(path, buf); + return zend_stat(path, buf); } if (path_len >= 1 && path[1] == ':') { @@ -407,7 +407,7 @@ CWD_API int php_sys_stat_ex(const char *path, struct stat *buf, int lstat) /* {{ static int php_is_dir_ok(const cwd_state *state) /* {{{ */ { - struct stat buf; + zend_stat_t buf; if (php_sys_stat(state->cwd, &buf) == 0 && S_ISDIR(buf.st_mode)) return (0); @@ -418,7 +418,7 @@ static int php_is_dir_ok(const cwd_state *state) /* {{{ */ static int php_is_file_ok(const cwd_state *state) /* {{{ */ { - struct stat buf; + zend_stat_t buf; if (php_sys_stat(state->cwd, &buf) == 0 && S_ISREG(buf.st_mode)) return (0); @@ -582,9 +582,9 @@ CWD_API char *virtual_getcwd(char *buf, size_t size TSRMLS_DC) /* {{{ */ /* }}} */ #ifdef PHP_WIN32 -static inline unsigned long realpath_cache_key(const char *path, int path_len TSRMLS_DC) /* {{{ */ +static inline zend_uint_t realpath_cache_key(const char *path, int path_len TSRMLS_DC) /* {{{ */ { - register unsigned long h; + register zend_uint_t h; char *bucket_key_start = tsrm_win32_get_path_sid_key(path TSRMLS_CC); char *bucket_key = (char *)bucket_key_start; const char *e = bucket_key + strlen(bucket_key); @@ -602,9 +602,9 @@ static inline unsigned long realpath_cache_key(const char *path, int path_len TS } /* }}} */ #else -static inline unsigned long realpath_cache_key(const char *path, int path_len) /* {{{ */ +static inline zend_uint_t realpath_cache_key(const char *path, int path_len) /* {{{ */ { - register unsigned long h; + register zend_uint_t h; const char *e = path + path_len; for (h = 2166136261U; path < e;) { @@ -637,11 +637,11 @@ CWD_API void realpath_cache_clean(TSRMLS_D) /* {{{ */ CWD_API void realpath_cache_del(const char *path, int path_len TSRMLS_DC) /* {{{ */ { #ifdef PHP_WIN32 - unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC); + zend_uint_t key = realpath_cache_key(path, path_len TSRMLS_CC); #else - unsigned long key = realpath_cache_key(path, path_len); + zend_uint_t key = realpath_cache_key(path, path_len); #endif - unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0])); + zend_uint_t n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0])); realpath_cache_bucket **bucket = &CWDG(realpath_cache)[n]; while (*bucket != NULL) { @@ -668,7 +668,7 @@ CWD_API void realpath_cache_del(const char *path, int path_len TSRMLS_DC) /* {{{ static inline void realpath_cache_add(const char *path, int path_len, const char *realpath, int realpath_len, int is_dir, time_t t TSRMLS_DC) /* {{{ */ { - long size = sizeof(realpath_cache_bucket) + path_len + 1; + zend_int_t size = sizeof(realpath_cache_bucket) + path_len + 1; int same = 1; if (realpath_len != path_len || @@ -679,7 +679,7 @@ static inline void realpath_cache_add(const char *path, int path_len, const char if (CWDG(realpath_cache_size) + size <= CWDG(realpath_cache_size_limit)) { realpath_cache_bucket *bucket = malloc(size); - unsigned long n; + zend_uint_t n; if (bucket == NULL) { return; @@ -719,12 +719,12 @@ static inline void realpath_cache_add(const char *path, int path_len, const char static inline realpath_cache_bucket* realpath_cache_find(const char *path, int path_len, time_t t TSRMLS_DC) /* {{{ */ { #ifdef PHP_WIN32 - unsigned long key = realpath_cache_key(path, path_len TSRMLS_CC); + zend_uint_t key = realpath_cache_key(path, path_len TSRMLS_CC); #else - unsigned long key = realpath_cache_key(path, path_len); + zend_uint_t key = realpath_cache_key(path, path_len); #endif - unsigned long n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0])); + zend_uint_t n = key % (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0])); realpath_cache_bucket **bucket = &CWDG(realpath_cache)[n]; while (*bucket != NULL) { @@ -784,7 +784,7 @@ static int tsrm_realpath_r(char *path, int start, int len, int *ll, time_t *t, i HANDLE hFind; ALLOCA_FLAG(use_heap_large) #else - struct stat st; + zend_stat_t st; #endif realpath_cache_bucket *bucket; char *tmp; @@ -1739,7 +1739,7 @@ CWD_API int virtual_rename(const char *oldname, const char *newname TSRMLS_DC) / } /* }}} */ -CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC) /* {{{ */ +CWD_API int virtual_stat(const char *path, zend_stat_t *buf TSRMLS_DC) /* {{{ */ { cwd_state new_state; int retval; @@ -1757,7 +1757,7 @@ CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC) /* {{{ */ } /* }}} */ -CWD_API int virtual_lstat(const char *path, struct stat *buf TSRMLS_DC) /* {{{ */ +CWD_API int virtual_lstat(const char *path, zend_stat_t *buf TSRMLS_DC) /* {{{ */ { cwd_state new_state; int retval; diff --git a/Zend/zend_virtual_cwd.h b/Zend/zend_virtual_cwd.h index b0df0ad310..383b65db32 100644 --- a/Zend/zend_virtual_cwd.h +++ b/Zend/zend_virtual_cwd.h @@ -130,7 +130,7 @@ typedef unsigned short mode_t; #endif #ifdef TSRM_WIN32 -CWD_API int php_sys_stat_ex(const char *path, struct stat *buf, int lstat); +CWD_API int php_sys_stat_ex(const char *path, zend_stat_t *buf, int lstat); # define php_sys_stat(path, buf) php_sys_stat_ex(path, buf, 0) # define php_sys_lstat(path, buf) php_sys_stat_ex(path, buf, 1) CWD_API int php_sys_readlink(const char *link, char *target, size_t target_len); @@ -164,8 +164,8 @@ CWD_API FILE *virtual_fopen(const char *path, const char *mode TSRMLS_DC); CWD_API int virtual_open(const char *path TSRMLS_DC, int flags, ...); CWD_API int virtual_creat(const char *path, mode_t mode TSRMLS_DC); CWD_API int virtual_rename(const char *oldname, const char *newname TSRMLS_DC); -CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC); -CWD_API int virtual_lstat(const char *path, struct stat *buf TSRMLS_DC); +CWD_API int virtual_stat(const char *path, zend_stat_t *buf TSRMLS_DC); +CWD_API int virtual_lstat(const char *path, zend_stat_t *buf TSRMLS_DC); CWD_API int virtual_unlink(const char *path TSRMLS_DC); CWD_API int virtual_mkdir(const char *pathname, mode_t mode TSRMLS_DC); CWD_API int virtual_rmdir(const char *pathname TSRMLS_DC); @@ -211,7 +211,7 @@ CWD_API char *tsrm_realpath(const char *path, char *real_path TSRMLS_DC); #define REALPATH_CACHE_SIZE 0 /* disabled while php.ini isn't loaded */ typedef struct _realpath_cache_bucket { - unsigned long key; + zend_uint_t key; char *path; int path_len; char *realpath; @@ -229,9 +229,9 @@ typedef struct _realpath_cache_bucket { typedef struct _virtual_cwd_globals { cwd_state cwd; - long realpath_cache_size; - long realpath_cache_size_limit; - long realpath_cache_ttl; + zend_int_t realpath_cache_size; + zend_int_t realpath_cache_size_limit; + zend_int_t realpath_cache_ttl; realpath_cache_bucket *realpath_cache[1024]; } virtual_cwd_globals; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 7749197a74..be01accf6a 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -867,7 +867,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_increment_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -922,7 +922,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_decrement_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -977,7 +977,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_increment_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -1031,7 +1031,7 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY) SAVE_OPLINE(); var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_decrement_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -1096,7 +1096,7 @@ ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY) { USE_OPLINE - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO); } @@ -2412,11 +2412,11 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV) ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRSIZE_P(function_name) - 1); } else { - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); } if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); @@ -3633,7 +3633,7 @@ ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->brk); } @@ -3644,7 +3644,7 @@ ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->cont); } @@ -3656,7 +3656,7 @@ ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->extended_value, &EX(func)->op_array, execute_data TSRMLS_CC); brk_opline = EX(func)->op_array.opcodes + el->brk; @@ -3818,7 +3818,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRSIZE_P(opline->op2.zv)); if(!actual) { actual = Z_STRVAL_P(opline->op2.zv); } else { @@ -3826,7 +3826,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRSIZE_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -3889,7 +3889,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRSIZE_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR(EX_VAR(opline->result.var), ce->name); STR_ADDREF(ce->name); @@ -3941,15 +3941,15 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS zend_free_op free_op2; zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R); zend_string *str; - ulong hval; + zend_uint_t hval; ZEND_VM_C_LABEL(add_again): switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); ZEND_VM_C_GOTO(num_index); - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); ZEND_VM_C_LABEL(num_index): zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -4052,8 +4052,8 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY) case _IS_BOOL: ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); + case IS_INT: + ZVAL_INT(result, zval_get_int(expr)); break; case IS_DOUBLE: ZVAL_DOUBLE(result, zval_get_double(expr)); @@ -4149,7 +4149,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY) inc_filename = &tmp_inc_filename; } - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRSIZE_P(inc_filename)) { if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); } else { @@ -4162,7 +4162,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY) zend_file_handle file_handle; char *resolved_path; - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRSIZE_P(inc_filename) TSRMLS_CC); if (resolved_path) { failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { @@ -4332,7 +4332,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV) zend_free_op free_op1, free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET); @@ -4348,11 +4348,11 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV) ZEND_VM_C_LABEL(offset_again): switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); ZEND_VM_C_LABEL(num_index_dim): zend_hash_index_del(ht, hval); break; @@ -4605,12 +4605,12 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY) zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { zend_string *str_key; - ulong int_key; + zend_uint_t int_key; zend_uchar key_type; key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && - (key_type == HASH_KEY_IS_LONG || + (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } @@ -4669,7 +4669,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) zend_object *zobj = Z_OBJ_P(array); int key_type; zend_string *str_key; - zend_ulong int_key; + zend_uint_t int_key; fe_ht = Z_OBJPROP_P(array); zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); @@ -4690,15 +4690,15 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); zend_hash_move_forward(fe_ht); - if (key_type == HASH_KEY_IS_LONG || + if (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) { break; } } if (key) { - if (key_type == HASH_KEY_IS_LONG) { - ZVAL_LONG(key, int_key); + if (key_type == HASH_KEY_IS_INT) { + ZVAL_INT(key, int_key); } else { const char *class_name, *prop_name; int prop_name_len; @@ -4764,7 +4764,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) HANDLE_EXCEPTION(); } } else { - ZVAL_LONG(key, iter->index); + ZVAL_INT(key, iter->index); } } break; @@ -4869,7 +4869,7 @@ ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV zend_free_op free_op1, free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -4891,14 +4891,14 @@ ZEND_VM_C_LABEL(isset_again): } ZEND_VM_C_LABEL(str_index_prop): value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); ZEND_VM_C_LABEL(num_index_prop): value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); ZEND_VM_C_GOTO(num_index_prop); case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -4943,20 +4943,20 @@ ZEND_VM_C_LABEL(num_index_prop): zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -5020,8 +5020,8 @@ ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY) zend_free_op free_op1; zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -5037,9 +5037,9 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY) USE_OPLINE SAVE_OPLINE(); - ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting)); + ZVAL_INT(EX_VAR(opline->result.var), EG(error_reporting)); if (Z_TYPE(EX(old_error_reporting)) == IS_UNDEF) { - ZVAL_LONG(&EX(old_error_reporting), EG(error_reporting)); + ZVAL_INT(&EX(old_error_reporting), EG(error_reporting)); } if (EG(error_reporting)) { @@ -5085,13 +5085,13 @@ ZEND_VM_HANDLER(142, ZEND_RAISE_ABSTRACT_ERROR, ANY, ANY) ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY) { USE_OPLINE - char buf[MAX_LENGTH_OF_LONG + 1]; + char buf[MAX_LENGTH_OF_ZEND_INT + 1]; char *res; SAVE_OPLINE(); - if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) { - EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); - _zend_print_signed_to_buf(buf + sizeof(buf) - 1, EG(error_reporting), unsigned long, res); + if (!EG(error_reporting) && Z_IVAL_P(EX_VAR(opline->op1.var)) != 0) { + EG(error_reporting) = Z_IVAL_P(EX_VAR(opline->op1.var)); + _zend_print_signed_to_buf(buf + sizeof(buf) - 1, EG(error_reporting), zend_uint_t, res); if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) { if (EXPECTED(EG(error_reporting_ini_entry)->modified && EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) { @@ -5460,14 +5460,14 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } /* restore previous error_reporting value */ - if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_LVAL(EX(old_error_reporting)) != 0) { + if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_IVAL(EX(old_error_reporting)) != 0) { zval restored_error_reporting; zend_string *key; - ZVAL_LONG(&restored_error_reporting, Z_LVAL(EX(old_error_reporting))); + ZVAL_INT(&restored_error_reporting, Z_IVAL(EX(old_error_reporting))); convert_to_string(&restored_error_reporting); key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0); - zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); + zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRSIZE(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); STR_FREE(key); zval_dtor(&restored_error_reporting); } @@ -5721,15 +5721,15 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -5868,15 +5868,15 @@ ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMP|VAR|CV, ANY) SAVE_OPLINE(); value = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value)); } else { if (Z_TYPE_P(value) < IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 0); + ZVAL_INT(EX_VAR(opline->result.var), 0); } else if (Z_TYPE_P(value) == IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); } else if (Z_TYPE_P(value) <= IS_DOUBLE) { zend_string *str = zval_get_string(value); - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else if (Z_TYPE_P(value) == IS_OBJECT) { zend_string *str; @@ -5884,7 +5884,7 @@ ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMP|VAR|CV, ANY) if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) { ZEND_VM_C_GOTO(strlen_error); } - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else { ZEND_VM_C_LABEL(strlen_error): @@ -5907,7 +5907,7 @@ ZEND_VM_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMP|VAR|CV, ANY) value = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); switch (opline->extended_value) { case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_ARRAY: diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index c2e59c1441..9bc2c13c30 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1110,9 +1110,9 @@ static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE SAVE_OPLINE(); - ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting)); + ZVAL_INT(EX_VAR(opline->result.var), EG(error_reporting)); if (Z_TYPE(EX(old_error_reporting)) == IS_UNDEF) { - ZVAL_LONG(&EX(old_error_reporting), EG(error_reporting)); + ZVAL_INT(&EX(old_error_reporting), EG(error_reporting)); } if (EG(error_reporting)) { @@ -1367,14 +1367,14 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER } /* restore previous error_reporting value */ - if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_LVAL(EX(old_error_reporting)) != 0) { + if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_IVAL(EX(old_error_reporting)) != 0) { zval restored_error_reporting; zend_string *key; - ZVAL_LONG(&restored_error_reporting, Z_LVAL(EX(old_error_reporting))); + ZVAL_INT(&restored_error_reporting, Z_IVAL(EX(old_error_reporting))); convert_to_string(&restored_error_reporting); key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0); - zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); + zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRSIZE(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); STR_FREE(key); zval_dtor(&restored_error_reporting); } @@ -1583,11 +1583,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRSIZE_P(function_name) - 1); } else { - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); } if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); @@ -1769,7 +1769,7 @@ static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->brk); } @@ -1780,7 +1780,7 @@ static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->cont); } @@ -1792,7 +1792,7 @@ static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value, + el = zend_brk_cont(Z_IVAL_P(opline->op2.zv), opline->extended_value, &EX(func)->op_array, execute_data TSRMLS_CC); brk_opline = EX(func)->op_array.opcodes + el->brk; @@ -1912,11 +1912,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRSIZE_P(function_name) - 1); } else { - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); } if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); @@ -2086,11 +2086,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRSIZE_P(function_name) - 1); } else { - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); } if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); @@ -2298,11 +2298,11 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { if (Z_STRVAL_P(function_name)[0] == '\\') { - lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRSIZE_P(function_name) - 1); } else { - lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); - zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); + lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name)); } if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); @@ -2441,7 +2441,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -2868,8 +2868,8 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) case _IS_BOOL: ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); + case IS_INT: + ZVAL_INT(result, zval_get_int(expr)); break; case IS_DOUBLE: ZVAL_DOUBLE(result, zval_get_double(expr)); @@ -2963,7 +2963,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA inc_filename = &tmp_inc_filename; } - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRSIZE_P(inc_filename)) { if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); } else { @@ -2976,7 +2976,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA zend_file_handle file_handle; char *resolved_path; - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRSIZE_P(inc_filename) TSRMLS_CC); if (resolved_path) { failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { @@ -3219,12 +3219,12 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { zend_string *str_key; - ulong int_key; + zend_uint_t int_key; zend_uchar key_type; key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && - (key_type == HASH_KEY_IS_LONG || + (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } @@ -3259,8 +3259,8 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *ptr = opline->op1.zv; - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -3370,15 +3370,15 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); value = opline->op1.zv; if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value)); } else { if (Z_TYPE_P(value) < IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 0); + ZVAL_INT(EX_VAR(opline->result.var), 0); } else if (Z_TYPE_P(value) == IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); } else if (Z_TYPE_P(value) <= IS_DOUBLE) { zend_string *str = zval_get_string(value); - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else if (Z_TYPE_P(value) == IS_OBJECT) { zend_string *str; @@ -3386,7 +3386,7 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) { goto strlen_error; } - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else { strlen_error: @@ -3409,7 +3409,7 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER value = opline->op1.zv; switch (opline->extended_value) { case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_ARRAY: @@ -4122,7 +4122,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRSIZE_P(opline->op2.zv)); if(!actual) { actual = Z_STRVAL_P(opline->op2.zv); } else { @@ -4130,7 +4130,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRSIZE_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -4193,7 +4193,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRSIZE_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR(EX_VAR(opline->result.var), ce->name); STR_ADDREF(ce->name); @@ -4245,15 +4245,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O zval *offset = opline->op2.zv; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -4609,15 +4609,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -5160,15 +5160,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -5339,15 +5339,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -6043,15 +6043,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -6374,15 +6374,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -6728,15 +6728,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_ zval *offset = NULL; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -7084,15 +7084,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -7671,15 +7671,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -7850,15 +7850,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -7942,7 +7942,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -8384,8 +8384,8 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) case _IS_BOOL: ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); + case IS_INT: + ZVAL_INT(result, zval_get_int(expr)); break; case IS_DOUBLE: ZVAL_DOUBLE(result, zval_get_double(expr)); @@ -8480,7 +8480,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND inc_filename = &tmp_inc_filename; } - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRSIZE_P(inc_filename)) { if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); } else { @@ -8493,7 +8493,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND zend_file_handle file_handle; char *resolved_path; - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRSIZE_P(inc_filename) TSRMLS_CC); if (resolved_path) { failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { @@ -8736,12 +8736,12 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { zend_string *str_key; - ulong int_key; + zend_uint_t int_key; zend_uchar key_type; key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && - (key_type == HASH_KEY_IS_LONG || + (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } @@ -8776,8 +8776,8 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; zval *ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -8791,13 +8791,13 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - char buf[MAX_LENGTH_OF_LONG + 1]; + char buf[MAX_LENGTH_OF_ZEND_INT + 1]; char *res; SAVE_OPLINE(); - if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) { - EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); - _zend_print_signed_to_buf(buf + sizeof(buf) - 1, EG(error_reporting), unsigned long, res); + if (!EG(error_reporting) && Z_IVAL_P(EX_VAR(opline->op1.var)) != 0) { + EG(error_reporting) = Z_IVAL_P(EX_VAR(opline->op1.var)); + _zend_print_signed_to_buf(buf + sizeof(buf) - 1, EG(error_reporting), zend_uint_t, res); if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) { if (EXPECTED(EG(error_reporting_ini_entry)->modified && EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) { @@ -8936,15 +8936,15 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value)); } else { if (Z_TYPE_P(value) < IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 0); + ZVAL_INT(EX_VAR(opline->result.var), 0); } else if (Z_TYPE_P(value) == IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); } else if (Z_TYPE_P(value) <= IS_DOUBLE) { zend_string *str = zval_get_string(value); - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else if (Z_TYPE_P(value) == IS_OBJECT) { zend_string *str; @@ -8952,7 +8952,7 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) { goto strlen_error; } - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else { strlen_error: @@ -8975,7 +8975,7 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_A value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); switch (opline->extended_value) { case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_ARRAY: @@ -9645,15 +9645,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC zval *offset = opline->op2.zv; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -9976,15 +9976,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -10484,15 +10484,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -10663,15 +10663,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -11324,15 +11324,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -11655,15 +11655,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -11893,15 +11893,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP zval *offset = NULL; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -12224,15 +12224,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -12714,15 +12714,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -12893,15 +12893,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -12974,7 +12974,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_increment_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -13029,7 +13029,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_decrement_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -13084,7 +13084,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_increment_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -13138,7 +13138,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_decrement_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -13203,7 +13203,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -13823,8 +13823,8 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) case _IS_BOOL: ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); + case IS_INT: + ZVAL_INT(result, zval_get_int(expr)); break; case IS_DOUBLE: ZVAL_DOUBLE(result, zval_get_double(expr)); @@ -13920,7 +13920,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND inc_filename = &tmp_inc_filename; } - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRSIZE_P(inc_filename)) { if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); } else { @@ -13933,7 +13933,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND zend_file_handle file_handle; char *resolved_path; - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRSIZE_P(inc_filename) TSRMLS_CC); if (resolved_path) { failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { @@ -14176,12 +14176,12 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { zend_string *str_key; - ulong int_key; + zend_uint_t int_key; zend_uchar key_type; key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && - (key_type == HASH_KEY_IS_LONG || + (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } @@ -14240,7 +14240,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_object *zobj = Z_OBJ_P(array); int key_type; zend_string *str_key; - zend_ulong int_key; + zend_uint_t int_key; fe_ht = Z_OBJPROP_P(array); zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); @@ -14261,15 +14261,15 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); zend_hash_move_forward(fe_ht); - if (key_type == HASH_KEY_IS_LONG || + if (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) { break; } } if (key) { - if (key_type == HASH_KEY_IS_LONG) { - ZVAL_LONG(key, int_key); + if (key_type == HASH_KEY_IS_INT) { + ZVAL_INT(key, int_key); } else { const char *class_name, *prop_name; int prop_name_len; @@ -14335,7 +14335,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG HANDLE_EXCEPTION(); } } else { - ZVAL_LONG(key, iter->index); + ZVAL_INT(key, iter->index); } } break; @@ -14364,8 +14364,8 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; zval *ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -14498,15 +14498,15 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); value = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value)); } else { if (Z_TYPE_P(value) < IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 0); + ZVAL_INT(EX_VAR(opline->result.var), 0); } else if (Z_TYPE_P(value) == IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); } else if (Z_TYPE_P(value) <= IS_DOUBLE) { zend_string *str = zval_get_string(value); - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else if (Z_TYPE_P(value) == IS_OBJECT) { zend_string *str; @@ -14514,7 +14514,7 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) { goto strlen_error; } - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else { strlen_error: @@ -14537,7 +14537,7 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_A value = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); switch (opline->extended_value) { case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_ARRAY: @@ -16180,7 +16180,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRSIZE_P(opline->op2.zv)); if(!actual) { actual = Z_STRVAL_P(opline->op2.zv); } else { @@ -16188,7 +16188,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRSIZE_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -16251,7 +16251,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRSIZE_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR(EX_VAR(opline->result.var), ce->name); STR_ADDREF(ce->name); @@ -16303,15 +16303,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC zval *offset = opline->op2.zv; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -16461,7 +16461,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND zend_free_op free_op1; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); @@ -16477,11 +16477,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -16669,7 +16669,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND zend_free_op free_op1; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -16691,14 +16691,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -16743,20 +16743,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -16908,15 +16908,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -18442,15 +18442,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -18528,7 +18528,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE zend_free_op free_op1, free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); @@ -18544,11 +18544,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -18656,7 +18656,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_O zend_free_op free_op1, free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -18678,14 +18678,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -18730,20 +18730,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -18897,15 +18897,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -20648,15 +20648,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -20806,7 +20806,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE zend_free_op free_op1, free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); @@ -20822,11 +20822,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -21014,7 +21014,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_O zend_free_op free_op1, free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -21036,14 +21036,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -21088,20 +21088,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -21255,15 +21255,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -22108,15 +22108,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP zval *offset = NULL; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -22458,15 +22458,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -24031,15 +24031,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -24117,7 +24117,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); @@ -24133,11 +24133,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -24245,7 +24245,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OP zend_free_op free_op1; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -24267,14 +24267,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -24319,20 +24319,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -24484,15 +24484,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -24603,8 +24603,8 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS zval *ptr = NULL; - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -25457,7 +25457,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRSIZE_P(opline->op2.zv)); if(!actual) { actual = Z_STRVAL_P(opline->op2.zv); } else { @@ -25465,7 +25465,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRSIZE_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -25528,7 +25528,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRSIZE_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR(EX_VAR(opline->result.var), ce->name); STR_ADDREF(ce->name); @@ -25578,7 +25578,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(TSRMLS_C); @@ -25594,11 +25594,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -25706,7 +25706,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(Z zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -25728,14 +25728,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -25780,20 +25780,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -25944,15 +25944,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -26858,7 +26858,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(TSRMLS_C); @@ -26874,11 +26874,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -26986,7 +26986,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEN zend_free_op free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -27008,14 +27008,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -27060,20 +27060,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -27226,15 +27226,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -28140,7 +28140,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(TSRMLS_C); @@ -28156,11 +28156,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -28268,7 +28268,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEN zend_free_op free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -28290,14 +28290,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -28342,20 +28342,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -28508,15 +28508,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -29024,15 +29024,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -29931,7 +29931,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(TSRMLS_C); @@ -29947,11 +29947,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -30059,7 +30059,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -30081,14 +30081,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -30133,20 +30133,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -30297,15 +30297,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -30368,7 +30368,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_increment_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -30422,7 +30422,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { fast_decrement_function(var_ptr); if (RETURN_VALUE_USED(opline)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); @@ -30476,7 +30476,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_increment_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -30529,7 +30529,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); fast_decrement_function(var_ptr); ZEND_VM_NEXT_OPCODE(); @@ -30592,7 +30592,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -31183,8 +31183,8 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) case _IS_BOOL: ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); + case IS_INT: + ZVAL_INT(result, zval_get_int(expr)); break; case IS_DOUBLE: ZVAL_DOUBLE(result, zval_get_double(expr)); @@ -31278,7 +31278,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL inc_filename = &tmp_inc_filename; } - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { + if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRSIZE_P(inc_filename)) { if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); } else { @@ -31291,7 +31291,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL zend_file_handle file_handle; char *resolved_path; - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); + resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRSIZE_P(inc_filename) TSRMLS_CC); if (resolved_path) { failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { @@ -31534,12 +31534,12 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { zend_string *str_key; - ulong int_key; + zend_uint_t int_key; zend_uchar key_type; key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && - (key_type == HASH_KEY_IS_LONG || + (key_type == HASH_KEY_IS_INT || zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } @@ -31574,8 +31574,8 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); + if (Z_TYPE_P(ptr) == IS_INT) { + EG(exit_status) = Z_IVAL_P(ptr); } else { zend_print_variable(ptr TSRMLS_CC); } @@ -31706,15 +31706,15 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value)); } else { if (Z_TYPE_P(value) < IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 0); + ZVAL_INT(EX_VAR(opline->result.var), 0); } else if (Z_TYPE_P(value) == IS_TRUE) { - ZVAL_LONG(EX_VAR(opline->result.var), 1); + ZVAL_INT(EX_VAR(opline->result.var), 1); } else if (Z_TYPE_P(value) <= IS_DOUBLE) { zend_string *str = zval_get_string(value); - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else if (Z_TYPE_P(value) == IS_OBJECT) { zend_string *str; @@ -31722,7 +31722,7 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) { goto strlen_error; } - ZVAL_LONG(EX_VAR(opline->result.var), str->len); + ZVAL_INT(EX_VAR(opline->result.var), str->len); STR_RELEASE(str); } else { strlen_error: @@ -31745,7 +31745,7 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); switch (opline->extended_value) { case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_STRING: case IS_ARRAY: @@ -33296,15 +33296,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO zval *offset = opline->op2.zv; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -33454,7 +33454,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); @@ -33470,11 +33470,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -33662,7 +33662,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_ zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -33684,14 +33684,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -33736,20 +33736,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_CV == IS_CV || IS_CV == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -33900,15 +33900,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -35346,15 +35346,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -35432,7 +35432,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); @@ -35448,11 +35448,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -35560,7 +35560,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OP zend_free_op free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -35582,14 +35582,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -35634,20 +35634,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_CV == IS_CV || IS_CV == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -35800,15 +35800,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -37432,15 +37432,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -37590,7 +37590,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); @@ -37606,11 +37606,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -37798,7 +37798,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OP zend_free_op free_op2; zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -37820,14 +37820,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -37872,20 +37872,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_CV == IS_CV || IS_CV == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -38038,15 +38038,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -38774,15 +38774,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC zval *offset = NULL; zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -39105,15 +39105,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { @@ -40559,15 +40559,15 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_ zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); zend_string *str; - ulong hval; + zend_uint_t hval; add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; @@ -40645,7 +40645,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ zval *container; zval *offset; - ulong hval; + zend_uint_t hval; SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); @@ -40661,11 +40661,11 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ offset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); zend_hash_index_del(ht, hval); break; - case IS_LONG: - hval = Z_LVAL_P(offset); + case IS_INT: + hval = Z_IVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); break; @@ -40773,7 +40773,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPC zval *container; int result; - ulong hval; + zend_uint_t hval; zval *offset; SAVE_OPLINE(); @@ -40795,14 +40795,14 @@ isset_again: } str_index_prop: value = zend_hash_find_ind(ht, str); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) { + hval = Z_IVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else { switch (Z_TYPE_P(offset)) { case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); + hval = zend_dval_to_ival(Z_DVAL_P(offset)); goto num_index_prop; case IS_NULL: str = STR_EMPTY_ALLOC(); @@ -40847,20 +40847,20 @@ num_index_prop: zval tmp; result = 0; - if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) { if (IS_CV == IS_CV || IS_CV == IS_VAR) { ZVAL_DEREF(offset); } if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { + && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) { ZVAL_DUP(&tmp, offset); - convert_to_long(&tmp); + convert_to_int(&tmp); offset = &tmp; } } - if (Z_TYPE_P(offset) == IS_LONG) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if (Z_TYPE_P(offset) == IS_INT) { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) { if ((opline->extended_value & ZEND_ISSET) || Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; @@ -41011,15 +41011,15 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_INT + && Z_IVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); + generator->largest_used_integer_key = Z_IVAL(generator->key); } } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + ZVAL_INT(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { diff --git a/ext/date/lib/parse_date.c b/ext/date/lib/parse_date.c index 015da88914..6849fa9385 100644 --- a/ext/date/lib/parse_date.c +++ b/ext/date/lib/parse_date.c @@ -1,5 +1,4 @@ /* Generated by re2c 0.13.5 on Thu Jul 31 14:33:37 2014 */ -#line 1 "ext/date/lib/parse_date.re" /* +----------------------------------------------------------------------+ | PHP Version 5 | @@ -840,11 +839,9 @@ static int scan(Scanner *s, timelib_tz_get_wrapper tz_get_wrapper) std: s->tok = cursor; s->len = 0; -#line 966 "ext/date/lib/parse_date.re" -#line 848 "ext/date/lib/parse_date.c" { YYCTYPE yych; unsigned int yyaccept = 0; @@ -984,7 +981,6 @@ yy2: } yy3: YYDEBUG(3, *YYCURSOR); -#line 1646 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("tzcorrection | tz"); @@ -997,7 +993,6 @@ yy3: TIMELIB_DEINIT; return TIMELIB_TIMEZONE; } -#line 1001 "ext/date/lib/parse_date.c" yy4: YYDEBUG(4, *YYCURSOR); yych = *++YYCURSOR; @@ -1308,12 +1303,10 @@ yy11: if (yych <= '9') goto yy1385; yy12: YYDEBUG(12, *YYCURSOR); -#line 1741 "ext/date/lib/parse_date.re" { add_error(s, "Unexpected character"); goto std; } -#line 1317 "ext/date/lib/parse_date.c" yy13: YYDEBUG(13, *YYCURSOR); yych = *++YYCURSOR; @@ -2370,11 +2363,9 @@ yy48: if (yych <= '9') goto yy54; yy49: YYDEBUG(49, *YYCURSOR); -#line 1730 "ext/date/lib/parse_date.re" { goto std; } -#line 2378 "ext/date/lib/parse_date.c" yy50: YYDEBUG(50, *YYCURSOR); yych = *++YYCURSOR; @@ -2383,12 +2374,10 @@ yy51: YYDEBUG(51, *YYCURSOR); ++YYCURSOR; YYDEBUG(52, *YYCURSOR); -#line 1735 "ext/date/lib/parse_date.re" { s->pos = cursor; s->line++; goto std; } -#line 2392 "ext/date/lib/parse_date.c" yy53: YYDEBUG(53, *YYCURSOR); yych = *++YYCURSOR; @@ -2775,7 +2764,6 @@ yy71: if (yych == 's') goto yy73; yy72: YYDEBUG(72, *YYCURSOR); -#line 1714 "ext/date/lib/parse_date.re" { timelib_ull i; DEBUG_OUTPUT("relative"); @@ -2790,7 +2778,6 @@ yy72: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 2794 "ext/date/lib/parse_date.c" yy73: YYDEBUG(73, *YYCURSOR); yych = *++YYCURSOR; @@ -3552,7 +3539,6 @@ yy165: } yy166: YYDEBUG(166, *YYCURSOR); -#line 1577 "ext/date/lib/parse_date.re" { const timelib_relunit* relunit; DEBUG_OUTPUT("daytext"); @@ -3569,7 +3555,6 @@ yy166: TIMELIB_DEINIT; return TIMELIB_WEEKDAY; } -#line 3573 "ext/date/lib/parse_date.c" yy167: YYDEBUG(167, *YYCURSOR); yych = *++YYCURSOR; @@ -4089,7 +4074,6 @@ yy192: } yy193: YYDEBUG(193, *YYCURSOR); -#line 1636 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("monthtext"); TIMELIB_INIT; @@ -4098,7 +4082,6 @@ yy193: TIMELIB_DEINIT; return TIMELIB_DATE_TEXT; } -#line 4102 "ext/date/lib/parse_date.c" yy194: YYDEBUG(194, *YYCURSOR); ++YYCURSOR; @@ -4149,7 +4132,6 @@ yy197: } yy198: YYDEBUG(198, *YYCURSOR); -#line 1382 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("datetextual | datenoyear"); @@ -4162,7 +4144,6 @@ yy198: TIMELIB_DEINIT; return TIMELIB_DATE_TEXT; } -#line 4166 "ext/date/lib/parse_date.c" yy199: YYDEBUG(199, *YYCURSOR); yyaccept = 6; @@ -4431,7 +4412,6 @@ yy221: } yy222: YYDEBUG(222, *YYCURSOR); -#line 1684 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("dateshortwithtimeshort | dateshortwithtimelong | dateshortwithtimelongtz"); @@ -4460,7 +4440,6 @@ yy222: TIMELIB_DEINIT; return TIMELIB_SHORTDATE_WITH_TIME; } -#line 4464 "ext/date/lib/parse_date.c" yy223: YYDEBUG(223, *YYCURSOR); yyaccept = 7; @@ -5158,7 +5137,6 @@ yy277: YYDEBUG(277, *YYCURSOR); ++YYCURSOR; YYDEBUG(278, *YYCURSOR); -#line 1660 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("dateshortwithtimeshort12 | dateshortwithtimelong12"); TIMELIB_INIT; @@ -5181,7 +5159,6 @@ yy277: TIMELIB_DEINIT; return TIMELIB_SHORTDATE_WITH_TIME; } -#line 5185 "ext/date/lib/parse_date.c" yy279: YYDEBUG(279, *YYCURSOR); yych = *++YYCURSOR; @@ -5359,7 +5336,6 @@ yy293: ++YYCURSOR; yy294: YYDEBUG(294, *YYCURSOR); -#line 1354 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("datenoday"); @@ -5372,7 +5348,6 @@ yy294: TIMELIB_DEINIT; return TIMELIB_DATE_NO_DAY; } -#line 5376 "ext/date/lib/parse_date.c" yy295: YYDEBUG(295, *YYCURSOR); yych = *++YYCURSOR; @@ -6592,7 +6567,6 @@ yy361: if (yych <= '9') goto yy364; yy363: YYDEBUG(363, *YYCURSOR); -#line 1498 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("pgtextshort"); @@ -6605,7 +6579,6 @@ yy363: TIMELIB_DEINIT; return TIMELIB_PG_TEXT; } -#line 6609 "ext/date/lib/parse_date.c" yy364: YYDEBUG(364, *YYCURSOR); yych = *++YYCURSOR; @@ -7243,7 +7216,6 @@ yy391: } yy392: YYDEBUG(392, *YYCURSOR); -#line 1556 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("ago"); TIMELIB_INIT; @@ -7263,7 +7235,6 @@ yy392: TIMELIB_DEINIT; return TIMELIB_AGO; } -#line 7267 "ext/date/lib/parse_date.c" yy393: YYDEBUG(393, *YYCURSOR); yyaccept = 5; @@ -9013,7 +8984,6 @@ yy453: ++YYCURSOR; yy454: YYDEBUG(454, *YYCURSOR); -#line 1259 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("iso8601date4 | iso8601date2 | iso8601dateslash | dateslash"); TIMELIB_INIT; @@ -9024,7 +8994,6 @@ yy454: TIMELIB_DEINIT; return TIMELIB_ISO_DATE; } -#line 9028 "ext/date/lib/parse_date.c" yy455: YYDEBUG(455, *YYCURSOR); yyaccept = 0; @@ -9584,7 +9553,6 @@ yy474: } yy475: YYDEBUG(475, *YYCURSOR); -#line 1396 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("datenoyearrev"); TIMELIB_INIT; @@ -9595,7 +9563,6 @@ yy475: TIMELIB_DEINIT; return TIMELIB_DATE_TEXT; } -#line 9599 "ext/date/lib/parse_date.c" yy476: YYDEBUG(476, *YYCURSOR); yyaccept = 10; @@ -9736,7 +9703,6 @@ yy487: YYDEBUG(487, *YYCURSOR); ++YYCURSOR; YYDEBUG(488, *YYCURSOR); -#line 1114 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("timetiny12 | timeshort12 | timelong12"); TIMELIB_INIT; @@ -9752,7 +9718,6 @@ yy487: TIMELIB_DEINIT; return TIMELIB_TIME12; } -#line 9756 "ext/date/lib/parse_date.c" yy489: YYDEBUG(489, *YYCURSOR); yyaccept = 11; @@ -9765,7 +9730,6 @@ yy489: } yy490: YYDEBUG(490, *YYCURSOR); -#line 1151 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("timeshort24 | timelong24 | iso8601long"); @@ -9790,7 +9754,6 @@ yy490: TIMELIB_DEINIT; return TIMELIB_TIME24_WITH_ZONE; } -#line 9794 "ext/date/lib/parse_date.c" yy491: YYDEBUG(491, *YYCURSOR); yyaccept = 11; @@ -10100,7 +10063,6 @@ yy522: YYDEBUG(522, *YYCURSOR); ++YYCURSOR; YYDEBUG(523, *YYCURSOR); -#line 1131 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("mssqltime"); TIMELIB_INIT; @@ -10119,7 +10081,6 @@ yy522: TIMELIB_DEINIT; return TIMELIB_TIME24_WITH_ZONE; } -#line 10123 "ext/date/lib/parse_date.c" yy524: YYDEBUG(524, *YYCURSOR); yyaccept = 11; @@ -10225,7 +10186,6 @@ yy533: if (yych <= '9') goto yy540; yy534: YYDEBUG(534, *YYCURSOR); -#line 1313 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("datefull"); @@ -10239,7 +10199,6 @@ yy534: TIMELIB_DEINIT; return TIMELIB_DATE_FULL; } -#line 10243 "ext/date/lib/parse_date.c" yy535: YYDEBUG(535, *YYCURSOR); yych = *++YYCURSOR; @@ -10976,7 +10935,6 @@ yy604: YYDEBUG(605, *YYCURSOR); ++YYCURSOR; YYDEBUG(606, *YYCURSOR); -#line 1328 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("pointed date YYYY"); TIMELIB_INIT; @@ -10987,7 +10945,6 @@ yy604: TIMELIB_DEINIT; return TIMELIB_DATE_FULL_POINTED; } -#line 10991 "ext/date/lib/parse_date.c" yy607: YYDEBUG(607, *YYCURSOR); yyaccept = 11; @@ -11023,7 +10980,6 @@ yy610: if (yych <= '9') goto yy604; yy611: YYDEBUG(611, *YYCURSOR); -#line 1340 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("pointed date YY"); @@ -11036,7 +10992,6 @@ yy611: TIMELIB_DEINIT; return TIMELIB_DATE_FULL_POINTED; } -#line 11040 "ext/date/lib/parse_date.c" yy612: YYDEBUG(612, *YYCURSOR); yyaccept = 11; @@ -11677,7 +11632,6 @@ yy655: } yy656: YYDEBUG(656, *YYCURSOR); -#line 1299 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("gnudateshort"); @@ -11690,7 +11644,6 @@ yy656: TIMELIB_DEINIT; return TIMELIB_ISO_DATE; } -#line 11694 "ext/date/lib/parse_date.c" yy657: YYDEBUG(657, *YYCURSOR); yyaccept = 13; @@ -11796,7 +11749,6 @@ yy665: } yy666: YYDEBUG(666, *YYCURSOR); -#line 1243 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("americanshort | american"); @@ -11811,7 +11763,6 @@ yy666: TIMELIB_DEINIT; return TIMELIB_AMERICAN; } -#line 11815 "ext/date/lib/parse_date.c" yy667: YYDEBUG(667, *YYCURSOR); yyaccept = 14; @@ -12044,7 +11995,6 @@ yy699: if (yych <= ':') goto yy703; yy700: YYDEBUG(700, *YYCURSOR); -#line 1526 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("clf"); @@ -12064,7 +12014,6 @@ yy700: TIMELIB_DEINIT; return TIMELIB_CLF; } -#line 12068 "ext/date/lib/parse_date.c" yy701: YYDEBUG(701, *YYCURSOR); yych = *++YYCURSOR; @@ -12616,7 +12565,6 @@ yy762: } yy763: YYDEBUG(763, *YYCURSOR); -#line 1271 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("iso8601date2"); @@ -12629,7 +12577,6 @@ yy763: TIMELIB_DEINIT; return TIMELIB_ISO_DATE; } -#line 12633 "ext/date/lib/parse_date.c" yy764: YYDEBUG(764, *YYCURSOR); yych = *++YYCURSOR; @@ -12668,7 +12615,6 @@ yy770: YYDEBUG(770, *YYCURSOR); ++YYCURSOR; YYDEBUG(771, *YYCURSOR); -#line 1512 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("pgtextreverse"); @@ -12681,7 +12627,6 @@ yy770: TIMELIB_DEINIT; return TIMELIB_PG_TEXT; } -#line 12685 "ext/date/lib/parse_date.c" yy772: YYDEBUG(772, *YYCURSOR); yych = *++YYCURSOR; @@ -12819,7 +12764,6 @@ yy782: } yy783: YYDEBUG(783, *YYCURSOR); -#line 1547 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("year4"); TIMELIB_INIT; @@ -12827,7 +12771,6 @@ yy783: TIMELIB_DEINIT; return TIMELIB_CLF; } -#line 12831 "ext/date/lib/parse_date.c" yy784: YYDEBUG(784, *YYCURSOR); yych = *++YYCURSOR; @@ -12978,7 +12921,6 @@ yy792: } yy793: YYDEBUG(793, *YYCURSOR); -#line 1368 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("datenodayrev"); @@ -12991,7 +12933,6 @@ yy793: TIMELIB_DEINIT; return TIMELIB_DATE_NO_DAY; } -#line 12995 "ext/date/lib/parse_date.c" yy794: YYDEBUG(794, *YYCURSOR); yych = *++YYCURSOR; @@ -13206,7 +13147,6 @@ yy813: if (yych <= '7') goto yy816; yy814: YYDEBUG(814, *YYCURSOR); -#line 1479 "ext/date/lib/parse_date.re" { timelib_sll w, d; DEBUG_OUTPUT("isoweek"); @@ -13224,7 +13164,6 @@ yy814: TIMELIB_DEINIT; return TIMELIB_ISO_WEEK; } -#line 13228 "ext/date/lib/parse_date.c" yy815: YYDEBUG(815, *YYCURSOR); yych = *++YYCURSOR; @@ -13234,7 +13173,6 @@ yy816: YYDEBUG(816, *YYCURSOR); ++YYCURSOR; YYDEBUG(817, *YYCURSOR); -#line 1460 "ext/date/lib/parse_date.re" { timelib_sll w, d; DEBUG_OUTPUT("isoweekday"); @@ -13252,7 +13190,6 @@ yy816: TIMELIB_DEINIT; return TIMELIB_ISO_WEEK; } -#line 13256 "ext/date/lib/parse_date.c" yy818: YYDEBUG(818, *YYCURSOR); yych = *++YYCURSOR; @@ -13316,7 +13253,6 @@ yy820: } yy821: YYDEBUG(821, *YYCURSOR); -#line 1446 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("pgydotd"); @@ -13329,7 +13265,6 @@ yy821: TIMELIB_DEINIT; return TIMELIB_PG_YEARDAY; } -#line 13333 "ext/date/lib/parse_date.c" yy822: YYDEBUG(822, *YYCURSOR); yych = *++YYCURSOR; @@ -13432,7 +13367,6 @@ yy841: ++YYCURSOR; yy842: YYDEBUG(842, *YYCURSOR); -#line 1420 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("xmlrpc | xmlrpcnocolon | soap | wddx | exif"); @@ -13457,7 +13391,6 @@ yy842: TIMELIB_DEINIT; return TIMELIB_XMLRPC_SOAP; } -#line 13461 "ext/date/lib/parse_date.c" yy843: YYDEBUG(843, *YYCURSOR); yych = *++YYCURSOR; @@ -13719,7 +13652,6 @@ yy847: } yy848: YYDEBUG(848, *YYCURSOR); -#line 1408 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("datenocolon"); TIMELIB_INIT; @@ -13730,7 +13662,6 @@ yy848: TIMELIB_DEINIT; return TIMELIB_DATE_NOCOLON; } -#line 13734 "ext/date/lib/parse_date.c" yy849: YYDEBUG(849, *YYCURSOR); yych = *++YYCURSOR; @@ -14650,7 +14581,6 @@ yy972: if (yych <= '9') goto yy995; yy973: YYDEBUG(973, *YYCURSOR); -#line 1285 "ext/date/lib/parse_date.re" { int length = 0; DEBUG_OUTPUT("gnudateshorter"); @@ -14663,7 +14593,6 @@ yy973: TIMELIB_DEINIT; return TIMELIB_ISO_DATE; } -#line 14667 "ext/date/lib/parse_date.c" yy974: YYDEBUG(974, *YYCURSOR); yyaccept = 22; @@ -15672,7 +15601,6 @@ yy1065: } yy1067: YYDEBUG(1067, *YYCURSOR); -#line 1177 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("gnunocolon"); TIMELIB_INIT; @@ -15694,7 +15622,6 @@ yy1067: TIMELIB_DEINIT; return TIMELIB_GNU_NOCOLON; } -#line 15698 "ext/date/lib/parse_date.c" yy1068: YYDEBUG(1068, *YYCURSOR); yych = *++YYCURSOR; @@ -15786,7 +15713,6 @@ yy1074: } yy1075: YYDEBUG(1075, *YYCURSOR); -#line 1223 "ext/date/lib/parse_date.re" { int tz_not_found; DEBUG_OUTPUT("iso8601nocolon"); @@ -15805,7 +15731,6 @@ yy1075: TIMELIB_DEINIT; return TIMELIB_ISO_NOCOLON; } -#line 15809 "ext/date/lib/parse_date.c" yy1076: YYDEBUG(1076, *YYCURSOR); yyaccept = 25; @@ -16703,7 +16628,6 @@ yy1116: } yy1117: YYDEBUG(1117, *YYCURSOR); -#line 1619 "ext/date/lib/parse_date.re" { timelib_sll i; int behavior = 0; @@ -16719,7 +16643,6 @@ yy1117: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 16723 "ext/date/lib/parse_date.c" yy1118: YYDEBUG(1118, *YYCURSOR); ++YYCURSOR; @@ -16770,7 +16693,6 @@ yy1125: YYDEBUG(1125, *YYCURSOR); ++YYCURSOR; YYDEBUG(1126, *YYCURSOR); -#line 1092 "ext/date/lib/parse_date.re" { timelib_sll i; int behavior = 0; @@ -16791,7 +16713,6 @@ yy1125: TIMELIB_DEINIT; return TIMELIB_WEEK_DAY_OF_MONTH; } -#line 16795 "ext/date/lib/parse_date.c" yy1127: YYDEBUG(1127, *YYCURSOR); yyaccept = 26; @@ -16899,7 +16820,6 @@ yy1140: } yy1141: YYDEBUG(1141, *YYCURSOR); -#line 1595 "ext/date/lib/parse_date.re" { timelib_sll i; int behavior = 0; @@ -16922,7 +16842,6 @@ yy1141: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 16926 "ext/date/lib/parse_date.c" yy1142: YYDEBUG(1142, *YYCURSOR); yych = *++YYCURSOR; @@ -19599,7 +19518,6 @@ yy1293: goto yy1297; yy1294: YYDEBUG(1294, *YYCURSOR); -#line 1069 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("backof | frontof"); TIMELIB_INIT; @@ -19621,7 +19539,6 @@ yy1294: TIMELIB_DEINIT; return TIMELIB_LF_DAY_OF_MONTH; } -#line 19625 "ext/date/lib/parse_date.c" yy1295: YYDEBUG(1295, *YYCURSOR); yyaccept = 28; @@ -19882,7 +19799,6 @@ yy1315: YYDEBUG(1315, *YYCURSOR); ++YYCURSOR; YYDEBUG(1316, *YYCURSOR); -#line 1052 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("firstdayof | lastdayof"); TIMELIB_INIT; @@ -19898,7 +19814,6 @@ yy1315: TIMELIB_DEINIT; return TIMELIB_LF_DAY_OF_MONTH; } -#line 19902 "ext/date/lib/parse_date.c" yy1317: YYDEBUG(1317, *YYCURSOR); yyaccept = 0; @@ -21329,7 +21244,6 @@ yy1385: if (yych <= '9') goto yy1385; yy1387: YYDEBUG(1387, *YYCURSOR); -#line 1026 "ext/date/lib/parse_date.re" { timelib_ull i; @@ -21354,7 +21268,6 @@ yy1387: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 21358 "ext/date/lib/parse_date.c" yy1388: YYDEBUG(1388, *YYCURSOR); yych = *++YYCURSOR; @@ -21790,7 +21703,6 @@ yy1416: ++YYCURSOR; yy1417: YYDEBUG(1417, *YYCURSOR); -#line 1014 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("tomorrow"); TIMELIB_INIT; @@ -21801,7 +21713,6 @@ yy1417: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 21805 "ext/date/lib/parse_date.c" yy1418: YYDEBUG(1418, *YYCURSOR); yych = *++YYCURSOR; @@ -21836,7 +21747,6 @@ yy1419: } yy1420: YYDEBUG(1420, *YYCURSOR); -#line 1004 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("midnight | today"); TIMELIB_INIT; @@ -21845,7 +21755,6 @@ yy1420: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 21849 "ext/date/lib/parse_date.c" yy1421: YYDEBUG(1421, *YYCURSOR); yych = *++YYCURSOR; @@ -23857,7 +23766,6 @@ yy1499: } yy1500: YYDEBUG(1500, *YYCURSOR); -#line 983 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("now"); TIMELIB_INIT; @@ -23865,7 +23773,6 @@ yy1500: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 23869 "ext/date/lib/parse_date.c" yy1501: YYDEBUG(1501, *YYCURSOR); yych = *++YYCURSOR; @@ -24004,7 +23911,6 @@ yy1507: } yy1508: YYDEBUG(1508, *YYCURSOR); -#line 992 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("noon"); TIMELIB_INIT; @@ -24015,7 +23921,6 @@ yy1508: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 24019 "ext/date/lib/parse_date.c" yy1509: YYDEBUG(1509, *YYCURSOR); yyaccept = 0; @@ -24548,7 +24453,6 @@ yy1530: ++YYCURSOR; yy1531: YYDEBUG(1531, *YYCURSOR); -#line 971 "ext/date/lib/parse_date.re" { DEBUG_OUTPUT("yesterday"); TIMELIB_INIT; @@ -24559,7 +24463,6 @@ yy1531: TIMELIB_DEINIT; return TIMELIB_RELATIVE; } -#line 24563 "ext/date/lib/parse_date.c" yy1532: YYDEBUG(1532, *YYCURSOR); yyaccept = 0; @@ -24732,7 +24635,6 @@ yy1537: goto yy1531; } } -#line 1745 "ext/date/lib/parse_date.re" } diff --git a/ext/date/php_date.c b/ext/date/php_date.c index 6cea2af048..63cdc511ab 100644 --- a/ext/date/php_date.c +++ b/ext/date/php_date.c @@ -860,9 +860,9 @@ PHP_MINIT_FUNCTION(date) REGISTER_STRING_CONSTANT("DATE_RSS", DATE_FORMAT_RFC1123, CONST_CS | CONST_PERSISTENT); REGISTER_STRING_CONSTANT("DATE_W3C", DATE_FORMAT_RFC3339, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_TIMESTAMP", SUNFUNCS_RET_TIMESTAMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_STRING", SUNFUNCS_RET_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SUNFUNCS_RET_DOUBLE", SUNFUNCS_RET_DOUBLE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_TIMESTAMP", SUNFUNCS_RET_TIMESTAMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_STRING", SUNFUNCS_RET_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SUNFUNCS_RET_DOUBLE", SUNFUNCS_RET_DOUBLE, CONST_CS | CONST_PERSISTENT); php_date_global_timezone_db = NULL; php_date_global_timezone_db_enabled = 0; @@ -962,7 +962,7 @@ static char* guess_timezone(const timelib_tzdb *tzdb TSRMLS_DC) zval ztz; if (SUCCESS == zend_get_configuration_directive("date.timezone", sizeof("date.timezone"), &ztz) - && Z_TYPE(ztz) == IS_STRING && Z_STRLEN(ztz) > 0 && timelib_timezone_id_is_valid(Z_STRVAL(ztz), tzdb)) { + && Z_TYPE(ztz) == IS_STRING && Z_STRSIZE(ztz) > 0 && timelib_timezone_id_is_valid(Z_STRVAL(ztz), tzdb)) { return Z_STRVAL(ztz); } } else if (*DATEG(default_timezone)) { @@ -1394,7 +1394,7 @@ PHP_FUNCTION(idate) php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unrecognized date format token."); RETURN_FALSE; } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1490,7 +1490,7 @@ PHP_FUNCTION(strtotime) if (error1 || error2) { RETURN_FALSE; } else { - RETURN_LONG(ts); + RETURN_INT(ts); } } /* }}} */ @@ -1582,7 +1582,7 @@ PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt) if (error) { RETURN_FALSE; } else { - RETURN_LONG(ts); + RETURN_INT(ts); } } /* }}} */ @@ -1737,7 +1737,7 @@ PHP_FUNCTION(gmstrftime) Return current UNIX timestamp */ PHP_FUNCTION(time) { - RETURN_LONG((long)time(NULL)); + RETURN_INT((long)time(NULL)); } /* }}} */ @@ -1763,25 +1763,25 @@ PHP_FUNCTION(localtime) array_init(return_value); if (associative) { - add_assoc_long(return_value, "tm_sec", ts->s); - add_assoc_long(return_value, "tm_min", ts->i); - add_assoc_long(return_value, "tm_hour", ts->h); - add_assoc_long(return_value, "tm_mday", ts->d); - add_assoc_long(return_value, "tm_mon", ts->m - 1); - add_assoc_long(return_value, "tm_year", ts->y - 1900); - add_assoc_long(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_isdst", ts->dst); + add_assoc_int(return_value, "tm_sec", ts->s); + add_assoc_int(return_value, "tm_min", ts->i); + add_assoc_int(return_value, "tm_hour", ts->h); + add_assoc_int(return_value, "tm_mday", ts->d); + add_assoc_int(return_value, "tm_mon", ts->m - 1); + add_assoc_int(return_value, "tm_year", ts->y - 1900); + add_assoc_int(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "tm_isdst", ts->dst); } else { - add_next_index_long(return_value, ts->s); - add_next_index_long(return_value, ts->i); - add_next_index_long(return_value, ts->h); - add_next_index_long(return_value, ts->d); - add_next_index_long(return_value, ts->m - 1); - add_next_index_long(return_value, ts->y- 1900); - add_next_index_long(return_value, timelib_day_of_week(ts->y, ts->m, ts->d)); - add_next_index_long(return_value, timelib_day_of_year(ts->y, ts->m, ts->d)); - add_next_index_long(return_value, ts->dst); + add_next_index_int(return_value, ts->s); + add_next_index_int(return_value, ts->i); + add_next_index_int(return_value, ts->h); + add_next_index_int(return_value, ts->d); + add_next_index_int(return_value, ts->m - 1); + add_next_index_int(return_value, ts->y- 1900); + add_next_index_int(return_value, timelib_day_of_week(ts->y, ts->m, ts->d)); + add_next_index_int(return_value, timelib_day_of_year(ts->y, ts->m, ts->d)); + add_next_index_int(return_value, ts->dst); } timelib_time_dtor(ts); @@ -1808,17 +1808,17 @@ PHP_FUNCTION(getdate) array_init(return_value); - add_assoc_long(return_value, "seconds", ts->s); - add_assoc_long(return_value, "minutes", ts->i); - add_assoc_long(return_value, "hours", ts->h); - add_assoc_long(return_value, "mday", ts->d); - add_assoc_long(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "mon", ts->m); - add_assoc_long(return_value, "year", ts->y); - add_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "seconds", ts->s); + add_assoc_int(return_value, "minutes", ts->i); + add_assoc_int(return_value, "hours", ts->h); + add_assoc_int(return_value, "mday", ts->d); + add_assoc_int(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_assoc_int(return_value, "mon", ts->m); + add_assoc_int(return_value, "year", ts->y); + add_assoc_int(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d)); add_assoc_string(return_value, "month", mon_full_names[ts->m - 1]); - add_index_long(return_value, 0, timestamp); + add_index_int(return_value, 0, timestamp); timelib_time_dtor(ts); } @@ -1925,7 +1925,7 @@ static zval *date_period_it_current_data(zend_object_iterator *iter TSRMLS_DC) static void date_period_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) { date_period_it *iterator = (date_period_it *)iter; - ZVAL_LONG(key, iterator->current_index); + ZVAL_INT(key, iterator->current_index); } /* }}} */ @@ -2049,7 +2049,7 @@ static void date_register_classes(TSRMLS_D) /* {{{ */ date_object_handlers_timezone.get_gc = date_object_get_gc_timezone; #define REGISTER_TIMEZONE_CLASS_CONST_STRING(const_name, value) \ - zend_declare_class_constant_long(date_ce_timezone, const_name, sizeof(const_name)-1, value TSRMLS_CC); + zend_declare_class_constant_int(date_ce_timezone, const_name, sizeof(const_name)-1, value TSRMLS_CC); REGISTER_TIMEZONE_CLASS_CONST_STRING("AFRICA", PHP_DATE_TIMEZONE_GROUP_AFRICA); REGISTER_TIMEZONE_CLASS_CONST_STRING("AMERICA", PHP_DATE_TIMEZONE_GROUP_AMERICA); @@ -2096,7 +2096,7 @@ static void date_register_classes(TSRMLS_D) /* {{{ */ date_object_handlers_period.write_property = date_period_write_property; #define REGISTER_PERIOD_CLASS_CONST_STRING(const_name, value) \ - zend_declare_class_constant_long(date_ce_period, const_name, sizeof(const_name)-1, value TSRMLS_CC); + zend_declare_class_constant_int(date_ce_period, const_name, sizeof(const_name)-1, value TSRMLS_CC); REGISTER_PERIOD_CLASS_CONST_STRING("EXCLUDE_START_DATE", PHP_DATE_PERIOD_EXCLUDE_START_DATE); } /* }}} */ @@ -2203,7 +2203,7 @@ static HashTable *date_object_get_properties(zval *object TSRMLS_DC) /* {{{ */ /* then we add the timezone name (or similar) */ if (dateobj->time->is_localtime) { - ZVAL_LONG(&zv, dateobj->time->zone_type); + ZVAL_INT(&zv, dateobj->time->zone_type); zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv); switch (dateobj->time->zone_type) { @@ -2296,7 +2296,7 @@ static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC) /* return props; } - ZVAL_LONG(&zv, tzobj->type); + ZVAL_INT(&zv, tzobj->type); zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv); switch (tzobj->type) { @@ -2377,7 +2377,7 @@ static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC) /* } #define PHP_DATE_INTERVAL_ADD_PROPERTY(n,f) \ - ZVAL_LONG(&zv, (long)intervalobj->diff->f); \ + ZVAL_INT(&zv, (long)intervalobj->diff->f); \ zend_hash_str_update(props, n, sizeof(n)-1, &zv); PHP_DATE_INTERVAL_ADD_PROPERTY("y", y); @@ -2760,18 +2760,18 @@ static int php_date_initialize_from_hash(php_date_obj **dateobj, HashTable *myht convert_to_string(z_date); z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1); if (z_timezone_type) { - convert_to_long(z_timezone_type); + convert_to_int(z_timezone_type); z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1); if (z_timezone) { convert_to_string(z_timezone); - switch (Z_LVAL_P(z_timezone_type)) { + switch (Z_IVAL_P(z_timezone_type)) { case TIMELIB_ZONETYPE_OFFSET: case TIMELIB_ZONETYPE_ABBR: { - char *tmp = emalloc(Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2); + char *tmp = emalloc(Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 2); int ret; - snprintf(tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2, "%s %s", Z_STRVAL_P(z_date), Z_STRVAL_P(z_timezone)); - ret = php_date_initialize(*dateobj, tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC); + snprintf(tmp, Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 2, "%s %s", Z_STRVAL_P(z_date), Z_STRVAL_P(z_timezone)); + ret = php_date_initialize(*dateobj, tmp, Z_STRSIZE_P(z_date) + Z_STRSIZE_P(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC); efree(tmp); return 1 == ret; } @@ -2791,7 +2791,7 @@ static int php_date_initialize_from_hash(php_date_obj **dateobj, HashTable *myht tzobj->tzi.tz = tzi; tzobj->initialized = 1; - ret = php_date_initialize(*dateobj, Z_STRVAL_P(z_date), Z_STRLEN_P(z_date), NULL, &tmp_obj, 0 TSRMLS_CC); + ret = php_date_initialize(*dateobj, Z_STRVAL_P(z_date), Z_STRSIZE_P(z_date), NULL, &tmp_obj, 0 TSRMLS_CC); zval_ptr_dtor(&tmp_obj); return 1 == ret; } @@ -2870,14 +2870,14 @@ static void zval_from_error_container(zval *z, timelib_error_container *error) / int i; zval element; - add_assoc_long(z, "warning_count", error->warning_count); + add_assoc_int(z, "warning_count", error->warning_count); array_init(&element); for (i = 0; i < error->warning_count; i++) { add_index_string(&element, error->warning_messages[i].position, error->warning_messages[i].message); } add_assoc_zval(z, "warnings", &element); - add_assoc_long(z, "error_count", error->error_count); + add_assoc_int(z, "error_count", error->error_count); array_init(&element); for (i = 0; i < error->error_count; i++) { add_index_string(&element, error->error_messages[i].position, error->error_messages[i].message); @@ -2908,7 +2908,7 @@ void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time * if (parsed_time->elem == -99999) { \ add_assoc_bool(return_value, #name, 0); \ } else { \ - add_assoc_long(return_value, #name, parsed_time->elem); \ + add_assoc_int(return_value, #name, parsed_time->elem); \ } PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(year, y); PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(month, m); @@ -2953,17 +2953,17 @@ void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time * } if (parsed_time->have_relative) { array_init(&element); - add_assoc_long(&element, "year", parsed_time->relative.y); - add_assoc_long(&element, "month", parsed_time->relative.m); - add_assoc_long(&element, "day", parsed_time->relative.d); - add_assoc_long(&element, "hour", parsed_time->relative.h); - add_assoc_long(&element, "minute", parsed_time->relative.i); - add_assoc_long(&element, "second", parsed_time->relative.s); + add_assoc_int(&element, "year", parsed_time->relative.y); + add_assoc_int(&element, "month", parsed_time->relative.m); + add_assoc_int(&element, "day", parsed_time->relative.d); + add_assoc_int(&element, "hour", parsed_time->relative.h); + add_assoc_int(&element, "minute", parsed_time->relative.i); + add_assoc_int(&element, "second", parsed_time->relative.s); if (parsed_time->relative.have_weekday_relative) { - add_assoc_long(&element, "weekday", parsed_time->relative.weekday); + add_assoc_int(&element, "weekday", parsed_time->relative.weekday); } if (parsed_time->relative.have_special_relative && (parsed_time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY)) { - add_assoc_long(&element, "weekdays", parsed_time->relative.special.amount); + add_assoc_int(&element, "weekdays", parsed_time->relative.special.amount); } if (parsed_time->relative.first_last_day_of) { add_assoc_bool(&element, parsed_time->relative.first_last_day_of == 1 ? "first_day_of_month" : "last_day_of_month", 1); @@ -3360,19 +3360,19 @@ PHP_FUNCTION(date_offset_get) switch (dateobj->time->zone_type) { case TIMELIB_ZONETYPE_ID: offset = timelib_get_time_zone_info(dateobj->time->sse, dateobj->time->tz_info); - RETVAL_LONG(offset->offset); + RETVAL_INT(offset->offset); timelib_time_offset_dtor(offset); break; case TIMELIB_ZONETYPE_OFFSET: - RETVAL_LONG(dateobj->time->z * -60); + RETVAL_INT(dateobj->time->z * -60); break; case TIMELIB_ZONETYPE_ABBR: - RETVAL_LONG((dateobj->time->z - (60 * dateobj->time->dst)) * -60); + RETVAL_INT((dateobj->time->z - (60 * dateobj->time->dst)) * -60); break; } return; } else { - RETURN_LONG(0); + RETURN_INT(0); } } /* }}} */ @@ -3592,7 +3592,7 @@ PHP_FUNCTION(date_timestamp_get) if (error) { RETURN_FALSE; } else { - RETVAL_LONG(timestamp); + RETVAL_INT(timestamp); } } /* }}} */ @@ -3692,7 +3692,7 @@ static int php_date_timezone_initialize_from_hash(zval **return_value, php_timez if ((z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1)) != NULL) { if ((z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1)) != NULL) { - convert_to_long(z_timezone_type); + convert_to_int(z_timezone_type); if (SUCCESS == timezone_initialize(*tzobj, Z_STRVAL_P(z_timezone) TSRMLS_CC)) { return SUCCESS; } @@ -3819,14 +3819,14 @@ PHP_FUNCTION(timezone_offset_get) switch (tzobj->type) { case TIMELIB_ZONETYPE_ID: offset = timelib_get_time_zone_info(dateobj->time->sse, tzobj->tzi.tz); - RETVAL_LONG(offset->offset); + RETVAL_INT(offset->offset); timelib_time_offset_dtor(offset); break; case TIMELIB_ZONETYPE_OFFSET: - RETURN_LONG(tzobj->tzi.utc_offset * -60); + RETURN_INT(tzobj->tzi.utc_offset * -60); break; case TIMELIB_ZONETYPE_ABBR: - RETURN_LONG((tzobj->tzi.z.utc_offset - (tzobj->tzi.z.dst*60)) * -60); + RETURN_INT((tzobj->tzi.z.utc_offset - (tzobj->tzi.z.dst*60)) * -60); break; } } @@ -3853,18 +3853,18 @@ PHP_FUNCTION(timezone_transitions_get) #define add_nominal() \ array_init(&element); \ - add_assoc_long(&element, "ts", timestamp_begin); \ + add_assoc_int(&element, "ts", timestamp_begin); \ add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, timestamp_begin, 0 TSRMLS_CC)); \ - add_assoc_long(&element, "offset", tzobj->tzi.tz->type[0].offset); \ + add_assoc_int(&element, "offset", tzobj->tzi.tz->type[0].offset); \ add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[0].isdst); \ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx]); \ add_next_index_zval(return_value, &element); #define add(i,ts) \ array_init(&element); \ - add_assoc_long(&element, "ts", ts); \ + add_assoc_int(&element, "ts", ts); \ add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, ts, 0 TSRMLS_CC)); \ - add_assoc_long(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \ + add_assoc_int(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \ add_assoc_bool(&element, "isdst", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \ add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx]); \ add_next_index_zval(return_value, &element); @@ -4023,7 +4023,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, void **c retval = rv; if (value != -99999) { - ZVAL_LONG(retval, value); + ZVAL_INT(retval, value); } else { ZVAL_FALSE(retval); } @@ -4062,7 +4062,7 @@ void date_interval_write_property(zval *object, zval *member, zval *value, void #define SET_VALUE_FROM_STRUCT(n,m) \ if (strcmp(Z_STRVAL_P(member), m) == 0) { \ - obj->diff->n = zval_get_long(value); \ + obj->diff->n = zval_get_int(value); \ break; \ } @@ -4119,7 +4119,7 @@ static int php_date_interval_initialize_from_hash(zval **return_value, php_inter do { \ zval *z_arg = zend_hash_str_find(myht, element, sizeof(element) - 1); \ if (z_arg) { \ - (*intobj)->diff->member = (itype)zval_get_long(z_arg); \ + (*intobj)->diff->member = (itype)zval_get_int(z_arg); \ } else { \ (*intobj)->diff->member = (itype)def; \ } \ @@ -4496,7 +4496,7 @@ PHP_FUNCTION(timezone_abbreviations_list) do { array_init(&element); add_assoc_bool(&element, "dst", entry->type); - add_assoc_long(&element, "offset", entry->gmtoffset); + add_assoc_int(&element, "offset", entry->gmtoffset); if (entry->full_tz_name) { add_assoc_string(&element, "timezone_id", entry->full_tz_name); } else { @@ -4617,7 +4617,7 @@ static void php_do_date_sunrise_sunset(INTERNAL_FUNCTION_PARAMETERS, int calc_su } if (retformat == SUNFUNCS_RET_TIMESTAMP) { - RETURN_LONG(calc_sunset ? set : rise); + RETURN_INT(calc_sunset ? set : rise); } N = (calc_sunset ? h_set : h_rise) + gmt_offset; @@ -4693,12 +4693,12 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "sunset", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "sunset", timelib_date_to_int(t2, &dummy)); } t2->sse = transit; - add_assoc_long(return_value, "transit", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "transit", timelib_date_to_int(t2, &dummy)); /* Get civil twilight */ rs = timelib_astro_rise_set_altitude(t, longitude, latitude, -6.0, 0, &ddummy, &ddummy, &rise, &set, &transit); @@ -4713,9 +4713,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get nautical twilight */ @@ -4731,9 +4731,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get astronomical twilight */ @@ -4749,9 +4749,9 @@ PHP_FUNCTION(date_sun_info) break; default: t2->sse = rise; - add_assoc_long(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_assoc_int(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); } timelib_time_dtor(t); timelib_time_dtor(t2); @@ -4821,7 +4821,7 @@ static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC) /* { zend_hash_str_update(props, "interval", sizeof("interval")-1, &zv); /* converted to larger type (int->long); must check when unserializing */ - ZVAL_LONG(&zv, (long) period_obj->recurrences); + ZVAL_INT(&zv, (long) period_obj->recurrences); zend_hash_str_update(props, "recurrences", sizeof("recurrences")-1, &zv); ZVAL_BOOL(&zv, period_obj->include_start_date); @@ -4891,8 +4891,8 @@ static int php_date_period_initialize_from_hash(php_period_obj *period_obj, Hash ht_entry = zend_hash_str_find(myht, "recurrences", sizeof("recurrences")-1); if (ht_entry && - Z_TYPE_P(ht_entry) == IS_LONG && Z_LVAL_P(ht_entry) >= 0 && Z_LVAL_P(ht_entry) <= INT_MAX) { - period_obj->recurrences = Z_LVAL_P(ht_entry); + Z_TYPE_P(ht_entry) == IS_INT && Z_IVAL_P(ht_entry) >= 0 && Z_IVAL_P(ht_entry) <= INT_MAX) { + period_obj->recurrences = Z_IVAL_P(ht_entry); } else { return 0; } diff --git a/ext/ereg/ereg.c b/ext/ereg/ereg.c index 79bee9b79f..280b54a43d 100644 --- a/ext/ereg/ereg.c +++ b/ext/ereg/ereg.c @@ -323,7 +323,7 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase) } else { /* we convert numbers to integers and treat them as a string */ if (Z_TYPE_P(regex) == IS_DOUBLE) { - convert_to_long_ex(regex); /* get rid of decimal places */ + convert_to_int_ex(regex); /* get rid of decimal places */ } convert_to_string_ex(regex); /* don't bother doing an extended regex with just a number */ @@ -379,7 +379,7 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase) } else { if (match_len == 0) match_len = 1; - RETVAL_LONG(match_len); + RETVAL_INT(match_len); } regfree(&re); } @@ -564,28 +564,28 @@ static void php_do_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase) } if (Z_TYPE_P(arg_pattern) == IS_STRING) { - if (Z_STRVAL_P(arg_pattern) && Z_STRLEN_P(arg_pattern)) { + if (Z_STRVAL_P(arg_pattern) && Z_STRSIZE_P(arg_pattern)) { pattern = STR_COPY(Z_STR_P(arg_pattern)); } else { pattern = STR_EMPTY_ALLOC(); } } else { - convert_to_long_ex(arg_pattern); + convert_to_int_ex(arg_pattern); pattern = STR_ALLOC(1, 0); - pattern->val[0] = (char) Z_LVAL_P(arg_pattern); + pattern->val[0] = (char) Z_IVAL_P(arg_pattern); pattern->val[1] = '\0'; } if (Z_TYPE_P(arg_replace) == IS_STRING) { - if (Z_STRVAL_P(arg_replace) && Z_STRLEN_P(arg_replace)) { + if (Z_STRVAL_P(arg_replace) && Z_STRSIZE_P(arg_replace)) { replace = STR_COPY(Z_STR_P(arg_replace)); } else { replace = STR_EMPTY_ALLOC(); } } else { - convert_to_long_ex(arg_replace); + convert_to_int_ex(arg_replace); replace = STR_ALLOC(1, 0); - replace->val[0] = (char) Z_LVAL_P(arg_replace); + replace->val[0] = (char) Z_IVAL_P(arg_replace); replace->val[1] = '\0'; } diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c index 4731db21fb..d7c7c56a93 100644 --- a/ext/pcre/php_pcre.c +++ b/ext/pcre/php_pcre.c @@ -143,20 +143,20 @@ static PHP_MINIT_FUNCTION(pcre) { REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_PATTERN_ORDER", PREG_PATTERN_ORDER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SET_ORDER", PREG_SET_ORDER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_OFFSET_CAPTURE", PREG_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_NO_EMPTY", PREG_SPLIT_NO_EMPTY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_DELIM_CAPTURE", PREG_SPLIT_DELIM_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_SPLIT_OFFSET_CAPTURE", PREG_SPLIT_OFFSET_CAPTURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_GREP_INVERT", PREG_GREP_INVERT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("PREG_NO_ERROR", PHP_PCRE_NO_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_INTERNAL_ERROR", PHP_PCRE_INTERNAL_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BACKTRACK_LIMIT_ERROR", PHP_PCRE_BACKTRACK_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_RECURSION_LIMIT_ERROR", PHP_PCRE_RECURSION_LIMIT_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BAD_UTF8_ERROR", PHP_PCRE_BAD_UTF8_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PREG_BAD_UTF8_OFFSET_ERROR", PHP_PCRE_BAD_UTF8_OFFSET_ERROR, CONST_CS | CONST_PERSISTENT); REGISTER_STRING_CONSTANT("PCRE_VERSION", (char *)pcre_version(), CONST_CS | CONST_PERSISTENT); return SUCCESS; @@ -527,7 +527,7 @@ static inline void add_offset_pair(zval *result, char *str, int len, int offset, /* Add (match, offset) to the return value */ add_next_index_stringl(&match_pair, str, len); - add_next_index_long(&match_pair, offset); + add_next_index_int(&match_pair, offset); if (name) { zval_add_ref(&match_pair); @@ -541,26 +541,25 @@ static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ * { /* parameters */ zend_string *regex; /* Regular expression */ - char *subject; /* String to match against */ - int subject_len; + zend_string *subject; /* String to match against */ pcre_cache_entry *pce; /* Compiled regular expression */ zval *subpats = NULL; /* Array for subpatterns */ - long flags = 0; /* Match control flags */ - long start_offset = 0; /* Where the new search starts */ + php_int_t flags = 0; /* Match control flags */ + php_int_t start_offset = 0; /* Where the new search starts */ #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|z/ll", ®ex, - &subject, &subject_len, &subpats, &flags, &start_offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|z/ii", ®ex, + &subject, &subpats, &flags, &start_offset) == FAILURE) { RETURN_FALSE; } #else ZEND_PARSE_PARAMETERS_START(2, 5) Z_PARAM_STR(regex) - Z_PARAM_STRING(subject, subject_len) + Z_PARAM_STR(subject) Z_PARAM_OPTIONAL Z_PARAM_ZVAL_EX(subpats, 0, 1) - Z_PARAM_LONG(flags) - Z_PARAM_LONG(start_offset) + Z_PARAM_INT(flags) + Z_PARAM_INT(start_offset) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); #endif @@ -569,7 +568,7 @@ static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ * RETURN_FALSE; } - php_pcre_match_impl(pce, subject, subject_len, return_value, subpats, + php_pcre_match_impl(pce, subject->val, subject->len, return_value, subpats, global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC); } /* }}} */ @@ -888,7 +887,7 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec /* Did we encounter an error? */ if (PCRE_G(error_code) == PHP_PCRE_NO_ERROR) { - RETVAL_LONG(matched); + RETVAL_INT(matched); } else { RETVAL_FALSE; } @@ -1142,7 +1141,7 @@ PHPAPI zend_string *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, } } else { replace = Z_STRVAL_P(replace_val); - replace_len = Z_STRLEN_P(replace_val); + replace_len = Z_STRSIZE_P(replace_val); replace_end = replace + replace_len; } @@ -1435,16 +1434,16 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_repl *subject_entry, *zcount = NULL; int limit_val = -1; - long limit = -1; + php_int_t limit = -1; zend_string *result; zend_string *string_key; - ulong num_key; + php_uint_t num_key; zend_string *callback_name; int replace_count=0, old_replace_count; - + #ifndef FAST_ZPP /* Get function parameters and do error-checking. */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|lz/", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|iz/", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) { return; } #else @@ -1453,7 +1452,7 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_repl Z_PARAM_ZVAL(replace) Z_PARAM_ZVAL(subject) Z_PARAM_OPTIONAL - Z_PARAM_LONG(limit) + Z_PARAM_INT(limit) Z_PARAM_ZVAL_EX(zcount, 0, 1) ZEND_PARSE_PARAMETERS_END(); #endif @@ -1519,7 +1518,7 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_repl } if (ZEND_NUM_ARGS() > 4) { zval_dtor(zcount); - ZVAL_LONG(zcount, replace_count); + ZVAL_INT(zcount, replace_count); } } @@ -1554,25 +1553,24 @@ static PHP_FUNCTION(preg_filter) static PHP_FUNCTION(preg_split) { zend_string *regex; /* Regular expression */ - char *subject; /* String to match against */ - int subject_len; - long limit_val = -1;/* Integer value of limit */ - long flags = 0; /* Match control flags */ + zend_string *subject; /* String to match against */ + php_int_t limit_val = -1;/* Integer value of limit */ + php_int_t flags = 0; /* Match control flags */ pcre_cache_entry *pce; /* Compiled regular expression */ /* Get function parameters and do error checking */ #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|ll", ®ex, + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|ii", ®ex, &subject, &subject_len, &limit_val, &flags) == FAILURE) { RETURN_FALSE; } #else ZEND_PARSE_PARAMETERS_START(2, 4) Z_PARAM_STR(regex) - Z_PARAM_STRING(subject, subject_len) + Z_PARAM_STR(subject) Z_PARAM_OPTIONAL - Z_PARAM_LONG(limit_val) - Z_PARAM_LONG(flags) + Z_PARAM_INT(limit_val) + Z_PARAM_INT(flags) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); #endif @@ -1581,7 +1579,7 @@ static PHP_FUNCTION(preg_split) RETURN_FALSE; } - php_pcre_split_impl(pce, subject, subject_len, return_value, limit_val, flags TSRMLS_CC); + php_pcre_split_impl(pce, subject->val, subject->len, return_value, limit_val, flags TSRMLS_CC); } /* }}} */ @@ -1864,12 +1862,12 @@ static PHP_FUNCTION(preg_grep) { zend_string *regex; /* Regular expression */ zval *input; /* Input array */ - long flags = 0; /* Match control flags */ + php_int_t flags = 0; /* Match control flags */ pcre_cache_entry *pce; /* Compiled regular expression */ /* Get arguments and do error checking */ #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sa|l", ®ex, + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sa|i", ®ex, &input, &flags) == FAILURE) { return; } @@ -1878,7 +1876,7 @@ static PHP_FUNCTION(preg_grep) Z_PARAM_STR(regex) Z_PARAM_ARRAY(input) Z_PARAM_OPTIONAL - Z_PARAM_LONG(flags) + Z_PARAM_INT(flags) ZEND_PARSE_PARAMETERS_END(); #endif @@ -1900,7 +1898,7 @@ PHPAPI void php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return int size_offsets; /* Size of the offsets array */ int count = 0; /* Count of matched subpatterns */ zend_string *string_key; - ulong num_key; + php_uint_t num_key; zend_bool invert; /* Whether to return non-matching entries */ ALLOCA_FLAG(use_heap); @@ -1988,7 +1986,7 @@ static PHP_FUNCTION(preg_last_error) ZEND_PARSE_PARAMETERS_END(); #endif - RETURN_LONG(PCRE_G(error_code)); + RETURN_INT(PCRE_G(error_code)); } /* }}} */ diff --git a/ext/pdo/pdo_sql_parser.c b/ext/pdo/pdo_sql_parser.c index 9cd205f4eb..cbaa0b057b 100644 --- a/ext/pdo/pdo_sql_parser.c +++ b/ext/pdo/pdo_sql_parser.c @@ -1,5 +1,4 @@ /* Generated by re2c 0.13.5 */ -#line 1 "ext/pdo/pdo_sql_parser.re" /* +----------------------------------------------------------------------+ | PHP Version 5 | @@ -47,11 +46,9 @@ static int scan(Scanner *s) char *cursor = s->cur; s->tok = cursor; - #line 55 "ext/pdo/pdo_sql_parser.re" -#line 55 "ext/pdo/pdo_sql_parser.c" { YYCTYPE yych; unsigned int yyaccept = 0; @@ -79,9 +76,7 @@ yy3: yych = *(YYMARKER = ++YYCURSOR); if (yych >= 0x01) goto yy43; yy4: -#line 63 "ext/pdo/pdo_sql_parser.re" { SKIP_ONE(PDO_PARSER_TEXT); } -#line 85 "ext/pdo/pdo_sql_parser.c" yy5: yyaccept = 0; yych = *(YYMARKER = ++YYCURSOR); @@ -163,9 +158,7 @@ yy7: default: goto yy8; } yy8: -#line 62 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_BIND_POS); } -#line 169 "ext/pdo/pdo_sql_parser.c" yy9: ++YYCURSOR; switch ((yych = *YYCURSOR)) { @@ -173,9 +166,7 @@ yy9: default: goto yy13; } yy10: -#line 65 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_TEXT); } -#line 179 "ext/pdo/pdo_sql_parser.c" yy11: yych = *++YYCURSOR; switch (yych) { @@ -210,9 +201,7 @@ yy14: default: goto yy14; } yy16: -#line 64 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_TEXT); } -#line 216 "ext/pdo/pdo_sql_parser.c" yy17: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -290,9 +279,7 @@ yy29: default: goto yy31; } yy31: -#line 60 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_TEXT); } -#line 296 "ext/pdo/pdo_sql_parser.c" yy32: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -364,9 +351,7 @@ yy32: default: goto yy34; } yy34: -#line 61 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_BIND); } -#line 370 "ext/pdo/pdo_sql_parser.c" yy35: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -394,9 +379,7 @@ yy39: goto yy37; yy40: ++YYCURSOR; -#line 59 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_TEXT); } -#line 400 "ext/pdo/pdo_sql_parser.c" yy42: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -416,11 +399,8 @@ yy44: goto yy42; yy45: ++YYCURSOR; -#line 58 "ext/pdo/pdo_sql_parser.re" { RET(PDO_PARSER_TEXT); } -#line 422 "ext/pdo/pdo_sql_parser.c" } -#line 66 "ext/pdo/pdo_sql_parser.re" } diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index e4ad9416f0..fa94785153 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -110,8 +110,8 @@ ZEND_DECLARE_MODULE_GLOBALS(reflection) target = intern->ptr; \ /* Class constants */ -#define REGISTER_REFLECTION_CLASS_CONST_LONG(class_name, const_name, value) \ - zend_declare_class_constant_long(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); +#define REGISTER_REFLECTION_CLASS_CONST_INT(class_name, const_name, value) \ + zend_declare_class_constant_int(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); /* {{{ Smart string functions */ typedef struct _string { @@ -435,7 +435,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in HashPosition pos; zval *value; zend_string *key; - ulong num_index; + php_uint_t num_index; zend_hash_internal_pointer_reset_ex(&ce->constants_table, &pos); @@ -565,7 +565,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in while ((prop = zend_hash_get_current_data_ptr_ex(properties, &pos)) != NULL) { zend_string *prop_name; - ulong index; + php_uint_t index; if (zend_hash_get_current_key_ex(properties, &prop_name, &index, 0, &pos) == HASH_KEY_IS_STRING) { if (prop_name->len && prop_name->val[0]) { /* skip all private and protected properties */ @@ -602,7 +602,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in && ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce)) { zend_string *key; - ulong num_index; + php_uint_t num_index; uint len = mptr->common.function_name->len; /* Do not display old-style inherited constructors */ @@ -729,8 +729,8 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg string_write(str, "NULL", sizeof("NULL")-1); } else if (Z_TYPE(zv) == IS_STRING) { string_write(str, "'", sizeof("'")-1); - string_write(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15)); - if (Z_STRLEN(zv) > 15) { + string_write(str, Z_STRVAL(zv), MIN(Z_STRSIZE(zv), 15)); + if (Z_STRSIZE(zv) > 15) { string_write(str, "...", sizeof("...")-1); } string_write(str, "'", sizeof("'")-1); @@ -774,7 +774,7 @@ static void _function_parameter_string(string *str, zend_function *fptr, char* i static void _function_closure_string(string *str, zend_function *fptr, char* indent TSRMLS_DC) { zend_uint i, count; - ulong num_index; + php_uint_t num_index; zend_string *key; HashTable *static_variables; HashPosition pos; @@ -1808,7 +1808,7 @@ ZEND_METHOD(reflection_function, getStartLine) } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { - RETURN_LONG(fptr->op_array.line_start); + RETURN_INT(fptr->op_array.line_start); } RETURN_FALSE; } @@ -1826,7 +1826,7 @@ ZEND_METHOD(reflection_function, getEndLine) } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { - RETURN_LONG(fptr->op_array.line_end); + RETURN_INT(fptr->op_array.line_end); } RETURN_FALSE; } @@ -2009,7 +2009,7 @@ ZEND_METHOD(reflection_function, getNumberOfParameters) METHOD_NOTSTATIC(reflection_function_abstract_ptr); GET_REFLECTION_OBJECT_PTR(fptr); - RETURN_LONG(fptr->common.num_args); + RETURN_INT(fptr->common.num_args); } /* }}} */ @@ -2023,7 +2023,7 @@ ZEND_METHOD(reflection_function, getNumberOfRequiredParameters) METHOD_NOTSTATIC(reflection_function_abstract_ptr); GET_REFLECTION_OBJECT_PTR(fptr); - RETURN_LONG(fptr->common.required_num_args); + RETURN_INT(fptr->common.required_num_args); } /* }}} */ @@ -2140,7 +2140,7 @@ ZEND_METHOD(reflection_parameter, __construct) unsigned int lcname_len; char *lcname; - lcname_len = Z_STRLEN_P(reference); + lcname_len = Z_STRSIZE_P(reference); lcname = zend_str_tolower_dup(Z_STRVAL_P(reference), lcname_len); if ((fptr = zend_hash_str_find_ptr(EG(function_table), lcname, lcname_len)) == NULL) { efree(lcname); @@ -2178,7 +2178,7 @@ ZEND_METHOD(reflection_parameter, __construct) } convert_to_string_ex(method); - lcname_len = Z_STRLEN_P(method); + lcname_len = Z_STRSIZE_P(method); lcname = zend_str_tolower_dup(Z_STRVAL_P(method), lcname_len); if (ce == zend_ce_closure && Z_TYPE_P(classref) == IS_OBJECT && (lcname_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) @@ -2219,8 +2219,8 @@ ZEND_METHOD(reflection_parameter, __construct) /* Now, search for the parameter */ arg_info = fptr->common.arg_info; - if (Z_TYPE_P(parameter) == IS_LONG) { - position= Z_LVAL_P(parameter); + if (Z_TYPE_P(parameter) == IS_INT) { + position= Z_IVAL_P(parameter); if (position < 0 || (zend_uint)position >= fptr->common.num_args) { if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) { if (fptr->type != ZEND_OVERLOADED_FUNCTION) { @@ -2503,7 +2503,7 @@ ZEND_METHOD(reflection_parameter, getPosition) } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_LONG(param->offset); + RETVAL_INT(param->offset); } /* }}} */ @@ -3103,7 +3103,7 @@ ZEND_METHOD(reflection_function, inNamespace) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_TRUE; @@ -3126,7 +3126,7 @@ ZEND_METHOD(reflection_function, getNamespaceName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name)); @@ -3149,10 +3149,10 @@ ZEND_METHOD(reflection_function, getShortName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { - RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1)); + RETURN_STRINGL(backslash + 1, Z_STRSIZE_P(name) - (backslash - Z_STRVAL_P(name) + 1)); } RETURN_ZVAL(name, 1, 0); } @@ -3203,7 +3203,7 @@ ZEND_METHOD(reflection_method, getModifiers) } GET_REFLECTION_OBJECT_PTR(mptr); - RETURN_LONG(mptr->common.fn_flags); + RETURN_INT(mptr->common.fn_flags); } /* }}} */ @@ -3343,7 +3343,7 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value zend_property_info *prop_info; zval *prop, prop_copy; zend_string *key; - ulong num_index; + php_uint_t num_index; ZEND_HASH_FOREACH_KEY_PTR(&ce->properties_info, num_index, key, prop_info) { if (((prop_info->flags & ZEND_ACC_SHADOW) && @@ -3566,7 +3566,7 @@ ZEND_METHOD(reflection_class, getStartLine) } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_FUNCTION) { - RETURN_LONG(ce->info.user.line_start); + RETURN_INT(ce->info.user.line_start); } RETURN_FALSE; } @@ -3584,7 +3584,7 @@ ZEND_METHOD(reflection_class, getEndLine) } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS) { - RETURN_LONG(ce->info.user.line_end); + RETURN_INT(ce->info.user.line_end); } RETURN_FALSE; } @@ -4137,7 +4137,7 @@ ZEND_METHOD(reflection_class, getModifiers) } GET_REFLECTION_OBJECT_PTR(ce); - RETURN_LONG(ce->ce_flags & ~ZEND_ACC_CONSTANTS_UPDATED); + RETURN_INT(ce->ce_flags & ~ZEND_ACC_CONSTANTS_UPDATED); } /* }}} */ @@ -4648,7 +4648,7 @@ ZEND_METHOD(reflection_class, inNamespace) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_TRUE; @@ -4671,7 +4671,7 @@ ZEND_METHOD(reflection_class, getNamespaceName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name)); @@ -4694,10 +4694,10 @@ ZEND_METHOD(reflection_class, getShortName) RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING - && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name))) + && (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRSIZE_P(name))) && backslash > Z_STRVAL_P(name)) { - RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1)); + RETURN_STRINGL(backslash + 1, Z_STRSIZE_P(name) - (backslash - Z_STRVAL_P(name) + 1)); } RETURN_ZVAL(name, 1, 0); } @@ -4917,7 +4917,7 @@ ZEND_METHOD(reflection_property, getModifiers) } GET_REFLECTION_OBJECT_PTR(ref); - RETURN_LONG(ref->prop.flags); + RETURN_INT(ref->prop.flags); } /* }}} */ @@ -6048,8 +6048,8 @@ static void _reflection_write_property(zval *object, zval *member, zval *value, { if ((Z_TYPE_P(member) == IS_STRING) && zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member)) - && ((Z_STRLEN_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name"))) - || (Z_STRLEN_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class"))))) + && ((Z_STRSIZE_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name"))) + || (Z_STRSIZE_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class"))))) { zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Cannot set read-only property %s::$%s", Z_OBJCE_P(object)->name->val, Z_STRVAL_P(member)); @@ -6092,7 +6092,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr TSRMLS_CC); zend_declare_property_string(reflection_function_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED); + REGISTER_REFLECTION_CLASS_CONST_INT(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionParameter", reflection_parameter_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6106,12 +6106,12 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ zend_declare_property_string(reflection_method_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); zend_declare_property_string(reflection_method_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_STATIC", ZEND_ACC_STATIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PUBLIC", ZEND_ACC_PUBLIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PROTECTED", ZEND_ACC_PROTECTED); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PRIVATE", ZEND_ACC_PRIVATE); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT); - REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_FINAL", ZEND_ACC_FINAL); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_STATIC", ZEND_ACC_STATIC); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PUBLIC", ZEND_ACC_PUBLIC); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PROTECTED", ZEND_ACC_PROTECTED); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_PRIVATE", ZEND_ACC_PRIVATE); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT); + REGISTER_REFLECTION_CLASS_CONST_INT(method, "IS_FINAL", ZEND_ACC_FINAL); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClass", reflection_class_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6119,9 +6119,9 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ zend_class_implements(reflection_class_ptr TSRMLS_CC, 1, reflector_ptr); zend_declare_property_string(reflection_class_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_IMPLICIT_ABSTRACT", ZEND_ACC_IMPLICIT_ABSTRACT_CLASS); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); - REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_FINAL", ZEND_ACC_FINAL_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_IMPLICIT_ABSTRACT", ZEND_ACC_IMPLICIT_ABSTRACT_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + REGISTER_REFLECTION_CLASS_CONST_INT(class, "IS_FINAL", ZEND_ACC_FINAL_CLASS); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", reflection_object_functions); _reflection_entry.create_object = reflection_objects_new; @@ -6134,10 +6134,10 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ zend_declare_property_string(reflection_property_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); zend_declare_property_string(reflection_property_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_STATIC", ZEND_ACC_STATIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PUBLIC", ZEND_ACC_PUBLIC); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PROTECTED", ZEND_ACC_PROTECTED); - REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PRIVATE", ZEND_ACC_PRIVATE); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_STATIC", ZEND_ACC_STATIC); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PUBLIC", ZEND_ACC_PUBLIC); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PROTECTED", ZEND_ACC_PROTECTED); + REGISTER_REFLECTION_CLASS_CONST_INT(property, "IS_PRIVATE", ZEND_ACC_PRIVATE); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionExtension", reflection_extension_functions); _reflection_entry.create_object = reflection_objects_new; diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c index f9a642410f..a938ac05c0 100644 --- a/ext/spl/php_spl.c +++ b/ext/spl/php_spl.c @@ -417,8 +417,8 @@ PHP_FUNCTION(spl_autoload_call) if (SPL_G(autoload_functions)) { int l_autoload_running = SPL_G(autoload_running); SPL_G(autoload_running) = 1; - lc_name = STR_ALLOC(Z_STRLEN_P(class_name), 0); - zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name)); + lc_name = STR_ALLOC(Z_STRSIZE_P(class_name), 0); + zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(class_name), Z_STRSIZE_P(class_name)); ZEND_HASH_FOREACH_STR_KEY_PTR(SPL_G(autoload_functions), func_name, alfi) { zend_call_method(Z_ISUNDEF(alfi->obj)? NULL : &alfi->obj, alfi->ce, &alfi->func_ptr, func_name->val, func_name->len, retval, 1, class_name, NULL TSRMLS_CC); zend_exception_save(TSRMLS_C); diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 720a704e92..23f48c802f 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -66,7 +66,7 @@ typedef struct _spl_array_object { zval array; zval retval; HashPosition pos; - ulong pos_h; + php_uint_t pos_h; int ar_flags; int is_self; zend_function *fptr_offset_get; @@ -300,7 +300,7 @@ static zend_object *spl_array_object_clone(zval *zobject TSRMLS_DC) static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */ { zval *retval; - long index; + php_int_t index; zend_string *offset_key; spl_array_object *intern = Z_SPLARRAY_P(object); HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); @@ -360,11 +360,11 @@ fetch_dim_string: } return retval; case IS_RESOURCE: - zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_P(offset)->handle, Z_RES_P(offset)->handle); + zend_error(E_STRICT, "Resource ID#%pd used as offset, casting to integer (%pd)", Z_RES_P(offset)->handle, Z_RES_P(offset)->handle); index = Z_RES_P(offset)->handle; goto num_index; case IS_DOUBLE: - index = (long)Z_DVAL_P(offset); + index = (php_int_t)Z_DVAL_P(offset); goto num_index; case IS_FALSE: index = 0; @@ -372,19 +372,19 @@ fetch_dim_string: case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: if ((retval = zend_hash_index_find(ht, index)) == NULL) { switch (type) { case BP_VAR_R: - zend_error(E_NOTICE, "Undefined offset: %ld", index); + zend_error(E_NOTICE, "Undefined offset: %pd", index); case BP_VAR_UNSET: case BP_VAR_IS: retval = &EG(uninitialized_zval); break; case BP_VAR_RW: - zend_error(E_NOTICE, "Undefined offset: %ld", index); + zend_error(E_NOTICE, "Undefined offset: %pd", index); case BP_VAR_W: { zval value; ZVAL_UNDEF(&value); @@ -450,7 +450,7 @@ static zval *spl_array_read_dimension(zval *object, zval *offset, int type, zval static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */ { spl_array_object *intern = Z_SPLARRAY_P(object); - long index; + php_int_t index; HashTable *ht; if (check_inherited && intern->fptr_offset_set) { @@ -504,8 +504,8 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (ht->u.v.nApplyCount > 0) { @@ -535,7 +535,7 @@ static void spl_array_write_dimension(zval *object, zval *offset, zval *value TS static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval *offset TSRMLS_DC) /* {{{ */ { - long index; + php_int_t index; HashTable *ht; spl_array_object *intern = Z_SPLARRAY_P(object); @@ -585,7 +585,7 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval } break; case IS_DOUBLE: - index = (long)Z_DVAL_P(offset); + index = (php_int_t)Z_DVAL_P(offset); goto num_index; case IS_RESOURCE: index = Z_RES_HANDLE_P(offset); @@ -596,8 +596,8 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); if (ht->u.v.nApplyCount > 0) { @@ -605,7 +605,7 @@ num_index: return; } if (zend_hash_index_del(ht, index) == FAILURE) { - zend_error(E_NOTICE,"Undefined offset: %ld", index); + zend_error(E_NOTICE,"Undefined offset: %pd", index); } break; default: @@ -623,7 +623,7 @@ static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* { static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */ { spl_array_object *intern = Z_SPLARRAY_P(object); - long index; + php_int_t index; zval rv, *value = NULL, *tmp; if (check_inherited && intern->fptr_offset_has) { @@ -664,7 +664,7 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o break; case IS_DOUBLE: - index = (long)Z_DVAL_P(offset); + index = (php_int_t)Z_DVAL_P(offset); goto num_index; case IS_RESOURCE: index = Z_RES_HANDLE_P(offset); @@ -675,8 +675,8 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o case IS_TRUE: index = 1; goto num_index; - case IS_LONG: - index = Z_LVAL_P(offset); + case IS_INT: + index = Z_IVAL_P(offset); num_index: if ((tmp = zend_hash_index_find(ht, index)) != NULL) { if (check_empty == 2) { @@ -957,7 +957,7 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ ht2 = spl_array_get_hash_table(intern2, 0 TSRMLS_CC); zend_compare_symbol_tables(&temp_zv, ht1, ht2 TSRMLS_CC); - result = (int)Z_LVAL(temp_zv); + result = (int)Z_IVAL(temp_zv); /* if we just compared std.properties, don't do it again */ if (result == 0 && !(ht1 == intern1->std.properties && ht2 == intern2->std.properties)) { @@ -969,7 +969,7 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */ static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */ { zend_string *string_key; - ulong num_key; + php_uint_t num_key; zval *data; if (Z_TYPE(intern->array) == IS_OBJECT) { @@ -1141,7 +1141,7 @@ static void spl_array_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */ /* }}} */ /* {{{ spl_array_set_array */ -static void spl_array_set_array(zval *object, spl_array_object *intern, zval *array, long ar_flags, int just_array TSRMLS_DC) { +static void spl_array_set_array(zval *object, spl_array_object *intern, zval *array, php_int_t ar_flags, int just_array TSRMLS_DC) { if (Z_TYPE_P(array) == IS_ARRAY) { SEPARATE_ZVAL_IF_NOT_REF(array); @@ -1223,7 +1223,7 @@ SPL_METHOD(Array, __construct) zval *object = getThis(); spl_array_object *intern; zval *array; - long ar_flags = 0; + php_int_t ar_flags = 0; zend_class_entry *ce_get_iterator = spl_ce_Iterator; zend_error_handling error_handling; @@ -1302,7 +1302,7 @@ SPL_METHOD(Array, getFlags) return; } - RETURN_LONG(intern->ar_flags & ~SPL_ARRAY_INT_MASK); + RETURN_INT(intern->ar_flags & ~SPL_ARRAY_INT_MASK); } /* }}} */ @@ -1312,9 +1312,9 @@ SPL_METHOD(Array, setFlags) { zval *object = getThis(); spl_array_object *intern = Z_SPLARRAY_P(object); - long ar_flags = 0; + php_int_t ar_flags = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ar_flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &ar_flags) == FAILURE) { return; } @@ -1381,13 +1381,13 @@ SPL_METHOD(Array, rewind) Seek to position. */ SPL_METHOD(Array, seek) { - long opos, position; + php_int_t opos, position; zval *object = getThis(); spl_array_object *intern = Z_SPLARRAY_P(object); HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); int result; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &position) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &position) == FAILURE) { return; } @@ -1408,10 +1408,10 @@ SPL_METHOD(Array, seek) return; /* ok */ } } - zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Seek position %ld is out of range", opos); + zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Seek position %pd is out of range", opos); } /* }}} */ -int static spl_array_object_count_elements_helper(spl_array_object *intern, long *count TSRMLS_DC) /* {{{ */ +int static spl_array_object_count_elements_helper(spl_array_object *intern, php_int_t *count TSRMLS_DC) /* {{{ */ { HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC); HashPosition pos; @@ -1439,7 +1439,7 @@ int static spl_array_object_count_elements_helper(spl_array_object *intern, long } } /* }}} */ -int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */ +int spl_array_object_count_elements(zval *object, php_int_t *count TSRMLS_DC) /* {{{ */ { spl_array_object *intern = Z_SPLARRAY_P(object); @@ -1449,8 +1449,8 @@ int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ if (Z_TYPE(rv) != IS_UNDEF) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long)Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (php_int_t)Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -1464,7 +1464,7 @@ int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ Return the number of elements in the Iterator. */ SPL_METHOD(Array, count) { - long count; + php_int_t count; spl_array_object *intern = Z_SPLARRAY_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { @@ -1473,7 +1473,7 @@ SPL_METHOD(Array, count) spl_array_object_count_elements_helper(intern, &count TSRMLS_CC); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ static void spl_array_method(INTERNAL_FUNCTION_PARAMETERS, char *fname, int fname_len, int use_arg) /* {{{ */ @@ -1706,7 +1706,7 @@ SPL_METHOD(Array, getChildren) } } - ZVAL_LONG(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags); + ZVAL_INT(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags); spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, entry, &flags TSRMLS_CC); } /* }}} */ @@ -1733,7 +1733,7 @@ SPL_METHOD(Array, serialize) PHP_VAR_SERIALIZE_INIT(var_hash); - ZVAL_LONG(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK)); + ZVAL_INT(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK)); /* storage */ smart_str_appendl(&buf, "x:", 2); @@ -1781,7 +1781,7 @@ SPL_METHOD(Array, unserialize) php_unserialize_data_t var_hash; zval members, zflags; HashTable *aht; - long flags; + php_int_t flags; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) { return; @@ -1806,12 +1806,12 @@ SPL_METHOD(Array, unserialize) } ++p; - if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_LONG) { + if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_INT) { goto outexcept; } --p; /* for ';' */ - flags = Z_LVAL(zflags); + flags = Z_IVAL(zflags); /* flags needs to be verified and we also need to verify whether the next * thing we get is ';'. After that we require an 'm' or somethign else * where 'm' stands for members and anything else should be an array. If @@ -1861,7 +1861,7 @@ SPL_METHOD(Array, unserialize) outexcept: PHP_VAR_UNSERIALIZE_DESTROY(var_hash); - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %pd of %d bytes", (php_int_t)((char*)p - buf), buf_len); return; } /* }}} */ @@ -2018,13 +2018,13 @@ PHP_MINIT_FUNCTION(spl_array) REGISTER_SPL_IMPLEMENTS(RecursiveArrayIterator, RecursiveIterator); spl_ce_RecursiveArrayIterator->get_iterator = spl_array_get_iterator; - REGISTER_SPL_CLASS_CONST_LONG(ArrayObject, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); - REGISTER_SPL_CLASS_CONST_LONG(ArrayObject, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); + REGISTER_SPL_CLASS_CONST_INT(ArrayObject, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); + REGISTER_SPL_CLASS_CONST_INT(ArrayObject, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); - REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); - REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); + REGISTER_SPL_CLASS_CONST_INT(ArrayIterator, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST); + REGISTER_SPL_CLASS_CONST_INT(ArrayIterator, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveArrayIterator, "CHILD_ARRAYS_ONLY", SPL_ARRAY_CHILD_ARRAYS_ONLY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveArrayIterator, "CHILD_ARRAYS_ONLY", SPL_ARRAY_CHILD_ARRAYS_ONLY); return SUCCESS; } diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index f9fe83e26d..9c940433df 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -671,19 +671,19 @@ zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend #define DIT_CTOR_FLAGS 0x00000001 #define DIT_CTOR_GLOB 0x00000002 -void spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAMETERS, long ctor_flags) /* {{{ */ +void spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAMETERS, php_int_t ctor_flags) /* {{{ */ { spl_filesystem_object *intern; char *path; int parsed, len; - long flags; + php_int_t flags; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC); if (SPL_HAS_FLAG(ctor_flags, DIT_CTOR_FLAGS)) { flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO; - parsed = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &path, &len, &flags); + parsed = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &path, &len, &flags); } else { flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_SELF; parsed = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &len); @@ -767,7 +767,7 @@ SPL_METHOD(DirectoryIterator, key) } if (intern->u.dir.dirp) { - RETURN_LONG(intern->u.dir.index); + RETURN_INT(intern->u.dir.index); } else { RETURN_FALSE; } @@ -813,9 +813,9 @@ SPL_METHOD(DirectoryIterator, seek) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); zval retval; - long pos; + php_int_t pos; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pos) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &pos) == FAILURE) { return; } @@ -1445,7 +1445,7 @@ SPL_METHOD(FilesystemIterator, getFlags) return; } - RETURN_LONG(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK)); + RETURN_INT(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK)); } /* }}} */ /* {{{ proto void FilesystemIterator::setFlags(long $flags) @@ -1453,9 +1453,9 @@ SPL_METHOD(FilesystemIterator, getFlags) SPL_METHOD(FilesystemIterator, setFlags) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); - long flags; + php_int_t flags; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &flags) == FAILURE) { return; } @@ -1506,7 +1506,7 @@ SPL_METHOD(RecursiveDirectoryIterator, getChildren) if (SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) { RETURN_STRINGL(intern->file_name, intern->file_name_len); } else { - ZVAL_LONG(&zflags, intern->flags); + ZVAL_INT(&zflags, intern->flags); ZVAL_STRINGL(&zpath, intern->file_name, intern->file_name_len); spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, &zpath, &zflags TSRMLS_CC); zval_ptr_dtor(&zpath); @@ -1597,7 +1597,7 @@ SPL_METHOD(GlobIterator, count) } if (intern->u.dir.dirp && php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) { - RETURN_LONG(php_glob_stream_get_count(intern->u.dir.dirp, NULL)); + RETURN_INT(php_glob_stream_get_count(intern->u.dir.dirp, NULL)); } else { /* should not happen */ php_error_docref(NULL TSRMLS_CC, E_ERROR, "GlobIterator lost glob state"); @@ -1686,7 +1686,7 @@ static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval * { spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC); - ZVAL_LONG(key, object->u.dir.index); + ZVAL_INT(key, object->u.dir.index); } /* }}} */ @@ -2025,7 +2025,7 @@ static int spl_filesystem_file_read(spl_filesystem_object *intern, int silent TS { char *buf; size_t line_len = 0; - long line_add = (intern->u.file.current_line || !Z_ISUNDEF(intern->u.file.current_zval)) ? 1 : 0; + php_int_t line_add = (intern->u.file.current_line || !Z_ISUNDEF(intern->u.file.current_zval)) ? 1 : 0; spl_filesystem_file_free_line(intern TSRMLS_CC); @@ -2177,8 +2177,8 @@ static int spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesystem_obje } spl_filesystem_file_free_line(intern TSRMLS_CC); if (Z_TYPE(retval) == IS_STRING) { - intern->u.file.current_line = estrndup(Z_STRVAL(retval), Z_STRLEN(retval)); - intern->u.file.current_line_len = Z_STRLEN(retval); + intern->u.file.current_line = estrndup(Z_STRVAL(retval), Z_STRSIZE(retval)); + intern->u.file.current_line_len = Z_STRSIZE(retval); } else { ZVAL_ZVAL(&intern->u.file.current_zval, &retval, 1, 0); } @@ -2199,7 +2199,7 @@ static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRML } else if (!Z_ISUNDEF(intern->u.file.current_zval)) { switch(Z_TYPE(intern->u.file.current_zval)) { case IS_STRING: - return Z_STRLEN(intern->u.file.current_zval) == 0; + return Z_STRSIZE(intern->u.file.current_zval) == 0; case IS_ARRAY: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) && zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 1) { @@ -2210,7 +2210,7 @@ static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRML idx++; } first = &Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val; - return Z_TYPE_P(first) == IS_STRING && Z_STRLEN_P(first) == 0; + return Z_TYPE_P(first) == IS_STRING && Z_STRSIZE_P(first) == 0; } return zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 0; case IS_NULL: @@ -2319,14 +2319,14 @@ SPL_METHOD(SplFileObject, __construct) Construct a new temp file object */ SPL_METHOD(SplTempFileObject, __construct) { - long max_memory = PHP_STREAM_MAX_MEM; + php_int_t max_memory = PHP_STREAM_MAX_MEM; char tmp_fname[48]; spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &max_memory) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &max_memory) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } @@ -2463,7 +2463,7 @@ SPL_METHOD(SplFileObject, key) if (!intern->current_line) { spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC); } */ - RETURN_LONG(intern->u.file.current_line_num); + RETURN_INT(intern->u.file.current_line_num); } /* }}} */ /* {{{ proto void SplFileObject::next() @@ -2504,7 +2504,7 @@ SPL_METHOD(SplFileObject, getFlags) return; } - RETURN_LONG(intern->flags & SPL_FILE_OBJECT_MASK); + RETURN_INT(intern->flags & SPL_FILE_OBJECT_MASK); } /* }}} */ /* {{{ proto void SplFileObject::setMaxLineLen(int max_len) @@ -2537,7 +2537,7 @@ SPL_METHOD(SplFileObject, getMaxLineLen) return; } - RETURN_LONG((long)intern->u.file.max_line_len); + RETURN_INT((php_int_t)intern->u.file.max_line_len); } /* }}} */ /* {{{ proto bool SplFileObject::hasChildren() @@ -2649,7 +2649,7 @@ SPL_METHOD(SplFileObject, fputcsv) break; } ret = php_fputcsv(intern->u.file.stream, fields, delimiter, enclosure, escape TSRMLS_CC); - RETURN_LONG(ret); + RETURN_INT(ret); } } /* }}} */ @@ -2740,7 +2740,7 @@ SPL_METHOD(SplFileObject, fflush) SPL_METHOD(SplFileObject, ftell) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); - long ret; + php_int_t ret; if(!intern->u.file.stream) { zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Object not initialized"); @@ -2752,7 +2752,7 @@ SPL_METHOD(SplFileObject, ftell) if (ret == -1) { RETURN_FALSE; } else { - RETURN_LONG(ret); + RETURN_INT(ret); } } /* }}} */ @@ -2761,9 +2761,9 @@ SPL_METHOD(SplFileObject, ftell) SPL_METHOD(SplFileObject, fseek) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); - long pos, whence = SEEK_SET; + php_int_t pos, whence = SEEK_SET; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &pos, &whence) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i|i", &pos, &whence) == FAILURE) { return; } @@ -2773,7 +2773,7 @@ SPL_METHOD(SplFileObject, fseek) } spl_filesystem_file_free_line(intern TSRMLS_CC); - RETURN_LONG(php_stream_seek(intern->u.file.stream, pos, whence)); + RETURN_INT(php_stream_seek(intern->u.file.stream, pos, whence)); } /* }}} */ /* {{{ proto int SplFileObject::fgetc() @@ -2819,9 +2819,9 @@ SPL_METHOD(SplFileObject, fgetss) } if (intern->u.file.max_line_len > 0) { - ZVAL_LONG(&arg2, intern->u.file.max_line_len); + ZVAL_INT(&arg2, intern->u.file.max_line_len); } else { - ZVAL_LONG(&arg2, 1024); + ZVAL_INT(&arg2, 1024); } spl_filesystem_file_free_line(intern TSRMLS_CC); @@ -2841,7 +2841,7 @@ SPL_METHOD(SplFileObject, fpassthru) return; } - RETURN_LONG(php_stream_passthru(intern->u.file.stream)); + RETURN_INT(php_stream_passthru(intern->u.file.stream)); } /* }}} */ /* {{{ proto bool SplFileObject::fscanf(string format [, string ...]) @@ -2869,9 +2869,9 @@ SPL_METHOD(SplFileObject, fwrite) spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); char *str; int str_len; - long length = 0; + php_int_t length = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &length) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &str, &str_len, &length) == FAILURE) { return; } @@ -2884,10 +2884,10 @@ SPL_METHOD(SplFileObject, fwrite) str_len = MAX(0, MIN(length, str_len)); } if (!str_len) { - RETURN_LONG(0); + RETURN_INT(0); } - RETURN_LONG(php_stream_write(intern->u.file.stream, str, str_len)); + RETURN_INT(php_stream_write(intern->u.file.stream, str, str_len)); } /* }}} */ SPL_METHOD(SplFileObject, fread) @@ -2910,10 +2910,10 @@ SPL_METHOD(SplFileObject, fread) } ZVAL_STR(return_value, STR_ALLOC(length, 0)); - Z_STRLEN_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length); + Z_STRSIZE_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length); /* needed because recv/read/gzread doesnt put a null at the end*/ - Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0; + Z_STRVAL_P(return_value)[Z_STRSIZE_P(return_value)] = 0; } /* {{{ proto bool SplFileObject::fstat() @@ -2926,9 +2926,9 @@ FileFunction(fstat) SPL_METHOD(SplFileObject, ftruncate) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); - long size; + php_int_t size; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &size) == FAILURE) { return; } @@ -2950,9 +2950,9 @@ SPL_METHOD(SplFileObject, ftruncate) SPL_METHOD(SplFileObject, seek) { spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); - long line_pos; + php_int_t line_pos; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &line_pos) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &line_pos) == FAILURE) { return; } if(!intern->u.file.stream) { @@ -2961,7 +2961,7 @@ SPL_METHOD(SplFileObject, seek) } if (line_pos < 0) { - zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Can't seek file %s to negative line %ld", intern->file_name, line_pos); + zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Can't seek file %s to negative line %pd", intern->file_name, line_pos); RETURN_FALSE; } @@ -3110,18 +3110,18 @@ PHP_MINIT_FUNCTION(spl_directory) REGISTER_SPL_SUB_CLASS_EX(FilesystemIterator, DirectoryIterator, spl_filesystem_object_new, spl_FilesystemIterator_functions); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_FILEINFO", SPL_FILE_DIR_CURRENT_AS_FILEINFO); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_SELF", SPL_FILE_DIR_CURRENT_AS_SELF); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_MODE_MASK", SPL_FILE_DIR_KEY_MODE_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_PATHNAME", SPL_FILE_DIR_KEY_AS_PATHNAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "FOLLOW_SYMLINKS", SPL_FILE_DIR_FOLLOW_SYMLINKS); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_FILENAME", SPL_FILE_DIR_KEY_AS_FILENAME); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "NEW_CURRENT_AND_KEY", SPL_FILE_DIR_KEY_AS_FILENAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "OTHER_MODE_MASK", SPL_FILE_DIR_OTHERS_MASK); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "SKIP_DOTS", SPL_FILE_DIR_SKIPDOTS); - REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "UNIX_PATHS", SPL_FILE_DIR_UNIXPATHS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_FILEINFO", SPL_FILE_DIR_CURRENT_AS_FILEINFO); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "CURRENT_AS_SELF", SPL_FILE_DIR_CURRENT_AS_SELF); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_MODE_MASK", SPL_FILE_DIR_KEY_MODE_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_AS_PATHNAME", SPL_FILE_DIR_KEY_AS_PATHNAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "FOLLOW_SYMLINKS", SPL_FILE_DIR_FOLLOW_SYMLINKS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "KEY_AS_FILENAME", SPL_FILE_DIR_KEY_AS_FILENAME); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "NEW_CURRENT_AND_KEY", SPL_FILE_DIR_KEY_AS_FILENAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "OTHER_MODE_MASK", SPL_FILE_DIR_OTHERS_MASK); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "SKIP_DOTS", SPL_FILE_DIR_SKIPDOTS); + REGISTER_SPL_CLASS_CONST_INT(FilesystemIterator, "UNIX_PATHS", SPL_FILE_DIR_UNIXPATHS); spl_ce_FilesystemIterator->get_iterator = spl_filesystem_tree_get_iterator; @@ -3140,10 +3140,10 @@ PHP_MINIT_FUNCTION(spl_directory) REGISTER_SPL_IMPLEMENTS(SplFileObject, RecursiveIterator); REGISTER_SPL_IMPLEMENTS(SplFileObject, SeekableIterator); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "DROP_NEW_LINE", SPL_FILE_OBJECT_DROP_NEW_LINE); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_AHEAD", SPL_FILE_OBJECT_READ_AHEAD); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY); - REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "DROP_NEW_LINE", SPL_FILE_OBJECT_DROP_NEW_LINE); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "READ_AHEAD", SPL_FILE_OBJECT_READ_AHEAD); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY); + REGISTER_SPL_CLASS_CONST_INT(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV); REGISTER_SPL_SUB_CLASS_EX(SplTempFileObject, SplFileObject, spl_filesystem_object_new_check, spl_SplTempFileObject_functions); return SUCCESS; diff --git a/ext/spl/spl_directory.h b/ext/spl/spl_directory.h index 3276d51463..a958e30874 100644 --- a/ext/spl/spl_directory.h +++ b/ext/spl/spl_directory.h @@ -68,7 +68,7 @@ struct _spl_filesystem_object { char *file_name; int file_name_len; SPL_FS_OBJ_TYPE type; - long flags; + php_int_t flags; zend_class_entry *file_class; zend_class_entry *info_class; union { @@ -93,7 +93,7 @@ struct _spl_filesystem_object { char *current_line; size_t current_line_len; size_t max_line_len; - long current_line_num; + php_int_t current_line_num; zval zresource; zend_function *func_getCurr; char delimiter; diff --git a/ext/spl/spl_dllist.c b/ext/spl/spl_dllist.c index 09d874645d..49b7271c22 100644 --- a/ext/spl/spl_dllist.c +++ b/ext/spl/spl_dllist.c @@ -143,9 +143,9 @@ static spl_ptr_llist *spl_ptr_llist_init(spl_ptr_llist_ctor_func ctor, spl_ptr_l } /* }}} */ -static long spl_ptr_llist_count(spl_ptr_llist *llist) /* {{{ */ +static php_int_t spl_ptr_llist_count(spl_ptr_llist *llist) /* {{{ */ { - return (long)llist->count; + return (php_int_t)llist->count; } /* }}} */ @@ -167,7 +167,7 @@ static void spl_ptr_llist_destroy(spl_ptr_llist *llist TSRMLS_DC) /* {{{ */ } /* }}} */ -static spl_ptr_llist_element *spl_ptr_llist_offset(spl_ptr_llist *llist, long offset, int backward) /* {{{ */ +static spl_ptr_llist_element *spl_ptr_llist_offset(spl_ptr_llist *llist, php_int_t offset, int backward) /* {{{ */ { spl_ptr_llist_element *current; @@ -474,7 +474,7 @@ static zend_object *spl_dllist_object_clone(zval *zobject TSRMLS_DC) /* {{{ */ } /* }}} */ -static int spl_dllist_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */ +static int spl_dllist_object_count_elements(zval *object, php_int_t *count TSRMLS_DC) /* {{{ */ { spl_dllist_object *intern = Z_SPLDLLIST_P(object); @@ -484,8 +484,8 @@ static int spl_dllist_object_count_elements(zval *object, long *count TSRMLS_DC) if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (php_int_t) Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -520,7 +520,7 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1 TSRMLS_CC); - ZVAL_LONG(&tmp, intern->flags); + ZVAL_INT(&tmp, intern->flags); zend_hash_add(intern->debug_info, pnstr, &tmp); STR_RELEASE(pnstr); @@ -673,7 +673,7 @@ SPL_METHOD(SplDoublyLinkedList, bottom) Return the number of elements in the datastructure. */ SPL_METHOD(SplDoublyLinkedList, count) { - long count; + php_int_t count; spl_dllist_object *intern = Z_SPLDLLIST_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { @@ -681,7 +681,7 @@ SPL_METHOD(SplDoublyLinkedList, count) } count = spl_ptr_llist_count(intern->llist); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -689,7 +689,7 @@ SPL_METHOD(SplDoublyLinkedList, count) Return true if the SplDoublyLinkedList is empty. */ SPL_METHOD(SplDoublyLinkedList, isEmpty) { - long count; + php_int_t count; if (zend_parse_parameters_none() == FAILURE) { return; @@ -704,10 +704,10 @@ SPL_METHOD(SplDoublyLinkedList, isEmpty) Set the mode of iteration */ SPL_METHOD(SplDoublyLinkedList, setIteratorMode) { - long value; + php_int_t value; spl_dllist_object *intern; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &value) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &value) == FAILURE) { return; } @@ -721,7 +721,7 @@ SPL_METHOD(SplDoublyLinkedList, setIteratorMode) intern->flags = value & SPL_DLLIST_IT_MASK; - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -737,7 +737,7 @@ SPL_METHOD(SplDoublyLinkedList, getIteratorMode) intern = Z_SPLDLLIST_P(getThis()); - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -747,14 +747,14 @@ SPL_METHOD(SplDoublyLinkedList, offsetExists) { zval *zindex; spl_dllist_object *intern; - long index; + php_int_t index; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zindex) == FAILURE) { return; } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); RETURN_BOOL(index >= 0 && index < intern->llist->count); } /* }}} */ @@ -764,7 +764,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetExists) SPL_METHOD(SplDoublyLinkedList, offsetGet) { zval *zindex; - long index; + php_int_t index; spl_dllist_object *intern; spl_ptr_llist_element *element; @@ -773,7 +773,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetGet) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index >= intern->llist->count) { zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid or out of range", 0 TSRMLS_CC); @@ -808,10 +808,10 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet) spl_ptr_llist_push(intern->llist, value TSRMLS_CC); } else { /* $obj[$foo] = ... */ - long index; + php_int_t index; spl_ptr_llist_element *element; - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index >= intern->llist->count) { zval_ptr_dtor(value); @@ -849,7 +849,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet) SPL_METHOD(SplDoublyLinkedList, offsetUnset) { zval *zindex; - long index; + php_int_t index; spl_dllist_object *intern; spl_ptr_llist_element *element; spl_ptr_llist *llist; @@ -859,7 +859,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetUnset) } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); llist = intern->llist; if (index < 0 || index >= intern->llist->count) { @@ -1006,7 +1006,7 @@ static void spl_dllist_it_get_current_key(zend_object_iterator *iter, zval *key { spl_dllist_it *iterator = (spl_dllist_it *)iter; - ZVAL_LONG(key, iterator->traverse_position); + ZVAL_INT(key, iterator->traverse_position); } /* }}} */ @@ -1031,7 +1031,7 @@ SPL_METHOD(SplDoublyLinkedList, key) return; } - RETURN_LONG(intern->traverse_position); + RETURN_INT(intern->traverse_position); } /* }}} */ @@ -1127,7 +1127,7 @@ SPL_METHOD(SplDoublyLinkedList, serialize) PHP_VAR_SERIALIZE_INIT(var_hash); /* flags */ - ZVAL_LONG(&flags, intern->flags); + ZVAL_INT(&flags, intern->flags); php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC); zval_ptr_dtor(&flags); @@ -1181,12 +1181,12 @@ SPL_METHOD(SplDoublyLinkedList, unserialize) goto error; } - if (Z_TYPE(flags) != IS_LONG) { + if (Z_TYPE(flags) != IS_INT) { zval_ptr_dtor(&flags); goto error; } - intern->flags = Z_LVAL(flags); + intern->flags = Z_IVAL(flags); zval_ptr_dtor(&flags); /* elements */ @@ -1221,14 +1221,14 @@ SPL_METHOD(SplDoublyLinkedList, add) zval *zindex, *value; spl_dllist_object *intern; spl_ptr_llist_element *element; - long index; + php_int_t index; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &zindex, &value) == FAILURE) { return; } intern = Z_SPLDLLIST_P(getThis()); - index = spl_offset_convert_to_long(zindex TSRMLS_CC); + index = spl_offset_convert_to_int(zindex TSRMLS_CC); if (index < 0 || index > intern->llist->count) { zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid or out of range", 0 TSRMLS_CC); @@ -1385,10 +1385,10 @@ PHP_MINIT_FUNCTION(spl_dllist) /* {{{ */ spl_handler_SplDoublyLinkedList.dtor_obj = zend_objects_destroy_object; spl_handler_SplDoublyLinkedList.free_obj = spl_dllist_object_free_storage; - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_LIFO", SPL_DLLIST_IT_LIFO); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_FIFO", 0); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_DELETE",SPL_DLLIST_IT_DELETE); - REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_KEEP", 0); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_LIFO", SPL_DLLIST_IT_LIFO); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_FIFO", 0); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_DELETE",SPL_DLLIST_IT_DELETE); + REGISTER_SPL_CLASS_CONST_INT(SplDoublyLinkedList, "IT_MODE_KEEP", 0); REGISTER_SPL_IMPLEMENTS(SplDoublyLinkedList, Iterator); REGISTER_SPL_IMPLEMENTS(SplDoublyLinkedList, Countable); diff --git a/ext/spl/spl_engine.c b/ext/spl/spl_engine.c index 0cfcb8ee18..1cae08e652 100644 --- a/ext/spl/spl_engine.c +++ b/ext/spl/spl_engine.c @@ -40,9 +40,9 @@ PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) } /* }}} */ -PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC) /* {{{ */ +PHPAPI php_int_t spl_offset_convert_to_int(zval *offset TSRMLS_DC) /* {{{ */ { - ulong idx; + php_uint_t idx; switch (Z_TYPE_P(offset)) { case IS_STRING: @@ -51,9 +51,9 @@ PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC) /* {{{ */ } break; case IS_DOUBLE: - return (long)Z_DVAL_P(offset); - case IS_LONG: - return Z_LVAL_P(offset); + return (php_int_t)Z_DVAL_P(offset); + case IS_INT: + return Z_IVAL_P(offset); case IS_FALSE: return 0; case IS_TRUE: diff --git a/ext/spl/spl_engine.h b/ext/spl/spl_engine.h index 8c72ca9691..f5a58e835e 100644 --- a/ext/spl/spl_engine.h +++ b/ext/spl/spl_engine.h @@ -27,7 +27,7 @@ PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC); -PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC); +PHPAPI php_int_t spl_offset_convert_to_int(zval *offset TSRMLS_DC); /* {{{ spl_instantiate_arg_ex1 */ static inline int spl_instantiate_arg_ex1(zend_class_entry *pce, zval *retval, zval *arg1 TSRMLS_DC) diff --git a/ext/spl/spl_fixedarray.c b/ext/spl/spl_fixedarray.c index 62aaffbc3c..6109b35b6d 100644 --- a/ext/spl/spl_fixedarray.c +++ b/ext/spl/spl_fixedarray.c @@ -43,7 +43,7 @@ ZEND_GET_MODULE(spl_fixedarray) #endif typedef struct _spl_fixedarray { /* {{{ */ - long size; + php_int_t size; zval *elements; } spl_fixedarray; /* }}} */ @@ -81,7 +81,7 @@ static inline spl_fixedarray_object *spl_fixed_array_from_obj(zend_object *obj) #define Z_SPLFIXEDARRAY_P(zv) spl_fixed_array_from_obj(Z_OBJ_P((zv))) -static void spl_fixedarray_init(spl_fixedarray *array, long size TSRMLS_DC) /* {{{ */ +static void spl_fixedarray_init(spl_fixedarray *array, php_int_t size TSRMLS_DC) /* {{{ */ { if (size > 0) { array->size = 0; /* reset size in case ecalloc() fails */ @@ -94,7 +94,7 @@ static void spl_fixedarray_init(spl_fixedarray *array, long size TSRMLS_DC) /* { } /* }}} */ -static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /* {{{ */ +static void spl_fixedarray_resize(spl_fixedarray *array, php_int_t size TSRMLS_DC) /* {{{ */ { if (size == array->size) { /* nothing to do */ @@ -109,7 +109,7 @@ static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /* /* clearing the array */ if (size == 0) { - long i; + php_int_t i; for (i = 0; i < array->size; i++) { zval_ptr_dtor(&(array->elements[i])); @@ -123,7 +123,7 @@ static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /* array->elements = safe_erealloc(array->elements, size, sizeof(zval), 0); memset(array->elements + array->size, '\0', sizeof(zval) * (size - array->size)); } else { /* size < array->size */ - long i; + php_int_t i; for (i = size; i < array->size; i++) { zval_ptr_dtor(&(array->elements[i])); @@ -194,7 +194,7 @@ static HashTable* spl_fixedarray_object_get_properties(zval *obj TSRMLS_DC) /* { static void spl_fixedarray_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */ { spl_fixedarray_object *intern = spl_fixed_array_from_obj(object); - long i; + php_int_t i; if (intern->array) { for (i = 0; i < intern->array->size; i++) { @@ -328,7 +328,7 @@ static zend_object *spl_fixedarray_object_clone(zval *zobject TSRMLS_DC) /* {{{ static inline zval *spl_fixedarray_object_read_dimension_helper(spl_fixedarray_object *intern, zval *offset TSRMLS_DC) /* {{{ */ { - long index; + php_int_t index; /* we have to return NULL on error here to avoid memleak because of * ZE duplicating uninitialized_zval_ptr */ @@ -337,10 +337,10 @@ static inline zval *spl_fixedarray_object_read_dimension_helper(spl_fixedarray_o return NULL; } - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -384,7 +384,7 @@ static zval *spl_fixedarray_object_read_dimension(zval *object, zval *offset, in static inline void spl_fixedarray_object_write_dimension_helper(spl_fixedarray_object *intern, zval *offset, zval *value TSRMLS_DC) /* {{{ */ { - long index; + php_int_t index; if (!offset) { /* '$array[] = value' syntax is not supported */ @@ -392,10 +392,10 @@ static inline void spl_fixedarray_object_write_dimension_helper(spl_fixedarray_o return; } - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -438,12 +438,12 @@ static void spl_fixedarray_object_write_dimension(zval *object, zval *offset, zv static inline void spl_fixedarray_object_unset_dimension_helper(spl_fixedarray_object *intern, zval *offset TSRMLS_DC) /* {{{ */ { - long index; + php_int_t index; - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -476,13 +476,13 @@ static void spl_fixedarray_object_unset_dimension(zval *object, zval *offset TSR static inline int spl_fixedarray_object_has_dimension_helper(spl_fixedarray_object *intern, zval *offset, int check_empty TSRMLS_DC) /* {{{ */ { - long index; + php_int_t index; int retval; - if (Z_TYPE_P(offset) != IS_LONG) { - index = spl_offset_convert_to_long(offset TSRMLS_CC); + if (Z_TYPE_P(offset) != IS_INT) { + index = spl_offset_convert_to_int(offset TSRMLS_CC); } else { - index = Z_LVAL_P(offset); + index = Z_IVAL_P(offset); } if (index < 0 || intern->array == NULL || index >= intern->array->size) { @@ -528,7 +528,7 @@ static int spl_fixedarray_object_has_dimension(zval *object, zval *offset, int c } /* }}} */ -static int spl_fixedarray_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */ +static int spl_fixedarray_object_count_elements(zval *object, php_int_t *count TSRMLS_DC) /* {{{ */ { spl_fixedarray_object *intern; @@ -539,8 +539,8 @@ static int spl_fixedarray_object_count_elements(zval *object, long *count TSRMLS if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (php_int_t) Z_IVAL(intern->retval); return SUCCESS; } } else if (intern->array) { @@ -559,9 +559,9 @@ SPL_METHOD(SplFixedArray, __construct) { zval *object = getThis(); spl_fixedarray_object *intern; - long size = 0; + php_int_t size = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &size) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &size) == FAILURE) { return; } @@ -629,9 +629,9 @@ SPL_METHOD(SplFixedArray, count) intern = Z_SPLFIXEDARRAY_P(object); if (intern->array) { - RETURN_LONG(intern->array->size); + RETURN_INT(intern->array->size); } - RETURN_LONG(0); + RETURN_INT(0); } /* }}} */ @@ -684,11 +684,11 @@ SPL_METHOD(SplFixedArray, fromArray) if (num > 0 && save_indexes) { zval *element; zend_string *str_index; - ulong num_index, max_index = 0; - long tmp; + php_uint_t num_index, max_index = 0; + php_int_t tmp; ZEND_HASH_FOREACH_KEY(Z_ARRVAL_P(data), num_index, str_index) { - if (str_index != NULL || (long)num_index < 0) { + if (str_index != NULL || (php_int_t)num_index < 0) { efree(array); zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "array must contain only positive integer keys"); return; @@ -714,7 +714,7 @@ SPL_METHOD(SplFixedArray, fromArray) } else if (num > 0 && !save_indexes) { zval *element; - long i = 0; + php_int_t i = 0; spl_fixedarray_init(array, num TSRMLS_CC); @@ -747,9 +747,9 @@ SPL_METHOD(SplFixedArray, getSize) intern = Z_SPLFIXEDARRAY_P(object); if (intern->array) { - RETURN_LONG(intern->array->size); + RETURN_INT(intern->array->size); } - RETURN_LONG(0); + RETURN_INT(0); } /* }}} */ @@ -759,7 +759,7 @@ SPL_METHOD(SplFixedArray, setSize) { zval *object = getThis(); spl_fixedarray_object *intern; - long size; + php_int_t size; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) { return; @@ -895,7 +895,7 @@ static zval *spl_fixedarray_it_get_current_data(zend_object_iterator *iter TSRML } else { zval *data; - ZVAL_LONG(&zindex, object->current); + ZVAL_INT(&zindex, object->current); data = spl_fixedarray_object_read_dimension_helper(object, &zindex TSRMLS_CC); zval_ptr_dtor(&zindex); @@ -915,7 +915,7 @@ static void spl_fixedarray_it_get_current_key(zend_object_iterator *iter, zval * if (object->flags & SPL_FIXEDARRAY_OVERLOADED_KEY) { zend_user_it_get_current_key(iter, key TSRMLS_CC); } else { - ZVAL_LONG(key, object->current); + ZVAL_INT(key, object->current); } } /* }}} */ @@ -943,7 +943,7 @@ SPL_METHOD(SplFixedArray, key) return; } - RETURN_LONG(intern->current); + RETURN_INT(intern->current); } /* }}} */ @@ -1000,7 +1000,7 @@ SPL_METHOD(SplFixedArray, current) return; } - ZVAL_LONG(&zindex, intern->current); + ZVAL_INT(&zindex, intern->current); value = spl_fixedarray_object_read_dimension_helper(intern, &zindex TSRMLS_CC); diff --git a/ext/spl/spl_functions.h b/ext/spl/spl_functions.h index 1d116ff783..f3d8f26a07 100644 --- a/ext/spl/spl_functions.h +++ b/ext/spl/spl_functions.h @@ -46,8 +46,8 @@ typedef zend_object* (*create_object_func_t)(zend_class_entry *class_type TSRMLS #define REGISTER_SPL_PROPERTY(class_name, prop_name, prop_flags) \ spl_register_property(spl_ce_ ## class_name, prop_name, sizeof(prop_name)-1, prop_flags TSRMLS_CC); -#define REGISTER_SPL_CLASS_CONST_LONG(class_name, const_name, value) \ - zend_declare_class_constant_long(spl_ce_ ## class_name, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); +#define REGISTER_SPL_CLASS_CONST_INT(class_name, const_name, value) \ + zend_declare_class_constant_int(spl_ce_ ## class_name, const_name, sizeof(const_name)-1, (php_int_t)value TSRMLS_CC); void spl_register_std_class(zend_class_entry ** ppce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC); void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC); diff --git a/ext/spl/spl_heap.c b/ext/spl/spl_heap.c index 90d78db6ee..1dbfe935ff 100644 --- a/ext/spl/spl_heap.c +++ b/ext/spl/spl_heap.c @@ -105,7 +105,7 @@ static void spl_ptr_heap_zval_ctor(zval *elem TSRMLS_DC) { /* {{{ */ } /* }}} */ -static int spl_ptr_heap_cmp_cb_helper(zval *object, spl_heap_object *heap_object, zval *a, zval *b, long *result TSRMLS_DC) { /* {{{ */ +static int spl_ptr_heap_cmp_cb_helper(zval *object, spl_heap_object *heap_object, zval *a, zval *b, php_int_t *result TSRMLS_DC) { /* {{{ */ zval zresult; zend_call_method_with_2_params(object, heap_object->std.ce, &heap_object->fptr_cmp, "compare", &zresult, a, b); @@ -114,8 +114,8 @@ static int spl_ptr_heap_cmp_cb_helper(zval *object, spl_heap_object *heap_object return FAILURE; } - convert_to_long(&zresult); - *result = Z_LVAL(zresult); + convert_to_int(&zresult); + *result = Z_IVAL(zresult); zval_ptr_dtor(&zresult); @@ -155,7 +155,7 @@ static int spl_ptr_heap_zval_max_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { if (object) { spl_heap_object *heap_object = Z_SPLHEAP_P(object); if (heap_object->fptr_cmp) { - long lval = 0; + php_int_t lval = 0; if (spl_ptr_heap_cmp_cb_helper(object, heap_object, a, b, &lval TSRMLS_CC) == FAILURE) { /* exception or call failure */ return 0; @@ -165,7 +165,7 @@ static int spl_ptr_heap_zval_max_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { } compare_function(&result, a, b TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -179,7 +179,7 @@ static int spl_ptr_heap_zval_min_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { if (object) { spl_heap_object *heap_object = Z_SPLHEAP_P(object); if (heap_object->fptr_cmp) { - long lval = 0; + php_int_t lval = 0; if (spl_ptr_heap_cmp_cb_helper(object, heap_object, a, b, &lval TSRMLS_CC) == FAILURE) { /* exception or call failure */ return 0; @@ -189,7 +189,7 @@ static int spl_ptr_heap_zval_min_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { } compare_function(&result, b, a TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -210,7 +210,7 @@ static int spl_ptr_pqueue_zval_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { / if (object) { spl_heap_object *heap_object = Z_SPLHEAP_P(object); if (heap_object->fptr_cmp) { - long lval = 0; + php_int_t lval = 0; if (spl_ptr_heap_cmp_cb_helper((zval *)object, heap_object, a_priority_p, b_priority_p, &lval TSRMLS_CC) == FAILURE) { /* exception or call failure */ return 0; @@ -220,7 +220,7 @@ static int spl_ptr_pqueue_zval_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { / } compare_function(&result, a_priority_p, b_priority_p TSRMLS_CC); - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -493,8 +493,8 @@ static int spl_heap_object_count_elements(zval *object, long *count TSRMLS_DC) / if (!Z_ISUNDEF(rv)) { zval_ptr_dtor(&intern->retval); ZVAL_ZVAL(&intern->retval, &rv, 0, 0); - convert_to_long(&intern->retval); - *count = (long) Z_LVAL(intern->retval); + convert_to_int(&intern->retval); + *count = (long) Z_IVAL(intern->retval); return SUCCESS; } *count = 0; @@ -529,7 +529,7 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1 TSRMLS_CC); - ZVAL_LONG(&tmp, intern->flags); + ZVAL_INT(&tmp, intern->flags); zend_hash_update(intern->debug_info, pnstr, &tmp); STR_RELEASE(pnstr); @@ -572,7 +572,7 @@ static HashTable* spl_pqueue_object_get_debug_info(zval *obj, int *is_temp TSRML Return the number of elements in the heap. */ SPL_METHOD(SplHeap, count) { - long count; + php_int_t count; spl_heap_object *intern = Z_SPLHEAP_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { @@ -580,7 +580,7 @@ SPL_METHOD(SplHeap, count) } count = spl_ptr_heap_count(intern->heap); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -765,10 +765,10 @@ SPL_METHOD(SplPriorityQueue, top) Set the flags of extraction*/ SPL_METHOD(SplPriorityQueue, setExtractFlags) { - long value; + php_int_t value; spl_heap_object *intern; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &value) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &value) == FAILURE) { return; } @@ -776,7 +776,7 @@ SPL_METHOD(SplPriorityQueue, setExtractFlags) intern->flags = value & SPL_PQUEUE_EXTR_MASK; - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -808,7 +808,7 @@ SPL_METHOD(SplPriorityQueue, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -851,7 +851,7 @@ SPL_METHOD(SplMinHeap, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_min_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_min_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -865,7 +865,7 @@ SPL_METHOD(SplMaxHeap, compare) return; } - RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); + RETURN_INT(spl_ptr_heap_zval_max_cmp(a, b, NULL TSRMLS_CC)); } /* }}} */ @@ -934,7 +934,7 @@ static void spl_heap_it_get_current_key(zend_object_iterator *iter, zval *key TS { spl_heap_object *object = Z_SPLHEAP_P(&iter->data); - ZVAL_LONG(key, object->heap->count - 1); + ZVAL_INT(key, object->heap->count - 1); } /* }}} */ @@ -966,7 +966,7 @@ SPL_METHOD(SplHeap, key) return; } - RETURN_LONG(intern->heap->count - 1); + RETURN_INT(intern->heap->count - 1); } /* }}} */ @@ -1226,9 +1226,9 @@ PHP_MINIT_FUNCTION(spl_heap) /* {{{ */ spl_ce_SplPriorityQueue->get_iterator = spl_pqueue_get_iterator; - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_BOTH", SPL_PQUEUE_EXTR_BOTH); - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_PRIORITY", SPL_PQUEUE_EXTR_PRIORITY); - REGISTER_SPL_CLASS_CONST_LONG(SplPriorityQueue, "EXTR_DATA", SPL_PQUEUE_EXTR_DATA); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_BOTH", SPL_PQUEUE_EXTR_BOTH); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_PRIORITY", SPL_PQUEUE_EXTR_PRIORITY); + REGISTER_SPL_CLASS_CONST_INT(SplPriorityQueue, "EXTR_DATA", SPL_PQUEUE_EXTR_DATA); return SUCCESS; } diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c index e503f9b581..87cdb70007 100644 --- a/ext/spl/spl_iterators.c +++ b/ext/spl/spl_iterators.c @@ -228,7 +228,7 @@ static void spl_recursive_it_get_current_key(zend_object_iterator *iter, zval *k if (sub_iter->funcs->get_current_key) { sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC); } else { - ZVAL_LONG(key, iter->index); + ZVAL_INT(key, iter->index); } } @@ -473,7 +473,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla spl_recursive_it_object *intern; zval *iterator; zend_class_entry *ce_iterator; - long mode, flags; + php_int_t mode, flags; int inc_refcount = 1; zend_error_handling error_handling; @@ -486,7 +486,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla mode = RIT_SELF_FIRST; flags = RTIT_BYPASS_KEY; - if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|lzl", &iterator, &flags, &user_caching_it_flags, &mode) == SUCCESS) { + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|izi", &iterator, &flags, &user_caching_it_flags, &mode) == SUCCESS) { if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) { zval *aggregate = iterator; zend_call_method_with_0_params(aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", iterator); @@ -496,7 +496,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla if (user_caching_it_flags) { ZVAL_ZVAL(&caching_it_flags, user_caching_it_flags, 1, 0); } else { - ZVAL_LONG(&caching_it_flags, CIT_CATCH_GET_CHILD); + ZVAL_INT(&caching_it_flags, CIT_CATCH_GET_CHILD); } spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &caching_it, iterator, &caching_it_flags TSRMLS_CC); zval_ptr_dtor(&caching_it_flags); @@ -515,7 +515,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla mode = RIT_LEAVES_ONLY; flags = 0; - if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|ll", &iterator, &mode, &flags) == SUCCESS) { + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|ii", &iterator, &mode, &flags) == SUCCESS) { if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) { zval *aggregate = iterator; zend_call_method_with_0_params(aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", iterator); @@ -695,7 +695,7 @@ SPL_METHOD(RecursiveIteratorIterator, getDepth) return; } - RETURN_LONG(object->level); + RETURN_INT(object->level); } /* }}} */ /* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level]) @@ -703,9 +703,9 @@ SPL_METHOD(RecursiveIteratorIterator, getDepth) SPL_METHOD(RecursiveIteratorIterator, getSubIterator) { spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(getThis()); - long level = object->level; + php_int_t level = object->level; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &level) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &level) == FAILURE) { return; } if (level < 0 || level > object->level) { @@ -846,9 +846,9 @@ SPL_METHOD(RecursiveIteratorIterator, nextElement) SPL_METHOD(RecursiveIteratorIterator, setMaxDepth) { spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(getThis()); - long max_depth = -1; + php_int_t max_depth = -1; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &max_depth) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &max_depth) == FAILURE) { return; } if (max_depth < -1) { @@ -871,7 +871,7 @@ SPL_METHOD(RecursiveIteratorIterator, getMaxDepth) if (object->max_depth == -1) { RETURN_FALSE; } else { - RETURN_LONG(object->max_depth); + RETURN_INT(object->max_depth); } } /* }}} */ @@ -879,7 +879,7 @@ static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, { union _zend_function *function_handler; spl_recursive_it_object *object = spl_recursive_it_from_obj(*zobject); - long level = object->level; + php_int_t level = object->level; zval *zobj; if (!object->iterators) { @@ -1088,12 +1088,12 @@ SPL_METHOD(RecursiveTreeIterator, __construct) Sets prefix parts as used in getPrefix() */ SPL_METHOD(RecursiveTreeIterator, setPrefixPart) { - long part; + php_int_t part; char* prefix; int prefix_len; spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(getThis()); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &part, &prefix, &prefix_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "is", &part, &prefix, &prefix_len) == FAILURE) { return; } @@ -1222,15 +1222,15 @@ SPL_METHOD(RecursiveTreeIterator, current) } spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC); - str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix), 0); + str = STR_ALLOC(Z_STRSIZE(prefix) + Z_STRSIZE(entry) + Z_STRSIZE(postfix), 0); ptr = str->val; - memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix)); - ptr += Z_STRLEN(prefix); - memcpy(ptr, Z_STRVAL(entry), Z_STRLEN(entry)); - ptr += Z_STRLEN(entry); - memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix)); - ptr += Z_STRLEN(postfix); + memcpy(ptr, Z_STRVAL(prefix), Z_STRSIZE(prefix)); + ptr += Z_STRSIZE(prefix); + memcpy(ptr, Z_STRVAL(entry), Z_STRSIZE(entry)); + ptr += Z_STRSIZE(entry); + memcpy(ptr, Z_STRVAL(postfix), Z_STRSIZE(postfix)); + ptr += Z_STRSIZE(postfix); *ptr = 0; zval_ptr_dtor(&prefix); @@ -1278,15 +1278,15 @@ SPL_METHOD(RecursiveTreeIterator, key) spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC); spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC); - str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix), 0); + str = STR_ALLOC(Z_STRSIZE(prefix) + Z_STRSIZE(key) + Z_STRSIZE(postfix), 0); ptr = str->val; - memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix)); - ptr += Z_STRLEN(prefix); - memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key)); - ptr += Z_STRLEN(key); - memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix)); - ptr += Z_STRLEN(postfix); + memcpy(ptr, Z_STRVAL(prefix), Z_STRSIZE(prefix)); + ptr += Z_STRSIZE(prefix); + memcpy(ptr, Z_STRVAL(key), Z_STRSIZE(key)); + ptr += Z_STRSIZE(key); + memcpy(ptr, Z_STRVAL(postfix), Z_STRSIZE(postfix)); + ptr += Z_STRSIZE(postfix); *ptr = 0; zval_ptr_dtor(&prefix); @@ -1387,7 +1387,7 @@ int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS) } p = EG(argument_stack).top_element-2; - arg_count = (ulong) *p; + arg_count = (php_uint_t) *p; func_params = safe_emalloc(sizeof(zval **), arg_count, 0); @@ -1457,7 +1457,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z case DIT_LimitIterator: { intern->u.limit.offset = 0; /* start at beginning */ intern->u.limit.count = -1; /* get all */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|ll", &zobject, ce_inner, &intern->u.limit.offset, &intern->u.limit.count) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|ii", &zobject, ce_inner, &intern->u.limit.offset, &intern->u.limit.count) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return NULL; } @@ -1475,8 +1475,8 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z } case DIT_CachingIterator: case DIT_RecursiveCachingIterator: { - long flags = CIT_CALL_TOSTRING; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &zobject, ce_inner, &flags) == FAILURE) { + php_int_t flags = CIT_CALL_TOSTRING; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|i", &zobject, ce_inner, &flags) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return NULL; } @@ -1539,17 +1539,17 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z case DIT_RegexIterator: case DIT_RecursiveRegexIterator: { zend_string *regex; - long mode = REGIT_MODE_MATCH; + php_int_t mode = REGIT_MODE_MATCH; intern->u.regex.use_flags = ZEND_NUM_ARGS() >= 5; intern->u.regex.flags = 0; intern->u.regex.preg_flags = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OS|lll", &zobject, ce_inner, ®ex, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OS|iii", &zobject, ce_inner, ®ex, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return NULL; } if (mode < 0 || mode >= REGIT_MODE_MAX) { - zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode); + zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %pd", mode); zend_restore_error_handling(&error_handling TSRMLS_CC); return NULL; } @@ -1709,7 +1709,7 @@ static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more T ZVAL_UNDEF(&intern->current.key); } } else { - ZVAL_LONG(&intern->current.key, intern->current.pos); + ZVAL_INT(&intern->current.key, intern->current.pos); } return EG(exception) ? FAILURE : SUCCESS; } @@ -2049,10 +2049,10 @@ SPL_METHOD(RegexIterator, accept) use_copy = zend_make_printable_zval(subject_ptr, &subject_copy TSRMLS_CC); if (use_copy) { subject = Z_STRVAL(subject_copy); - subject_len = Z_STRLEN(subject_copy); + subject_len = Z_STRSIZE(subject_copy); } else { subject = Z_STRVAL_P(subject_ptr); - subject_len = Z_STRLEN_P(subject_ptr); + subject_len = Z_STRSIZE_P(subject_ptr); } use_copy = 0; @@ -2151,7 +2151,7 @@ SPL_METHOD(RegexIterator, getMode) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.regex.mode); + RETURN_INT(intern->u.regex.mode); } /* }}} */ /* {{{ proto bool RegexIterator::setMode(int new_mode) @@ -2159,14 +2159,14 @@ SPL_METHOD(RegexIterator, getMode) SPL_METHOD(RegexIterator, setMode) { spl_dual_it_object *intern; - long mode; + php_int_t mode; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &mode) == FAILURE) { return; } if (mode < 0 || mode >= REGIT_MODE_MAX) { - zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode); + zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %pd", mode); return;/* NULL */ } @@ -2187,7 +2187,7 @@ SPL_METHOD(RegexIterator, getFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.regex.flags); + RETURN_INT(intern->u.regex.flags); } /* }}} */ /* {{{ proto bool RegexIterator::setFlags(int new_flags) @@ -2195,9 +2195,9 @@ SPL_METHOD(RegexIterator, getFlags) SPL_METHOD(RegexIterator, setFlags) { spl_dual_it_object *intern; - long flags; + php_int_t flags; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &flags) == FAILURE) { return; } @@ -2219,7 +2219,7 @@ SPL_METHOD(RegexIterator, getPregFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); if (intern->u.regex.use_flags) { - RETURN_LONG(intern->u.regex.preg_flags); + RETURN_INT(intern->u.regex.preg_flags); } else { return; } @@ -2230,9 +2230,9 @@ SPL_METHOD(RegexIterator, getPregFlags) SPL_METHOD(RegexIterator, setPregFlags) { spl_dual_it_object *intern; - long preg_flags; + php_int_t preg_flags; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &preg_flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &preg_flags) == FAILURE) { return; } @@ -2472,21 +2472,21 @@ static inline int spl_limit_it_valid(spl_dual_it_object *intern TSRMLS_DC) } } -static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC) +static inline void spl_limit_it_seek(spl_dual_it_object *intern, php_int_t pos TSRMLS_DC) { zval zpos; spl_dual_it_free(intern TSRMLS_CC); if (pos < intern->u.limit.offset) { - zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is below the offset %ld", pos, intern->u.limit.offset); + zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %pd which is below the offset %pd", pos, intern->u.limit.offset); return; } if (pos >= intern->u.limit.offset + intern->u.limit.count && intern->u.limit.count != -1) { - zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is behind offset %ld plus count %ld", pos, intern->u.limit.offset, intern->u.limit.count); + zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %pd which is behind offset %pd plus count %pd", pos, intern->u.limit.offset, intern->u.limit.count); return; } if (pos != intern->current.pos && instanceof_function(intern->inner.ce, spl_ce_SeekableIterator TSRMLS_CC)) { - ZVAL_LONG(&zpos, pos); + ZVAL_INT(&zpos, pos); spl_dual_it_free(intern TSRMLS_CC); zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, &zpos); zval_ptr_dtor(&zpos); @@ -2560,15 +2560,15 @@ SPL_METHOD(LimitIterator, next) SPL_METHOD(LimitIterator, seek) { spl_dual_it_object *intern; - long pos; + php_int_t pos; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pos) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &pos) == FAILURE) { return; } SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); spl_limit_it_seek(intern, pos TSRMLS_CC); - RETURN_LONG(intern->current.pos); + RETURN_INT(intern->current.pos); } /* }}} */ /* {{{ proto int LimitIterator::getPosition() @@ -2577,7 +2577,7 @@ SPL_METHOD(LimitIterator, getPosition) { spl_dual_it_object *intern; SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->current.pos); + RETURN_INT(intern->current.pos); } /* }}} */ ZEND_BEGIN_ARG_INFO(arginfo_seekable_it_seek, 0) @@ -2660,7 +2660,7 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC) return; } } else { - ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC); + ZVAL_INT(&zflags, intern->u.caching.flags & CIT_PUBLIC); spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, &zchildren, &zflags TSRMLS_CC); zval_ptr_dtor(&zchildren); } @@ -2929,7 +2929,7 @@ SPL_METHOD(CachingIterator, getFlags) SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - RETURN_LONG(intern->u.caching.flags); + RETURN_INT(intern->u.caching.flags); } /* }}} */ @@ -2938,11 +2938,11 @@ SPL_METHOD(CachingIterator, getFlags) SPL_METHOD(CachingIterator, setFlags) { spl_dual_it_object *intern; - long flags; + php_int_t flags; SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis()); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &flags) == FAILURE) { return; } @@ -2983,7 +2983,7 @@ SPL_METHOD(CachingIterator, count) return; } - RETURN_LONG(zend_hash_num_elements(HASH_OF(&intern->u.caching.zcache))); + RETURN_INT(zend_hash_num_elements(HASH_OF(&intern->u.caching.zcache))); } /* }}} */ @@ -3574,7 +3574,7 @@ PHP_FUNCTION(iterator_to_array) static int spl_iterator_count_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */ { - (*(long*)puser)++; + (*(php_int_t*)puser)++; return ZEND_HASH_APPLY_KEEP; } /* }}} */ @@ -3584,14 +3584,14 @@ static int spl_iterator_count_apply(zend_object_iterator *iter, void *puser TSRM PHP_FUNCTION(iterator_count) { zval *obj; - long count = 0; + php_int_t count = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, zend_ce_traversable) == FAILURE) { RETURN_FALSE; } if (spl_iterator_apply(obj, spl_iterator_count_apply, (void*)&count TSRMLS_CC) == SUCCESS) { - RETURN_LONG(count); + RETURN_INT(count); } } /* }}} */ @@ -3599,7 +3599,7 @@ PHP_FUNCTION(iterator_count) typedef struct { zval *obj; zval *args; - long count; + php_int_t count; zend_fcall_info fci; zend_fcall_info_cache fcc; } spl_iterator_apply_info; @@ -3636,7 +3636,7 @@ PHP_FUNCTION(iterator_apply) apply_info.count = 0; zend_fcall_info_args(&apply_info.fci, apply_info.args TSRMLS_CC); if (spl_iterator_apply(apply_info.obj, spl_iterator_func_apply, (void*)&apply_info TSRMLS_CC) == SUCCESS) { - RETVAL_LONG(apply_info.count); + RETVAL_INT(apply_info.count); } else { RETVAL_FALSE; } @@ -3682,10 +3682,10 @@ PHP_MINIT_FUNCTION(spl_iterators) spl_ce_RecursiveIteratorIterator->get_iterator = spl_recursive_it_get_iterator; spl_ce_RecursiveIteratorIterator->iterator_funcs.funcs = &spl_recursive_it_iterator_funcs; - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "LEAVES_ONLY", RIT_LEAVES_ONLY); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "SELF_FIRST", RIT_SELF_FIRST); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CHILD_FIRST", RIT_CHILD_FIRST); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CATCH_GET_CHILD", RIT_CATCH_GET_CHILD); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "LEAVES_ONLY", RIT_LEAVES_ONLY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "SELF_FIRST", RIT_SELF_FIRST); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "CHILD_FIRST", RIT_CHILD_FIRST); + REGISTER_SPL_CLASS_CONST_INT(RecursiveIteratorIterator, "CATCH_GET_CHILD", RIT_CATCH_GET_CHILD); REGISTER_SPL_INTERFACE(OuterIterator); REGISTER_SPL_ITERATOR(OuterIterator); @@ -3718,12 +3718,12 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_IMPLEMENTS(CachingIterator, ArrayAccess); REGISTER_SPL_IMPLEMENTS(CachingIterator, Countable); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER); - REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER); + REGISTER_SPL_CLASS_CONST_INT(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE); REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, spl_funcs_RecursiveCachingIterator); REGISTER_SPL_IMPLEMENTS(RecursiveCachingIterator, RecursiveIterator); @@ -3737,13 +3737,13 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, spl_funcs_InfiniteIterator); #if HAVE_PCRE || HAVE_BUNDLED_PCRE REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, spl_funcs_RegexIterator); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "USE_KEY", REGIT_USE_KEY); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "INVERT_MATCH",REGIT_INVERTED); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "MATCH", REGIT_MODE_MATCH); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "SPLIT", REGIT_MODE_SPLIT); - REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "REPLACE", REGIT_MODE_REPLACE); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "USE_KEY", REGIT_USE_KEY); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "INVERT_MATCH",REGIT_INVERTED); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "MATCH", REGIT_MODE_MATCH); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "SPLIT", REGIT_MODE_SPLIT); + REGISTER_SPL_CLASS_CONST_INT(RegexIterator, "REPLACE", REGIT_MODE_REPLACE); REGISTER_SPL_PROPERTY(RegexIterator, "replacement", 0); REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, spl_funcs_RecursiveRegexIterator); REGISTER_SPL_IMPLEMENTS(RecursiveRegexIterator, RecursiveIterator); @@ -3756,14 +3756,14 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_ITERATOR(EmptyIterator); REGISTER_SPL_SUB_CLASS_EX(RecursiveTreeIterator, RecursiveIteratorIterator, spl_RecursiveTreeIterator_new, spl_funcs_RecursiveTreeIterator); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_LEFT", 0); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_HAS_NEXT", 1); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_LAST", 2); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_HAS_NEXT", 3); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_LAST", 4); - REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_RIGHT", 5); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_LEFT", 0); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_MID_HAS_NEXT", 1); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_MID_LAST", 2); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_END_HAS_NEXT", 3); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_END_LAST", 4); + REGISTER_SPL_CLASS_CONST_INT(RecursiveTreeIterator, "PREFIX_RIGHT", 5); return SUCCESS; } diff --git a/ext/spl/spl_iterators.h b/ext/spl/spl_iterators.h index f51fc3a990..851436350b 100644 --- a/ext/spl/spl_iterators.h +++ b/ext/spl/spl_iterators.h @@ -139,11 +139,11 @@ typedef struct _spl_dual_it_object { dual_it_type dit_type; union { struct { - long offset; - long count; + php_int_t offset; + php_int_t count; } limit; struct { - long flags; /* CIT_* */ + php_int_t flags; /* CIT_* */ zval zstr; zval zchildren; zval zcache; @@ -155,9 +155,9 @@ typedef struct _spl_dual_it_object { #if HAVE_PCRE || HAVE_BUNDLED_PCRE struct { int use_flags; - long flags; + php_int_t flags; regex_mode mode; - long preg_flags; + php_int_t preg_flags; pcre_cache_entry *pce; zend_string *regex; } regex; diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c index bdfff35506..77bb9d11af 100644 --- a/ext/spl/spl_observer.c +++ b/ext/spl/spl_observer.c @@ -81,9 +81,9 @@ PHPAPI zend_object_handlers spl_handler_SplObjectStorage; typedef struct _spl_SplObjectStorage { /* {{{ */ HashTable storage; - long index; + php_int_t index; HashPosition pos; - long flags; + php_int_t flags; zend_function *fptr_get_hash; HashTable *debug_info; zend_object std; @@ -397,7 +397,7 @@ static int spl_object_storage_compare_info(zval *e1, zval *e2 TSRMLS_DC) /* {{{ return 1; } - return Z_LVAL(result); + return Z_IVAL(result); } /* }}} */ @@ -526,7 +526,7 @@ SPL_METHOD(SplObjectStorage, addAll) spl_object_storage_addall(intern, getThis(), other TSRMLS_CC); - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto bool SplObjectStorage::removeAll(SplObjectStorage $os) @@ -554,7 +554,7 @@ SPL_METHOD(SplObjectStorage, removeAll) zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos); intern->index = 0; - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto bool SplObjectStorage::removeAllExcept(SplObjectStorage $os) @@ -581,7 +581,7 @@ SPL_METHOD(SplObjectStorage, removeAllExcept) zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos); intern->index = 0; - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ @@ -603,25 +603,25 @@ SPL_METHOD(SplObjectStorage, contains) SPL_METHOD(SplObjectStorage, count) { spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis()); - long mode = COUNT_NORMAL; + php_int_t mode = COUNT_NORMAL; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &mode) == FAILURE) { return; } if (mode == COUNT_RECURSIVE) { - long ret = zend_hash_num_elements(&intern->storage); + php_int_t ret = zend_hash_num_elements(&intern->storage); zval *element; ZEND_HASH_FOREACH_VAL(&intern->storage, element) { ret += php_count_recursive(element, mode TSRMLS_CC); } ZEND_HASH_FOREACH_END(); - RETURN_LONG(ret); + RETURN_INT(ret); return; } - RETURN_LONG(zend_hash_num_elements(&intern->storage)); + RETURN_INT(zend_hash_num_elements(&intern->storage)); } /* }}} */ /* {{{ proto void SplObjectStorage::rewind() @@ -661,7 +661,7 @@ SPL_METHOD(SplObjectStorage, key) return; } - RETURN_LONG(intern->index); + RETURN_INT(intern->index); } /* }}} */ /* {{{ proto mixed SplObjectStorage::current() @@ -751,7 +751,7 @@ SPL_METHOD(SplObjectStorage, serialize) /* storage */ smart_str_appendl(&buf, "x:", 2); - ZVAL_LONG(&flags, zend_hash_num_elements(&intern->storage)); + ZVAL_INT(&flags, zend_hash_num_elements(&intern->storage)); php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC); zval_ptr_dtor(&flags); @@ -800,7 +800,7 @@ SPL_METHOD(SplObjectStorage, unserialize) php_unserialize_data_t var_hash; zval entry, pmembers, pcount, inf; spl_SplObjectStorageElement *element; - long count; + php_int_t count; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) { return; @@ -822,13 +822,13 @@ SPL_METHOD(SplObjectStorage, unserialize) if (!php_var_unserialize(&pcount, &p, s + buf_len, &var_hash TSRMLS_CC)) { goto outexcept; } - if (Z_TYPE(pcount) != IS_LONG) { + if (Z_TYPE(pcount) != IS_INT) { zval_ptr_dtor(&pcount); goto outexcept; } --p; /* for ';' */ - count = Z_LVAL(pcount); + count = Z_IVAL(pcount); while (count-- > 0) { spl_SplObjectStorageElement *pelement; @@ -909,7 +909,7 @@ SPL_METHOD(SplObjectStorage, unserialize) outexcept: PHP_VAR_UNSERIALIZE_DESTROY(var_hash); - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %ld of %d bytes", (php_int_t)((char*)p - buf), buf_len); return; } /* }}} */ @@ -986,12 +986,12 @@ typedef enum { SPL_METHOD(MultipleIterator, __construct) { spl_SplObjectStorage *intern; - long flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC; + php_int_t flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &flags) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } @@ -1011,7 +1011,7 @@ SPL_METHOD(MultipleIterator, getFlags) if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_LONG(intern->flags); + RETURN_INT(intern->flags); } /* }}} */ @@ -1022,7 +1022,7 @@ SPL_METHOD(MultipleIterator, setFlags) spl_SplObjectStorage *intern; intern = Z_SPLOBJSTORAGE_P(getThis()); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &intern->flags) == FAILURE) { return; } } @@ -1045,7 +1045,7 @@ SPL_METHOD(MultipleIterator, attachIterator) spl_SplObjectStorageElement *element; zval compare_result; - if (Z_TYPE_P(info) != IS_LONG && Z_TYPE_P(info) != IS_STRING) { + if (Z_TYPE_P(info) != IS_INT && Z_TYPE_P(info) != IS_STRING) { zend_throw_exception(spl_ce_InvalidArgumentException, "Info must be NULL, integer or string", 0 TSRMLS_CC); return; } @@ -1118,7 +1118,7 @@ SPL_METHOD(MultipleIterator, valid) spl_SplObjectStorage *intern; spl_SplObjectStorageElement *element; zval *it, retval; - long expect, valid; + php_int_t expect, valid; intern = Z_SPLOBJSTORAGE_P(getThis()); @@ -1203,8 +1203,8 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_ if (intern->flags & MIT_KEYS_ASSOC) { switch (Z_TYPE(element->inf)) { - case IS_LONG: - add_index_zval(return_value, Z_LVAL(element->inf), &retval); + case IS_INT: + add_index_zval(return_value, Z_IVAL(element->inf), &retval); break; case IS_STRING: zend_hash_update(Z_ARRVAL_P(return_value), Z_STR(element->inf), &retval); @@ -1312,10 +1312,10 @@ PHP_MINIT_FUNCTION(spl_observer) REGISTER_SPL_STD_CLASS_EX(MultipleIterator, spl_SplObjectStorage_new, spl_funcs_MultipleIterator); REGISTER_SPL_ITERATOR(MultipleIterator); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ALL", MIT_NEED_ALL); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_NUMERIC", MIT_KEYS_NUMERIC); - REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_ASSOC", MIT_KEYS_ASSOC); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_NEED_ALL", MIT_NEED_ALL); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_KEYS_NUMERIC", MIT_KEYS_NUMERIC); + REGISTER_SPL_CLASS_CONST_INT(MultipleIterator, "MIT_KEYS_ASSOC", MIT_KEYS_ASSOC); return SUCCESS; } diff --git a/ext/standard/array.c b/ext/standard/array.c index a177ee7e0f..b420dfb307 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -99,33 +99,33 @@ PHP_MINIT_FUNCTION(array) /* {{{ */ { ZEND_INIT_MODULE_GLOBALS(array, php_array_init_globals, NULL); - REGISTER_LONG_CONSTANT("EXTR_OVERWRITE", EXTR_OVERWRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_SKIP", EXTR_SKIP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_SAME", EXTR_PREFIX_SAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_ALL", EXTR_PREFIX_ALL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_INVALID", EXTR_PREFIX_INVALID, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_PREFIX_IF_EXISTS", EXTR_PREFIX_IF_EXISTS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_IF_EXISTS", EXTR_IF_EXISTS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("EXTR_REFS", EXTR_REFS, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("SORT_ASC", PHP_SORT_ASC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_DESC", PHP_SORT_DESC, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("SORT_REGULAR", PHP_SORT_REGULAR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_NUMERIC", PHP_SORT_NUMERIC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_STRING", PHP_SORT_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_LOCALE_STRING", PHP_SORT_LOCALE_STRING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_NATURAL", PHP_SORT_NATURAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SORT_FLAG_CASE", PHP_SORT_FLAG_CASE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("CASE_LOWER", CASE_LOWER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CASE_UPPER", CASE_UPPER, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("COUNT_NORMAL", COUNT_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("COUNT_RECURSIVE", COUNT_RECURSIVE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("ARRAY_FILTER_USE_BOTH", ARRAY_FILTER_USE_BOTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ARRAY_FILTER_USE_KEY", ARRAY_FILTER_USE_KEY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_OVERWRITE", EXTR_OVERWRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_SKIP", EXTR_SKIP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_SAME", EXTR_PREFIX_SAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_ALL", EXTR_PREFIX_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_INVALID", EXTR_PREFIX_INVALID, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_PREFIX_IF_EXISTS", EXTR_PREFIX_IF_EXISTS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_IF_EXISTS", EXTR_IF_EXISTS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("EXTR_REFS", EXTR_REFS, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("SORT_ASC", PHP_SORT_ASC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_DESC", PHP_SORT_DESC, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("SORT_REGULAR", PHP_SORT_REGULAR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_NUMERIC", PHP_SORT_NUMERIC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_STRING", PHP_SORT_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_LOCALE_STRING", PHP_SORT_LOCALE_STRING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_NATURAL", PHP_SORT_NATURAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SORT_FLAG_CASE", PHP_SORT_FLAG_CASE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("CASE_LOWER", CASE_LOWER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CASE_UPPER", CASE_UPPER, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("COUNT_NORMAL", COUNT_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("COUNT_RECURSIVE", COUNT_RECURSIVE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("ARRAY_FILTER_USE_BOTH", ARRAY_FILTER_USE_BOTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ARRAY_FILTER_USE_KEY", ARRAY_FILTER_USE_KEY, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -182,13 +182,13 @@ static int php_array_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ s = (Bucket *) b; if (f->key == NULL) { - ZVAL_LONG(&first, f->h); + ZVAL_INT(&first, f->h); } else { ZVAL_STR(&first, f->key); } if (s->key == 0) { - ZVAL_LONG(&second, s->h); + ZVAL_INT(&second, s->h); } else { ZVAL_STR(&second, s->key); } @@ -197,13 +197,13 @@ static int php_array_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ return 0; } - if (EXPECTED(Z_TYPE(result) == IS_LONG)) { - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + if (EXPECTED(Z_TYPE(result) == IS_INT)) { + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } else if (Z_TYPE(result) == IS_DOUBLE) { return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } - return ZEND_NORMALIZE_BOOL(zval_get_long(&result)); + return ZEND_NORMALIZE_BOOL(zval_get_int(&result)); } /* }}} */ @@ -255,7 +255,7 @@ PHP_FUNCTION(ksort) PHPAPI int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */ { - long cnt = 0; + php_int_t cnt = 0; zval *element; if (Z_TYPE_P(array) == IS_ARRAY) { @@ -288,25 +288,25 @@ PHPAPI int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */ PHP_FUNCTION(count) { zval *array; - long mode = COUNT_NORMAL; - long cnt; + php_int_t mode = COUNT_NORMAL; + php_int_t cnt; zval *element; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &array, &mode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|i", &array, &mode) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 2) Z_PARAM_ZVAL(array) Z_PARAM_OPTIONAL - Z_PARAM_LONG(mode) + Z_PARAM_INT(mode) ZEND_PARSE_PARAMETERS_END(); #endif switch (Z_TYPE_P(array)) { case IS_NULL: - RETURN_LONG(0); + RETURN_INT(0); break; case IS_ARRAY: cnt = zend_hash_num_elements(Z_ARRVAL_P(array)); @@ -316,7 +316,7 @@ PHP_FUNCTION(count) cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC); } ZEND_HASH_FOREACH_END(); } - RETURN_LONG(cnt); + RETURN_INT(cnt); break; case IS_OBJECT: { #ifdef HAVE_SPL @@ -324,8 +324,8 @@ PHP_FUNCTION(count) #endif /* first, we check if the handler is defined */ if (Z_OBJ_HT_P(array)->count_elements) { - RETVAL_LONG(1); - if (SUCCESS == Z_OBJ_HT(*array)->count_elements(array, &Z_LVAL_P(return_value) TSRMLS_CC)) { + RETVAL_INT(1); + if (SUCCESS == Z_OBJ_HT(*array)->count_elements(array, &Z_IVAL_P(return_value) TSRMLS_CC)) { return; } } @@ -334,7 +334,7 @@ PHP_FUNCTION(count) if (Z_OBJ_HT_P(array)->get_class_entry && instanceof_function(Z_OBJCE_P(array), spl_ce_Countable TSRMLS_CC)) { zend_call_method_with_0_params(array, NULL, NULL, "count", &retval); if (Z_TYPE(retval) != IS_UNDEF) { - RETVAL_LONG(zval_get_long(&retval)); + RETVAL_INT(zval_get_int(&retval)); zval_ptr_dtor(&retval); } return; @@ -342,7 +342,7 @@ PHP_FUNCTION(count) #endif } default: - RETURN_LONG(1); + RETURN_INT(1); break; } } @@ -378,13 +378,13 @@ static int php_array_data_compare(const void *a, const void *b TSRMLS_DC) /* {{{ return 0; } - if (EXPECTED(Z_TYPE(result) == IS_LONG)) { - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + if (EXPECTED(Z_TYPE(result) == IS_INT)) { + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } else if (Z_TYPE(result) == IS_DOUBLE) { return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } - return ZEND_NORMALIZE_BOOL(zval_get_long(&result)); + return ZEND_NORMALIZE_BOOL(zval_get_int(&result)); } /* }}} */ @@ -557,7 +557,7 @@ static int php_array_user_compare(const void *a, const void *b TSRMLS_DC) /* {{{ BG(user_compare_fci).retval = &retval; BG(user_compare_fci).no_separation = 0; if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - long ret = zval_get_long(&retval); + long ret = zval_get_int(&retval); zval_ptr_dtor(&retval); zval_ptr_dtor(&args[1]); zval_ptr_dtor(&args[0]); @@ -704,12 +704,12 @@ static int php_array_user_key_compare(const void *a, const void *b TSRMLS_DC) /* s = (Bucket *) b; if (f->key == NULL) { - ZVAL_LONG(&args[0], f->h); + ZVAL_INT(&args[0], f->h); } else { ZVAL_STR(&args[0], STR_COPY(f->key)); } if (s->key == NULL) { - ZVAL_LONG(&args[1], s->h); + ZVAL_INT(&args[1], s->h); } else { ZVAL_STR(&args[1], STR_COPY(s->key)); } @@ -719,7 +719,7 @@ static int php_array_user_key_compare(const void *a, const void *b TSRMLS_DC) /* BG(user_compare_fci).retval = &retval; BG(user_compare_fci).no_separation = 0; if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - result = zval_get_long(&retval); + result = zval_get_int(&retval); zval_ptr_dtor(&retval); } else { result = 0; @@ -1230,7 +1230,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ *array, /* array to check in */ *entry, /* pointer to array entry */ res; /* comparison result */ - ulong num_idx; + php_uint_t num_idx; zend_string *str_idx; zend_bool strict = 0; /* strict comparison or not */ @@ -1258,7 +1258,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ if (str_idx) { RETVAL_STR(STR_COPY(str_idx)); } else { - RETVAL_LONG(num_idx); + RETVAL_INT(num_idx); } return; } @@ -1273,7 +1273,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ if (str_idx) { RETVAL_STR(STR_COPY(str_idx)); } else { - RETVAL_LONG(num_idx); + RETVAL_INT(num_idx); } return; } @@ -1339,14 +1339,14 @@ static int php_valid_var_name(char *var_name, int var_name_len) /* {{{ */ PHPAPI int php_prefix_varname(zval *result, zval *prefix, char *var_name, int var_name_len, zend_bool add_underscore TSRMLS_DC) /* {{{ */ { - ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0)); - memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRLEN_P(prefix)); + ZVAL_NEW_STR(result, STR_ALLOC(Z_STRSIZE_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0)); + memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRSIZE_P(prefix)); if (add_underscore) { - Z_STRVAL_P(result)[Z_STRLEN_P(prefix)] = '_'; + Z_STRVAL_P(result)[Z_STRSIZE_P(prefix)] = '_'; } - memcpy(Z_STRVAL_P(result) + Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0), var_name, var_name_len + 1); + memcpy(Z_STRVAL_P(result) + Z_STRSIZE_P(prefix) + (add_underscore ? 1 : 0), var_name, var_name_len + 1); return SUCCESS; } @@ -1360,7 +1360,7 @@ PHP_FUNCTION(extract) long extract_type = EXTR_OVERWRITE; zval *entry; zend_string *var_name; - ulong num_key; + php_uint_t num_key; int var_exists, count = 0; int extract_refs = 0; zend_array *symbol_table; @@ -1384,7 +1384,7 @@ PHP_FUNCTION(extract) if (prefix) { convert_to_string(prefix); - if (Z_STRLEN_P(prefix) && !php_valid_var_name(Z_STRVAL_P(prefix), Z_STRLEN_P(prefix))) { + if (Z_STRSIZE_P(prefix) && !php_valid_var_name(Z_STRVAL_P(prefix), Z_STRSIZE_P(prefix))) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "prefix is not a valid identifier"); return; } @@ -1403,9 +1403,9 @@ PHP_FUNCTION(extract) } else if (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID) { zval num; - ZVAL_LONG(&num, num_key); + ZVAL_INT(&num, num_key); convert_to_string(&num); - php_prefix_varname(&final_name, prefix, Z_STRVAL(num), Z_STRLEN(num), 1 TSRMLS_CC); + php_prefix_varname(&final_name, prefix, Z_STRVAL(num), Z_STRSIZE(num), 1 TSRMLS_CC); zval_dtor(&num); } else { continue; @@ -1462,7 +1462,7 @@ PHP_FUNCTION(extract) break; } - if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) { + if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRSIZE(final_name))) { if (extract_refs) { zval *orig_var; @@ -1487,7 +1487,7 @@ PHP_FUNCTION(extract) zval_dtor(&final_name); } ZEND_HASH_FOREACH_END(); - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -1554,9 +1554,9 @@ PHP_FUNCTION(compact) PHP_FUNCTION(array_fill) { zval *val; - long start_key, num; + php_int_t start_key, num; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llz", &start_key, &num, &val) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iiz", &start_key, &num, &val) == FAILURE) { return; } @@ -1603,9 +1603,9 @@ PHP_FUNCTION(array_fill_keys) ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(keys), entry) { ZVAL_DEREF(entry); - if (Z_TYPE_P(entry) == IS_LONG) { + if (Z_TYPE_P(entry) == IS_INT) { zval_add_ref(val); - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), val); } else { zend_string *key = zval_get_string(entry); @@ -1632,7 +1632,7 @@ PHP_FUNCTION(range) if (zstep) { if (Z_TYPE_P(zstep) == IS_DOUBLE || - (Z_TYPE_P(zstep) == IS_STRING && is_numeric_string(Z_STRVAL_P(zstep), Z_STRLEN_P(zstep), NULL, NULL, 0) == IS_DOUBLE) + (Z_TYPE_P(zstep) == IS_STRING && is_numeric_string(Z_STRVAL_P(zstep), Z_STRSIZE_P(zstep), NULL, NULL, 0) == IS_DOUBLE) ) { is_step_double = 1; } @@ -1649,17 +1649,17 @@ PHP_FUNCTION(range) array_init(return_value); /* If the range is given as strings, generate an array of characters. */ - if (Z_TYPE_P(zlow) == IS_STRING && Z_TYPE_P(zhigh) == IS_STRING && Z_STRLEN_P(zlow) >= 1 && Z_STRLEN_P(zhigh) >= 1) { + if (Z_TYPE_P(zlow) == IS_STRING && Z_TYPE_P(zhigh) == IS_STRING && Z_STRSIZE_P(zlow) >= 1 && Z_STRSIZE_P(zhigh) >= 1) { int type1, type2; unsigned char low, high; - long lstep = (long) step; + php_int_t lstep = (php_int_t) step; - type1 = is_numeric_string(Z_STRVAL_P(zlow), Z_STRLEN_P(zlow), NULL, NULL, 0); - type2 = is_numeric_string(Z_STRVAL_P(zhigh), Z_STRLEN_P(zhigh), NULL, NULL, 0); + type1 = is_numeric_string(Z_STRVAL_P(zlow), Z_STRSIZE_P(zlow), NULL, NULL, 0); + type2 = is_numeric_string(Z_STRVAL_P(zhigh), Z_STRSIZE_P(zhigh), NULL, NULL, 0); if (type1 == IS_DOUBLE || type2 == IS_DOUBLE || is_step_double) { goto double_str; - } else if (type1 == IS_LONG || type2 == IS_LONG) { + } else if (type1 == IS_INT || type2 == IS_INT) { goto long_str; } @@ -1709,7 +1709,7 @@ PHP_FUNCTION(range) } else if (Z_TYPE_P(zlow) == IS_DOUBLE || Z_TYPE_P(zhigh) == IS_DOUBLE || is_step_double) { double low, high, value; - long i; + php_int_t i; double_str: low = zval_get_double(zlow); high = zval_get_double(zhigh); @@ -1742,20 +1742,20 @@ double_str: } } else { double low, high; - long lstep; + php_int_t lstep; long_str: low = zval_get_double(zlow); high = zval_get_double(zhigh); - lstep = (long) step; + lstep = (php_int_t) step; - Z_TYPE_INFO(tmp) = IS_LONG; + Z_TYPE_INFO(tmp) = IS_INT; if (low > high) { /* Negative steps */ if (low - high < lstep || lstep <= 0) { err = 1; goto err; } for (; low >= high; low -= lstep) { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (php_int_t)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } else if (high > low) { /* Positive steps */ @@ -1764,11 +1764,11 @@ long_str: goto err; } for (; low <= high; low += lstep) { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (php_int_t)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } else { - Z_LVAL(tmp) = (long)low; + Z_IVAL(tmp) = (php_int_t)low; zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &tmp); } } @@ -1985,7 +1985,7 @@ PHP_FUNCTION(array_push) } /* Clean up and return the number of values in the stack */ - RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack))); + RETVAL_INT(zend_hash_num_elements(Z_ARRVAL_P(stack))); } /* }}} */ @@ -1995,7 +1995,7 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end) zval *stack, /* Input stack */ *val; /* Value to be popped */ zend_string *key = NULL; - ulong index; + php_uint_t index; #ifndef FAST_ZPP if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &stack) == FAILURE) { @@ -2129,7 +2129,7 @@ PHP_FUNCTION(array_unshift) zend_hash_destroy(&old_hash); /* Clean up and return the number of elements in the stack */ - RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack))); + RETVAL_INT(zend_hash_num_elements(Z_ARRVAL_P(stack))); } /* }}} */ @@ -2145,13 +2145,13 @@ PHP_FUNCTION(array_splice) HashTable old_hash; uint idx; Bucket *p; /* Bucket used for traversing hash */ - long i, + php_int_t i, offset, length = 0, repl_num = 0; /* Number of replacement elements */ int num_in; /* Number of elements in the input array */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/l|lz/", &array, &offset, &length, &repl_array) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/i|iz/", &array, &offset, &length, &repl_array) == FAILURE) { return; } @@ -2190,7 +2190,7 @@ PHP_FUNCTION(array_splice) /* ..and the length */ if (length < 0) { size = num_in - offset + length; - } else if (((unsigned long) offset + (unsigned long) length) > (unsigned) num_in) { + } else if (((php_uint_t) offset + (php_uint_t) length) > (unsigned) num_in) { size = num_in - offset; } @@ -2222,22 +2222,22 @@ PHP_FUNCTION(array_slice) zval *input, /* Input array */ *z_length = NULL, /* How many elements to get */ *entry; /* An array entry */ - long offset, /* Offset to get elements from */ + php_int_t offset, /* Offset to get elements from */ length = 0; zend_bool preserve_keys = 0; /* Whether to preserve keys while copying to the new array or not */ int num_in, /* Number of elements in the input array */ pos; /* Current position in the array */ zend_string *string_key; - ulong num_key; + php_uint_t num_key; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ai|zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(2, 4) Z_PARAM_ARRAY(input) - Z_PARAM_LONG(offset) + Z_PARAM_INT(offset) Z_PARAM_OPTIONAL Z_PARAM_ZVAL(z_length) Z_PARAM_BOOL(preserve_keys) @@ -2251,7 +2251,7 @@ PHP_FUNCTION(array_slice) if (ZEND_NUM_ARGS() < 3 || Z_TYPE_P(z_length) == IS_NULL) { length = num_in; } else { - length = zval_get_long(z_length); + length = zval_get_int(z_length); } /* Clamp the offset.. */ @@ -2265,7 +2265,7 @@ PHP_FUNCTION(array_slice) /* ..and the length */ if (length < 0) { length = num_in - offset + length; - } else if (((unsigned long) offset + (unsigned long) length) > (unsigned) num_in) { + } else if (((php_uint_t) offset + (php_uint_t) length) > (unsigned) num_in) { length = num_in - offset; } @@ -2404,7 +2404,7 @@ PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC { zval *src_entry, *dest_entry, *src_zval, *dest_zval; zend_string *string_key; - ulong num_key; + php_uint_t num_key; int ret; ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) { @@ -2564,7 +2564,7 @@ PHP_FUNCTION(array_keys) new_val; /* New value */ int add_key; /* Flag to indicate whether a key should be added */ zend_bool strict = 0; /* do strict comparison */ - ulong num_idx; + php_uint_t num_idx; zend_string *str_idx; int (*is_equal_func)(zval *, zval *, zval * TSRMLS_DC) = is_equal_function; @@ -2604,7 +2604,7 @@ PHP_FUNCTION(array_keys) if (str_idx) { ZVAL_STR(&new_val, STR_COPY(str_idx)); } else { - ZVAL_LONG(&new_val, num_idx); + ZVAL_INT(&new_val, num_idx); } zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &new_val); } @@ -2653,21 +2653,21 @@ PHP_FUNCTION(array_count_values) /* Go through input array and add values to the return array */ myht = Z_ARRVAL_P(input); ZEND_HASH_FOREACH_VAL(myht, entry) { - if (Z_TYPE_P(entry) == IS_LONG) { - if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_P(entry))) == NULL) { + if (Z_TYPE_P(entry) == IS_INT) { + if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_IVAL_P(entry))) == NULL) { zval data; - ZVAL_LONG(&data, 1); - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data); + ZVAL_INT(&data, 1); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), &data); } else { - Z_LVAL_P(tmp)++; + Z_IVAL_P(tmp)++; } } else if (Z_TYPE_P(entry) == IS_STRING) { if ((tmp = zend_symtable_find(Z_ARRVAL_P(return_value), Z_STR_P(entry))) == NULL) { zval data; - ZVAL_LONG(&data, 1); + ZVAL_INT(&data, 1); zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data); } else { - Z_LVAL_P(tmp)++; + Z_IVAL_P(tmp)++; } } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only count STRING and INTEGER values!"); @@ -2684,9 +2684,9 @@ zend_bool array_column_param_helper(zval *param, const char *name TSRMLS_DC) { switch (Z_TYPE_P(param)) { case IS_DOUBLE: - convert_to_long_ex(param); + convert_to_int_ex(param); /* fallthrough */ - case IS_LONG: + case IS_INT: return 1; case IS_OBJECT: @@ -2736,8 +2736,8 @@ PHP_FUNCTION(array_column) } else if ((Z_TYPE_P(zcolumn) == IS_STRING) && ((zcolval = zend_hash_find(ht, Z_STR_P(zcolumn))) == NULL)) { continue; - } else if ((Z_TYPE_P(zcolumn) == IS_LONG) && - ((zcolval = zend_hash_index_find(ht, Z_LVAL_P(zcolumn))) == NULL)) { + } else if ((Z_TYPE_P(zcolumn) == IS_INT) && + ((zcolval = zend_hash_index_find(ht, Z_IVAL_P(zcolumn))) == NULL)) { continue; } @@ -2746,8 +2746,8 @@ PHP_FUNCTION(array_column) */ if (zkey && (Z_TYPE_P(zkey) == IS_STRING)) { zkeyval = zend_hash_find(ht, Z_STR_P(zkey)); - } else if (zkey && (Z_TYPE_P(zkey) == IS_LONG)) { - zkeyval = zend_hash_index_find(ht, Z_LVAL_P(zkey)); + } else if (zkey && (Z_TYPE_P(zkey) == IS_INT)) { + zkeyval = zend_hash_index_find(ht, Z_IVAL_P(zkey)); } if (Z_REFCOUNTED_P(zcolval)) { @@ -2755,8 +2755,8 @@ PHP_FUNCTION(array_column) } if (zkeyval && Z_TYPE_P(zkeyval) == IS_STRING) { zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(zkeyval), zcolval); - } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_LONG) { - add_index_zval(return_value, Z_LVAL_P(zkeyval), zcolval); + } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_INT) { + add_index_zval(return_value, Z_IVAL_P(zkeyval), zcolval); } else if (zkeyval && Z_TYPE_P(zkeyval) == IS_OBJECT) { SEPARATE_ZVAL(zkeyval); convert_to_string(zkeyval); @@ -2775,7 +2775,7 @@ PHP_FUNCTION(array_reverse) zval *input, /* Input array */ *entry; /* An entry in the input array */ zend_string *string_key; - ulong num_key; + php_uint_t num_key; zend_bool preserve_keys = 0; /* whether to preserve keys */ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &input, &preserve_keys) == FAILURE) { @@ -2810,20 +2810,20 @@ PHP_FUNCTION(array_pad) zval *pads; /* Array to pass to splice */ HashTable *new_hash;/* Return value from splice */ HashTable old_hash; - long pad_size; /* Size to pad to */ - long pad_size_abs; /* Absolute value of pad_size */ + php_int_t pad_size; /* Size to pad to */ + php_int_t pad_size_abs; /* Absolute value of pad_size */ int input_size; /* Size of the input array */ int num_pads; /* How many pads do we need */ int do_pad; /* Whether we should do padding at all */ int i; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "alz", &input, &pad_size, &pad_value) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aiz", &input, &pad_size, &pad_value) == FAILURE) { return; } /* Do some initial calculations */ input_size = zend_hash_num_elements(Z_ARRVAL_P(input)); - pad_size_abs = abs(pad_size); + pad_size_abs = ZEND_ABS(pad_size); if (pad_size_abs < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "You may only pad up to 1048576 elements at a time"); zval_dtor(return_value); @@ -2874,7 +2874,7 @@ PHP_FUNCTION(array_pad) PHP_FUNCTION(array_flip) { zval *array, *entry, data; - ulong num_idx; + php_uint_t num_idx; zend_string *str_idx; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) { @@ -2884,18 +2884,18 @@ PHP_FUNCTION(array_flip) array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array))); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) { - if (Z_TYPE_P(entry) == IS_LONG) { + if (Z_TYPE_P(entry) == IS_INT) { if (str_idx) { ZVAL_STR(&data, STR_COPY(str_idx)); } else { - ZVAL_LONG(&data, num_idx); + ZVAL_INT(&data, num_idx); } - zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data); + zend_hash_index_update(Z_ARRVAL_P(return_value), Z_IVAL_P(entry), &data); } else if (Z_TYPE_P(entry) == IS_STRING) { if (str_idx) { ZVAL_STR(&data, STR_COPY(str_idx)); } else { - ZVAL_LONG(&data, num_idx); + ZVAL_INT(&data, num_idx); } zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data); } else { @@ -2912,10 +2912,10 @@ PHP_FUNCTION(array_change_key_case) zval *array, *entry; zend_string *string_key; zend_string *new_key; - ulong num_key; - long change_to_upper=0; + php_uint_t num_key; + php_int_t change_to_upper=0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &change_to_upper) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|i", &array, &change_to_upper) == FAILURE) { return; } @@ -3035,8 +3035,8 @@ static int zval_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */ return ZEND_NORMALIZE_BOOL(Z_DVAL(result)); } - convert_to_long(&result); - return ZEND_NORMALIZE_BOOL(Z_LVAL(result)); + convert_to_int(&result); + return ZEND_NORMALIZE_BOOL(Z_IVAL(result)); } /* }}} */ @@ -3061,7 +3061,7 @@ static int zval_user_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */ BG(user_compare_fci).no_separation = 0; if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - long ret = zval_get_long(&retval); + long ret = zval_get_int(&retval); zval_ptr_dtor(&retval); return ret < 0 ? -1 : ret > 0 ? 1 : 0;; } else { @@ -3935,7 +3935,7 @@ PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC) /* {{{ php_set_compare_func(ARRAYG(multisort_flags)[MULTISORT_TYPE][r] TSRMLS_CC); ARRAYG(compare_func)(&temp, &ab[r].val, &bb[r].val TSRMLS_CC); - result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_LVAL(temp); + result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_IVAL(temp); if (result != 0) { return result; } @@ -4008,14 +4008,14 @@ PHP_FUNCTION(array_multisort) for (k = 0; k < MULTISORT_LAST; k++) { parse_state[k] = 1; } - } else if (Z_TYPE_P(arg) == IS_LONG) { - switch (Z_LVAL_P(arg) & ~PHP_SORT_FLAG_CASE) { + } else if (Z_TYPE_P(arg) == IS_INT) { + switch (Z_IVAL_P(arg) & ~PHP_SORT_FLAG_CASE) { case PHP_SORT_ASC: case PHP_SORT_DESC: /* flag allowed here */ if (parse_state[MULTISORT_ORDER] == 1) { /* Save the flag and make sure then next arg is not the current flag. */ - sort_order = Z_LVAL(args[i]) == PHP_SORT_DESC ? -1 : 1; + sort_order = Z_IVAL(args[i]) == PHP_SORT_DESC ? -1 : 1; parse_state[MULTISORT_ORDER] = 0; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1); @@ -4033,7 +4033,7 @@ PHP_FUNCTION(array_multisort) /* flag allowed here */ if (parse_state[MULTISORT_TYPE] == 1) { /* Save the flag and make sure then next arg is not the current flag. */ - sort_type = Z_LVAL(args[i]); + sort_type = Z_IVAL(args[i]); parse_state[MULTISORT_TYPE] = 0; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1); @@ -4141,12 +4141,12 @@ PHP_FUNCTION(array_multisort) PHP_FUNCTION(array_rand) { zval *input; - long randval, num_req = 1; + php_int_t randval, num_req = 1; int num_avail; zend_string *string_key; - ulong num_key; + php_uint_t num_key; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &input, &num_req) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|i", &input, &num_req) == FAILURE) { return; } @@ -4178,14 +4178,14 @@ PHP_FUNCTION(array_rand) if (string_key) { RETURN_STR(STR_COPY(string_key)); } else { - RETURN_LONG(num_key); + RETURN_INT(num_key); } } else { /* Append the result to the return value. */ if (string_key) { add_next_index_str(return_value, STR_COPY(string_key)); } else { - add_next_index_long(return_value, num_key); + add_next_index_int(return_value, num_key); } } num_req--; @@ -4207,7 +4207,7 @@ PHP_FUNCTION(array_sum) return; } - ZVAL_LONG(return_value, 0); + ZVAL_INT(return_value, 0); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), entry) { if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) { @@ -4233,7 +4233,7 @@ PHP_FUNCTION(array_product) return; } - ZVAL_LONG(return_value, 1); + ZVAL_INT(return_value, 1); if (!zend_hash_num_elements(Z_ARRVAL_P(input))) { return; } @@ -4245,10 +4245,10 @@ PHP_FUNCTION(array_product) ZVAL_DUP(&entry_n, entry); convert_scalar_to_number(&entry_n TSRMLS_CC); - if (Z_TYPE(entry_n) == IS_LONG && Z_TYPE_P(return_value) == IS_LONG) { - dval = (double)Z_LVAL_P(return_value) * (double)Z_LVAL(entry_n); - if ( (double)LONG_MIN <= dval && dval <= (double)LONG_MAX ) { - Z_LVAL_P(return_value) *= Z_LVAL(entry_n); + if (Z_TYPE(entry_n) == IS_INT && Z_TYPE_P(return_value) == IS_INT) { + dval = (double)Z_IVAL_P(return_value) * (double)Z_IVAL(entry_n); + if ( (double)PHP_INT_MIN <= dval && dval <= (double)PHP_INT_MAX ) { + Z_IVAL_P(return_value) *= Z_IVAL(entry_n); continue; } } @@ -4328,7 +4328,7 @@ PHP_FUNCTION(array_filter) zend_string *string_key; zend_fcall_info fci = empty_fcall_info; zend_fcall_info_cache fci_cache = empty_fcall_info_cache; - ulong num_key; + php_uint_t num_key; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|fl", &array, &fci, &fci_cache, &use_type) == FAILURE) { return; @@ -4353,9 +4353,9 @@ PHP_FUNCTION(array_filter) if (!string_key) { if (use_type == ARRAY_FILTER_USE_BOTH) { fci.param_count = 2; - ZVAL_LONG(&args[1], num_key); + ZVAL_INT(&args[1], num_key); } else if (use_type == ARRAY_FILTER_USE_KEY) { - ZVAL_LONG(&args[0], num_key); + ZVAL_INT(&args[0], num_key); } } else { if (use_type == ARRAY_FILTER_USE_BOTH) { @@ -4432,7 +4432,7 @@ PHP_FUNCTION(array_map) RETVAL_NULL(); if (n_arrays == 1) { - ulong num_key; + php_uint_t num_key; zend_string *str_key; zval *zv; @@ -4597,8 +4597,8 @@ PHP_FUNCTION(array_key_exists) RETURN_TRUE; } RETURN_FALSE; - case IS_LONG: - if (zend_hash_index_exists(array, Z_LVAL_P(key))) { + case IS_INT: + if (zend_hash_index_exists(array, Z_IVAL_P(key))) { RETURN_TRUE; } RETURN_FALSE; @@ -4620,15 +4620,15 @@ PHP_FUNCTION(array_key_exists) PHP_FUNCTION(array_chunk) { int argc = ZEND_NUM_ARGS(), num_in; - long size, current = 0; + php_int_t size, current = 0; zend_string *str_key; - ulong num_key; + php_uint_t num_key; zend_bool preserve_keys = 0; zval *input = NULL; zval chunk; zval *entry; - if (zend_parse_parameters(argc TSRMLS_CC, "al|b", &input, &size, &preserve_keys) == FAILURE) { + if (zend_parse_parameters(argc TSRMLS_CC, "ai|b", &input, &size, &preserve_keys) == FAILURE) { return; } /* Do bounds checking for size parameter. */ @@ -4714,9 +4714,9 @@ PHP_FUNCTION(array_combine) break; } else if (Z_TYPE(Z_ARRVAL_P(values)->arData[pos_values].val) != IS_UNDEF) { entry_values = &Z_ARRVAL_P(values)->arData[pos_values].val; - if (Z_TYPE_P(entry_keys) == IS_LONG) { + if (Z_TYPE_P(entry_keys) == IS_INT) { zval_add_ref(entry_values); - add_index_zval(return_value, Z_LVAL_P(entry_keys), entry_values); + add_index_zval(return_value, Z_IVAL_P(entry_keys), entry_values); } else { zend_string *key = zval_get_string(entry_keys); diff --git a/ext/standard/assert.c b/ext/standard/assert.c index e64e2e1ecb..062b15f8b6 100644 --- a/ext/standard/assert.c +++ b/ext/standard/assert.c @@ -98,11 +98,11 @@ PHP_MINIT_FUNCTION(assert) /* {{{ */ REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("ASSERT_ACTIVE", ASSERT_ACTIVE, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_CALLBACK", ASSERT_CALLBACK, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_BAIL", ASSERT_BAIL, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_WARNING", ASSERT_WARNING, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("ASSERT_QUIET_EVAL", ASSERT_QUIET_EVAL, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_ACTIVE", ASSERT_ACTIVE, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_CALLBACK", ASSERT_CALLBACK, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_BAIL", ASSERT_BAIL, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_WARNING", ASSERT_WARNING, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("ASSERT_QUIET_EVAL", ASSERT_QUIET_EVAL, CONST_CS|CONST_PERSISTENT); return SUCCESS; } @@ -164,7 +164,7 @@ PHP_FUNCTION(assert) } compiled_string_description = zend_make_compiled_string_description("assert code" TSRMLS_CC); - if (zend_eval_stringl(myeval, Z_STRLEN_P(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) { + if (zend_eval_stringl(myeval, Z_STRSIZE_P(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) { efree(compiled_string_description); if (description_len == 0) { php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Failure evaluating code: %s%s", PHP_EOL, myeval); @@ -205,7 +205,7 @@ PHP_FUNCTION(assert) const char *filename = zend_get_executed_filename(TSRMLS_C); ZVAL_STRING(&args[0], SAFE_STRING(filename)); - ZVAL_LONG (&args[1], lineno); + ZVAL_INT (&args[1], lineno); ZVAL_STRING(&args[2], SAFE_STRING(myeval)); ZVAL_FALSE(&retval); @@ -275,7 +275,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_BAIL: @@ -287,7 +287,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_QUIET_EVAL: @@ -299,7 +299,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_WARNING: @@ -311,7 +311,7 @@ PHP_FUNCTION(assert_options) STR_RELEASE(key); STR_RELEASE(value_str); } - RETURN_LONG(oldint); + RETURN_INT(oldint); break; case ASSERT_CALLBACK: diff --git a/ext/standard/base64.c b/ext/standard/base64.c index 3bc96267b2..7ee643a7d5 100644 --- a/ext/standard/base64.c +++ b/ext/standard/base64.c @@ -53,7 +53,7 @@ static const short base64_reverse_table[256] = { }; /* }}} */ -PHPAPI zend_string *php_base64_encode(const unsigned char *str, int length) /* {{{ */ +PHPAPI zend_string *php_base64_encode(const unsigned char *str, php_size_t length) /* {{{ */ { const unsigned char *current = str; unsigned char *p; @@ -131,13 +131,13 @@ void php_base64_init(void) */ /* }}} */ -PHPAPI zend_string *php_base64_decode(const unsigned char *str, int length) /* {{{ */ +PHPAPI zend_string *php_base64_decode(const unsigned char *str, php_size_t length) /* {{{ */ { return php_base64_decode_ex(str, length, 0); } /* }}} */ -PHPAPI zend_string *php_base64_decode_ex(const unsigned char *str, int length, zend_bool strict) /* {{{ */ +PHPAPI zend_string *php_base64_decode_ex(const unsigned char *str, php_size_t length, zend_bool strict) /* {{{ */ { const unsigned char *current = str; int ch, i = 0, j = 0, k; diff --git a/ext/standard/base64.h b/ext/standard/base64.h index e58565702a..dd07db56e1 100644 --- a/ext/standard/base64.h +++ b/ext/standard/base64.h @@ -24,9 +24,9 @@ PHP_FUNCTION(base64_decode); PHP_FUNCTION(base64_encode); -PHPAPI extern zend_string *php_base64_encode(const unsigned char *, int); -PHPAPI extern zend_string *php_base64_decode_ex(const unsigned char *, int, zend_bool); -PHPAPI extern zend_string *php_base64_decode(const unsigned char *, int); +PHPAPI extern zend_string *php_base64_encode(const unsigned char *, php_size_t); +PHPAPI extern zend_string *php_base64_decode_ex(const unsigned char *, php_size_t, zend_bool); +PHPAPI extern zend_string *php_base64_decode(const unsigned char *, php_size_t); #endif /* BASE64_H */ diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index 17bdae5719..4137823257 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -395,7 +395,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_array_merge, 0, 0, 2) ZEND_ARG_INFO(0, arr1) /* ARRAY_INFO(0, arg, 0) */ ZEND_ARG_VARIADIC_INFO(0, arrays) ZEND_END_ARG_INFO() - + ZEND_BEGIN_ARG_INFO_EX(arginfo_array_merge_recursive, 0, 0, 2) ZEND_ARG_INFO(0, arr1) /* ARRAY_INFO(0, arg, 0) */ ZEND_ARG_VARIADIC_INFO(0, arrays) @@ -3545,28 +3545,28 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */ BG(incomplete_class) = incomplete_class_entry = php_create_incomplete_class(TSRMLS_C); - REGISTER_LONG_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CONNECTION_NORMAL", PHP_CONNECTION_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CONNECTION_TIMEOUT", PHP_CONNECTION_TIMEOUT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("INI_USER", ZEND_INI_USER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_PERDIR", ZEND_INI_PERDIR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_SYSTEM", ZEND_INI_SYSTEM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_ALL", ZEND_INI_ALL, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("INI_SCANNER_NORMAL", ZEND_INI_SCANNER_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("INI_SCANNER_RAW", ZEND_INI_SCANNER_RAW, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("PHP_URL_SCHEME", PHP_URL_SCHEME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_HOST", PHP_URL_HOST, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PORT", PHP_URL_PORT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_USER", PHP_URL_USER, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PASS", PHP_URL_PASS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_PATH", PHP_URL_PATH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_QUERY", PHP_URL_QUERY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_URL_FRAGMENT", PHP_URL_FRAGMENT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_QUERY_RFC1738", PHP_QUERY_RFC1738, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_QUERY_RFC3986", PHP_QUERY_RFC3986, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_NORMAL", PHP_CONNECTION_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CONNECTION_TIMEOUT", PHP_CONNECTION_TIMEOUT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("INI_USER", ZEND_INI_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_PERDIR", ZEND_INI_PERDIR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_SYSTEM", ZEND_INI_SYSTEM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_ALL", ZEND_INI_ALL, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("INI_SCANNER_NORMAL", ZEND_INI_SCANNER_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("INI_SCANNER_RAW", ZEND_INI_SCANNER_RAW, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("PHP_URL_SCHEME", PHP_URL_SCHEME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_HOST", PHP_URL_HOST, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PORT", PHP_URL_PORT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_USER", PHP_URL_USER, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PASS", PHP_URL_PASS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_PATH", PHP_URL_PATH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_QUERY", PHP_URL_QUERY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_URL_FRAGMENT", PHP_URL_FRAGMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_QUERY_RFC1738", PHP_QUERY_RFC1738, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_QUERY_RFC3986", PHP_QUERY_RFC3986, CONST_CS | CONST_PERSISTENT); #define REGISTER_MATH_CONSTANT(x) REGISTER_DOUBLE_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) REGISTER_MATH_CONSTANT(M_E); @@ -3589,10 +3589,10 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */ REGISTER_DOUBLE_CONSTANT("INF", php_get_inf(), CONST_CS | CONST_PERSISTENT); REGISTER_DOUBLE_CONSTANT("NAN", php_get_nan(), CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_UP", PHP_ROUND_HALF_UP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_DOWN", PHP_ROUND_HALF_DOWN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_EVEN", PHP_ROUND_HALF_EVEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PHP_ROUND_HALF_ODD", PHP_ROUND_HALF_ODD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_UP", PHP_ROUND_HALF_UP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_DOWN", PHP_ROUND_HALF_DOWN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_EVEN", PHP_ROUND_HALF_EVEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PHP_ROUND_HALF_ODD", PHP_ROUND_HALF_ODD, CONST_CS | CONST_PERSISTENT); #if ENABLE_TEST_CLASS test_class_startup(); @@ -3925,7 +3925,7 @@ PHP_FUNCTION(ip2long) if (addr_len == 0 || inet_pton(AF_INET, addr, &ip) != 1) { RETURN_FALSE; } - RETURN_LONG(ntohl(ip.s_addr)); + RETURN_INT(ntohl(ip.s_addr)); #else if (addr_len == 0 || (ip = inet_addr(addr)) == INADDR_NONE) { /* The only special case when we should return -1 ourselves, @@ -3934,11 +3934,11 @@ PHP_FUNCTION(ip2long) if (addr_len == sizeof("255.255.255.255") - 1 && !memcmp(addr, "255.255.255.255", sizeof("255.255.255.255") - 1) ) { - RETURN_LONG(0xFFFFFFFF); + RETURN_INT(0xFFFFFFFF); } RETURN_FALSE; } - RETURN_LONG(ntohl(ip)); + RETURN_INT(ntohl(ip)); #endif } /* }}} */ @@ -4342,7 +4342,7 @@ PHP_FUNCTION(getopt) /* Add this option / argument pair to the result hash. */ optname_len = strlen(optname); - if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_LONG) { + if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_INT) { /* numeric string */ int optname_int = atoi(optname); if ((args = zend_hash_index_find(HASH_OF(return_value), optname_int)) != NULL) { @@ -4386,9 +4386,9 @@ PHP_FUNCTION(flush) Delay for a given number of seconds */ PHP_FUNCTION(sleep) { - long num; + php_int_t num; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &num) == FAILURE) { RETURN_FALSE; } if (num < 0) { @@ -4396,7 +4396,7 @@ PHP_FUNCTION(sleep) RETURN_FALSE; } #ifdef PHP_SLEEP_NON_VOID - RETURN_LONG(php_sleep(num)); + RETURN_INT(php_sleep(num)); #else php_sleep(num); #endif @@ -4409,9 +4409,9 @@ PHP_FUNCTION(sleep) PHP_FUNCTION(usleep) { #if HAVE_USLEEP - long num; + php_int_t num; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &num) == FAILURE) { return; } if (num < 0) { @@ -4450,8 +4450,8 @@ PHP_FUNCTION(time_nanosleep) RETURN_TRUE; } else if (errno == EINTR) { array_init(return_value); - add_assoc_long_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); - add_assoc_long_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); + add_assoc_int_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); + add_assoc_int_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); return; } else if (errno == EINVAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "nanoseconds was not in the range 0 to 999 999 999 or seconds was negative"); @@ -4703,10 +4703,10 @@ PHP_FUNCTION(error_get_last) if (PG(last_error_message)) { array_init(return_value); - add_assoc_long_ex(return_value, "type", sizeof("type")-1, PG(last_error_type)); + add_assoc_int_ex(return_value, "type", sizeof("type")-1, PG(last_error_type)); add_assoc_string_ex(return_value, "message", sizeof("message")-1, PG(last_error_message)); add_assoc_string_ex(return_value, "file", sizeof("file")-1, PG(last_error_file)?PG(last_error_file):"-"); - add_assoc_long_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno)); + add_assoc_int_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno)); } } /* }}} */ @@ -4937,11 +4937,11 @@ static int user_tick_function_compare(user_tick_function_entry * tick_fe1, user_ } else if (Z_TYPE_P(func1) == IS_ARRAY && Z_TYPE_P(func2) == IS_ARRAY) { zval result; zend_compare_arrays(&result, func1, func2 TSRMLS_CC); - ret = (Z_LVAL(result) == 0); + ret = (Z_IVAL(result) == 0); } else if (Z_TYPE_P(func1) == IS_OBJECT && Z_TYPE_P(func2) == IS_OBJECT) { zval result; zend_compare_objects(&result, func1, func2 TSRMLS_CC); - ret = (Z_LVAL(result) == 0); + ret = (Z_IVAL(result) == 0); } else { ret = 0; } @@ -5242,7 +5242,7 @@ static int php_ini_get_option(zval *zv TSRMLS_DC, int num_args, va_list args, ze add_assoc_null(&option, "local_value"); } - add_assoc_long(&option, "access", ini_entry->modifiable); + add_assoc_int(&option, "access", ini_entry->modifiable); add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, &option); } else { @@ -5450,7 +5450,7 @@ PHP_FUNCTION(print_r) Returns true if client disconnected */ PHP_FUNCTION(connection_aborted) { - RETURN_LONG(PG(connection_status) & PHP_CONNECTION_ABORTED); + RETURN_INT(PG(connection_status) & PHP_CONNECTION_ABORTED); } /* }}} */ @@ -5458,7 +5458,7 @@ PHP_FUNCTION(connection_aborted) Returns the connection status bitfield */ PHP_FUNCTION(connection_status) { - RETURN_LONG(PG(connection_status)); + RETURN_INT(PG(connection_status)); } /* }}} */ @@ -5482,7 +5482,7 @@ PHP_FUNCTION(ignore_user_abort) STR_RELEASE(key); } - RETURN_LONG(old_setting); + RETURN_INT(old_setting); } /* }}} */ @@ -5514,7 +5514,7 @@ PHP_FUNCTION(getservbyname) RETURN_FALSE; } - RETURN_LONG(ntohs(serv->s_port)); + RETURN_INT(ntohs(serv->s_port)); } /* }}} */ #endif @@ -5563,7 +5563,7 @@ PHP_FUNCTION(getprotobyname) RETURN_FALSE; } - RETURN_LONG(ent->p_proto); + RETURN_INT(ent->p_proto); } /* }}} */ #endif @@ -5777,8 +5777,8 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal break; } - if (!(Z_STRLEN_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), NULL, NULL, 0) == IS_LONG) { - ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)); + if (!(Z_STRSIZE_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRSIZE_P(arg1), NULL, NULL, 0) == IS_INT) { + php_uint_t key = (php_uint_t) zend_atol(Z_STRVAL_P(arg1), Z_STRSIZE_P(arg1)); if ((find_hash = zend_hash_index_find(Z_ARRVAL_P(arr), key)) == NULL) { array_init(&hash); find_hash = zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash); @@ -5797,7 +5797,7 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal ZVAL_DUP(&element, arg2); - if (arg3 && Z_STRLEN_P(arg3) > 0) { + if (arg3 && Z_STRSIZE_P(arg3) > 0) { zend_symtable_update(Z_ARRVAL_P(find_hash), Z_STR_P(arg3), &element); } else { add_next_index_zval(find_hash, &element); diff --git a/ext/standard/basic_functions.h b/ext/standard/basic_functions.h index 3cabf87d1a..ee79269cae 100644 --- a/ext/standard/basic_functions.h +++ b/ext/standard/basic_functions.h @@ -167,7 +167,7 @@ typedef struct _php_basic_globals { char *locale_string; char *strtok_last; char strtok_table[256]; - ulong strtok_len; + php_uint_t strtok_len; char str_ebuf[40]; zend_fcall_info array_walk_fci; zend_fcall_info_cache array_walk_fci_cache; @@ -178,9 +178,9 @@ typedef struct _php_basic_globals { zval active_ini_file_section; /* pageinfo.c */ - long page_uid; - long page_gid; - long page_inode; + php_int_t page_uid; + php_int_t page_gid; + php_int_t page_inode; time_t page_mtime; /* filestat.c && main/streams/streams.c */ diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c index f494cc86b1..c5a4b47744 100644 --- a/ext/standard/browscap.c +++ b/ext/standard/browscap.c @@ -83,15 +83,15 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */ zend_string *res; char *lc_pattern; - res = STR_SAFE_ALLOC(Z_STRLEN_P(pattern), 2, 4, persistent); + res = STR_SAFE_ALLOC(Z_STRSIZE_P(pattern), 2, 4, persistent); t = res->val; - lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern)); + lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRSIZE_P(pattern)); t[j++] = '\xA7'; /* section sign */ t[j++] = '^'; - for (i=0; i<Z_STRLEN_P(pattern); i++, j++) { + for (i=0; i<Z_STRSIZE_P(pattern); i++, j++) { switch (lc_pattern[i]) { case '?': t[j] = '.'; @@ -163,16 +163,16 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb } /* Set proper value for true/false settings */ - if ((Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) || - (Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) || - (Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1)) + if ((Z_STRSIZE_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) || + (Z_STRSIZE_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) || + (Z_STRSIZE_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1)) ) { ZVAL_NEW_STR(&new_property, STR_INIT("1", sizeof("1")-1, persistent)); } else if ( - (Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) || - (Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) || - (Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) || - (Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1)) + (Z_STRSIZE_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) || + (Z_STRSIZE_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) || + (Z_STRSIZE_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) || + (Z_STRSIZE_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1)) ) { // TODO: USE STR_EMPTY_ALLOC()? ZVAL_NEW_STR(&new_property, STR_INIT("", sizeof("")-1, persistent)); @@ -203,7 +203,7 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb pefree(bdata->current_section_name, persistent); } bdata->current_section_name = pestrndup(Z_STRVAL_P(arg1), - Z_STRLEN_P(arg1), persistent); + Z_STRSIZE_P(arg1), persistent); zend_hash_update(bdata->htab, Z_STR_P(arg1), &bdata->current_section); @@ -388,7 +388,7 @@ static int browser_reg_compare(zval *browser TSRMLS_DC, int num_args, va_list ar ua_len = lookup_browser_length; - for (i = 0; i < Z_STRLEN_P(previous_match); i++) { + for (i = 0; i < Z_STRSIZE_P(previous_match); i++) { switch (Z_STRVAL_P(previous_match)[i]) { case '?': case '*': @@ -400,7 +400,7 @@ static int browser_reg_compare(zval *browser TSRMLS_DC, int num_args, va_list ar } } - for (i = 0; i < Z_STRLEN_P(current_match); i++) { + for (i = 0; i < Z_STRSIZE_P(current_match); i++) { switch (Z_STRVAL_P(current_match)[i]) { case '?': case '*': @@ -475,7 +475,7 @@ PHP_FUNCTION(get_browser) RETURN_FALSE; } agent_name = Z_STRVAL_P(http_user_agent); - agent_name_len = Z_STRLEN_P(http_user_agent); + agent_name_len = Z_STRSIZE_P(http_user_agent); } lookup_browser_name = estrndup(agent_name, agent_name_len); diff --git a/ext/standard/crc32.c b/ext/standard/crc32.c index e9176e84da..6ff40d57c8 100644 --- a/ext/standard/crc32.c +++ b/ext/standard/crc32.c @@ -39,7 +39,7 @@ PHP_NAMED_FUNCTION(php_if_crc32) for (; nr--; ++p) { crc = ((crc >> 8) & 0x00FFFFFF) ^ crc32tab[(crc ^ (*p)) & 0xFF ]; } - RETVAL_LONG(crc^0xFFFFFFFF); + RETVAL_INT(crc^0xFFFFFFFF); } /* }}} */ diff --git a/ext/standard/crypt.c b/ext/standard/crypt.c index 2a2304be20..86ae9bee13 100644 --- a/ext/standard/crypt.c +++ b/ext/standard/crypt.c @@ -102,18 +102,18 @@ PHP_MINIT_FUNCTION(crypt) /* {{{ */ { - REGISTER_LONG_CONSTANT("CRYPT_SALT_LENGTH", PHP_MAX_SALT_LEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_STD_DES", PHP_STD_DES_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_EXT_DES", PHP_EXT_DES_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_MD5", PHP_MD5_CRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("CRYPT_BLOWFISH", PHP_BLOWFISH_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SALT_LENGTH", PHP_MAX_SALT_LEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_STD_DES", PHP_STD_DES_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_EXT_DES", PHP_EXT_DES_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_MD5", PHP_MD5_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_BLOWFISH", PHP_BLOWFISH_CRYPT, CONST_CS | CONST_PERSISTENT); #ifdef PHP_SHA256_CRYPT - REGISTER_LONG_CONSTANT("CRYPT_SHA256", PHP_SHA256_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SHA256", PHP_SHA256_CRYPT, CONST_CS | CONST_PERSISTENT); #endif #ifdef PHP_SHA512_CRYPT - REGISTER_LONG_CONSTANT("CRYPT_SHA512", PHP_SHA512_CRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CRYPT_SHA512", PHP_SHA512_CRYPT, CONST_CS | CONST_PERSISTENT); #endif #if PHP_USE_PHP_CRYPT_R diff --git a/ext/standard/crypt_sha256.c b/ext/standard/crypt_sha256.c index ccfa66bd60..bf731b256f 100644 --- a/ext/standard/crypt_sha256.c +++ b/ext/standard/crypt_sha256.c @@ -372,7 +372,7 @@ char * php_sha256_crypt_r(const char *key, const char *salt, char *buffer, int b if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1) == 0) { const char *num = salt + sizeof(sha256_rounds_prefix) - 1; char *endp; - unsigned long int srounds = strtoul(num, &endp, 10); + php_uint_t srounds = ZEND_STRTOUI(num, &endp, 10); if (*endp == '$') { salt = endp + 1; rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX)); diff --git a/ext/standard/crypt_sha512.c b/ext/standard/crypt_sha512.c index ebabed9d24..f0732e3e17 100644 --- a/ext/standard/crypt_sha512.c +++ b/ext/standard/crypt_sha512.c @@ -405,7 +405,7 @@ php_sha512_crypt_r(const char *key, const char *salt, char *buffer, int buflen) if (strncmp(salt, sha512_rounds_prefix, sizeof(sha512_rounds_prefix) - 1) == 0) { const char *num = salt + sizeof(sha512_rounds_prefix) - 1; char *endp; - unsigned long int srounds = strtoul(num, &endp, 10); + php_uint_t srounds = ZEND_STRTOUI(num, &endp, 10); if (*endp == '$') { salt = endp + 1; diff --git a/ext/standard/datetime.c b/ext/standard/datetime.c index 80a34a4548..8743708ad9 100644 --- a/ext/standard/datetime.c +++ b/ext/standard/datetime.c @@ -104,14 +104,14 @@ PHP_FUNCTION(strptime) } array_init(return_value); - add_assoc_long(return_value, "tm_sec", parsed_time.tm_sec); - add_assoc_long(return_value, "tm_min", parsed_time.tm_min); - add_assoc_long(return_value, "tm_hour", parsed_time.tm_hour); - add_assoc_long(return_value, "tm_mday", parsed_time.tm_mday); - add_assoc_long(return_value, "tm_mon", parsed_time.tm_mon); - add_assoc_long(return_value, "tm_year", parsed_time.tm_year); - add_assoc_long(return_value, "tm_wday", parsed_time.tm_wday); - add_assoc_long(return_value, "tm_yday", parsed_time.tm_yday); + add_assoc_int(return_value, "tm_sec", parsed_time.tm_sec); + add_assoc_int(return_value, "tm_min", parsed_time.tm_min); + add_assoc_int(return_value, "tm_hour", parsed_time.tm_hour); + add_assoc_int(return_value, "tm_mday", parsed_time.tm_mday); + add_assoc_int(return_value, "tm_mon", parsed_time.tm_mon); + add_assoc_int(return_value, "tm_year", parsed_time.tm_year); + add_assoc_int(return_value, "tm_wday", parsed_time.tm_wday); + add_assoc_int(return_value, "tm_yday", parsed_time.tm_yday); add_assoc_string(return_value, "unparsed", unparsed_part); } /* }}} */ diff --git a/ext/standard/dir.c b/ext/standard/dir.c index 16cc8db054..3e65f72699 100644 --- a/ext/standard/dir.c +++ b/ext/standard/dir.c @@ -148,44 +148,44 @@ PHP_MINIT_FUNCTION(dir) pathsep_str[1] = '\0'; REGISTER_STRING_CONSTANT("PATH_SEPARATOR", pathsep_str, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_ASCENDING", PHP_SCANDIR_SORT_ASCENDING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_DESCENDING", PHP_SCANDIR_SORT_DESCENDING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SCANDIR_SORT_NONE", PHP_SCANDIR_SORT_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_ASCENDING", PHP_SCANDIR_SORT_ASCENDING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_DESCENDING", PHP_SCANDIR_SORT_DESCENDING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SCANDIR_SORT_NONE", PHP_SCANDIR_SORT_NONE, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_GLOB #ifdef GLOB_BRACE - REGISTER_LONG_CONSTANT("GLOB_BRACE", GLOB_BRACE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_BRACE", GLOB_BRACE, CONST_CS | CONST_PERSISTENT); #else # define GLOB_BRACE 0 #endif #ifdef GLOB_MARK - REGISTER_LONG_CONSTANT("GLOB_MARK", GLOB_MARK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_MARK", GLOB_MARK, CONST_CS | CONST_PERSISTENT); #else # define GLOB_MARK 0 #endif #ifdef GLOB_NOSORT - REGISTER_LONG_CONSTANT("GLOB_NOSORT", GLOB_NOSORT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOSORT", GLOB_NOSORT, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOSORT 0 #endif #ifdef GLOB_NOCHECK - REGISTER_LONG_CONSTANT("GLOB_NOCHECK", GLOB_NOCHECK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOCHECK", GLOB_NOCHECK, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOCHECK 0 #endif #ifdef GLOB_NOESCAPE - REGISTER_LONG_CONSTANT("GLOB_NOESCAPE", GLOB_NOESCAPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_NOESCAPE", GLOB_NOESCAPE, CONST_CS | CONST_PERSISTENT); #else # define GLOB_NOESCAPE 0 #endif #ifdef GLOB_ERR - REGISTER_LONG_CONSTANT("GLOB_ERR", GLOB_ERR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_ERR", GLOB_ERR, CONST_CS | CONST_PERSISTENT); #else # define GLOB_ERR 0 #endif @@ -201,8 +201,8 @@ PHP_MINIT_FUNCTION(dir) /* This is used for checking validity of passed flags (passing invalid flags causes segfault in glob()!! */ #define GLOB_AVAILABLE_FLAGS (0 | GLOB_BRACE | GLOB_MARK | GLOB_NOSORT | GLOB_NOCHECK | GLOB_NOESCAPE | GLOB_ERR | GLOB_ONLYDIR) - REGISTER_LONG_CONSTANT("GLOB_ONLYDIR", GLOB_ONLYDIR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("GLOB_AVAILABLE_FLAGS", GLOB_AVAILABLE_FLAGS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_ONLYDIR", GLOB_ONLYDIR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("GLOB_AVAILABLE_FLAGS", GLOB_AVAILABLE_FLAGS, CONST_CS | CONST_PERSISTENT); #endif /* HAVE_GLOB */ @@ -524,7 +524,7 @@ no_results: * able to filter directories out. */ if (flags & GLOB_ONLYDIR) { - struct stat s; + php_stat_t s; if (0 != VCWD_STAT(globbuf.gl_pathv[n], &s)) { continue; diff --git a/ext/standard/dl.c b/ext/standard/dl.c index 19573d8e42..2f92c82d2c 100644 --- a/ext/standard/dl.c +++ b/ext/standard/dl.c @@ -83,7 +83,7 @@ PHPAPI PHP_FUNCTION(dl) } php_dl(filename, MODULE_TEMPORARY, return_value, 0 TSRMLS_CC); - if (Z_LVAL_P(return_value) == 1) { + if (Z_IVAL_P(return_value) == 1) { EG(full_tables_cleanup) = 1; } } diff --git a/ext/standard/dns.c b/ext/standard/dns.c index cabe3d72f1..c760fc0713 100644 --- a/ext/standard/dns.c +++ b/ext/standard/dns.c @@ -448,10 +448,10 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int add_assoc_string(subarray, "host", name); add_assoc_string(subarray, "class", "IN"); - add_assoc_long(subarray, "ttl", ttl); + add_assoc_int(subarray, "ttl", ttl); if (raw) { - add_assoc_long(subarray, "type", type); + add_assoc_int(subarray, "type", type); add_assoc_stringl(subarray, "data", (char*) cp, (uint) dlen); cp += dlen; return cp; @@ -467,7 +467,7 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_MX: add_assoc_string(subarray, "type", "MX"); GETSHORT(n, cp); - add_assoc_long(subarray, "pri", n); + add_assoc_int(subarray, "pri", n); /* no break; */ case DNS_T_CNAME: if (type == DNS_T_CNAME) { @@ -546,15 +546,15 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int cp += n; add_assoc_string(subarray, "rname", name); GETLONG(n, cp); - add_assoc_long(subarray, "serial", n); + add_assoc_int(subarray, "serial", n); GETLONG(n, cp); - add_assoc_long(subarray, "refresh", n); + add_assoc_int(subarray, "refresh", n); GETLONG(n, cp); - add_assoc_long(subarray, "retry", n); + add_assoc_int(subarray, "retry", n); GETLONG(n, cp); - add_assoc_long(subarray, "expire", n); + add_assoc_int(subarray, "expire", n); GETLONG(n, cp); - add_assoc_long(subarray, "minimum-ttl", n); + add_assoc_int(subarray, "minimum-ttl", n); break; case DNS_T_AAAA: tp = (u_char*)name; @@ -594,7 +594,7 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int add_assoc_string(subarray, "type", "A6"); n = ((int)cp[0]) & 0xFF; cp++; - add_assoc_long(subarray, "masklen", n); + add_assoc_int(subarray, "masklen", n); tp = (u_char*)name; if (n > 15) { have_v6_break = 1; @@ -667,11 +667,11 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_SRV: add_assoc_string(subarray, "type", "SRV"); GETSHORT(n, cp); - add_assoc_long(subarray, "pri", n); + add_assoc_int(subarray, "pri", n); GETSHORT(n, cp); - add_assoc_long(subarray, "weight", n); + add_assoc_int(subarray, "weight", n); GETSHORT(n, cp); - add_assoc_long(subarray, "port", n); + add_assoc_int(subarray, "port", n); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; @@ -682,9 +682,9 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int case DNS_T_NAPTR: add_assoc_string(subarray, "type", "NAPTR"); GETSHORT(n, cp); - add_assoc_long(subarray, "order", n); + add_assoc_int(subarray, "order", n); GETSHORT(n, cp); - add_assoc_long(subarray, "pref", n); + add_assoc_int(subarray, "pref", n); n = (cp[0] & 0xFF); add_assoc_stringl(subarray, "flags", (char*)++cp, n); cp += n; @@ -1011,7 +1011,7 @@ PHP_FUNCTION(dns_get_mx) cp += i; add_next_index_string(mx_list, buf); if (weight_list) { - add_next_index_long(weight_list, weight); + add_next_index_int(weight_list, weight); } } php_dns_free_handle(handle); @@ -1023,20 +1023,20 @@ PHP_FUNCTION(dns_get_mx) #if HAVE_FULL_DNS_FUNCS || defined(PHP_WIN32) PHP_MINIT_FUNCTION(dns) { - REGISTER_LONG_CONSTANT("DNS_A", PHP_DNS_A, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_NS", PHP_DNS_NS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_CNAME", PHP_DNS_CNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_SOA", PHP_DNS_SOA, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_PTR", PHP_DNS_PTR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_HINFO", PHP_DNS_HINFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_MX", PHP_DNS_MX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_TXT", PHP_DNS_TXT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_SRV", PHP_DNS_SRV, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_NAPTR", PHP_DNS_NAPTR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_AAAA", PHP_DNS_AAAA, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_A6", PHP_DNS_A6, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_ANY", PHP_DNS_ANY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("DNS_ALL", PHP_DNS_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_A", PHP_DNS_A, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_NS", PHP_DNS_NS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_CNAME", PHP_DNS_CNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_SOA", PHP_DNS_SOA, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_PTR", PHP_DNS_PTR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_HINFO", PHP_DNS_HINFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_MX", PHP_DNS_MX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_TXT", PHP_DNS_TXT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_SRV", PHP_DNS_SRV, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_NAPTR", PHP_DNS_NAPTR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_AAAA", PHP_DNS_AAAA, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_A6", PHP_DNS_A6, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_ANY", PHP_DNS_ANY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("DNS_ALL", PHP_DNS_ALL, CONST_CS | CONST_PERSISTENT); return SUCCESS; } #endif /* HAVE_FULL_DNS_FUNCS */ diff --git a/ext/standard/dns_win32.c b/ext/standard/dns_win32.c index f255ebba63..7ef53dd0e7 100644 --- a/ext/standard/dns_win32.c +++ b/ext/standard/dns_win32.c @@ -77,7 +77,7 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */ add_next_index_string(mx_list, pRec->Data.MX.pNameExchange); if (weight_list) { - add_next_index_long(weight_list, srv->wPriority); + add_next_index_int(weight_list, srv->wPriority); } } @@ -158,10 +158,10 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, add_assoc_string(subarray, "host", pRec->pName); add_assoc_string(subarray, "class", "IN"); - add_assoc_long(subarray, "ttl", ttl); + add_assoc_int(subarray, "ttl", ttl); if (raw) { - add_assoc_long(subarray, "type", type); + add_assoc_int(subarray, "type", type); add_assoc_stringl(subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength); return; } @@ -177,7 +177,7 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, case DNS_TYPE_MX: add_assoc_string(subarray, "type", "MX"); - add_assoc_long(subarray, "pri", pRec->Data.Srv.wPriority); + add_assoc_int(subarray, "pri", pRec->Data.Srv.wPriority); /* no break; */ case DNS_TYPE_CNAME: @@ -241,11 +241,11 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, add_assoc_string(subarray, "mname", data_soa->pNamePrimaryServer); add_assoc_string(subarray, "rname", data_soa->pNameAdministrator); - add_assoc_long(subarray, "serial", data_soa->dwSerialNo); - add_assoc_long(subarray, "refresh", data_soa->dwRefresh); - add_assoc_long(subarray, "retry", data_soa->dwRetry); - add_assoc_long(subarray, "expire", data_soa->dwExpire); - add_assoc_long(subarray, "minimum-ttl", data_soa->dwDefaultTtl); + add_assoc_int(subarray, "serial", data_soa->dwSerialNo); + add_assoc_int(subarray, "refresh", data_soa->dwRefresh); + add_assoc_int(subarray, "retry", data_soa->dwRetry); + add_assoc_int(subarray, "expire", data_soa->dwExpire); + add_assoc_int(subarray, "minimum-ttl", data_soa->dwDefaultTtl); } break; @@ -309,9 +309,9 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, DNS_SRV_DATA *data_srv = &pRec->Data.Srv; add_assoc_string(subarray, "type", "SRV"); - add_assoc_long(subarray, "pri", data_srv->wPriority); - add_assoc_long(subarray, "weight", data_srv->wWeight); - add_assoc_long(subarray, "port", data_srv->wPort); + add_assoc_int(subarray, "pri", data_srv->wPriority); + add_assoc_int(subarray, "weight", data_srv->wWeight); + add_assoc_int(subarray, "port", data_srv->wPort); add_assoc_string(subarray, "target", data_srv->pNameTarget); } break; @@ -322,8 +322,8 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw, DNS_NAPTR_DATA * data_naptr = &pRec->Data.Naptr; add_assoc_string(subarray, "type", "NAPTR"); - add_assoc_long(subarray, "order", data_naptr->wOrder); - add_assoc_long(subarray, "pref", data_naptr->wPreference); + add_assoc_int(subarray, "order", data_naptr->wOrder); + add_assoc_int(subarray, "pref", data_naptr->wPreference); add_assoc_string(subarray, "flags", data_naptr->pFlags); add_assoc_string(subarray, "services", data_naptr->pService); add_assoc_string(subarray, "regex", data_naptr->pRegularExpression); diff --git a/ext/standard/exec.c b/ext/standard/exec.c index 6720231089..87e73ee4f2 100644 --- a/ext/standard/exec.c +++ b/ext/standard/exec.c @@ -200,7 +200,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */ } if (ret_code) { zval_dtor(ret_code); - ZVAL_LONG(ret_code, ret); + ZVAL_INT(ret_code, ret); } } /* }}} */ diff --git a/ext/standard/file.c b/ext/standard/file.c index 4551bef8cf..c58db9fd64 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -188,135 +188,135 @@ PHP_MINIT_FUNCTION(file) REGISTER_INI_ENTRIES(); - REGISTER_LONG_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_SH", PHP_LOCK_SH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_EX", PHP_LOCK_EX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_UN", PHP_LOCK_UN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOCK_NB", PHP_LOCK_NB, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_CONNECT", PHP_STREAM_NOTIFY_CONNECT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_REQUIRED", PHP_STREAM_NOTIFY_AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_AUTH_RESULT", PHP_STREAM_NOTIFY_AUTH_RESULT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_MIME_TYPE_IS", PHP_STREAM_NOTIFY_MIME_TYPE_IS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FILE_SIZE_IS", PHP_STREAM_NOTIFY_FILE_SIZE_IS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_REDIRECTED", PHP_STREAM_NOTIFY_REDIRECTED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_PROGRESS", PHP_STREAM_NOTIFY_PROGRESS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_FAILURE", PHP_STREAM_NOTIFY_FAILURE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_COMPLETED", PHP_STREAM_NOTIFY_COMPLETED, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_RESOLVE", PHP_STREAM_NOTIFY_RESOLVE, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_INFO", PHP_STREAM_NOTIFY_SEVERITY_INFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_WARN", PHP_STREAM_NOTIFY_SEVERITY_WARN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_NOTIFY_SEVERITY_ERR", PHP_STREAM_NOTIFY_SEVERITY_ERR, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_FILTER_READ", PHP_STREAM_FILTER_READ, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_FILTER_WRITE", PHP_STREAM_FILTER_WRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_FILTER_ALL", PHP_STREAM_FILTER_ALL, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_CLIENT_PERSISTENT", PHP_STREAM_CLIENT_PERSISTENT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CLIENT_ASYNC_CONNECT", PHP_STREAM_CLIENT_ASYNC_CONNECT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CLIENT_CONNECT", PHP_STREAM_CLIENT_CONNECT, CONST_CS | CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_CLIENT", STREAM_CRYPTO_METHOD_ANY_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_CLIENT", STREAM_CRYPTO_METHOD_SSLv2_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_CLIENT", STREAM_CRYPTO_METHOD_SSLv3_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_CLIENT", STREAM_CRYPTO_METHOD_SSLv23_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_CLIENT", STREAM_CRYPTO_METHOD_TLS_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_ANY_SERVER", STREAM_CRYPTO_METHOD_ANY_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_SERVER", STREAM_CRYPTO_METHOD_SSLv2_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_SERVER", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_SERVER", STREAM_CRYPTO_METHOD_SSLv23_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLS_SERVER", STREAM_CRYPTO_METHOD_TLS_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_SERVER", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_SERVER", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_SERVER", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_SHUT_RD", STREAM_SHUT_RD, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SHUT_WR", STREAM_SHUT_WR, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SHUT_RDWR", STREAM_SHUT_RDWR, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_CUR", SEEK_CUR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("SEEK_END", SEEK_END, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_SH", PHP_LOCK_SH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_EX", PHP_LOCK_EX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_UN", PHP_LOCK_UN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOCK_NB", PHP_LOCK_NB, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_NOTIFY_CONNECT", PHP_STREAM_NOTIFY_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_AUTH_REQUIRED", PHP_STREAM_NOTIFY_AUTH_REQUIRED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_AUTH_RESULT", PHP_STREAM_NOTIFY_AUTH_RESULT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_MIME_TYPE_IS", PHP_STREAM_NOTIFY_MIME_TYPE_IS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_FILE_SIZE_IS", PHP_STREAM_NOTIFY_FILE_SIZE_IS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_REDIRECTED", PHP_STREAM_NOTIFY_REDIRECTED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_PROGRESS", PHP_STREAM_NOTIFY_PROGRESS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_FAILURE", PHP_STREAM_NOTIFY_FAILURE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_COMPLETED", PHP_STREAM_NOTIFY_COMPLETED, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_RESOLVE", PHP_STREAM_NOTIFY_RESOLVE, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_INFO", PHP_STREAM_NOTIFY_SEVERITY_INFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_WARN", PHP_STREAM_NOTIFY_SEVERITY_WARN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_NOTIFY_SEVERITY_ERR", PHP_STREAM_NOTIFY_SEVERITY_ERR, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_FILTER_READ", PHP_STREAM_FILTER_READ, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_FILTER_WRITE", PHP_STREAM_FILTER_WRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_FILTER_ALL", PHP_STREAM_FILTER_ALL, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_CLIENT_PERSISTENT", PHP_STREAM_CLIENT_PERSISTENT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CLIENT_ASYNC_CONNECT", PHP_STREAM_CLIENT_ASYNC_CONNECT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CLIENT_CONNECT", PHP_STREAM_CLIENT_CONNECT, CONST_CS | CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_ANY_CLIENT", STREAM_CRYPTO_METHOD_ANY_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_CLIENT", STREAM_CRYPTO_METHOD_SSLv2_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_CLIENT", STREAM_CRYPTO_METHOD_SSLv3_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_CLIENT", STREAM_CRYPTO_METHOD_SSLv23_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLS_CLIENT", STREAM_CRYPTO_METHOD_TLS_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT", STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_ANY_SERVER", STREAM_CRYPTO_METHOD_ANY_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv2_SERVER", STREAM_CRYPTO_METHOD_SSLv2_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv3_SERVER", STREAM_CRYPTO_METHOD_SSLv3_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_SSLv23_SERVER", STREAM_CRYPTO_METHOD_SSLv23_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLS_SERVER", STREAM_CRYPTO_METHOD_TLS_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_0_SERVER", STREAM_CRYPTO_METHOD_TLSv1_0_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_1_SERVER", STREAM_CRYPTO_METHOD_TLSv1_1_SERVER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CRYPTO_METHOD_TLSv1_2_SERVER", STREAM_CRYPTO_METHOD_TLSv1_2_SERVER, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_SHUT_RD", STREAM_SHUT_RD, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SHUT_WR", STREAM_SHUT_WR, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SHUT_RDWR", STREAM_SHUT_RDWR, CONST_CS|CONST_PERSISTENT); #ifdef PF_INET - REGISTER_LONG_CONSTANT("STREAM_PF_INET", PF_INET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET", PF_INET, CONST_CS|CONST_PERSISTENT); #elif defined(AF_INET) - REGISTER_LONG_CONSTANT("STREAM_PF_INET", AF_INET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET", AF_INET, CONST_CS|CONST_PERSISTENT); #endif #if HAVE_IPV6 # ifdef PF_INET6 - REGISTER_LONG_CONSTANT("STREAM_PF_INET6", PF_INET6, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET6", PF_INET6, CONST_CS|CONST_PERSISTENT); # elif defined(AF_INET6) - REGISTER_LONG_CONSTANT("STREAM_PF_INET6", AF_INET6, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_INET6", AF_INET6, CONST_CS|CONST_PERSISTENT); # endif #endif #ifdef PF_UNIX - REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", PF_UNIX, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_UNIX", PF_UNIX, CONST_CS|CONST_PERSISTENT); #elif defined(AF_UNIX) - REGISTER_LONG_CONSTANT("STREAM_PF_UNIX", AF_UNIX, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PF_UNIX", AF_UNIX, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_IP /* most people will use this one when calling socket() or socketpair() */ - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_IP", IPPROTO_IP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_TCP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_TCP", IPPROTO_TCP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_UDP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_UDP", IPPROTO_UDP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_ICMP - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_ICMP", IPPROTO_ICMP, CONST_CS|CONST_PERSISTENT); #endif #ifdef IPPROTO_RAW - REGISTER_LONG_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IPPROTO_RAW", IPPROTO_RAW, CONST_CS|CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("STREAM_SOCK_STREAM", SOCK_STREAM, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SOCK_DGRAM", SOCK_DGRAM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_STREAM", SOCK_STREAM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_DGRAM", SOCK_DGRAM, CONST_CS|CONST_PERSISTENT); #ifdef SOCK_RAW - REGISTER_LONG_CONSTANT("STREAM_SOCK_RAW", SOCK_RAW, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_RAW", SOCK_RAW, CONST_CS|CONST_PERSISTENT); #endif #ifdef SOCK_SEQPACKET - REGISTER_LONG_CONSTANT("STREAM_SOCK_SEQPACKET", SOCK_SEQPACKET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_SEQPACKET", SOCK_SEQPACKET, CONST_CS|CONST_PERSISTENT); #endif #ifdef SOCK_RDM - REGISTER_LONG_CONSTANT("STREAM_SOCK_RDM", SOCK_RDM, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SOCK_RDM", SOCK_RDM, CONST_CS|CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("STREAM_PEEK", STREAM_PEEK, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_OOB", STREAM_OOB, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_PEEK", STREAM_PEEK, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_OOB", STREAM_OOB, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SERVER_BIND", STREAM_XPORT_BIND, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_SERVER_LISTEN", STREAM_XPORT_LISTEN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SERVER_BIND", STREAM_XPORT_BIND, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_SERVER_LISTEN", STREAM_XPORT_LISTEN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_USE_INCLUDE_PATH", PHP_FILE_USE_INCLUDE_PATH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_IGNORE_NEW_LINES", PHP_FILE_IGNORE_NEW_LINES, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_SKIP_EMPTY_LINES", PHP_FILE_SKIP_EMPTY_LINES, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_APPEND", PHP_FILE_APPEND, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_NO_DEFAULT_CONTEXT", PHP_FILE_NO_DEFAULT_CONTEXT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_USE_INCLUDE_PATH", PHP_FILE_USE_INCLUDE_PATH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_IGNORE_NEW_LINES", PHP_FILE_IGNORE_NEW_LINES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_SKIP_EMPTY_LINES", PHP_FILE_SKIP_EMPTY_LINES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_APPEND", PHP_FILE_APPEND, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_NO_DEFAULT_CONTEXT", PHP_FILE_NO_DEFAULT_CONTEXT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_TEXT", 0, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FILE_BINARY", 0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_TEXT", 0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FILE_BINARY", 0, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_FNMATCH - REGISTER_LONG_CONSTANT("FNM_NOESCAPE", FNM_NOESCAPE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FNM_PATHNAME", FNM_PATHNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("FNM_PERIOD", FNM_PERIOD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_NOESCAPE", FNM_NOESCAPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_PATHNAME", FNM_PATHNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_PERIOD", FNM_PERIOD, CONST_CS | CONST_PERSISTENT); # ifdef FNM_CASEFOLD /* a GNU extension */ /* TODO emulate if not available */ - REGISTER_LONG_CONSTANT("FNM_CASEFOLD", FNM_CASEFOLD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("FNM_CASEFOLD", FNM_CASEFOLD, CONST_CS | CONST_PERSISTENT); # endif #endif @@ -342,9 +342,9 @@ PHP_FUNCTION(flock) zval *arg1, *arg3 = NULL; int act; php_stream *stream; - long operation = 0; + php_int_t operation = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z/", &arg1, &operation, &arg3) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri|z/", &arg1, &operation, &arg3) == FAILURE) { return; } @@ -358,14 +358,14 @@ PHP_FUNCTION(flock) if (arg3) { zval_dtor(arg3); - ZVAL_LONG(arg3, 0); + ZVAL_INT(arg3, 0); } /* flock_values contains all possible actions if (operation & 4) we won't block on the lock */ act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0); if (php_stream_lock(stream, act)) { if (operation && errno == EWOULDBLOCK && arg3) { - ZVAL_LONG(arg3, 1); + ZVAL_INT(arg3, 1); } RETURN_FALSE; } @@ -526,14 +526,14 @@ PHP_FUNCTION(file_get_contents) int filename_len; zend_bool use_include_path = 0; php_stream *stream; - long offset = -1; - long maxlen = PHP_STREAM_COPY_ALL; + php_int_t offset = -1; + php_int_t maxlen = PHP_STREAM_COPY_ALL; zval *zcontext = NULL; php_stream_context *context = NULL; zend_string *contents; /* Parse arguments */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|br!ll", &filename, &filename_len, &use_include_path, &zcontext, &offset, &maxlen) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|br!ii", &filename, &filename_len, &use_include_path, &zcontext, &offset, &maxlen) == FAILURE) { return; } @@ -552,7 +552,7 @@ PHP_FUNCTION(file_get_contents) } if (offset > 0 && php_stream_seek(stream, offset, SEEK_SET) < 0) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to seek to position %ld in the stream", offset); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to seek to position " ZEND_INT_FMT " in the stream", offset); php_stream_close(stream); RETURN_FALSE; } @@ -579,14 +579,15 @@ PHP_FUNCTION(file_put_contents) char *filename; int filename_len; zval *data; - long numbytes = 0; - long flags = 0; + php_int_t numbytes = 0; + php_int_t flags = 0; zval *zcontext = NULL; php_stream_context *context = NULL; php_stream *srcstream = NULL; char mode[3] = "wb"; + char ret_ok = 1; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pz/|lr!", &filename, &filename_len, &data, &flags, &zcontext) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pz/|ir!", &filename, &filename_len, &data, &flags, &zcontext) == FAILURE) { return; } @@ -627,30 +628,30 @@ PHP_FUNCTION(file_put_contents) switch (Z_TYPE_P(data)) { case IS_RESOURCE: { - size_t len; + php_size_t len; if (php_stream_copy_to_stream_ex(srcstream, stream, PHP_STREAM_COPY_ALL, &len) != SUCCESS) { - numbytes = -1; + ret_ok = 0; } else { - if (len > LONG_MAX) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "content truncated from %lu to %ld bytes", (unsigned long) len, LONG_MAX); - len = LONG_MAX; + if (len > PHP_INT_MAX) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "content truncated from %zu to " ZEND_INT_FMT " bytes", len, PHP_INT_MAX); + len = PHP_INT_MAX; } numbytes = len; } break; } case IS_NULL: - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_FALSE: case IS_TRUE: convert_to_string_ex(data); case IS_STRING: - if (Z_STRLEN_P(data)) { - numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRLEN_P(data)); - if (numbytes != Z_STRLEN_P(data)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRLEN_P(data)); + if (Z_STRSIZE_P(data)) { + numbytes = php_stream_write(stream, Z_STRVAL_P(data), Z_STRSIZE_P(data)); + if (numbytes != Z_STRSIZE_P(data)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %zd bytes written, possibly out of free disk space", numbytes, Z_STRSIZE_P(data)); numbytes = -1; } } @@ -658,7 +659,7 @@ PHP_FUNCTION(file_put_contents) case IS_ARRAY: if (zend_hash_num_elements(Z_ARRVAL_P(data))) { - int bytes_written; + php_size_t bytes_written; zval *tmp; ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), tmp) { @@ -666,13 +667,9 @@ PHP_FUNCTION(file_put_contents) if (str->len) { numbytes += str->len; bytes_written = php_stream_write(stream, str->val, str->len); - if (bytes_written < 0 || bytes_written != str->len) { - if (bytes_written < 0) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %d bytes to %s", str->len, filename); - } else { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %d of %d bytes written, possibly out of free disk space", bytes_written, str->len); - } - numbytes = -1; + if (bytes_written != str->len) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %zd bytes to %s", str->len, filename); + ret_ok = 0; STR_RELEASE(str); break; } @@ -687,9 +684,9 @@ PHP_FUNCTION(file_put_contents) zval out; if (zend_std_cast_object_tostring(data, &out, IS_STRING TSRMLS_CC) == SUCCESS) { - numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRLEN(out)); - if (numbytes != Z_STRLEN(out)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %d bytes written, possibly out of free disk space", numbytes, Z_STRLEN(out)); + numbytes = php_stream_write(stream, Z_STRVAL(out), Z_STRSIZE(out)); + if (numbytes != Z_STRSIZE(out)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %ld of %zd bytes written, possibly out of free disk space", numbytes, Z_STRSIZE(out)); numbytes = -1; } zval_dtor(&out); @@ -697,16 +694,16 @@ PHP_FUNCTION(file_put_contents) } } default: - numbytes = -1; + ret_ok = 0; break; } php_stream_close(stream); - if (numbytes < 0) { + if (!ret_ok) { RETURN_FALSE; } - RETURN_LONG(numbytes); + RETURN_INT(numbytes); } /* }}} */ @@ -721,7 +718,7 @@ PHP_FUNCTION(file) char *p, *s, *e; register int i = 0; char eol_marker = '\n'; - long flags = 0; + php_int_t flags = 0; zend_bool use_include_path; zend_bool include_new_line; zend_bool skip_blank_lines; @@ -731,11 +728,11 @@ PHP_FUNCTION(file) zend_string *target_buf; /* Parse arguments */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|lr!", &filename, &filename_len, &flags, &zcontext) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ir!", &filename, &filename_len, &flags, &zcontext) == FAILURE) { return; } if (flags < 0 || flags > (PHP_FILE_USE_INCLUDE_PATH | PHP_FILE_IGNORE_NEW_LINES | PHP_FILE_SKIP_EMPTY_LINES | PHP_FILE_NO_DEFAULT_CONTEXT)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%ld' flag is not supported", flags); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "'" ZEND_INT_FMT "' flag is not supported", flags); RETURN_FALSE; } @@ -980,7 +977,7 @@ PHP_FUNCTION(pclose) FG(pclose_wait) = 1; zend_list_close(stream->res); FG(pclose_wait) = 0; - RETURN_LONG(FG(pclose_ret)); + RETURN_INT(FG(pclose_ret)); } /* }}} */ @@ -1010,13 +1007,13 @@ PHPAPI PHP_FUNCTION(feof) PHPAPI PHP_FUNCTION(fgets) { zval *arg1; - long len = 1024; + php_int_t len = 1024; char *buf = NULL; int argc = ZEND_NUM_ARGS(); size_t line_len = 0; php_stream *stream; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &arg1, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|i", &arg1, &len) == FAILURE) { RETURN_FALSE; } @@ -1094,7 +1091,7 @@ PHPAPI PHP_FUNCTION(fgetc) PHPAPI PHP_FUNCTION(fgetss) { zval *fd; - long bytes = 0; + php_int_t bytes = 0; size_t len = 0; size_t actual_len, retval_len; char *buf = NULL, *retval; @@ -1103,7 +1100,7 @@ PHPAPI PHP_FUNCTION(fgetss) char *allowed_tags=NULL; int allowed_tags_len=0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|lS", &fd, &bytes, &allowed) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|iS", &fd, &bytes, &allowed) == FAILURE) { RETURN_FALSE; } @@ -1200,11 +1197,11 @@ PHPAPI PHP_FUNCTION(fwrite) int arg2len; int ret; int num_bytes; - long arg3 = 0; + php_int_t arg3 = 0; char *buffer = NULL; php_stream *stream; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &arg1, &arg2, &arg2len, &arg3) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|i", &arg1, &arg2, &arg2len, &arg3) == FAILURE) { RETURN_FALSE; } @@ -1215,7 +1212,7 @@ PHPAPI PHP_FUNCTION(fwrite) } if (!num_bytes) { - RETURN_LONG(0); + RETURN_INT(0); } PHP_STREAM_TO_ZVAL(stream, arg1); @@ -1225,7 +1222,7 @@ PHPAPI PHP_FUNCTION(fwrite) efree(buffer); } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1276,7 +1273,7 @@ PHPAPI PHP_FUNCTION(rewind) PHPAPI PHP_FUNCTION(ftell) { zval *arg1; - long ret; + php_int_t ret; php_stream *stream; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) { @@ -1289,7 +1286,7 @@ PHPAPI PHP_FUNCTION(ftell) if (ret == -1) { RETURN_FALSE; } - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ @@ -1298,16 +1295,16 @@ PHPAPI PHP_FUNCTION(ftell) PHPAPI PHP_FUNCTION(fseek) { zval *arg1; - long arg2, whence = SEEK_SET; + php_int_t arg2, whence = SEEK_SET; php_stream *stream; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &arg1, &arg2, &whence) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri|i", &arg1, &arg2, &whence) == FAILURE) { RETURN_FALSE; } PHP_STREAM_TO_ZVAL(stream, arg1); - RETURN_LONG(php_stream_seek(stream, arg2, whence)); + RETURN_INT(php_stream_seek(stream, arg2, whence)); } /* }}} */ @@ -1315,7 +1312,7 @@ PHPAPI PHP_FUNCTION(fseek) */ /* DEPRECATED APIs: Use php_stream_mkdir() instead */ -PHPAPI int php_mkdir_ex(const char *dir, long mode, int options TSRMLS_DC) +PHPAPI int php_mkdir_ex(const char *dir, php_int_t mode, int options TSRMLS_DC) { int ret; @@ -1330,7 +1327,7 @@ PHPAPI int php_mkdir_ex(const char *dir, long mode, int options TSRMLS_DC) return ret; } -PHPAPI int php_mkdir(const char *dir, long mode TSRMLS_DC) +PHPAPI int php_mkdir(const char *dir, php_int_t mode TSRMLS_DC) { return php_mkdir_ex(dir, mode, REPORT_ERRORS TSRMLS_CC); } @@ -1398,7 +1395,7 @@ PHP_FUNCTION(readfile) if (stream) { size = php_stream_passthru(stream); php_stream_close(stream); - RETURN_LONG(size); + RETURN_INT(size); } RETURN_FALSE; @@ -1409,7 +1406,7 @@ PHP_FUNCTION(readfile) Return or change the umask */ PHP_FUNCTION(umask) { - long arg1 = 0; + php_int_t arg1 = 0; int oldumask; oldumask = umask(077); @@ -1418,7 +1415,7 @@ PHP_FUNCTION(umask) BG(umask) = oldumask; } - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &arg1) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &arg1) == FAILURE) { RETURN_FALSE; } @@ -1428,7 +1425,7 @@ PHP_FUNCTION(umask) umask(arg1); } - RETURN_LONG(oldumask); + RETURN_INT(oldumask); } /* }}} */ @@ -1447,7 +1444,7 @@ PHPAPI PHP_FUNCTION(fpassthru) PHP_STREAM_TO_ZVAL(stream, arg1); size = php_stream_passthru(stream); - RETURN_LONG(size); + RETURN_INT(size); } /* }}} */ @@ -1524,10 +1521,10 @@ PHP_FUNCTION(unlink) PHP_NAMED_FUNCTION(php_if_ftruncate) { zval *fp; - long size; + php_int_t size; php_stream *stream; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &fp, &size) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &fp, &size) == FAILURE) { RETURN_FALSE; } @@ -1568,30 +1565,30 @@ PHP_NAMED_FUNCTION(php_if_fstat) array_init(return_value); - ZVAL_LONG(&stat_dev, stat_ssb.sb.st_dev); - ZVAL_LONG(&stat_ino, stat_ssb.sb.st_ino); - ZVAL_LONG(&stat_mode, stat_ssb.sb.st_mode); - ZVAL_LONG(&stat_nlink, stat_ssb.sb.st_nlink); - ZVAL_LONG(&stat_uid, stat_ssb.sb.st_uid); - ZVAL_LONG(&stat_gid, stat_ssb.sb.st_gid); + ZVAL_INT(&stat_dev, stat_ssb.sb.st_dev); + ZVAL_INT(&stat_ino, stat_ssb.sb.st_ino); + ZVAL_INT(&stat_mode, stat_ssb.sb.st_mode); + ZVAL_INT(&stat_nlink, stat_ssb.sb.st_nlink); + ZVAL_INT(&stat_uid, stat_ssb.sb.st_uid); + ZVAL_INT(&stat_gid, stat_ssb.sb.st_gid); #ifdef HAVE_ST_RDEV - ZVAL_LONG(&stat_rdev, stat_ssb.sb.st_rdev); + ZVAL_INT(&stat_rdev, stat_ssb.sb.st_rdev); #else - ZVAL_LONG(&stat_rdev, -1); + ZVAL_INT(&stat_rdev, -1); #endif - ZVAL_LONG(&stat_size, stat_ssb.sb.st_size); - ZVAL_LONG(&stat_atime, stat_ssb.sb.st_atime); - ZVAL_LONG(&stat_mtime, stat_ssb.sb.st_mtime); - ZVAL_LONG(&stat_ctime, stat_ssb.sb.st_ctime); + ZVAL_INT(&stat_size, stat_ssb.sb.st_size); + ZVAL_INT(&stat_atime, stat_ssb.sb.st_atime); + ZVAL_INT(&stat_mtime, stat_ssb.sb.st_mtime); + ZVAL_INT(&stat_ctime, stat_ssb.sb.st_ctime); #ifdef HAVE_ST_BLKSIZE - ZVAL_LONG(&stat_blksize, stat_ssb.sb.st_blksize); + ZVAL_INT(&stat_blksize, stat_ssb.sb.st_blksize); #else - ZVAL_LONG(&stat_blksize,-1); + ZVAL_INT(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS - ZVAL_LONG(&stat_blocks, stat_ssb.sb.st_blocks); + ZVAL_INT(&stat_blocks, stat_ssb.sb.st_blocks); #else - ZVAL_LONG(&stat_blocks,-1); + ZVAL_INT(&stat_blocks,-1); #endif /* Store numeric indexes in propper order */ zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); @@ -1767,10 +1764,10 @@ safe_to_copy: PHPAPI PHP_FUNCTION(fread) { zval *arg1; - long len; + php_int_t len; php_stream *stream; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &arg1, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &arg1, &len) == FAILURE) { RETURN_FALSE; } @@ -1782,10 +1779,10 @@ PHPAPI PHP_FUNCTION(fread) } ZVAL_NEW_STR(return_value, STR_ALLOC(len, 0)); - Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len); + Z_STRSIZE_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len); /* needed because recv/read/gzread doesnt put a null at the end*/ - Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0; + Z_STRVAL_P(return_value)[Z_STRSIZE_P(return_value)] = 0; } /* }}} */ @@ -1887,12 +1884,12 @@ PHP_FUNCTION(fputcsv) PHP_STREAM_TO_ZVAL(stream, fp); ret = php_fputcsv(stream, fields, delimiter, enclosure, escape_char TSRMLS_CC); - RETURN_LONG(ret); + RETURN_INT(ret); } /* }}} */ -/* {{{ PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC) */ -PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC) +/* {{{ PHPAPI php_size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC) */ +PHPAPI php_size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC) { int count, i = 0, ret; zval *field_tmp; @@ -1959,7 +1956,7 @@ PHP_FUNCTION(fgetcsv) /* first section exactly as php_fgetss */ - long len = 0; + php_int_t len = 0; size_t buf_len; char *buf; php_stream *stream; @@ -2018,7 +2015,7 @@ PHP_FUNCTION(fgetcsv) } if (len_zv != NULL && Z_TYPE_P(len_zv) != IS_NULL) { - len = zval_get_long(len_zv); + len = zval_get_int(len_zv); if (len < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter may not be negative"); RETURN_FALSE; diff --git a/ext/standard/file.h b/ext/standard/file.h index 9c044aff1e..b667a29233 100644 --- a/ext/standard/file.h +++ b/ext/standard/file.h @@ -77,10 +77,10 @@ PHPAPI int php_set_sock_blocking(int socketd, int block TSRMLS_DC); PHPAPI int php_copy_file(const char *src, const char *dest TSRMLS_DC); PHPAPI int php_copy_file_ex(const char *src, const char *dest, int src_chk TSRMLS_DC); PHPAPI int php_copy_file_ctx(const char *src, const char *dest, int src_chk, php_stream_context *ctx TSRMLS_DC); -PHPAPI int php_mkdir_ex(const char *dir, long mode, int options TSRMLS_DC); -PHPAPI int php_mkdir(const char *dir, long mode TSRMLS_DC); +PHPAPI int php_mkdir_ex(const char *dir, php_int_t mode, int options TSRMLS_DC); +PHPAPI int php_mkdir(const char *dir, php_int_t mode TSRMLS_DC); PHPAPI void php_fgetcsv(php_stream *stream, char delimiter, char enclosure, char escape_char, size_t buf_len, char *buf, zval *return_value TSRMLS_DC); -PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC); +PHPAPI php_size_t php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC); #define META_DEF_BUFSIZE 8192 @@ -117,8 +117,8 @@ php_meta_tags_token php_next_meta_token(php_meta_tags_data * TSRMLS_DC); typedef struct { int pclose_ret; size_t def_chunk_size; - long auto_detect_line_endings; - long default_socket_timeout; + php_int_t auto_detect_line_endings; + php_int_t default_socket_timeout; char *user_agent; /* for the http wrapper */ char *from_address; /* for the ftp and http wrappers */ const char *user_stream_current_filename; /* for simple recursion protection */ diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c index 9fb35ef344..8e24fec657 100644 --- a/ext/standard/filestat.c +++ b/ext/standard/filestat.c @@ -158,7 +158,7 @@ static int php_disk_total_space(char *path, double *space TSRMLS_DC) /* {{{ */ /* i know - this is ugly, but i works <thies@thieso.net> */ bytestotal = TotalNumberOfBytes.HighPart * - (double) (((unsigned long)1) << 31) * 2.0 + + (double) (((php_uint_t)1) << 31) * 2.0 + TotalNumberOfBytes.LowPart; } else { /* If it's not available, we just use GetDiskFreeSpace */ if (GetDiskFreeSpace(path, @@ -290,7 +290,7 @@ static int php_disk_free_space(char *path, double *space TSRMLS_DC) /* {{{ */ /* i know - this is ugly, but i works <thies@thieso.net> */ bytesfree = FreeBytesAvailableToCaller.HighPart * - (double) (((unsigned long)1) << 31) * 2.0 + + (double) (((php_uint_t)1) << 31) * 2.0 + FreeBytesAvailableToCaller.LowPart; } else { /* If it's not available, we just use GetDiskFreeSpace */ if (GetDiskFreeSpace(path, @@ -437,9 +437,9 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */ if(wrapper && wrapper->wops->stream_metadata) { int option; void *value; - if (Z_TYPE_P(group) == IS_LONG) { + if (Z_TYPE_P(group) == IS_INT) { option = PHP_STREAM_META_GROUP; - value = &Z_LVAL_P(group); + value = &Z_IVAL_P(group); } else if (Z_TYPE_P(group) == IS_STRING) { option = PHP_STREAM_META_GROUP_NAME; value = Z_STRVAL_P(group); @@ -465,8 +465,8 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */ /* We have no native chgrp on Windows, nothing left to do if stream doesn't have own implementation */ RETURN_FALSE; #else - if (Z_TYPE_P(group) == IS_LONG) { - gid = (gid_t)Z_LVAL_P(group); + if (Z_TYPE_P(group) == IS_INT) { + gid = (gid_t)Z_IVAL_P(group); } else if (Z_TYPE_P(group) == IS_STRING) { if(php_get_gid_by_name(Z_STRVAL_P(group), &gid TSRMLS_CC) != SUCCESS) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_P(group)); @@ -574,9 +574,9 @@ static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */ if(wrapper && wrapper->wops->stream_metadata) { int option; void *value; - if (Z_TYPE_P(user) == IS_LONG) { + if (Z_TYPE_P(user) == IS_INT) { option = PHP_STREAM_META_OWNER; - value = &Z_LVAL_P(user); + value = &Z_IVAL_P(user); } else if (Z_TYPE_P(user) == IS_STRING) { option = PHP_STREAM_META_OWNER_NAME; value = Z_STRVAL_P(user); @@ -603,8 +603,8 @@ static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */ RETURN_FALSE; #else - if (Z_TYPE_P(user) == IS_LONG) { - uid = (uid_t)Z_LVAL_P(user); + if (Z_TYPE_P(user) == IS_INT) { + uid = (uid_t)Z_IVAL_P(user); } else if (Z_TYPE_P(user) == IS_STRING) { if(php_get_uid_by_name(Z_STRVAL_P(user), &uid TSRMLS_CC) != SUCCESS) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_P(user)); @@ -668,12 +668,12 @@ PHP_FUNCTION(chmod) { char *filename; int filename_len; - long mode; + php_int_t mode; int ret; mode_t imode; php_stream_wrapper *wrapper; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pl", &filename, &filename_len, &mode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pi", &filename, &filename_len, &mode) == FAILURE) { return; } @@ -714,14 +714,14 @@ PHP_FUNCTION(touch) { char *filename; int filename_len; - long filetime = 0, fileatime = 0; + php_int_t filetime = 0, fileatime = 0; int ret, argc = ZEND_NUM_ARGS(); FILE *file; struct utimbuf newtimebuf; struct utimbuf *newtime = &newtimebuf; php_stream_wrapper *wrapper; - if (zend_parse_parameters(argc TSRMLS_CC, "p|ll", &filename, &filename_len, &filetime, &fileatime) == FAILURE) { + if (zend_parse_parameters(argc TSRMLS_CC, "p|ii", &filename, &filename_len, &filetime, &fileatime) == FAILURE) { return; } @@ -850,7 +850,7 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ { zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev, stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks; - struct stat *stat_sb; + zend_stat_t *stat_sb; php_stream_statbuf ssb; int flags = 0, rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */ char *stat_sb_names[13] = { @@ -962,21 +962,21 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ switch (type) { case FS_PERMS: - RETURN_LONG((long)ssb.sb.st_mode); + RETURN_INT((php_int_t)ssb.sb.st_mode); case FS_INODE: - RETURN_LONG((long)ssb.sb.st_ino); + RETURN_INT((php_int_t)ssb.sb.st_ino); case FS_SIZE: - RETURN_LONG((long)ssb.sb.st_size); + RETURN_INT((php_int_t)ssb.sb.st_size); case FS_OWNER: - RETURN_LONG((long)ssb.sb.st_uid); + RETURN_INT((php_int_t)ssb.sb.st_uid); case FS_GROUP: - RETURN_LONG((long)ssb.sb.st_gid); + RETURN_INT((php_int_t)ssb.sb.st_gid); case FS_ATIME: - RETURN_LONG((long)ssb.sb.st_atime); + RETURN_INT((php_int_t)ssb.sb.st_atime); case FS_MTIME: - RETURN_LONG((long)ssb.sb.st_mtime); + RETURN_INT((php_int_t)ssb.sb.st_mtime); case FS_CTIME: - RETURN_LONG((long)ssb.sb.st_ctime); + RETURN_INT((php_int_t)ssb.sb.st_ctime); case FS_TYPE: if (S_ISLNK(ssb.sb.st_mode)) { RETURN_STRING("link"); @@ -1012,30 +1012,30 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ case FS_STAT: array_init(return_value); - ZVAL_LONG(&stat_dev, stat_sb->st_dev); - ZVAL_LONG(&stat_ino, stat_sb->st_ino); - ZVAL_LONG(&stat_mode, stat_sb->st_mode); - ZVAL_LONG(&stat_nlink, stat_sb->st_nlink); - ZVAL_LONG(&stat_uid, stat_sb->st_uid); - ZVAL_LONG(&stat_gid, stat_sb->st_gid); + ZVAL_INT(&stat_dev, stat_sb->st_dev); + ZVAL_INT(&stat_ino, stat_sb->st_ino); + ZVAL_INT(&stat_mode, stat_sb->st_mode); + ZVAL_INT(&stat_nlink, stat_sb->st_nlink); + ZVAL_INT(&stat_uid, stat_sb->st_uid); + ZVAL_INT(&stat_gid, stat_sb->st_gid); #ifdef HAVE_ST_RDEV - ZVAL_LONG(&stat_rdev, stat_sb->st_rdev); + ZVAL_INT(&stat_rdev, stat_sb->st_rdev); #else - ZVAL_LONG(&stat_rdev, -1); + ZVAL_INT(&stat_rdev, -1); #endif - ZVAL_LONG(&stat_size, stat_sb->st_size); - ZVAL_LONG(&stat_atime, stat_sb->st_atime); - ZVAL_LONG(&stat_mtime, stat_sb->st_mtime); - ZVAL_LONG(&stat_ctime, stat_sb->st_ctime); + ZVAL_INT(&stat_size, stat_sb->st_size); + ZVAL_INT(&stat_atime, stat_sb->st_atime); + ZVAL_INT(&stat_mtime, stat_sb->st_mtime); + ZVAL_INT(&stat_ctime, stat_sb->st_ctime); #ifdef HAVE_ST_BLKSIZE - ZVAL_LONG(&stat_blksize, stat_sb->st_blksize); + ZVAL_INT(&stat_blksize, stat_sb->st_blksize); #else - ZVAL_LONG(&stat_blksize,-1); + ZVAL_INT(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS - ZVAL_LONG(&stat_blocks, stat_sb->st_blocks); + ZVAL_INT(&stat_blocks, stat_sb->st_blocks); #else - ZVAL_LONG(&stat_blocks,-1); + ZVAL_INT(&stat_blocks,-1); #endif /* Store numeric indexes in propper order */ zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); @@ -1201,7 +1201,7 @@ PHP_FUNCTION(realpath_cache_size) if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_LONG(realpath_cache_size(TSRMLS_C)); + RETURN_INT(realpath_cache_size(TSRMLS_C)); } /* {{{ proto bool realpath_cache_get() @@ -1223,14 +1223,14 @@ PHP_FUNCTION(realpath_cache_get) array_init(&entry); /* bucket->key is unsigned long */ - if (LONG_MAX >= bucket->key) { - add_assoc_long(&entry, "key", bucket->key); + if (ZEND_INT_MAX >= bucket->key) { + add_assoc_int(&entry, "key", bucket->key); } else { add_assoc_double(&entry, "key", (double)bucket->key); } add_assoc_bool(&entry, "is_dir", bucket->is_dir); add_assoc_stringl(&entry, "realpath", bucket->realpath, bucket->realpath_len); - add_assoc_long(&entry, "expires", bucket->expires); + add_assoc_int(&entry, "expires", bucket->expires); #ifdef PHP_WIN32 add_assoc_bool(&entry, "is_rvalid", bucket->is_rvalid); add_assoc_bool(&entry, "is_wvalid", bucket->is_wvalid); diff --git a/ext/standard/filters.c b/ext/standard/filters.c index d40321f959..9a0dc672c4 100644 --- a/ext/standard/filters.c +++ b/ext/standard/filters.c @@ -263,14 +263,14 @@ static php_stream_filter *strfilter_strip_tags_create(const char *filtername, zv ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(filterparams), tmp) { convert_to_string_ex(tmp); smart_str_appendc(&tags_ss, '<'); - smart_str_appendl(&tags_ss, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)); + smart_str_appendl(&tags_ss, Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); smart_str_appendc(&tags_ss, '>'); } ZEND_HASH_FOREACH_END(); smart_str_0(&tags_ss); } else { /* FIXME: convert_to_* may clutter zvals and lead it into segfault ? */ convert_to_string_ex(filterparams); - smart_str_setl(&tags_ss, Z_STRVAL_P(filterparams), Z_STRLEN_P(filterparams)); + smart_str_setl(&tags_ss, Z_STRVAL_P(filterparams), Z_STRSIZE_P(filterparams)); } } @@ -1232,7 +1232,7 @@ static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pr } #if IT_WAS_USED -static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, long *pretval, char *field_name, size_t field_name_len) +static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, php_int_t *pretval, char *field_name, size_t field_name_len) { zval **tmpval; @@ -1241,13 +1241,13 @@ static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, long *pretv if (zend_hash_find((HashTable *)ht, field_name, field_name_len, (void **)&tmpval) == SUCCESS) { zval tmp, *ztval = *tmpval; - if (Z_TYPE_PP(tmpval) != IS_LONG) { + if (Z_TYPE_PP(tmpval) != IS_INT) { tmp = *ztval; zval_copy_ctor(&tmp); - convert_to_long(&tmp); + convert_to_int(&tmp); ztval = &tmp; } - *pretval = Z_LVAL_P(ztval); + *pretval = Z_IVAL_P(ztval); } else { return PHP_CONV_ERR_NOT_FOUND; } @@ -1255,7 +1255,7 @@ static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, long *pretv } #endif -static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, unsigned long *pretval, char *field_name, size_t field_name_len) +static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, php_uint_t *pretval, char *field_name, size_t field_name_len) { zval *tmpval; @@ -1264,15 +1264,15 @@ static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, unsigned l if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) { zval tmp; - if (Z_TYPE_P(tmpval) != IS_LONG) { + if (Z_TYPE_P(tmpval) != IS_INT) { ZVAL_DUP(&tmp, tmpval);; - convert_to_long(&tmp); + convert_to_int(&tmp); tmpval = &tmp; } - if (Z_LVAL_P(tmpval) < 0) { + if (Z_IVAL_P(tmpval) < 0) { *pretval = 0; } else { - *pretval = Z_LVAL_P(tmpval); + *pretval = Z_IVAL_P(tmpval); } } else { return PHP_CONV_ERR_NOT_FOUND; @@ -1320,7 +1320,7 @@ static int php_conv_get_int_prop_ex(const HashTable *ht, int *pretval, char *fie static int php_conv_get_uint_prop_ex(const HashTable *ht, unsigned int *pretval, char *field_name, size_t field_name_len) { - unsigned long l; + php_uint_t l; php_conv_err_t err; *pretval = 0; diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c index edd704b068..3c570d32ee 100644 --- a/ext/standard/formatted_print.c +++ b/ext/standard/formatted_print.c @@ -52,7 +52,7 @@ static char HEXCHARS[] = "0123456789ABCDEF"; /* php_spintf_appendchar() {{{ */ inline static void -php_sprintf_appendchar(zend_string **buffer, int *pos, char add TSRMLS_DC) +php_sprintf_appendchar(zend_string **buffer, php_size_t *pos, char add TSRMLS_DC) { if (!*buffer || (*pos + 1) >= (*buffer)->len) { PRINTF_DEBUG(("%s(): ereallocing buffer to %d bytes\n", get_active_function_name(TSRMLS_C), (*buffer)->len)); @@ -65,22 +65,18 @@ php_sprintf_appendchar(zend_string **buffer, int *pos, char add TSRMLS_DC) /* php_spintf_appendstring() {{{ */ inline static void -php_sprintf_appendstring(zend_string **buffer, int *pos, char *add, - int min_width, int max_width, char padding, - int alignment, int len, int neg, int expprec, int always_sign) +php_sprintf_appendstring(zend_string **buffer, php_size_t *pos, char *add, + php_size_t min_width, php_size_t max_width, char padding, + php_size_t alignment, php_size_t len, int neg, int expprec, int always_sign) { - register int npad; - int req_size; - int copy_len; - int m_width; + register php_size_t npad; + php_size_t req_size; + php_size_t copy_len; + php_size_t m_width; copy_len = (expprec ? MIN(max_width, len) : len); - npad = min_width - copy_len; + npad = (min_width < copy_len) ? 0 : min_width - copy_len; - if (npad < 0) { - npad = 0; - } - PRINTF_DEBUG(("sprintf: appendstring(%x, %d, %d, \"%s\", %d, '%c', %d)\n", *buffer, *pos, (*buffer)->len, add, min_width, padding, alignment)); m_width = MAX(min_width, copy_len); @@ -92,10 +88,10 @@ php_sprintf_appendstring(zend_string **buffer, int *pos, char *add, req_size = *pos + m_width + 1; if (!*buffer || req_size > (*buffer)->len) { - int size = (*buffer)->len; + zend_size_t size = (*buffer)->len; while (req_size > size) { - if (size > INT_MAX/2) { - zend_error_noreturn(E_ERROR, "Field width %d is too long", req_size); + if (size > ZEND_SIZE_MAX/2) { + zend_error_noreturn(E_ERROR, "Field width %zd is too long", req_size); } size <<= 1; } @@ -126,21 +122,21 @@ php_sprintf_appendstring(zend_string **buffer, int *pos, char *add, /* php_spintf_appendint() {{{ */ inline static void -php_sprintf_appendint(zend_string **buffer, int *pos, long number, - int width, char padding, int alignment, +php_sprintf_appendint(zend_string **buffer, php_size_t *pos, php_int_t number, + php_size_t width, char padding, php_size_t alignment, int always_sign) { char numbuf[NUM_BUF_SIZE]; - register unsigned long magn, nmagn; + register php_uint_t magn, nmagn; register unsigned int i = NUM_BUF_SIZE - 1, neg = 0; PRINTF_DEBUG(("sprintf: appendint(%x, %x, %x, %d, %d, '%c', %d)\n", *buffer, pos, &(*buffer)->len, number, width, padding, alignment)); if (number < 0) { neg = 1; - magn = ((unsigned long) -(number + 1)) + 1; + magn = ((php_uint_t) -(number + 1)) + 1; } else { - magn = (unsigned long) number; + magn = (php_uint_t) number; } /* Can't right-pad 0's on integers */ @@ -170,17 +166,17 @@ php_sprintf_appendint(zend_string **buffer, int *pos, long number, /* php_spintf_appenduint() {{{ */ inline static void -php_sprintf_appenduint(zend_string **buffer, int *pos, - unsigned long number, - int width, char padding, int alignment) +php_sprintf_appenduint(zend_string **buffer, php_size_t *pos, + php_uint_t number, + php_size_t width, char padding, php_size_t alignment) { char numbuf[NUM_BUF_SIZE]; - register unsigned long magn, nmagn; + register php_uint_t magn, nmagn; register unsigned int i = NUM_BUF_SIZE - 1; PRINTF_DEBUG(("sprintf: appenduint(%x, %x, %x, %d, %d, '%c', %d)\n", *buffer, pos, &(*buffer)->len, number, width, padding, alignment)); - magn = (unsigned long) number; + magn = (php_uint_t) number; /* Can't right-pad 0's on integers */ if (alignment == 0 && padding == '0') padding = ' '; @@ -202,17 +198,18 @@ php_sprintf_appenduint(zend_string **buffer, int *pos, /* php_spintf_appenddouble() {{{ */ inline static void -php_sprintf_appenddouble(zend_string **buffer, int *pos, +php_sprintf_appenddouble(zend_string **buffer, php_size_t *pos, double number, - int width, char padding, - int alignment, int precision, + php_size_t width, char padding, + php_size_t alignment, int precision, int adjust, char fmt, int always_sign TSRMLS_DC) { char num_buf[NUM_BUF_SIZE]; char *s = NULL; - int s_len = 0, is_negative = 0; + php_size_t s_len = 0; + int is_negative = 0; #ifdef HAVE_LOCALE_H struct lconv *lconv; #endif @@ -293,13 +290,13 @@ php_sprintf_appenddouble(zend_string **buffer, int *pos, /* php_spintf_appendd2n() {{{ */ inline static void -php_sprintf_append2n(zend_string **buffer, int *pos, long number, - int width, char padding, int alignment, int n, +php_sprintf_append2n(zend_string **buffer, php_size_t *pos, php_int_t number, + php_size_t width, char padding, php_size_t alignment, int n, char *chartable, int expprec) { char numbuf[NUM_BUF_SIZE]; - register unsigned long num; - register unsigned int i = NUM_BUF_SIZE - 1; + register php_uint_t num; + register php_uint_t i = NUM_BUF_SIZE - 1; register int andbits = (1 << n) - 1; PRINTF_DEBUG(("sprintf: append2n(%x, %x, %x, %d, %d, '%c', %d, %d, %x)\n", @@ -307,7 +304,7 @@ php_sprintf_append2n(zend_string **buffer, int *pos, long number, chartable)); PRINTF_DEBUG(("sprintf: append2n 2^%d andbits=%x\n", n, andbits)); - num = (unsigned long) number; + num = (php_uint_t) number; numbuf[i] = '\0'; do { @@ -324,11 +321,11 @@ php_sprintf_append2n(zend_string **buffer, int *pos, long number, /* php_spintf_getnumber() {{{ */ inline static int -php_sprintf_getnumber(char *buffer, int *pos) +php_sprintf_getnumber(char *buffer, php_size_t *pos) { char *endptr; - register long num = strtol(&buffer[*pos], &endptr, 10); - register int i = 0; + register php_int_t num = ZEND_STRTOI(&buffer[*pos], &endptr, 10); + register php_size_t i = 0; if (endptr != NULL) { i = (endptr - &buffer[*pos]); @@ -373,7 +370,8 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) { zval *newargs = NULL; zval *args, *z_format; - int argc, size = 240, inpos = 0, outpos = 0, temppos; + int argc; + php_size_t size = 240, inpos = 0, outpos = 0, temppos; int alignment, currarg, adjusting, argnum, width, precision; char *format, padding; zend_string *result; @@ -416,12 +414,12 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) } format = Z_STRVAL(args[format_offset]); - format_len = Z_STRLEN(args[format_offset]); + format_len = Z_STRSIZE(args[format_offset]); result = STR_ALLOC(size, 0); currarg = 1; - while (inpos < Z_STRLEN(args[format_offset])) { + while (inpos < Z_STRSIZE(args[format_offset])) { int expprec = 0; zval *tmp; @@ -569,14 +567,14 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) case 'd': php_sprintf_appendint(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment, always_sign); break; case 'u': php_sprintf_appenduint(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment); break; @@ -596,33 +594,33 @@ php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC) case 'c': php_sprintf_appendchar(&result, &outpos, - (char) zval_get_long(tmp) TSRMLS_CC); + (char) zval_get_int(tmp) TSRMLS_CC); break; case 'o': php_sprintf_append2n(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment, 3, hexchars, expprec); break; case 'x': php_sprintf_append2n(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment, 4, hexchars, expprec); break; case 'X': php_sprintf_append2n(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment, 4, HEXCHARS, expprec); break; case 'b': php_sprintf_append2n(&result, &outpos, - zval_get_long(tmp), + zval_get_int(tmp), width, padding, alignment, 1, hexchars, expprec); break; @@ -680,14 +678,14 @@ PHP_FUNCTION(vsprintf) PHP_FUNCTION(user_printf) { zend_string *result; - int rlen; + php_size_t rlen; if ((result=php_formatted_print(ZEND_NUM_ARGS(), 0, 0 TSRMLS_CC))==NULL) { RETURN_FALSE; } rlen = PHPWRITE(result->val, result->len); STR_FREE(result); - RETURN_LONG(rlen); + RETURN_INT(rlen); } /* }}} */ @@ -696,14 +694,14 @@ PHP_FUNCTION(user_printf) PHP_FUNCTION(vprintf) { zend_string *result; - int rlen; + php_size_t rlen; if ((result=php_formatted_print(ZEND_NUM_ARGS(), 1, 0 TSRMLS_CC))==NULL) { RETURN_FALSE; } rlen = PHPWRITE(result->val, result->len); STR_FREE(result); - RETURN_LONG(rlen); + RETURN_INT(rlen); } /* }}} */ @@ -731,7 +729,7 @@ PHP_FUNCTION(fprintf) php_stream_write(stream, result->val, result->len); - RETVAL_LONG(result->len); + RETVAL_INT(result->len); STR_FREE(result); } /* }}} */ @@ -760,7 +758,7 @@ PHP_FUNCTION(vfprintf) php_stream_write(stream, result->val, result->len); - RETVAL_LONG(result->len); + RETVAL_INT(result->len); STR_FREE(result); } /* }}} */ diff --git a/ext/standard/fsock.c b/ext/standard/fsock.c index 300df8c1c0..17163b0234 100644 --- a/ext/standard/fsock.c +++ b/ext/standard/fsock.c @@ -36,7 +36,7 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent) long port = -1; zval *zerrno = NULL, *zerrstr = NULL; double timeout = FG(default_socket_timeout); - unsigned long conv; + php_uint_t conv; struct timeval tv; char *hashkey = NULL; php_stream *stream = NULL; @@ -63,13 +63,13 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent) } /* prepare the timeout value for use */ - conv = (unsigned long) (timeout * 1000000.0); + conv = (php_uint_t) (timeout * 1000000.0); tv.tv_sec = conv / 1000000; tv.tv_usec = conv % 1000000; if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -93,7 +93,7 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { /* no need to dup; we need to efree buf anyway */ diff --git a/ext/standard/ftok.c b/ext/standard/ftok.c index 4833bddc01..709d90840b 100644 --- a/ext/standard/ftok.c +++ b/ext/standard/ftok.c @@ -41,16 +41,16 @@ PHP_FUNCTION(ftok) if (pathname_len == 0){ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Pathname is invalid"); - RETURN_LONG(-1); + RETURN_INT(-1); } if (proj_len != 1){ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Project identifier is invalid"); - RETURN_LONG(-1); + RETURN_INT(-1); } if (php_check_open_basedir(pathname TSRMLS_CC)) { - RETURN_LONG(-1); + RETURN_INT(-1); } k = ftok(pathname, proj[0]); @@ -58,7 +58,7 @@ PHP_FUNCTION(ftok) php_error_docref(NULL TSRMLS_CC, E_WARNING, "ftok() failed - %s", strerror(errno)); } - RETURN_LONG(k); + RETURN_INT(k); } /* }}} */ #endif diff --git a/ext/standard/ftp_fopen_wrapper.c b/ext/standard/ftp_fopen_wrapper.c index 31b96fb68c..ae7f28b7da 100644 --- a/ext/standard/ftp_fopen_wrapper.c +++ b/ext/standard/ftp_fopen_wrapper.c @@ -498,7 +498,7 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa } else if (read_write == 2) { /* when writing file (but not appending), it must NOT exist, unless a context option exists which allows it */ if (context && (tmpzval = php_stream_context_get_option(context, "ftp", "overwrite")) != NULL) { - allow_overwrite = Z_LVAL_P(tmpzval); + allow_overwrite = Z_IVAL_P(tmpzval); } if (result <= 299 && result >= 200) { if (allow_overwrite) { @@ -529,12 +529,12 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa /* set resume position if applicable */ if (context && (tmpzval = php_stream_context_get_option(context, "ftp", "resume_pos")) != NULL && - Z_TYPE_P(tmpzval) == IS_LONG && - Z_LVAL_P(tmpzval) > 0) { - php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_LVAL_P(tmpzval)); + Z_TYPE_P(tmpzval) == IS_INT && + Z_IVAL_P(tmpzval) > 0) { + php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_IVAL_P(tmpzval)); result = GET_FTP_RESULT(stream); if (result < 300 || result > 399) { - php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_LVAL_P(tmpzval)); + php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_IVAL_P(tmpzval)); goto errexit; } } diff --git a/ext/standard/head.c b/ext/standard/head.c index ad82b9fbbf..ec792bee2c 100644 --- a/ext/standard/head.c +++ b/ext/standard/head.c @@ -239,7 +239,7 @@ PHP_FUNCTION(headers_sent) switch(ZEND_NUM_ARGS()) { case 2: zval_dtor(arg2); - ZVAL_LONG(arg2, line); + ZVAL_INT(arg2, line); case 1: zval_dtor(arg1); if (file) { @@ -303,7 +303,7 @@ PHP_FUNCTION(http_response_code) SG(sapi_headers).http_response_code = response_code; if (old_response_code) { - RETURN_LONG(old_response_code); + RETURN_INT(old_response_code); } RETURN_TRUE; @@ -313,7 +313,7 @@ PHP_FUNCTION(http_response_code) RETURN_FALSE; } - RETURN_LONG(SG(sapi_headers).http_response_code); + RETURN_INT(SG(sapi_headers).http_response_code); } /* }}} */ diff --git a/ext/standard/html.c b/ext/standard/html.c index 360639ea76..abb15f2440 100644 --- a/ext/standard/html.c +++ b/ext/standard/html.c @@ -856,7 +856,7 @@ static inline int process_named_entity_html(const char **buf, const char **start static inline int resolve_named_entity_html(const char *start, size_t length, const entity_ht *ht, unsigned *uni_cp1, unsigned *uni_cp2) { const entity_cp_map *s; - ulong hash = zend_inline_hash_func(start, length); + php_uint_t hash = zend_inline_hash_func(start, length); s = ht->buckets[hash % ht->num_elems]; while (s->entity) { @@ -1442,30 +1442,30 @@ encode_amp: */ static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all) { - char *str, *hint_charset = NULL; - int str_len, hint_charset_len = 0; - long flags = ENT_COMPAT; + zend_string *str, *hint_charset = NULL; + char *default_charset; + php_int_t flags = ENT_COMPAT; zend_string *replaced; zend_bool double_encode = 1; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls!b", &str, &str_len, &flags, &hint_charset, &hint_charset_len, &double_encode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|iS!b", &str, &flags, &hint_charset, &double_encode) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 4) - Z_PARAM_STRING(str, str_len) + Z_PARAM_STR(str) Z_PARAM_OPTIONAL - Z_PARAM_LONG(flags) - Z_PARAM_STRING_EX(hint_charset, hint_charset_len, 1, 0) + Z_PARAM_INT(flags) + Z_PARAM_STR_EX(hint_charset, 1, 0) Z_PARAM_BOOL(double_encode); ZEND_PARSE_PARAMETERS_END(); #endif if (!hint_charset) { - hint_charset = get_default_charset(TSRMLS_C); + default_charset = get_default_charset(TSRMLS_C); } - replaced = php_escape_html_entities_ex((unsigned char*)str, str_len, all, (int) flags, hint_charset, double_encode TSRMLS_CC); + replaced = php_escape_html_entities_ex((unsigned char*)str->val, str->len, all, (int) flags, (hint_charset ? hint_charset->val : default_charset), double_encode TSRMLS_CC); RETVAL_STR(replaced); } /* }}} */ @@ -1477,18 +1477,18 @@ static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all) */ void register_html_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("HTML_SPECIALCHARS", HTML_SPECIALCHARS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("HTML_ENTITIES", HTML_ENTITIES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_COMPAT", ENT_COMPAT, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_QUOTES", ENT_QUOTES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_NOQUOTES", ENT_NOQUOTES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_IGNORE", ENT_IGNORE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_SUBSTITUTE", ENT_SUBSTITUTE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_DISALLOWED", ENT_DISALLOWED, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_HTML401", ENT_HTML401, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_XML1", ENT_XML1, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_XHTML", ENT_XHTML, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("ENT_HTML5", ENT_HTML5, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("HTML_SPECIALCHARS", HTML_SPECIALCHARS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("HTML_ENTITIES", HTML_ENTITIES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_COMPAT", ENT_COMPAT, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_QUOTES", ENT_QUOTES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_NOQUOTES", ENT_NOQUOTES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_IGNORE", ENT_IGNORE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_SUBSTITUTE", ENT_SUBSTITUTE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_DISALLOWED", ENT_DISALLOWED, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_HTML401", ENT_HTML401, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_XML1", ENT_XML1, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_XHTML", ENT_XHTML, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("ENT_HTML5", ENT_HTML5, CONST_PERSISTENT|CONST_CS); } /* }}} */ @@ -1525,30 +1525,30 @@ PHP_FUNCTION(htmlspecialchars_decode) Convert all HTML entities to their applicable characters */ PHP_FUNCTION(html_entity_decode) { - char *str, *hint_charset = NULL; - int str_len, hint_charset_len = 0; + zend_string *str, *hint_charset = NULL; + char *default_charset; size_t new_len = 0; - long quote_style = ENT_COMPAT; + php_int_t quote_style = ENT_COMPAT; zend_string *replaced; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls", &str, &str_len, - "e_style, &hint_charset, &hint_charset_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|iS", &str, + "e_style, &hint_charset) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 3) - Z_PARAM_STRING(str, str_len) + Z_PARAM_STR(str) Z_PARAM_OPTIONAL - Z_PARAM_LONG(quote_style) - Z_PARAM_STRING(hint_charset, hint_charset_len) + Z_PARAM_INT(quote_style) + Z_PARAM_STR(hint_charset) ZEND_PARSE_PARAMETERS_END(); #endif if (!hint_charset) { - hint_charset = get_default_charset(TSRMLS_C); + default_charset = get_default_charset(TSRMLS_C); } - replaced = php_unescape_html_entities((unsigned char*)str, str_len, 1 /*all*/, quote_style, hint_charset TSRMLS_CC); + replaced = php_unescape_html_entities((unsigned char*)str->val, str->len, 1 /*all*/, quote_style, (hint_charset ? hint_charset->val : default_charset) TSRMLS_CC); if (replaced) { RETURN_STR(replaced); diff --git a/ext/standard/http.c b/ext/standard/http.c index 34b8e79389..27642da738 100644 --- a/ext/standard/http.c +++ b/ext/standard/http.c @@ -35,7 +35,7 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, char *newprefix, *p; const char *prop_name; int arg_sep_len, newprefix_len, prop_len; - ulong idx; + php_uint_t idx; zval *zdata = NULL, copyzval; if (!ht) { @@ -178,19 +178,19 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, case IS_STRING: { zend_string *ekey; if (enc_type == PHP_QUERY_RFC3986) { - ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)); + ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRSIZE_P(zdata)); } else { - ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)); + ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRSIZE_P(zdata)); } smart_str_appendl(formstr, ekey->val, ekey->len); STR_FREE(ekey); } break; - case IS_LONG: + case IS_INT: { char *ekey; int ekey_len; - ekey_len = spprintf(&ekey, 0, "%ld", Z_LVAL_P(zdata)); + ekey_len = spprintf(&ekey, 0, "%ld", Z_IVAL_P(zdata)); smart_str_appendl(formstr, ekey, ekey_len); efree(ekey); } @@ -217,9 +217,9 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr, ZVAL_DUP(©zval, zdata); convert_to_string_ex(©zval); if (enc_type == PHP_QUERY_RFC3986) { - ekey = php_raw_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval)); + ekey = php_raw_url_encode(Z_STRVAL(copyzval), Z_STRSIZE(copyzval)); } else { - ekey = php_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval)); + ekey = php_url_encode(Z_STRVAL(copyzval), Z_STRSIZE(copyzval)); } smart_str_appendl(formstr, ekey->val, ekey->len); zval_ptr_dtor(©zval); diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c index 73952dda31..7e8ddd51d4 100644 --- a/ext/standard/http_fopen_wrapper.c +++ b/ext/standard/http_fopen_wrapper.c @@ -160,7 +160,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, if (!context || (tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) == NULL || Z_TYPE_P(tmpzval) != IS_STRING || - Z_STRLEN_P(tmpzval) <= 0) { + Z_STRSIZE_P(tmpzval) <= 0) { php_url_free(resource); return php_stream_open_wrapper_ex(path, mode, REPORT_ERRORS, NULL, context); } @@ -169,8 +169,8 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, use_ssl = 0; use_proxy = 1; - transport_len = Z_STRLEN_P(tmpzval); - transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + transport_len = Z_STRSIZE_P(tmpzval); + transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { /* Normal http request (possibly with proxy) */ @@ -190,10 +190,10 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, if (context && (tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) != NULL && Z_TYPE_P(tmpzval) == IS_STRING && - Z_STRLEN_P(tmpzval) > 0) { + Z_STRSIZE_P(tmpzval) > 0) { use_proxy = 1; - transport_len = Z_STRLEN_P(tmpzval); - transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + transport_len = Z_STRSIZE_P(tmpzval); + transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { transport_len = spprintf(&transport_string, 0, "%s://%s:%d", use_ssl ? "ssl" : "tcp", resource->host, resource->port); } @@ -271,7 +271,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, } while (*s != 0); } } ZEND_HASH_FOREACH_END(); - } else if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) { + } else if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval)) { s = Z_STRVAL_P(tmpzval); do { while (*s == ' ' || *s == '\t') s++; @@ -346,20 +346,20 @@ finish: php_stream_notify_info(context, PHP_STREAM_NOTIFY_CONNECT, NULL, 0); if (header_init && context && (tmpzval = php_stream_context_get_option(context, "http", "max_redirects")) != NULL) { - redirect_max = zval_get_long(tmpzval); + redirect_max = zval_get_int(tmpzval); } if (context && (tmpzval = php_stream_context_get_option(context, "http", "method")) != NULL) { - if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) { + if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0) { /* As per the RFC, automatically redirected requests MUST NOT use other methods than * GET and HEAD unless it can be confirmed by the user */ if (!redirected - || (Z_STRLEN_P(tmpzval) == 3 && memcmp("GET", Z_STRVAL_P(tmpzval), 3) == 0) - || (Z_STRLEN_P(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_P(tmpzval), 4) == 0) + || (Z_STRSIZE_P(tmpzval) == 3 && memcmp("GET", Z_STRVAL_P(tmpzval), 3) == 0) + || (Z_STRSIZE_P(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_P(tmpzval), 4) == 0) ) { - scratch_len = strlen(path) + 29 + Z_STRLEN_P(tmpzval); + scratch_len = strlen(path) + 29 + Z_STRSIZE_P(tmpzval); scratch = emalloc(scratch_len); - strlcpy(scratch, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval) + 1); + strlcpy(scratch, Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval) + 1); strncat(scratch, " ", 1); } } @@ -422,7 +422,7 @@ finish: ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmpzval), tmpheader) { if (Z_TYPE_P(tmpheader) == IS_STRING) { - smart_str_appendl(&tmpstr, Z_STRVAL_P(tmpheader), Z_STRLEN_P(tmpheader)); + smart_str_appendl(&tmpstr, Z_STRVAL_P(tmpheader), Z_STRSIZE_P(tmpheader)); smart_str_appendl(&tmpstr, "\r\n", sizeof("\r\n") - 1); } } ZEND_HASH_FOREACH_END(); @@ -433,9 +433,9 @@ finish: smart_str_free(&tmpstr); } } - if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) { + if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval)) { /* Remove newlines and spaces from start and end php_trim will estrndup() */ - tmp = php_trim(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC); + tmp = php_trim(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC); } if (tmp && strlen(tmp) > 0) { char *s; @@ -609,9 +609,9 @@ finish: context && !(have_header & HTTP_HEADER_CONTENT_LENGTH) && (tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL && - Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0 + Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0 ) { - scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval)); + scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRSIZE_P(tmpzval)); php_stream_write(stream, scratch, scratch_len); have_header |= HTTP_HEADER_CONTENT_LENGTH; } @@ -624,9 +624,9 @@ finish: /* Request content, such as for POST requests */ if (header_init && context && (tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL && - Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) { + Z_TYPE_P(tmpzval) == IS_STRING && Z_STRSIZE_P(tmpzval) > 0) { if (!(have_header & HTTP_HEADER_CONTENT_LENGTH)) { - scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval)); + scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRSIZE_P(tmpzval)); php_stream_write(stream, scratch, scratch_len); } if (!(have_header & HTTP_HEADER_TYPE)) { @@ -635,7 +635,7 @@ finish: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Content-type not specified assuming application/x-www-form-urlencoded"); } php_stream_write(stream, "\r\n", sizeof("\r\n")-1); - php_stream_write(stream, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval)); + php_stream_write(stream, Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval)); } else { php_stream_write(stream, "\r\n", sizeof("\r\n")-1); } @@ -731,7 +731,7 @@ finish: if (!strncasecmp(http_header_line, "Location: ", 10)) { if (context && (tmpzval = php_stream_context_get_option(context, "http", "follow_location")) != NULL) { - follow_location = zval_get_long(tmpzval); + follow_location = zval_get_int(tmpzval); } else if (!(response_code >= 300 && response_code < 304 || 307 == response_code || 308 == response_code)) { /* we shouldn't redirect automatically if follow_location isn't set and response_code not in (300, 301, 302, 303 and 307) diff --git a/ext/standard/image.c b/ext/standard/image.c index 0ec4cd3885..87ab458800 100644 --- a/ext/standard/image.c +++ b/ext/standard/image.c @@ -72,28 +72,28 @@ struct gfxinfo { * Register IMAGETYPE_<xxx> constants used by GetImageSize(), image_type_to_mime_type, ext/exif */ PHP_MINIT_FUNCTION(imagetypes) { - REGISTER_LONG_CONSTANT("IMAGETYPE_GIF", IMAGE_FILETYPE_GIF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG", IMAGE_FILETYPE_JPEG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_PNG", IMAGE_FILETYPE_PNG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_SWF", IMAGE_FILETYPE_SWF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_PSD", IMAGE_FILETYPE_PSD, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_BMP", IMAGE_FILETYPE_BMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_II", IMAGE_FILETYPE_TIFF_II, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_MM", IMAGE_FILETYPE_TIFF_MM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPC", IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JP2", IMAGE_FILETYPE_JP2, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPX", IMAGE_FILETYPE_JPX, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JB2", IMAGE_FILETYPE_JB2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_GIF", IMAGE_FILETYPE_GIF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPEG", IMAGE_FILETYPE_JPEG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_PNG", IMAGE_FILETYPE_PNG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_SWF", IMAGE_FILETYPE_SWF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_PSD", IMAGE_FILETYPE_PSD, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_BMP", IMAGE_FILETYPE_BMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_TIFF_II", IMAGE_FILETYPE_TIFF_II, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_TIFF_MM", IMAGE_FILETYPE_TIFF_MM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPC", IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JP2", IMAGE_FILETYPE_JP2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPX", IMAGE_FILETYPE_JPX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JB2", IMAGE_FILETYPE_JB2, CONST_CS | CONST_PERSISTENT); #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) - REGISTER_LONG_CONSTANT("IMAGETYPE_SWC", IMAGE_FILETYPE_SWC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_SWC", IMAGE_FILETYPE_SWC, CONST_CS | CONST_PERSISTENT); #endif - REGISTER_LONG_CONSTANT("IMAGETYPE_IFF", IMAGE_FILETYPE_IFF, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_WBMP", IMAGE_FILETYPE_WBMP, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG2000",IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); /* keep alias */ - REGISTER_LONG_CONSTANT("IMAGETYPE_XBM", IMAGE_FILETYPE_XBM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_ICO", IMAGE_FILETYPE_ICO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_UNKNOWN", IMAGE_FILETYPE_UNKNOWN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("IMAGETYPE_COUNT", IMAGE_FILETYPE_COUNT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_IFF", IMAGE_FILETYPE_IFF, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_WBMP", IMAGE_FILETYPE_WBMP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_JPEG2000",IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); /* keep alias */ + REGISTER_INT_CONSTANT("IMAGETYPE_XBM", IMAGE_FILETYPE_XBM, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_ICO", IMAGE_FILETYPE_ICO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_UNKNOWN", IMAGE_FILETYPE_UNKNOWN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("IMAGETYPE_COUNT", IMAGE_FILETYPE_COUNT, CONST_CS | CONST_PERSISTENT); return SUCCESS; } /* }}} */ @@ -1364,19 +1364,19 @@ static void php_getimagesize_from_stream(php_stream *stream, zval *info, INTERNA } if (result) { - char temp[MAX_LENGTH_OF_LONG * 2 + sizeof("width=\"\" height=\"\"")]; + char temp[MAX_LENGTH_OF_ZEND_INT * 2 + sizeof("width=\"\" height=\"\"")]; array_init(return_value); - add_index_long(return_value, 0, result->width); - add_index_long(return_value, 1, result->height); - add_index_long(return_value, 2, itype); + add_index_int(return_value, 0, result->width); + add_index_int(return_value, 1, result->height); + add_index_int(return_value, 2, itype); snprintf(temp, sizeof(temp), "width=\"%d\" height=\"%d\"", result->width, result->height); add_index_string(return_value, 3, temp); if (result->bits != 0) { - add_assoc_long(return_value, "bits", result->bits); + add_assoc_int(return_value, "bits", result->bits); } if (result->channels != 0) { - add_assoc_long(return_value, "channels", result->channels); + add_assoc_int(return_value, "channels", result->channels); } add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype)); efree(result); diff --git a/ext/standard/info.c b/ext/standard/info.c index 47249466b0..27bc683ba5 100644 --- a/ext/standard/info.c +++ b/ext/standard/info.c @@ -196,7 +196,7 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC) { zval *data, *tmp, tmp2; zend_string *string_key; - ulong num_key; + php_uint_t num_key; zend_string *key; key = STR_INIT(name, name_length, 0); @@ -244,10 +244,10 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC) } if (!sapi_module.phpinfo_as_text) { - if (Z_STRLEN(tmp2) == 0) { + if (Z_STRSIZE(tmp2) == 0) { php_info_print("<i>no value</i>"); } else { - php_info_print_html_esc(Z_STRVAL(tmp2), Z_STRLEN(tmp2)); + php_info_print_html_esc(Z_STRVAL(tmp2), Z_STRSIZE(tmp2)); } } else { php_info_print(Z_STRVAL(tmp2)); @@ -1143,22 +1143,22 @@ PHPAPI void php_info_print_table_row_ex(int num_cols, const char *value_class, */ void register_phpinfo_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("INFO_GENERAL", PHP_INFO_GENERAL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_CREDITS", PHP_INFO_CREDITS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_CONFIGURATION", PHP_INFO_CONFIGURATION, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_MODULES", PHP_INFO_MODULES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_ENVIRONMENT", PHP_INFO_ENVIRONMENT, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_VARIABLES", PHP_INFO_VARIABLES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_LICENSE", PHP_INFO_LICENSE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("INFO_ALL", PHP_INFO_ALL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_GROUP", PHP_CREDITS_GROUP, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_GENERAL", PHP_CREDITS_GENERAL, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_SAPI", PHP_CREDITS_SAPI, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_MODULES", PHP_CREDITS_MODULES, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_DOCS", PHP_CREDITS_DOCS, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_FULLPAGE", PHP_CREDITS_FULLPAGE, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_QA", PHP_CREDITS_QA, CONST_PERSISTENT|CONST_CS); - REGISTER_LONG_CONSTANT("CREDITS_ALL", PHP_CREDITS_ALL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_GENERAL", PHP_INFO_GENERAL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_CREDITS", PHP_INFO_CREDITS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_CONFIGURATION", PHP_INFO_CONFIGURATION, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_MODULES", PHP_INFO_MODULES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_ENVIRONMENT", PHP_INFO_ENVIRONMENT, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_VARIABLES", PHP_INFO_VARIABLES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_LICENSE", PHP_INFO_LICENSE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("INFO_ALL", PHP_INFO_ALL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_GROUP", PHP_CREDITS_GROUP, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_GENERAL", PHP_CREDITS_GENERAL, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_SAPI", PHP_CREDITS_SAPI, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_MODULES", PHP_CREDITS_MODULES, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_DOCS", PHP_CREDITS_DOCS, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_FULLPAGE", PHP_CREDITS_FULLPAGE, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_QA", PHP_CREDITS_QA, CONST_PERSISTENT|CONST_CS); + REGISTER_INT_CONSTANT("CREDITS_ALL", PHP_CREDITS_ALL, CONST_PERSISTENT|CONST_CS); } /* }}} */ diff --git a/ext/standard/levenshtein.c b/ext/standard/levenshtein.c index 786ca052d7..86ce0f2fbe 100644 --- a/ext/standard/levenshtein.c +++ b/ext/standard/levenshtein.c @@ -128,7 +128,7 @@ PHP_FUNCTION(levenshtein) php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument string(s) too long"); } - RETURN_LONG(distance); + RETURN_INT(distance); } /* }}} */ diff --git a/ext/standard/link.c b/ext/standard/link.c index 0f889a9e6a..4265823616 100644 --- a/ext/standard/link.c +++ b/ext/standard/link.c @@ -106,11 +106,11 @@ PHP_FUNCTION(linkinfo) if (ret == -1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno)); efree(dirname); - RETURN_LONG(-1L); + RETURN_INT(-1L); } efree(dirname); - RETURN_LONG((long) sb.st_dev); + RETURN_INT((long) sb.st_dev); } /* }}} */ diff --git a/ext/standard/link_win32.c b/ext/standard/link_win32.c index 41ce9d20df..8a04fb3f77 100644 --- a/ext/standard/link_win32.c +++ b/ext/standard/link_win32.c @@ -88,7 +88,7 @@ PHP_FUNCTION(linkinfo) { char *link; int link_len; - struct stat sb; + php_stat_t sb; int ret; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &link, &link_len) == FAILURE) { @@ -98,10 +98,10 @@ PHP_FUNCTION(linkinfo) ret = VCWD_STAT(link, &sb); if (ret == -1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno)); - RETURN_LONG(-1L); + RETURN_INT(-1L); } - RETURN_LONG((long) sb.st_dev); + RETURN_INT((long) sb.st_dev); } /* }}} */ diff --git a/ext/standard/mail.c b/ext/standard/mail.c index 815f83118f..b08c4858e8 100644 --- a/ext/standard/mail.c +++ b/ext/standard/mail.c @@ -92,7 +92,7 @@ PHP_FUNCTION(ezmlm_hash) h = (h % 53); - RETURN_LONG((int) h); + RETURN_INT((int) h); } /* }}} */ diff --git a/ext/standard/math.c b/ext/standard/math.c index a392eb607c..648408e840 100644 --- a/ext/standard/math.c +++ b/ext/standard/math.c @@ -285,11 +285,11 @@ PHP_FUNCTION(abs) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(fabs(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { - if (Z_LVAL_P(value) == LONG_MIN) { - RETURN_DOUBLE(-(double)LONG_MIN); + } else if (Z_TYPE_P(value) == IS_INT) { + if (Z_IVAL_P(value) == ZEND_INT_MIN) { + RETURN_DOUBLE(-(double)ZEND_INT_MIN); } else { - RETURN_LONG(Z_LVAL_P(value) < 0 ? -Z_LVAL_P(value) : Z_LVAL_P(value)); + RETURN_INT(Z_IVAL_P(value) < 0 ? -Z_IVAL_P(value) : Z_IVAL_P(value)); } } RETURN_FALSE; @@ -309,7 +309,7 @@ PHP_FUNCTION(ceil) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(ceil(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { + } else if (Z_TYPE_P(value) == IS_INT) { RETURN_DOUBLE(zval_get_double(value)); } RETURN_FALSE; @@ -329,7 +329,7 @@ PHP_FUNCTION(floor) if (Z_TYPE_P(value) == IS_DOUBLE) { RETURN_DOUBLE(floor(Z_DVAL_P(value))); - } else if (Z_TYPE_P(value) == IS_LONG) { + } else if (Z_TYPE_P(value) == IS_INT) { RETURN_DOUBLE(zval_get_double(value)); } RETURN_FALSE; @@ -342,11 +342,11 @@ PHP_FUNCTION(round) { zval *value; int places = 0; - long precision = 0; - long mode = PHP_ROUND_HALF_UP; + php_int_t precision = 0; + php_int_t mode = PHP_ROUND_HALF_UP; double return_val; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ll", &value, &precision, &mode) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ii", &value, &precision, &mode) == FAILURE) { return; } @@ -356,15 +356,15 @@ PHP_FUNCTION(round) convert_scalar_to_number_ex(value); switch (Z_TYPE_P(value)) { - case IS_LONG: + case IS_INT: /* Simple case - long that doesn't need to be rounded. */ if (places >= 0) { - RETURN_DOUBLE((double) Z_LVAL_P(value)); + RETURN_DOUBLE((double) Z_IVAL_P(value)); } /* break omitted intentionally */ case IS_DOUBLE: - return_val = (Z_TYPE_P(value) == IS_LONG) ? (double)Z_LVAL_P(value) : Z_DVAL_P(value); + return_val = (Z_TYPE_P(value) == IS_INT) ? (double)Z_IVAL_P(value) : Z_DVAL_P(value); return_val = _php_math_round(return_val, places, mode); RETURN_DOUBLE(return_val); break; @@ -926,9 +926,9 @@ PHP_FUNCTION(rad2deg) /* * Convert a string representation of a base(2-36) number to a long. */ -PHPAPI long _php_math_basetolong(zval *arg, int base) +PHPAPI php_int_t _php_math_basetolong(zval *arg, int base) { - long num = 0, digit, onum; + php_int_t num = 0, digit, onum; int i; char c, *s; @@ -938,7 +938,7 @@ PHPAPI long _php_math_basetolong(zval *arg, int base) s = Z_STRVAL_P(arg); - for (i = Z_STRLEN_P(arg); i > 0; i--) { + for (i = Z_STRSIZE_P(arg); i > 0; i--) { c = *s++; digit = (c >= '0' && c <= '9') ? c - '0' @@ -959,7 +959,7 @@ PHPAPI long _php_math_basetolong(zval *arg, int base) TSRMLS_FETCH(); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number '%s' is too big to fit in long", s); - return LONG_MAX; + return ZEND_INT_MAX; } } @@ -973,12 +973,12 @@ PHPAPI long _php_math_basetolong(zval *arg, int base) */ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) { - long num = 0; + php_int_t num = 0; double fnum = 0; int i; int mode = 0; char c, *s; - long cutoff; + php_int_t cutoff; int cutlim; if (Z_TYPE_P(arg) != IS_STRING || base < 2 || base > 36) { @@ -987,10 +987,10 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) s = Z_STRVAL_P(arg); - cutoff = LONG_MAX / base; - cutlim = LONG_MAX % base; + cutoff = ZEND_INT_MAX / base; + cutlim = ZEND_INT_MAX % base; - for (i = Z_STRLEN_P(arg); i > 0; i--) { + for (i = Z_STRSIZE_P(arg); i > 0; i--) { c = *s++; /* might not work for EBCDIC */ @@ -1024,7 +1024,7 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) if (mode == 1) { ZVAL_DOUBLE(ret, fnum); } else { - ZVAL_LONG(ret, num); + ZVAL_INT(ret, num); } return SUCCESS; } @@ -1038,15 +1038,15 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret) PHPAPI zend_string * _php_math_longtobase(zval *arg, int base TSRMLS_DC) { static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; - char buf[(sizeof(unsigned long) << 3) + 1]; + char buf[(sizeof(php_uint_t) << 3) + 1]; char *ptr, *end; - unsigned long value; + php_uint_t value; - if (Z_TYPE_P(arg) != IS_LONG || base < 2 || base > 36) { + if (Z_TYPE_P(arg) != IS_INT || base < 2 || base > 36) { return STR_EMPTY_ALLOC(); } - value = Z_LVAL_P(arg); + value = Z_IVAL_P(arg); end = ptr = buf + sizeof(buf) - 1; *ptr = '\0'; @@ -1069,7 +1069,7 @@ PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC) { static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; - if ((Z_TYPE_P(arg) != IS_LONG && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) { + if ((Z_TYPE_P(arg) != IS_INT && Z_TYPE_P(arg) != IS_DOUBLE) || base < 2 || base > 36) { return STR_EMPTY_ALLOC(); } @@ -1157,7 +1157,7 @@ PHP_FUNCTION(decbin) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 2 TSRMLS_CC); RETURN_STR(result); } @@ -1173,7 +1173,7 @@ PHP_FUNCTION(decoct) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 8 TSRMLS_CC); RETURN_STR(result); } @@ -1189,7 +1189,7 @@ PHP_FUNCTION(dechex) if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) { return; } - convert_to_long_ex(arg); + convert_to_int_ex(arg); result = _php_math_longtobase(arg, 16 TSRMLS_CC); RETURN_STR(result); } @@ -1200,20 +1200,20 @@ PHP_FUNCTION(dechex) PHP_FUNCTION(base_convert) { zval *number, temp; - long frombase, tobase; + php_int_t frombase, tobase; zend_string *result; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zll", &number, &frombase, &tobase) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zii", &number, &frombase, &tobase) == FAILURE) { return; } convert_to_string_ex(number); if (frombase < 2 || frombase > 36) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid `from base' (%ld)", frombase); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid `from base' (%pd)", frombase); RETURN_FALSE; } if (tobase < 2 || tobase > 36) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid `to base' (%ld)", tobase); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid `to base' (%pd)", tobase); RETURN_FALSE; } @@ -1350,20 +1350,20 @@ PHPAPI zend_string *_php_math_number_format_ex(double d, int dec, char *dec_poin PHP_FUNCTION(number_format) { double num; - long dec = 0; + php_int_t dec = 0; char *thousand_sep = NULL, *dec_point = NULL; char thousand_sep_chr = ',', dec_point_chr = '.'; int thousand_sep_len = 0, dec_point_len = 0; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|ls!s!", &num, &dec, &dec_point, &dec_point_len, &thousand_sep, &thousand_sep_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|is!s!", &num, &dec, &dec_point, &dec_point_len, &thousand_sep, &thousand_sep_len) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 4) Z_PARAM_DOUBLE(num) Z_PARAM_OPTIONAL - Z_PARAM_LONG(dec) + Z_PARAM_INT(dec) Z_PARAM_STRING_EX(dec_point, dec_point_len, 1, 0) Z_PARAM_STRING_EX(thousand_sep, thousand_sep_len, 1, 0) ZEND_PARSE_PARAMETERS_END(); @@ -1434,10 +1434,10 @@ PHP_FUNCTION(intdiv) } else if (divisor == -1 && numerator == LONG_MIN) { /* Prevent overflow error/crash We don't return a float here as that violates function contract */ - RETURN_LONG(0); + RETURN_INT(0); } - RETURN_LONG(numerator/divisor); + RETURN_INT(numerator/divisor); } /* }}} */ diff --git a/ext/standard/microtime.c b/ext/standard/microtime.c index f8e19c74ca..3cadf729cc 100644 --- a/ext/standard/microtime.c +++ b/ext/standard/microtime.c @@ -73,11 +73,11 @@ static void _php_gettimeofday(INTERNAL_FUNCTION_PARAMETERS, int mode) offset = timelib_get_time_zone_info(tp.tv_sec, get_timezone_info(TSRMLS_C)); array_init(return_value); - add_assoc_long(return_value, "sec", tp.tv_sec); - add_assoc_long(return_value, "usec", tp.tv_usec); + add_assoc_int(return_value, "sec", tp.tv_sec); + add_assoc_int(return_value, "usec", tp.tv_usec); - add_assoc_long(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); - add_assoc_long(return_value, "dsttime", offset->is_dst); + add_assoc_int(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); + add_assoc_int(return_value, "dsttime", offset->is_dst); timelib_time_offset_dtor(offset); } else { @@ -130,7 +130,7 @@ PHP_FUNCTION(getrusage) array_init(return_value); #define PHP_RUSAGE_PARA(a) \ - add_assoc_long(return_value, #a, usg.a) + add_assoc_int(return_value, #a, usg.a) #if !defined( _OSD_POSIX) && !defined(__BEOS__) /* BS2000 has only a few fields in the rusage struct */ PHP_RUSAGE_PARA(ru_oublock); PHP_RUSAGE_PARA(ru_inblock); diff --git a/ext/standard/pack.c b/ext/standard/pack.c index c77a1a40c6..613a58b5fd 100644 --- a/ext/standard/pack.c +++ b/ext/standard/pack.c @@ -84,13 +84,13 @@ static int little_endian_long_map[4]; /* {{{ php_pack */ -static void php_pack(zval *val, int size, int *map, char *output) +static void php_pack(zval *val, php_size_t size, int *map, char *output) { int i; char *v; - convert_to_long_ex(val); - v = (char *) &Z_LVAL_P(val); + convert_to_int_ex(val); + v = (char *) &Z_IVAL_P(val); for (i = 0; i < size; i++) { *output++ = v[map[i]]; @@ -126,7 +126,7 @@ PHP_FUNCTION(pack) convert_to_string_ex(&argv[0]); format = Z_STRVAL(argv[0]); - formatlen = Z_STRLEN(argv[0]); + formatlen = Z_STRSIZE(argv[0]); /* We have a maximum of <formatlen> format codes to deal with */ formatcodes = safe_emalloc(formatlen, sizeof(*formatcodes), 0); @@ -185,7 +185,7 @@ PHP_FUNCTION(pack) SEPARATE_ZVAL(&argv[currentarg]); } convert_to_string_ex(&argv[currentarg]); - arg = Z_STRLEN(argv[currentarg]); + arg = Z_STRSIZE(argv[currentarg]); if (code == 'Z') { /* add one because Z is always NUL-terminated: * pack("Z*", "aa") === "aa\0" @@ -480,9 +480,9 @@ PHP_FUNCTION(pack) /* {{{ php_unpack */ -static long php_unpack(char *data, int size, int issigned, int *map) +static php_int_t php_unpack(char *data, php_size_t size, int issigned, int *map) { - long result; + php_int_t result; char *cresult = (char *) &result; int i; @@ -512,19 +512,20 @@ static long php_unpack(char *data, int size, int issigned, int *map) Unpack binary string into named array elements according to format argument */ PHP_FUNCTION(unpack) { - char *format, *input, *formatarg, *inputarg; - int formatlen, formatarg_len, inputarg_len; - int inputpos, inputlen, i; + char *format, *input; + zend_string *formatarg, *inputarg; + php_size_t formatlen, inputpos, inputlen; + int i; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &formatarg, &formatarg_len, - &inputarg, &inputarg_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &formatarg, + &inputarg) == FAILURE) { return; } - format = formatarg; - formatlen = formatarg_len; - input = inputarg; - inputlen = inputarg_len; + format = formatarg->val; + formatlen = formatarg->len; + input = inputarg->val; + inputlen = inputarg->len; inputpos = 0; array_init(return_value); @@ -656,11 +657,11 @@ PHP_FUNCTION(unpack) inputpos = 0; } - if ((inputpos + size) <= inputlen) { + if ((size >=0 && (inputpos + size) <= inputlen) || (size < 0 && -size <= (inputlen - inputpos))) { switch ((int) type) { case 'a': { /* a will not strip any trailing whitespace or null padding */ - int len = inputlen - inputpos; /* Remaining string */ + php_size_t len = inputlen - inputpos; /* Remaining string */ /* If size was given take minimum of len and size */ if ((size >= 0) && (len > size)) { @@ -675,7 +676,7 @@ PHP_FUNCTION(unpack) case 'A': { /* A will strip any trailing whitespace */ char padn = '\0'; char pads = ' '; char padt = '\t'; char padc = '\r'; char padl = '\n'; - int len = inputlen - inputpos; /* Remaining string */ + php_size_t len = inputlen - inputpos; /* Remaining string */ /* If size was given take minimum of len and size */ if ((size >= 0) && (len > size)) { @@ -702,7 +703,7 @@ PHP_FUNCTION(unpack) case 'Z': { /* Z will strip everything after the first null character */ char pad = '\0'; - int s, + php_size_t s, len = inputlen - inputpos; /* Remaining string */ /* If size was given take minimum of len and size */ @@ -726,11 +727,11 @@ PHP_FUNCTION(unpack) case 'h': case 'H': { - int len = (inputlen - inputpos) * 2; /* Remaining */ + php_size_t len = (inputlen - inputpos) * 2; /* Remaining */ int nibbleshift = (type == 'h') ? 0 : 4; int first = 1; char *buf; - int ipos, opos; + php_size_t ipos, opos; /* If size was given take minimum of len and size */ if (size >= 0 && len > (size * 2)) { @@ -770,8 +771,8 @@ PHP_FUNCTION(unpack) case 'c': case 'C': { int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0; - long v = php_unpack(&input[inputpos], 1, issigned, byte_map); - add_assoc_long(return_value, n, v); + php_int_t v = php_unpack(&input[inputpos], 1, issigned, byte_map); + add_assoc_int(return_value, n, v); break; } @@ -779,7 +780,7 @@ PHP_FUNCTION(unpack) case 'S': case 'n': case 'v': { - long v; + php_int_t v; int issigned = 0; int *map = machine_endian_short_map; @@ -792,13 +793,13 @@ PHP_FUNCTION(unpack) } v = php_unpack(&input[inputpos], 2, issigned, map); - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } case 'i': case 'I': { - long v; + php_int_t v; int issigned = 0; if (type == 'i') { @@ -806,7 +807,7 @@ PHP_FUNCTION(unpack) } v = php_unpack(&input[inputpos], sizeof(int), issigned, int_map); - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -816,7 +817,7 @@ PHP_FUNCTION(unpack) case 'V': { int issigned = 0; int *map = machine_endian_long_map; - long v = 0; + php_int_t v = 0; if (type == 'l' || type == 'L') { issigned = input[inputpos + (machine_little_endian ? 3 : 0)] & 0x80; @@ -828,19 +829,19 @@ PHP_FUNCTION(unpack) map = little_endian_long_map; } - if (sizeof(long) > 4 && issigned) { + if (SIZEOF_ZEND_INT > 4 && issigned) { v = ~INT_MAX; } v |= php_unpack(&input[inputpos], 4, issigned, map); - if (sizeof(long) > 4) { + if (SIZEOF_ZEND_INT > 4) { if (type == 'l') { v = (signed int) v; } else { v = (unsigned int) v; } } - add_assoc_long(return_value, n, v); + add_assoc_int(return_value, n, v); break; } @@ -903,8 +904,10 @@ PHP_FUNCTION(unpack) } } - formatlen--; /* Skip '/' separator, does no harm if inputlen == 0 */ - format++; + if (formatlen > 0) { + formatlen--; /* Skip '/' separator, does no harm if inputlen == 0 */ + format++; + } } } /* }}} */ @@ -948,8 +951,8 @@ PHP_MINIT_FUNCTION(pack) } else { zval val; - int size = sizeof(Z_LVAL(val)); - Z_LVAL(val)=0; /*silence a warning*/ + int size = sizeof(Z_IVAL(val)); + Z_IVAL(val)=0; /*silence a warning*/ /* Where to get hi to lo bytes from */ byte_map[0] = size - 1; diff --git a/ext/standard/pageinfo.c b/ext/standard/pageinfo.c index a9a4e58de0..a92457e842 100644 --- a/ext/standard/pageinfo.c +++ b/ext/standard/pageinfo.c @@ -59,7 +59,7 @@ */ PHPAPI void php_statpage(TSRMLS_D) { - struct stat *pstat; + php_stat_t *pstat; pstat = sapi_get_stat(TSRMLS_C); @@ -106,7 +106,7 @@ PHP_FUNCTION(getmyuid) if (uid < 0) { RETURN_FALSE; } else { - RETURN_LONG(uid); + RETURN_INT(uid); } } /* }}} */ @@ -125,7 +125,7 @@ PHP_FUNCTION(getmygid) if (gid < 0) { RETURN_FALSE; } else { - RETURN_LONG(gid); + RETURN_INT(gid); } } /* }}} */ @@ -144,7 +144,7 @@ PHP_FUNCTION(getmypid) if (pid < 0) { RETURN_FALSE; } else { - RETURN_LONG((long) pid); + RETURN_INT((long) pid); } } /* }}} */ @@ -161,7 +161,7 @@ PHP_FUNCTION(getmyinode) if (BG(page_inode) < 0) { RETURN_FALSE; } else { - RETURN_LONG(BG(page_inode)); + RETURN_INT(BG(page_inode)); } } /* }}} */ @@ -186,7 +186,7 @@ PHP_FUNCTION(getlastmod) if (lm < 0) { RETURN_FALSE; } else { - RETURN_LONG(lm); + RETURN_INT(lm); } } /* }}} */ diff --git a/ext/standard/password.c b/ext/standard/password.c index aa50ab1f00..d001e475f0 100644 --- a/ext/standard/password.c +++ b/ext/standard/password.c @@ -37,10 +37,10 @@ PHP_MINIT_FUNCTION(password) /* {{{ */ { - REGISTER_LONG_CONSTANT("PASSWORD_DEFAULT", PHP_PASSWORD_DEFAULT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PASSWORD_BCRYPT", PHP_PASSWORD_BCRYPT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_DEFAULT", PHP_PASSWORD_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_BCRYPT", PHP_PASSWORD_BCRYPT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PASSWORD_BCRYPT_DEFAULT_COST", PHP_PASSWORD_BCRYPT_COST, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PASSWORD_BCRYPT_DEFAULT_COST", PHP_PASSWORD_BCRYPT_COST, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -197,7 +197,7 @@ PHP_FUNCTION(password_get_info) { long cost = PHP_PASSWORD_BCRYPT_COST; sscanf(hash, "$2y$%ld$", &cost); - add_assoc_long(&options, "cost", cost); + add_assoc_int(&options, "cost", cost); } break; case PHP_PASSWORD_UNKNOWN: @@ -207,7 +207,7 @@ PHP_FUNCTION(password_get_info) array_init(return_value); - add_assoc_long(return_value, "algo", algo); + add_assoc_int(return_value, "algo", algo); add_assoc_string(return_value, "algoName", algo_name); add_assoc_zval(return_value, "options", &options); } @@ -242,14 +242,14 @@ PHP_FUNCTION(password_needs_rehash) long new_cost = PHP_PASSWORD_BCRYPT_COST, cost = 0; if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) { - if (Z_TYPE_P(option_buffer) != IS_LONG) { + if (Z_TYPE_P(option_buffer) != IS_INT) { zval cast_option_buffer; ZVAL_DUP(&cast_option_buffer, option_buffer); - convert_to_long(&cast_option_buffer); - new_cost = Z_LVAL(cast_option_buffer); + convert_to_int(&cast_option_buffer); + new_cost = Z_IVAL(cast_option_buffer); zval_dtor(&cast_option_buffer); } else { - new_cost = Z_LVAL_P(option_buffer); + new_cost = Z_IVAL_P(option_buffer); } } @@ -324,14 +324,14 @@ PHP_FUNCTION(password_hash) long cost = PHP_PASSWORD_BCRYPT_COST; if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) { - if (Z_TYPE_P(option_buffer) != IS_LONG) { + if (Z_TYPE_P(option_buffer) != IS_INT) { zval cast_option_buffer; ZVAL_DUP(&cast_option_buffer, option_buffer); - convert_to_long(&cast_option_buffer); - cost = Z_LVAL(cast_option_buffer); + convert_to_int(&cast_option_buffer); + cost = Z_IVAL(cast_option_buffer); zval_dtor(&cast_option_buffer); } else { - cost = Z_LVAL_P(option_buffer); + cost = Z_IVAL_P(option_buffer); } } @@ -358,10 +358,10 @@ PHP_FUNCTION(password_hash) size_t buffer_len; switch (Z_TYPE_P(option_buffer)) { case IS_STRING: - buffer = estrndup(Z_STRVAL_P(option_buffer), Z_STRLEN_P(option_buffer)); - buffer_len_int = Z_STRLEN_P(option_buffer); + buffer = estrndup(Z_STRVAL_P(option_buffer), Z_STRSIZE_P(option_buffer)); + buffer_len_int = Z_STRSIZE_P(option_buffer); break; - case IS_LONG: + case IS_INT: case IS_DOUBLE: case IS_OBJECT: { zval cast_option_buffer; @@ -369,8 +369,8 @@ PHP_FUNCTION(password_hash) ZVAL_DUP(&cast_option_buffer, option_buffer); convert_to_string(&cast_option_buffer); if (Z_TYPE(cast_option_buffer) == IS_STRING) { - buffer = estrndup(Z_STRVAL(cast_option_buffer), Z_STRLEN(cast_option_buffer)); - buffer_len_int = Z_STRLEN(cast_option_buffer); + buffer = estrndup(Z_STRVAL(cast_option_buffer), Z_STRSIZE(cast_option_buffer)); + buffer_len_int = Z_STRSIZE(cast_option_buffer); zval_dtor(&cast_option_buffer); break; } diff --git a/ext/standard/php_math.h b/ext/standard/php_math.h index a2dca282c5..f8be7da42c 100644 --- a/ext/standard/php_math.h +++ b/ext/standard/php_math.h @@ -25,7 +25,7 @@ PHPAPI zend_string *_php_math_number_format(double, int, char, char); PHPAPI zend_string *_php_math_number_format_ex(double, int, char *, size_t, char *, size_t); PHPAPI zend_string * _php_math_longtobase(zval *arg, int base TSRMLS_DC); -PHPAPI long _php_math_basetolong(zval *arg, int base); +PHPAPI php_int_t _php_math_basetolong(zval *arg, int base); PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret); PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC); diff --git a/ext/standard/php_rand.h b/ext/standard/php_rand.h index 0e8abb3613..dd41c57d88 100644 --- a/ext/standard/php_rand.h +++ b/ext/standard/php_rand.h @@ -42,19 +42,19 @@ #endif #define RAND_RANGE(__n, __min, __max, __tmax) \ - (__n) = (__min) + (long) ((double) ( (double) (__max) - (__min) + 1.0) * ((__n) / ((__tmax) + 1.0))) + (__n) = (__min) + (php_int_t) ((double) ( (double) (__max) - (__min) + 1.0) * ((__n) / ((__tmax) + 1.0))) /* MT Rand */ -#define PHP_MT_RAND_MAX ((long) (0x7FFFFFFF)) /* (1<<31) - 1 */ +#define PHP_MT_RAND_MAX ((php_int_t) (0x7FFFFFFF)) /* (1<<31) - 1 */ #ifdef PHP_WIN32 -#define GENERATE_SEED() (((long) (time(0) * GetCurrentProcessId())) ^ ((long) (1000000.0 * php_combined_lcg(TSRMLS_C)))) +#define GENERATE_SEED() (((php_int_t) (time(0) * GetCurrentProcessId())) ^ ((php_int_t) (1000000.0 * php_combined_lcg(TSRMLS_C)))) #else -#define GENERATE_SEED() (((long) (time(0) * getpid())) ^ ((long) (1000000.0 * php_combined_lcg(TSRMLS_C)))) +#define GENERATE_SEED() (((php_int_t) (time(0) * getpid())) ^ ((php_int_t) (1000000.0 * php_combined_lcg(TSRMLS_C)))) #endif -PHPAPI void php_srand(long seed TSRMLS_DC); -PHPAPI long php_rand(TSRMLS_D); +PHPAPI void php_srand(php_int_t seed TSRMLS_DC); +PHPAPI php_int_t php_rand(TSRMLS_D); PHPAPI void php_mt_srand(php_uint32 seed TSRMLS_DC); PHPAPI php_uint32 php_mt_rand(TSRMLS_D); diff --git a/ext/standard/php_smart_str.h b/ext/standard/php_smart_str.h index 71bcf0b223..f4913f7b99 100644 --- a/ext/standard/php_smart_str.h +++ b/ext/standard/php_smart_str.h @@ -91,8 +91,8 @@ smart_str_appendl_ex((dest), (src), (len), 0) #define smart_str_append(dest, src) \ smart_str_append_ex((dest), (src), 0) -#define smart_str_append_long(dest, val) \ - smart_str_append_long_ex((dest), (val), 0) +#define smart_str_append_int(dest, val) \ + smart_str_append_int_ex((dest), (val), 0) #define smart_str_append_off_t(dest, val) \ smart_str_append_off_t_ex((dest), (val), 0) #define smart_str_append_unsigned(dest, val) \ @@ -130,15 +130,15 @@ * #define f(..) ({char *r;..;__r;}) */ -static inline char *smart_str_print_long(char *buf, long num) { +static inline char *smart_str_print_long(char *buf, zend_int_t num) { char *r; - _zend_print_signed_to_buf(buf, num, long, r); + _zend_print_signed_to_buf(buf, num, zend_int_t, r); return r; } -static inline char *smart_str_print_unsigned(char *buf, long num) { +static inline char *smart_str_print_unsigned(char *buf, zend_int_t num) { char *r; - _zend_print_unsigned_to_buf(buf, num, unsigned long, r); + _zend_print_unsigned_to_buf(buf, num, zend_uint_t, r); return r; } @@ -150,13 +150,13 @@ static inline char *smart_str_print_unsigned(char *buf, long num) { } while (0) #define smart_str_append_unsigned_ex(dest, num, type) \ - smart_str_append_generic_ex((dest), (num), (type), unsigned long, _unsigned) + smart_str_append_generic_ex((dest), (num), (type), zend_uint_t, _unsigned) -#define smart_str_append_long_ex(dest, num, type) \ - smart_str_append_generic_ex((dest), (num), (type), unsigned long, _signed) +#define smart_str_append_int_ex(dest, num, type) \ + smart_str_append_generic_ex((dest), (num), (type), zend_uint_t, _signed) #define smart_str_append_off_t_ex(dest, num, type) \ - smart_str_append_generic_ex((dest), (num), (type), off_t, _signed) + smart_str_append_generic_ex((dest), (num), (type), zend_off_t, _signed) #define smart_str_append_ex(dest, src, what) \ smart_str_appendl_ex((dest), ((smart_str *)(src))->s->val, \ diff --git a/ext/standard/php_string.h b/ext/standard/php_string.h index 0f4240ea57..3618bdfe54 100644 --- a/ext/standard/php_string.h +++ b/ext/standard/php_string.h @@ -120,11 +120,11 @@ PHPAPI struct lconv *localeconv_r(struct lconv *out); PHPAPI char *php_strtoupper(char *s, size_t len); PHPAPI char *php_strtolower(char *s, size_t len); -PHPAPI char *php_strtr(char *str, int len, char *str_from, char *str_to, int trlen); -PHPAPI zend_string *php_addslashes(char *str, int length, int should_free TSRMLS_DC); -PHPAPI zend_string *php_addcslashes(const char *str, int length, int freeit, char *what, int wlength TSRMLS_DC); -PHPAPI void php_stripslashes(char *str, int *len TSRMLS_DC); -PHPAPI void php_stripcslashes(char *str, int *len); +PHPAPI char *php_strtr(char *str, php_size_t len, char *str_from, char *str_to, php_size_t trlen); +PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free TSRMLS_DC); +PHPAPI zend_string *php_addcslashes(const char *str, php_size_t length, int freeit, char *what, php_size_t wlength TSRMLS_DC); +PHPAPI void php_stripslashes(char *str, php_size_t *len TSRMLS_DC); +PHPAPI void php_stripcslashes(char *str, php_size_t *len); PHPAPI zend_string *php_basename(const char *s, size_t len, char *suffix, size_t sufflen TSRMLS_DC); PHPAPI size_t php_dirname(char *str, size_t len); PHPAPI char *php_stristr(char *s, char *t, size_t s_len, size_t t_len); @@ -132,7 +132,7 @@ PHPAPI zend_string *php_str_to_str_ex(char *haystack, int length, char *needle, int needle_len, char *str, int str_len, int case_sensitivity, int *replace_count); PHPAPI zend_string *php_str_to_str(char *haystack, int length, char *needle, int needle_len, char *str, int str_len); -PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zval *return_value, int mode TSRMLS_DC); +PHPAPI char *php_trim(char *c, php_size_t len, char *what, php_size_t what_len, zval *return_value, int mode TSRMLS_DC); PHPAPI size_t php_strip_tags(char *rbuf, int len, int *state, char *allow, int allow_len); PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, int *stateptr, char *allow, int allow_len, zend_bool allow_tag_spaces); PHPAPI int php_char_to_str_ex(char *str, uint len, char from, char *to, int to_len, zval *result, int case_sensitivity, int *replace_count); diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c index dea8c16c07..cd74ecac51 100644 --- a/ext/standard/proc_open.c +++ b/ext/standard/proc_open.c @@ -300,7 +300,7 @@ PHP_FUNCTION(proc_close) FG(pclose_wait) = 1; zend_list_close(Z_RES_P(zproc)); FG(pclose_wait) = 0; - RETURN_LONG(FG(pclose_ret)); + RETURN_INT(FG(pclose_ret)); } /* }}} */ @@ -328,7 +328,7 @@ PHP_FUNCTION(proc_get_status) array_init(return_value); add_assoc_string(return_value, "command", proc->command); - add_assoc_long(return_value, "pid", (long) proc->child); + add_assoc_int(return_value, "pid", (long) proc->child); #ifdef PHP_WIN32 @@ -368,9 +368,9 @@ PHP_FUNCTION(proc_get_status) add_assoc_bool(return_value, "running", running); add_assoc_bool(return_value, "signaled", signaled); add_assoc_bool(return_value, "stopped", stopped); - add_assoc_long(return_value, "exitcode", exitcode); - add_assoc_long(return_value, "termsig", termsig); - add_assoc_long(return_value, "stopsig", stopsig); + add_assoc_int(return_value, "exitcode", exitcode); + add_assoc_int(return_value, "termsig", termsig); + add_assoc_int(return_value, "stopsig", stopsig); } /* }}} */ @@ -427,7 +427,7 @@ PHP_FUNCTION(proc_open) int i; zval *descitem = NULL; zend_string *str_index; - ulong nindex; + php_uint_t nindex; struct php_proc_open_descriptor_item descriptors[PHP_PROC_OPEN_MAX_DESCRIPTORS]; #ifdef PHP_WIN32 PROCESS_INFORMATION pi; @@ -471,14 +471,14 @@ PHP_FUNCTION(proc_open) if (other_options) { zval *item = zend_hash_str_find(Z_ARRVAL_P(other_options), "suppress_errors", sizeof("suppress_errors") - 1); if (item != NULL) { - if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) { + if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_INT) && Z_IVAL_P(item))) { suppress_errors = 1; } } item = zend_hash_str_find(Z_ARRVAL_P(other_options), "bypass_shell", sizeof("bypass_shell") - 1); if (item != NULL) { - if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) { + if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_INT) && Z_IVAL_P(item))) { bypass_shell = 1; } } @@ -584,7 +584,7 @@ PHP_FUNCTION(proc_open) #endif descriptors[ndesc].mode_flags = descriptors[ndesc].mode & DESC_PARENT_MODE_WRITE ? O_WRONLY : O_RDONLY; #ifdef PHP_WIN32 - if (Z_STRLEN_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b') + if (Z_STRSIZE_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b') descriptors[ndesc].mode_flags |= O_BINARY; #endif diff --git a/ext/standard/quot_print.c b/ext/standard/quot_print.c index aa3d256c3a..c2e659d43e 100644 --- a/ext/standard/quot_print.c +++ b/ext/standard/quot_print.c @@ -147,7 +147,7 @@ PHPAPI zend_string *php_quot_print_decode(const unsigned char *str, size_t lengt PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length) /* {{{ */ { - unsigned long lp = 0; + php_uint_t lp = 0; unsigned char c, *d; char *hex = "0123456789ABCDEF"; zend_string *ret; diff --git a/ext/standard/rand.c b/ext/standard/rand.c index 702fec2311..972f015948 100644 --- a/ext/standard/rand.c +++ b/ext/standard/rand.c @@ -38,7 +38,7 @@ /* {{{ php_srand */ -PHPAPI void php_srand(long seed TSRMLS_DC) +PHPAPI void php_srand(php_int_t seed TSRMLS_DC) { #ifdef ZTS BG(rand_seed) = (unsigned int) seed; @@ -59,9 +59,9 @@ PHPAPI void php_srand(long seed TSRMLS_DC) /* {{{ php_rand */ -PHPAPI long php_rand(TSRMLS_D) +PHPAPI php_int_t php_rand(TSRMLS_D) { - long ret; + php_int_t ret; if (!BG(rand_is_seeded)) { php_srand(GENERATE_SEED() TSRMLS_CC); @@ -229,9 +229,9 @@ PHPAPI php_uint32 php_mt_rand(TSRMLS_D) Seeds random number generator */ PHP_FUNCTION(srand) { - long seed = 0; + php_int_t seed = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &seed) == FAILURE) + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &seed) == FAILURE) return; if (ZEND_NUM_ARGS() == 0) @@ -245,9 +245,9 @@ PHP_FUNCTION(srand) Seeds Mersenne Twister random number generator */ PHP_FUNCTION(mt_srand) { - long seed = 0; + php_int_t seed = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &seed) == FAILURE) + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &seed) == FAILURE) return; if (ZEND_NUM_ARGS() == 0) @@ -288,12 +288,12 @@ PHP_FUNCTION(mt_srand) Returns a random number */ PHP_FUNCTION(rand) { - long min; - long max; - long number; + php_int_t min; + php_int_t max; + php_int_t number; int argc = ZEND_NUM_ARGS(); - if (argc != 0 && zend_parse_parameters(argc TSRMLS_CC, "ll", &min, &max) == FAILURE) + if (argc != 0 && zend_parse_parameters(argc TSRMLS_CC, "ii", &min, &max) == FAILURE) return; number = php_rand(TSRMLS_C); @@ -301,7 +301,7 @@ PHP_FUNCTION(rand) RAND_RANGE(number, min, max, PHP_RAND_MAX); } - RETURN_LONG(number); + RETURN_INT(number); } /* }}} */ @@ -309,16 +309,16 @@ PHP_FUNCTION(rand) Returns a random number from Mersenne Twister */ PHP_FUNCTION(mt_rand) { - long min; - long max; - long number; + php_int_t min; + php_int_t max; + php_int_t number; int argc = ZEND_NUM_ARGS(); if (argc != 0) { - if (zend_parse_parameters(argc TSRMLS_CC, "ll", &min, &max) == FAILURE) { + if (zend_parse_parameters(argc TSRMLS_CC, "ii", &min, &max) == FAILURE) { return; } else if (max < min) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "max(%ld) is smaller than min(%ld)", max, min); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "max(" ZEND_INT_FMT ") is smaller than min(" ZEND_INT_FMT ")", max, min); RETURN_FALSE; } } @@ -335,12 +335,12 @@ PHP_FUNCTION(mt_rand) * Update: * I talked with Cokus via email and it won't ruin the algorithm */ - number = (long) (php_mt_rand(TSRMLS_C) >> 1); + number = (php_int_t) (php_mt_rand(TSRMLS_C) >> 1); if (argc == 2) { RAND_RANGE(number, min, max, PHP_MT_RAND_MAX); } - RETURN_LONG(number); + RETURN_INT(number); } /* }}} */ @@ -352,7 +352,7 @@ PHP_FUNCTION(getrandmax) return; } - RETURN_LONG(PHP_RAND_MAX); + RETURN_INT(PHP_RAND_MAX); } /* }}} */ @@ -368,7 +368,7 @@ PHP_FUNCTION(mt_getrandmax) * Melo: it could be 2^^32 but we only use 2^^31 to maintain * compatibility with the previous php_rand */ - RETURN_LONG(PHP_MT_RAND_MAX); /* 2^^31 */ + RETURN_INT(PHP_MT_RAND_MAX); /* 2^^31 */ } /* }}} */ diff --git a/ext/standard/scanf.c b/ext/standard/scanf.c index f5f97161f2..815d7c7290 100644 --- a/ext/standard/scanf.c +++ b/ext/standard/scanf.c @@ -356,7 +356,7 @@ PHPAPI int ValidateFormat(char *format, int numVars, int *totalSubs) * must not be a mixture of XPG3 specs and non-XPG3 specs * in the same format string. */ - value = strtoul(format-1, &end, 10); + value = ZEND_STRTOUI(format-1, &end, 10); if (*end != '$') { goto notXpg; } @@ -403,7 +403,7 @@ xpgCheckDone: * Parse any width specifier. */ if (isdigit(UCHAR(*ch))) { - value = strtoul(format-1, &format, 10); + value = ZEND_STRTOUI(format-1, &format, 10); flags |= SCAN_WIDTH; ch = format++; } @@ -582,7 +582,7 @@ PHPAPI int php_sscanf_internal( char *string, char *format, { int numVars, nconversions, totalVars = -1; int i, result; - long value; + php_int_t value; int objIndex; char *end, *baseString; zval *current; @@ -590,7 +590,7 @@ PHPAPI int php_sscanf_internal( char *string, char *format, int base = 0; int underflow = 0; size_t width; - long (*fn)() = NULL; + php_int_t (*fn)() = NULL; char *ch, sch; int flags; char buf[64]; /* Temporary buffer to hold scanned number @@ -708,7 +708,7 @@ literal: flags |= SCAN_SUPPRESS; ch = format++; } else if ( isdigit(UCHAR(*ch))) { - value = strtoul(format-1, &end, 10); + value = ZEND_STRTOUI(format-1, &end, 10); if (*end == '$') { format = end+1; ch = format++; @@ -720,7 +720,7 @@ literal: * Parse any width specifier. */ if ( isdigit(UCHAR(*ch))) { - width = strtoul(format-1, &format, 10); + width = ZEND_STRTOUI(format-1, &format, 10); ch = format++; } else { width = 0; @@ -744,9 +744,9 @@ literal: } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); - ZVAL_LONG(current, (long)(string - baseString) ); + ZVAL_INT(current, (php_int_t)(string - baseString) ); } else { - add_index_long(return_value, objIndex++, string - baseString); + add_index_int(return_value, objIndex++, string - baseString); } } nconversions++; @@ -756,29 +756,29 @@ literal: case 'D': op = 'i'; base = 10; - fn = (long (*)())strtol; + fn = (php_int_t (*)())ZEND_STRTOI_PTR; break; case 'i': op = 'i'; base = 0; - fn = (long (*)())strtol; + fn = (php_int_t (*)())ZEND_STRTOI_PTR; break; case 'o': op = 'i'; base = 8; - fn = (long (*)())strtol; + fn = (php_int_t (*)())ZEND_STRTOI_PTR; break; case 'x': case 'X': op = 'i'; base = 16; - fn = (long (*)())strtol; + fn = (php_int_t (*)())ZEND_STRTOI_PTR; break; case 'u': op = 'i'; base = 10; flags |= SCAN_UNSIGNED; - fn = (long (*)())strtoul; + fn = (php_int_t (*)())ZEND_STRTOUI_PTR; break; case 'f': @@ -1049,9 +1049,9 @@ addToInt: */ if (!(flags & SCAN_SUPPRESS)) { *end = '\0'; - value = (long) (*fn)(buf, NULL, base); + value = (php_int_t) (*fn)(buf, NULL, base); if ((flags & SCAN_UNSIGNED) && (value < 0)) { - snprintf(buf, sizeof(buf), "%lu", value); /* INTL: ISO digit */ + snprintf(buf, sizeof(buf), ZEND_UINT_FMT, value); /* INTL: ISO digit */ if (numVars && objIndex >= argCount) { break; } else if (numVars) { @@ -1068,9 +1068,9 @@ addToInt: } else if (numVars) { current = Z_REFVAL(args[objIndex++]); zval_ptr_dtor(current); - ZVAL_LONG(current, value); + ZVAL_INT(current, value); } else { - add_index_long(return_value, objIndex++, value); + add_index_int(return_value, objIndex++, value); } } } @@ -1190,8 +1190,8 @@ done: scan_set_error_return( numVars, return_value ); result = SCAN_ERROR_EOF; } else if (numVars) { - convert_to_long(return_value ); - Z_LVAL_P(return_value) = nconversions; + convert_to_int(return_value ); + Z_IVAL_P(return_value) = nconversions; } else if (nconversions < totalVars) { /* TODO: not all elements converted. we need to prune the list - cc */ } @@ -1203,7 +1203,7 @@ done: static inline void scan_set_error_return(int numVars, zval *return_value) /* {{{ */ { if (numVars) { - ZVAL_LONG(return_value, SCAN_ERROR_EOF); /* EOF marker */ + ZVAL_INT(return_value, SCAN_ERROR_EOF); /* EOF marker */ } else { /* convert_to_null calls destructor */ convert_to_null(return_value); diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c index 652512ce07..95c4c49aec 100644 --- a/ext/standard/streamsfuncs.c +++ b/ext/standard/streamsfuncs.c @@ -123,7 +123,7 @@ PHP_FUNCTION(stream_socket_client) #endif if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -151,7 +151,7 @@ PHP_FUNCTION(stream_socket_client) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { zval_dtor(zerrstr); @@ -198,7 +198,7 @@ PHP_FUNCTION(stream_socket_server) if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, 0); + ZVAL_INT(zerrno, 0); } if (zerrstr) { zval_dtor(zerrstr); @@ -216,7 +216,7 @@ PHP_FUNCTION(stream_socket_server) if (stream == NULL) { if (zerrno) { zval_dtor(zerrno); - ZVAL_LONG(zerrno, err); + ZVAL_INT(zerrno, err); } if (zerrstr && errstr) { zval_dtor(zerrstr); @@ -340,7 +340,7 @@ PHP_FUNCTION(stream_socket_sendto) } } - RETURN_LONG(php_stream_xport_sendto(stream, data, datalen, flags, target_addr ? &sa : NULL, sl TSRMLS_CC)); + RETURN_INT(php_stream_xport_sendto(stream, data, datalen, flags, target_addr ? &sa : NULL, sl TSRMLS_CC)); } /* }}} */ @@ -467,7 +467,7 @@ PHP_FUNCTION(stream_copy_to_stream) if (ret != SUCCESS) { RETURN_FALSE; } - RETURN_LONG(len); + RETURN_INT(len); } /* }}} */ @@ -511,7 +511,7 @@ PHP_FUNCTION(stream_get_meta_data) } #endif - add_assoc_long(return_value, "unread_bytes", stream->writepos - stream->readpos); + add_assoc_int(return_value, "unread_bytes", stream->writepos - stream->readpos); add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0); if (stream->orig_path) { @@ -619,7 +619,7 @@ static int stream_array_from_fd_set(zval *stream_array, fd_set *fds TSRMLS_DC) php_stream *stream; int ret = 0; zend_string *key; - ulong num_ind; + php_uint_t num_ind; if (Z_TYPE_P(stream_array) != IS_ARRAY) { return 0; @@ -763,9 +763,9 @@ PHP_FUNCTION(stream_select) /* If seconds is not set to null, build the timeval, else we wait indefinitely */ if (sec != NULL) { - convert_to_long_ex(sec); + convert_to_int_ex(sec); - if (Z_LVAL_P(sec) < 0) { + if (Z_IVAL_P(sec) < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The seconds parameter must be greater than 0"); RETURN_FALSE; } else if (usec < 0) { @@ -775,10 +775,10 @@ PHP_FUNCTION(stream_select) /* Solaris + BSD do not like microsecond values which are >= 1 sec */ if (usec > 999999) { - tv.tv_sec = Z_LVAL_P(sec) + (usec / 1000000); + tv.tv_sec = Z_IVAL_P(sec) + (usec / 1000000); tv.tv_usec = usec % 1000000; } else { - tv.tv_sec = Z_LVAL_P(sec); + tv.tv_sec = Z_IVAL_P(sec); tv.tv_usec = usec; } @@ -798,7 +798,7 @@ PHP_FUNCTION(stream_select) if (e_array != NULL) { zend_hash_clean(Z_ARRVAL_P(e_array)); } - RETURN_LONG(retval); + RETURN_INT(retval); } } @@ -814,7 +814,7 @@ PHP_FUNCTION(stream_select) if (w_array != NULL) stream_array_from_fd_set(w_array, &wfds TSRMLS_CC); if (e_array != NULL) stream_array_from_fd_set(e_array, &efds TSRMLS_CC); - RETURN_LONG(retval); + RETURN_INT(retval); } /* }}} */ @@ -827,16 +827,16 @@ static void user_space_stream_notifier(php_stream_context *context, int notifyco zval zvs[6]; int i; - ZVAL_LONG(&zvs[0], notifycode); - ZVAL_LONG(&zvs[1], severity); + ZVAL_INT(&zvs[0], notifycode); + ZVAL_INT(&zvs[1], severity); if (xmsg) { ZVAL_STRING(&zvs[2], xmsg); } else { ZVAL_NULL(&zvs[2]); } - ZVAL_LONG(&zvs[3], xcode); - ZVAL_LONG(&zvs[4], bytes_sofar); - ZVAL_LONG(&zvs[5], bytes_max); + ZVAL_INT(&zvs[3], xcode); + ZVAL_INT(&zvs[4], bytes_sofar); + ZVAL_INT(&zvs[5], bytes_max); if (FAILURE == call_user_function_ex(EG(function_table), NULL, callback, &retval, 6, zvs, 0, NULL TSRMLS_CC)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call user notifier"); @@ -1356,7 +1356,7 @@ PHP_FUNCTION(stream_set_write_buffer) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_WRITE_BUFFER, PHP_STREAM_BUFFER_FULL, &buff); } - RETURN_LONG(ret == 0 ? 0 : EOF); + RETURN_INT(ret == 0 ? 0 : EOF); } /* }}} */ @@ -1390,7 +1390,7 @@ PHP_FUNCTION(stream_set_chunk_size) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_SET_CHUNK_SIZE, (int)csize, NULL); - RETURN_LONG(ret > 0 ? (long)ret : (long)EOF); + RETURN_INT(ret > 0 ? (long)ret : (long)EOF); } /* }}} */ @@ -1419,7 +1419,7 @@ PHP_FUNCTION(stream_set_read_buffer) ret = php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER, PHP_STREAM_BUFFER_FULL, &buff); } - RETURN_LONG(ret == 0 ? 0 : EOF); + RETURN_INT(ret == 0 ? 0 : EOF); } /* }}} */ @@ -1448,7 +1448,7 @@ PHP_FUNCTION(stream_socket_enable_crypto) RETURN_FALSE; } - cryptokind = Z_LVAL_P(val); + cryptokind = Z_IVAL_P(val); } if (zsessstream) { @@ -1466,7 +1466,7 @@ PHP_FUNCTION(stream_socket_enable_crypto) RETURN_FALSE; case 0: - RETURN_LONG(0); + RETURN_INT(0); default: RETURN_TRUE; diff --git a/ext/standard/string.c b/ext/standard/string.c index 82b98eb094..c8205c4ad2 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -81,13 +81,13 @@ */ void register_string_constants(INIT_FUNC_ARGS) { - REGISTER_LONG_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_LEFT", STR_PAD_LEFT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_RIGHT", STR_PAD_RIGHT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STR_PAD_BOTH", STR_PAD_BOTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_DIRNAME", PHP_PATHINFO_DIRNAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_BASENAME", PHP_PATHINFO_BASENAME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_EXTENSION", PHP_PATHINFO_EXTENSION, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PATHINFO_FILENAME", PHP_PATHINFO_FILENAME, CONST_CS | CONST_PERSISTENT); #ifdef HAVE_LOCALECONV /* If last members of struct lconv equal CHAR_MAX, no grouping is done */ @@ -97,18 +97,18 @@ void register_string_constants(INIT_FUNC_ARGS) # define CHAR_MAX 127 # endif - REGISTER_LONG_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("CHAR_MAX", CHAR_MAX, CONST_CS | CONST_PERSISTENT); #endif #ifdef HAVE_LOCALE_H - REGISTER_LONG_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_CTYPE", LC_CTYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_NUMERIC", LC_NUMERIC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_TIME", LC_TIME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_COLLATE", LC_COLLATE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_MONETARY", LC_MONETARY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_ALL", LC_ALL, CONST_CS | CONST_PERSISTENT); # ifdef LC_MESSAGES - REGISTER_LONG_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LC_MESSAGES", LC_MESSAGES, CONST_CS | CONST_PERSISTENT); # endif #endif @@ -237,14 +237,13 @@ PHP_MSHUTDOWN_FUNCTION(localeconv) PHP_FUNCTION(bin2hex) { zend_string *result; - char *data; - int datalen; + zend_string *data; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &datalen) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &data) == FAILURE) { return; } - result = php_bin2hex((unsigned char *)data, datalen); + result = php_bin2hex((unsigned char *)data->val, data->len); if (!result) { RETURN_FALSE; @@ -282,55 +281,54 @@ PHP_FUNCTION(hex2bin) static void php_spn_common_handler(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */ { - char *s11, *s22; - int len1, len2; - long start = 0, len = 0; + zend_string *s11, *s22; + php_int_t start = 0, len = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &s11, &len1, - &s22, &len2, &start, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|ii", &s11, + &s22, &start, &len) == FAILURE) { return; } if (ZEND_NUM_ARGS() < 4) { - len = len1; + len = s11->len; } /* look at substr() function for more information */ if (start < 0) { - start += len1; + start += (php_int_t)s11->len; if (start < 0) { start = 0; } - } else if (start > len1) { + } else if ((php_size_t)start > s11->len) { RETURN_FALSE; } if (len < 0) { - len += (len1 - start); + len += (s11->len - start); if (len < 0) { len = 0; } } - if (len > len1 - start) { - len = len1 - start; + if (len > (php_int_t)s11->len - start) { + len = s11->len - start; } if(len == 0) { - RETURN_LONG(0); + RETURN_INT(0); } if (behavior == STR_STRSPN) { - RETURN_LONG(php_strspn(s11 + start /*str1_start*/, - s22 /*str2_start*/, - s11 + start + len /*str1_end*/, - s22 + len2 /*str2_end*/)); + RETURN_INT(php_strspn(s11->val + start /*str1_start*/, + s22->val /*str2_start*/, + s11->val + start + len /*str1_end*/, + s22->val + s22->len /*str2_end*/)); } else if (behavior == STR_STRCSPN) { - RETURN_LONG(php_strcspn(s11 + start /*str1_start*/, - s22 /*str2_start*/, - s11 + start + len /*str1_end*/, - s22 + len2 /*str2_end*/)); + RETURN_INT(php_strcspn(s11->val + start /*str1_start*/, + s22->val /*str2_start*/, + s11->val + start + len /*str1_end*/, + s22->val + s22->len /*str2_end*/)); } } @@ -356,7 +354,7 @@ PHP_FUNCTION(strcspn) #if HAVE_NL_LANGINFO PHP_MINIT_FUNCTION(nl_langinfo) { -#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_LONG_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) +#define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_INT_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT) #ifdef ABDAY_1 REGISTER_NL_LANGINFO_CONSTANT(ABDAY_1); REGISTER_NL_LANGINFO_CONSTANT(ABDAY_2); @@ -526,10 +524,10 @@ PHP_MINIT_FUNCTION(nl_langinfo) Query language and locale information */ PHP_FUNCTION(nl_langinfo) { - long item; + php_int_t item; char *value; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &item) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &item) == FAILURE) { return; } @@ -694,7 +692,7 @@ PHP_FUNCTION(nl_langinfo) #endif break; default: - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Item '%ld' is not valid", item); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Item '" ZEND_INT_FMT "' is not valid", item); RETURN_FALSE; } /* }}} */ @@ -714,15 +712,14 @@ PHP_FUNCTION(nl_langinfo) Compares two strings using the current locale */ PHP_FUNCTION(strcoll) { - char *s1, *s2; - int s1len, s2len; + zend_string *s1, *s2; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1len, &s2, &s2len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &s1, &s2) == FAILURE) { return; } - RETURN_LONG(strcoll((const char *) s1, - (const char *) s2)); + RETURN_INT(strcoll((const char *) s1->val, + (const char *) s2->val)); } /* }}} */ #endif @@ -732,7 +729,7 @@ PHP_FUNCTION(strcoll) * it needs to be incrementing. * Returns: FAILURE/SUCCESS whether the input was correct (i.e. no range errors) */ -static inline int php_charmask(unsigned char *input, int len, char *mask TSRMLS_DC) +static inline int php_charmask(unsigned char *input, php_size_t len, char *mask TSRMLS_DC) { unsigned char *end; unsigned char c; @@ -781,9 +778,9 @@ static inline int php_charmask(unsigned char *input, int len, char *mask TSRMLS_ * mode 3 : trim left and right * what indicates which chars are to be trimmed. NULL->default (' \t\n\r\v\0') */ -PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zval *return_value, int mode TSRMLS_DC) +PHPAPI char *php_trim(char *c, php_size_t len, char *what, php_size_t what_len, zval *return_value, int mode TSRMLS_DC) { - register int i; + register php_int_t i; int trimmed = 0; char mask[256]; @@ -828,23 +825,22 @@ PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zval *return_v */ static void php_do_trim(INTERNAL_FUNCTION_PARAMETERS, int mode) { - char *str; - char *what = NULL; - int str_len, what_len = 0; + zend_string *str; + zend_string *what = NULL; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &str, &str_len, &what, &what_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|S", &str, &what) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 2) - Z_PARAM_STRING(str, str_len) + Z_PARAM_STR(str) Z_PARAM_OPTIONAL - Z_PARAM_STRING(what, what_len) + Z_PARAM_STR(what) ZEND_PARSE_PARAMETERS_END(); #endif - php_trim(str, str_len, what, what_len, return_value, mode TSRMLS_CC); + php_trim(str->val, str->len, (what ? what->val : NULL), (what ? what->len : 0), return_value, mode TSRMLS_CC); } /* }}} */ @@ -1017,18 +1013,18 @@ PHPAPI void php_explode(zval *delim, zval *str, zval *return_value, long limit) { char *p1, *p2, *endp; - endp = Z_STRVAL_P(str) + Z_STRLEN_P(str); + endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp); + p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); if (p2 == NULL) { - add_next_index_stringl(return_value, p1, Z_STRLEN_P(str)); + add_next_index_stringl(return_value, p1, Z_STRSIZE_P(str)); } else { do { add_next_index_stringl(return_value, p1, p2 - p1); - p1 = p2 + Z_STRLEN_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL && + p1 = p2 + Z_STRSIZE_P(delim); + } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL && --limit > 1); if (p1 <= endp) @@ -1044,10 +1040,10 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu #define EXPLODE_ALLOC_STEP 64 char *p1, *p2, *endp; - endp = Z_STRVAL_P(str) + Z_STRLEN_P(str); + endp = Z_STRVAL_P(str) + Z_STRSIZE_P(str); p1 = Z_STRVAL_P(str); - p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp); + p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp); if (p2 == NULL) { /* @@ -1065,14 +1061,14 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu allocated = found + EXPLODE_ALLOC_STEP;/* make sure we have enough memory */ positions = erealloc(positions, allocated*sizeof(char *)); } - positions[found++] = p1 = p2 + Z_STRLEN_P(delim); - } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL); + positions[found++] = p1 = p2 + Z_STRSIZE_P(delim); + } while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRSIZE_P(delim), endp)) != NULL); to_return = limit + found; /* limit is at least -1 therefore no need of bounds checking : i will be always less than found */ for (i = 0;i < to_return;i++) { /* this checks also for to_return > 0 */ add_next_index_stringl(return_value, positions[i], - (positions[i+1] - Z_STRLEN_P(delim)) - positions[i]); + (positions[i+1] - Z_STRSIZE_P(delim)) - positions[i]); } efree(positions); } @@ -1085,11 +1081,11 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu PHP_FUNCTION(explode) { zend_string *str, *delim; - long limit = LONG_MAX; /* No limit */ + php_int_t limit = PHP_INT_MAX; /* No limit */ zval zdelim, zstr; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &delim, &str, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|i", &delim, &str, &limit) == FAILURE) { return; } #else @@ -1097,7 +1093,7 @@ PHP_FUNCTION(explode) Z_PARAM_STR(delim) Z_PARAM_STR(str) Z_PARAM_OPTIONAL - Z_PARAM_LONG(limit) + Z_PARAM_INT(limit) ZEND_PARSE_PARAMETERS_END(); #endif @@ -1150,11 +1146,11 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC) again: switch (Z_TYPE_P(tmp)) { case IS_STRING: - smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)); + smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRSIZE_P(tmp)); break; - case IS_LONG: - smart_str_append_long(&implstr, Z_LVAL_P(tmp)); + case IS_INT: + smart_str_append_int(&implstr, Z_IVAL_P(tmp)); break; case IS_TRUE: @@ -1186,7 +1182,7 @@ again: } if (++i != numelems) { - smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRLEN_P(delim)); + smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRSIZE_P(delim)); } } ZEND_HASH_FOREACH_END(); @@ -1384,21 +1380,20 @@ PHPAPI char *php_strtolower(char *s, size_t len) Makes a string lowercase */ PHP_FUNCTION(strtolower) { - char *str; - int arglen; + zend_string *str; zend_string *result; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &arglen) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_STRING(str, arglen) + Z_PARAM_STR(str) ZEND_PARSE_PARAMETERS_END(); #endif - result = STR_INIT(str, arglen, 0); + result = STR_INIT(str->val, str->len, 0); php_strtolower(result->val, result->len); RETURN_NEW_STR(result); } @@ -1661,8 +1656,8 @@ PHPAPI size_t php_strcspn(char *s1, char *s2, char *s1_end, char *s2_end) static int php_needle_char(zval *needle, char *target TSRMLS_DC) { switch (Z_TYPE_P(needle)) { - case IS_LONG: - *target = (char)Z_LVAL_P(needle); + case IS_INT: + *target = (char)Z_IVAL_P(needle); return SUCCESS; case IS_NULL: case IS_FALSE: @@ -1678,11 +1673,11 @@ static int php_needle_char(zval *needle, char *target TSRMLS_DC) { zval holder = *needle; zval_copy_ctor(&(holder)); - convert_to_long(&(holder)); - if(Z_TYPE(holder) != IS_LONG) { + convert_to_int(&(holder)); + if(Z_TYPE(holder) != IS_INT) { return FAILURE; } - *target = (char)Z_LVAL(holder); + *target = (char)Z_IVAL(holder); return SUCCESS; } default: { @@ -1714,13 +1709,13 @@ PHP_FUNCTION(stristr) if (Z_TYPE_P(needle) == IS_STRING) { char *orig_needle; - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); efree(haystack_dup); RETURN_FALSE; } - orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); - found = php_stristr(haystack_dup, orig_needle, haystack_len, Z_STRLEN_P(needle)); + orig_needle = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); + found = php_stristr(haystack_dup, orig_needle, haystack_len, Z_STRSIZE_P(needle)); efree(orig_needle); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { @@ -1764,12 +1759,12 @@ PHP_FUNCTION(strstr) } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } - found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len); + found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRSIZE_P(needle), haystack + haystack_len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1800,54 +1795,53 @@ PHP_FUNCTION(strstr) PHP_FUNCTION(strpos) { zval *needle; - char *haystack; + zend_string *haystack; char *found = NULL; char needle_char[2]; - long offset = 0; - int haystack_len; + php_int_t offset = 0; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &haystack, &haystack_len, &needle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &needle, &offset) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(2, 3) - Z_PARAM_STRING(haystack, haystack_len) + Z_PARAM_STR(haystack) Z_PARAM_ZVAL(needle) Z_PARAM_OPTIONAL - Z_PARAM_LONG(offset) + Z_PARAM_INT(offset) ZEND_PARSE_PARAMETERS_END(); #endif - if (offset < 0 || offset > haystack_len) { + if (offset < 0 || offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset not contained in string"); RETURN_FALSE; } if (Z_TYPE_P(needle) == IS_STRING) { - if (!Z_STRLEN_P(needle)) { + if (!Z_STRSIZE_P(needle)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty needle"); RETURN_FALSE; } - found = (char*)php_memnstr(haystack + offset, + found = (char*)php_memnstr(haystack->val + offset, Z_STRVAL_P(needle), - Z_STRLEN_P(needle), - haystack + haystack_len); + Z_STRSIZE_P(needle), + haystack->val + haystack->len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { RETURN_FALSE; } needle_char[1] = 0; - found = (char*)php_memnstr(haystack + offset, + found = (char*)php_memnstr(haystack->val + offset, needle_char, 1, - haystack + haystack_len); + haystack->val + haystack->len); } if (found) { - RETURN_LONG(found - haystack); + RETURN_INT(found - haystack->val); } else { RETURN_FALSE; } @@ -1883,14 +1877,14 @@ PHP_FUNCTION(stripos) php_strtolower(haystack_dup, haystack_len); if (Z_TYPE_P(needle) == IS_STRING) { - if (Z_STRLEN_P(needle) == 0 || Z_STRLEN_P(needle) > haystack_len) { + if (Z_STRSIZE_P(needle) == 0 || Z_STRSIZE_P(needle) > haystack_len) { efree(haystack_dup); RETURN_FALSE; } - needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle)); - php_strtolower(needle_dup, Z_STRLEN_P(needle)); - found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len); + needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRSIZE_P(needle)); + php_strtolower(needle_dup, Z_STRSIZE_P(needle)); + found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRSIZE_P(needle), haystack_dup + haystack_len); } else { if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) { efree(haystack_dup); @@ -1910,7 +1904,7 @@ PHP_FUNCTION(stripos) } if (found) { - RETURN_LONG(found - haystack_dup); + RETURN_INT(found - haystack_dup); } else { RETURN_FALSE; } @@ -1922,27 +1916,28 @@ PHP_FUNCTION(stripos) PHP_FUNCTION(strrpos) { zval *zneedle; - char *needle, *haystack; - int needle_len, haystack_len; - long offset = 0; + char *needle; + zend_string *haystack; + php_size_t needle_len; + php_int_t offset = 0; char *p, *e, ord_needle[2]; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &haystack, &haystack_len, &zneedle, &offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|i", &haystack, &zneedle, &offset) == FAILURE) { RETURN_FALSE; } #else ZEND_PARSE_PARAMETERS_START(2, 3) - Z_PARAM_STRING(haystack, haystack_len) + Z_PARAM_STR(haystack) Z_PARAM_ZVAL(zneedle) Z_PARAM_OPTIONAL - Z_PARAM_LONG(offset) + Z_PARAM_INT(offset) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); #endif if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRLEN_P(zneedle); + needle_len = Z_STRSIZE_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -1952,28 +1947,28 @@ PHP_FUNCTION(strrpos) needle_len = 1; } - if ((haystack_len == 0) || (needle_len == 0)) { + if ((haystack->len == 0) || (needle_len == 0)) { RETURN_FALSE; } if (offset >= 0) { - if (offset > haystack_len) { + if (offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } - p = haystack + offset; - e = haystack + haystack_len - needle_len; + p = haystack->val + offset; + e = haystack->val + haystack->len - needle_len; } else { - if (offset < -INT_MAX || -offset > haystack_len) { + if (offset < -INT_MAX || -offset > haystack->len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } - p = haystack; + p = haystack->val; if (needle_len > -offset) { - e = haystack + haystack_len - needle_len; + e = haystack->val + haystack->len - needle_len; } else { - e = haystack + haystack_len + offset; + e = haystack->val + haystack->len + offset; } } @@ -1981,7 +1976,7 @@ PHP_FUNCTION(strrpos) /* Single character search can shortcut memcmps */ while (e >= p) { if (*e == *needle) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -1990,7 +1985,7 @@ PHP_FUNCTION(strrpos) while (e >= p) { if (memcmp(e, needle, needle_len) == 0) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2016,7 +2011,7 @@ PHP_FUNCTION(strripos) if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); - needle_len = Z_STRLEN_P(zneedle); + needle_len = Z_STRSIZE_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle TSRMLS_CC) != SUCCESS) { RETURN_FALSE; @@ -2052,7 +2047,7 @@ PHP_FUNCTION(strripos) *ord_needle = tolower(*needle); while (e >= p) { if (tolower(*e) == *ord_needle) { - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2092,7 +2087,7 @@ PHP_FUNCTION(strripos) if (memcmp(e, needle_dup, needle_len) == 0) { efree(haystack_dup); efree(needle_dup); - RETURN_LONG(e - p + (offset > 0 ? offset : 0)); + RETURN_INT(e - p + (offset > 0 ? offset : 0)); } e--; } @@ -2234,41 +2229,40 @@ PHP_FUNCTION(chunk_split) Returns part of a string */ PHP_FUNCTION(substr) { - char *str; - long l = 0, f; - int str_len; + zend_string *str; + php_int_t l = 0, f; int argc = ZEND_NUM_ARGS(); #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", &str, &str_len, &f, &l) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Si|i", &str, &f, &l) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(2, 3) - Z_PARAM_STRING(str, str_len) - Z_PARAM_LONG(f) + Z_PARAM_STR(str) + Z_PARAM_INT(f) Z_PARAM_OPTIONAL - Z_PARAM_LONG(l) + Z_PARAM_INT(l) ZEND_PARSE_PARAMETERS_END(); #endif if (argc > 2) { - if ((l < 0 && -l > str_len)) { + if ((l < 0 && -l > str->len)) { RETURN_FALSE; - } else if (l > str_len) { - l = str_len; + } else if (l > (php_int_t)str->len) { + l = str->len; } } else { - l = str_len; + l = str->len; } - if (f > str_len) { + if (f > (php_int_t)str->len) { RETURN_FALSE; - } else if (f < 0 && -f > str_len) { + } else if (f < 0 && -f > str->len) { f = 0; } - if (l < 0 && (l + str_len - f) < 0) { + if (l < 0 && (l + (php_int_t)str->len - f) < 0) { RETURN_FALSE; } @@ -2276,7 +2270,7 @@ PHP_FUNCTION(substr) * of the string */ if (f < 0) { - f = str_len + f; + f = (php_int_t)str->len + f; if (f < 0) { f = 0; } @@ -2286,21 +2280,21 @@ PHP_FUNCTION(substr) * needed to stop that many chars from the end of the string */ if (l < 0) { - l = (str_len - f) + l; + l = ((php_int_t)str->len - f) + l; if (l < 0) { l = 0; } } - if (f >= str_len) { + if (f >= (php_int_t)str->len) { RETURN_FALSE; } - if ((f + l) > str_len) { - l = str_len - f; + if ((f + l) > (php_int_t)str->len) { + l = str->len - f; } - RETURN_STRINGL(str + f, l); + RETURN_STRINGL(str->val + f, l); } /* }}} */ @@ -2331,16 +2325,16 @@ PHP_FUNCTION(substr_replace) convert_to_string_ex(repl); } if (Z_TYPE_P(from) != IS_ARRAY) { - convert_to_long_ex(from); + convert_to_int_ex(from); } if (argc > 3) { if (Z_TYPE_P(len) != IS_ARRAY) { - l = zval_get_long(len); + l = zval_get_int(len); } } else { if (Z_TYPE_P(str) != IS_ARRAY) { - l = Z_STRLEN_P(str); + l = Z_STRSIZE_P(str); } } @@ -2364,55 +2358,55 @@ PHP_FUNCTION(substr_replace) if (Z_TYPE_P(from) != IS_ARRAY) { int repl_len = 0; - f = Z_LVAL_P(from); + f = Z_IVAL_P(from); /* if "from" position is negative, count start position from the end * of the string */ if (f < 0) { - f = Z_STRLEN_P(str) + f; + f = Z_STRSIZE_P(str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(str)) { - f = Z_STRLEN_P(str); + } else if (f > Z_STRSIZE_P(str)) { + f = Z_STRSIZE_P(str); } /* if "length" position is negative, set it to the length * needed to stop that many chars from the end of the string */ if (l < 0) { - l = (Z_STRLEN_P(str) - f) + l; + l = (Z_STRSIZE_P(str) - f) + l; if (l < 0) { l = 0; } } - if (f > Z_STRLEN_P(str) || (f < 0 && -f > Z_STRLEN_P(str))) { + if (f > Z_STRSIZE_P(str) || (f < 0 && -f > Z_STRSIZE_P(str))) { RETURN_FALSE; - } else if (l > Z_STRLEN_P(str) || (l < 0 && -l > Z_STRLEN_P(str))) { - l = Z_STRLEN_P(str); + } else if (l > Z_STRSIZE_P(str) || (l < 0 && -l > Z_STRSIZE_P(str))) { + l = Z_STRSIZE_P(str); } - if ((f + l) > Z_STRLEN_P(str)) { - l = Z_STRLEN_P(str) - f; + if ((f + l) > Z_STRSIZE_P(str)) { + l = Z_STRSIZE_P(str) - f; } if (Z_TYPE_P(repl) == IS_ARRAY) { zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl); if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { convert_to_string_ex(tmp_repl); - repl_len = Z_STRLEN_P(tmp_repl); + repl_len = Z_STRSIZE_P(tmp_repl); } } else { - repl_len = Z_STRLEN_P(repl); + repl_len = Z_STRSIZE_P(repl); } - result = STR_ALLOC(Z_STRLEN_P(str) - l + repl_len, 0); + result = STR_ALLOC(Z_STRSIZE_P(str) - l + repl_len, 0); memcpy(result->val, Z_STRVAL_P(str), f); if (repl_len) { memcpy((result->val + f), (Z_TYPE_P(repl) == IS_ARRAY ? Z_STRVAL_P(tmp_repl) : Z_STRVAL_P(repl)), repl_len); } - memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l); + memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRSIZE_P(str) - f - l); result->val[result->len] = '\0'; RETURN_NEW_STR(result); } else { @@ -2421,7 +2415,7 @@ PHP_FUNCTION(substr_replace) } } else { /* str is array of strings */ zend_string *str_index = NULL; - ulong num_index; + php_uint_t num_index; int result_len; array_init(return_value); @@ -2461,57 +2455,57 @@ PHP_FUNCTION(substr_replace) if (Z_TYPE_P(from) == IS_ARRAY) { if (NULL != (tmp_from = zend_hash_get_current_data_ex(Z_ARRVAL_P(from), &pos_from))) { - f = zval_get_long(tmp_from); + f = zval_get_int(tmp_from); if (f < 0) { - f = Z_STRLEN_P(orig_str) + f; + f = Z_STRSIZE_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(orig_str)) { - f = Z_STRLEN_P(orig_str); + } else if (f > Z_STRSIZE_P(orig_str)) { + f = Z_STRSIZE_P(orig_str); } zend_hash_move_forward_ex(Z_ARRVAL_P(from), &pos_from); } else { f = 0; } } else { - f = Z_LVAL_P(from); + f = Z_IVAL_P(from); if (f < 0) { - f = Z_STRLEN_P(orig_str) + f; + f = Z_STRSIZE_P(orig_str) + f; if (f < 0) { f = 0; } - } else if (f > Z_STRLEN_P(orig_str)) { - f = Z_STRLEN_P(orig_str); + } else if (f > Z_STRSIZE_P(orig_str)) { + f = Z_STRSIZE_P(orig_str); } } if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) { if (NULL != (tmp_len = zend_hash_get_current_data_ex(Z_ARRVAL_P(len), &pos_len))) { - l = zval_get_long(tmp_len); + l = zval_get_int(tmp_len); zend_hash_move_forward_ex(Z_ARRVAL_P(len), &pos_len); } else { - l = Z_STRLEN_P(orig_str); + l = Z_STRSIZE_P(orig_str); } } else if (argc > 3) { - l = Z_LVAL_P(len); + l = Z_IVAL_P(len); } else { - l = Z_STRLEN_P(orig_str); + l = Z_STRSIZE_P(orig_str); } if (l < 0) { - l = (Z_STRLEN_P(orig_str) - f) + l; + l = (Z_STRSIZE_P(orig_str) - f) + l; if (l < 0) { l = 0; } } - if ((f + l) > Z_STRLEN_P(orig_str)) { - l = Z_STRLEN_P(orig_str) - f; + if ((f + l) > Z_STRSIZE_P(orig_str)) { + l = Z_STRSIZE_P(orig_str) - f; } - result_len = Z_STRLEN_P(orig_str) - l; + result_len = Z_STRSIZE_P(orig_str) - l; if (Z_TYPE_P(repl) == IS_ARRAY) { if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) { @@ -2536,13 +2530,13 @@ PHP_FUNCTION(substr_replace) } */ - result_len += Z_STRLEN_P(repl_str); + result_len += Z_STRSIZE_P(repl_str); zend_hash_move_forward_ex(Z_ARRVAL_P(repl), &pos_repl); result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str)); - memcpy((result->val + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRSIZE_P(repl_str)); + memcpy((result->val + f + Z_STRSIZE_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); if(Z_TYPE_P(tmp_repl) != IS_STRING) { zval_dtor(repl_str); } @@ -2550,16 +2544,16 @@ PHP_FUNCTION(substr_replace) result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); } } else { - result_len += Z_STRLEN_P(repl); + result_len += Z_STRSIZE_P(repl); result = STR_ALLOC(result_len, 0); memcpy(result->val, Z_STRVAL_P(orig_str), f); - memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRLEN_P(repl)); - memcpy((result->val + f + Z_STRLEN_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l); + memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRSIZE_P(repl)); + memcpy((result->val + f + Z_STRSIZE_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRSIZE_P(orig_str) - f - l); } result->val[result->len] = '\0'; @@ -2650,7 +2644,7 @@ PHP_FUNCTION(ord) ZEND_PARSE_PARAMETERS_END(); #endif - RETURN_LONG((unsigned char) str[0]); + RETURN_INT((unsigned char) str[0]); } /* }}} */ @@ -2773,7 +2767,7 @@ PHP_FUNCTION(ucwords) r = Z_STRVAL_P(return_value); *r = toupper((unsigned char) *r); - for (r_end = r + Z_STRLEN_P(return_value) - 1; r < r_end; ) { + for (r_end = r + Z_STRSIZE_P(return_value) - 1; r < r_end; ) { if (mask[(unsigned char)*r++]) { *r = toupper((unsigned char) *r); } @@ -2783,9 +2777,9 @@ PHP_FUNCTION(ucwords) /* {{{ php_strtr */ -PHPAPI char *php_strtr(char *str, int len, char *str_from, char *str_to, int trlen) +PHPAPI char *php_strtr(char *str, php_size_t len, char *str_from, char *str_to, php_size_t trlen) { - int i; + php_size_t i; unsigned char xlat[256]; if ((trlen < 1) || (len < 1)) { @@ -2818,7 +2812,7 @@ static int php_strtr_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ /* {{{ php_strtr_array */ static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *pats TSRMLS_DC) { - ulong num_key; + php_uint_t num_key; zend_string *str_key; int len, pos, found; int num_keys = 0; @@ -2861,7 +2855,7 @@ static void php_strtr_array(zval *return_value, char *str, int slen, HashTable * zend_hash_init(&str_hash, zend_hash_num_elements(pats), NULL, NULL, 0); ZEND_HASH_FOREACH_KEY_VAL(pats, num_key, str_key, entry) { if (UNEXPECTED(!str_key)) { - ZVAL_LONG(&tmp, num_key); + ZVAL_INT(&tmp, num_key); convert_to_string(&tmp); str_key = Z_STR(tmp); len = str_key->len; @@ -3005,10 +2999,10 @@ PHP_FUNCTION(strtr) ZVAL_STRINGL(return_value, str, str_len); php_strtr(Z_STRVAL_P(return_value), - Z_STRLEN_P(return_value), + Z_STRSIZE_P(return_value), Z_STRVAL_P(from), to, - MIN(Z_STRLEN_P(from), + MIN(Z_STRSIZE_P(from), to_len)); } } @@ -3111,7 +3105,7 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = 0; } - RETURN_LONG(0); + RETURN_INT(0); } sim = php_similar_char(t1, t1_len, t2, t2_len); @@ -3120,17 +3114,17 @@ PHP_FUNCTION(similar_text) Z_DVAL_P(percent) = sim * 200.0 / (t1_len + t2_len); } - RETURN_LONG(sim); + RETURN_INT(sim); } /* }}} */ /* {{{ php_stripslashes * * be careful, this edits the string in-place */ -PHPAPI void php_stripslashes(char *str, int *len TSRMLS_DC) +PHPAPI void php_stripslashes(char *str, php_size_t *len TSRMLS_DC) { char *s, *t; - int l; + php_size_t l; if (len != NULL) { l = *len; @@ -3171,22 +3165,21 @@ PHPAPI void php_stripslashes(char *str, int *len TSRMLS_DC) Escapes all chars mentioned in charlist with backslash. It creates octal representations if asked to backslash characters with 8th bit set or with ASCII<32 (except '\n', '\r', '\t' etc...) */ PHP_FUNCTION(addcslashes) { - char *str, *what; - int str_len, what_len; + zend_string *str, *what; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &str, &str_len, &what, &what_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &str, &what) == FAILURE) { return; } - if (str_len == 0) { + if (str->len == 0) { RETURN_EMPTY_STRING(); } - if (what_len == 0) { - RETURN_STRINGL(str, str_len); + if (what->len == 0) { + RETURN_STRINGL(str->val, str->len); } - RETURN_STR(php_addcslashes(str, str_len, 0, what, what_len TSRMLS_CC)); + RETURN_STR(php_addcslashes(str->val, str->len, 0, what->val, what->len TSRMLS_CC)); } /* }}} */ @@ -3194,24 +3187,23 @@ PHP_FUNCTION(addcslashes) Escapes single quote, double quotes and backslash characters in a string with backslashes */ PHP_FUNCTION(addslashes) { - char *str; - int str_len; + zend_string *str; #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_STRING(str, str_len) + Z_PARAM_STR(str) ZEND_PARSE_PARAMETERS_END(); #endif - if (str_len == 0) { + if (str->len == 0) { RETURN_EMPTY_STRING(); } - RETURN_STR(php_addslashes(str, str_len, 0 TSRMLS_CC)); + RETURN_STR(php_addslashes(str->val, str->len, 0 TSRMLS_CC)); } /* }}} */ @@ -3219,15 +3211,14 @@ PHP_FUNCTION(addslashes) Strips backslashes from a string. Uses C-style conventions */ PHP_FUNCTION(stripcslashes) { - char *str; - int str_len; + zend_string *str; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str) == FAILURE) { return; } - ZVAL_STRINGL(return_value, str, str_len); - php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value)); + ZVAL_STRINGL(return_value, str->val, str->len); + php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value)); } /* }}} */ @@ -3235,15 +3226,14 @@ PHP_FUNCTION(stripcslashes) Strips backslashes from a string */ PHP_FUNCTION(stripslashes) { - char *str; - int str_len; + zend_string *str; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str) == FAILURE) { return; } - ZVAL_STRINGL(return_value, str, str_len); - php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC); + ZVAL_STRINGL(return_value, str->val, str->len); + php_stripslashes(Z_STRVAL_P(return_value), &Z_STRSIZE_P(return_value) TSRMLS_CC); } /* }}} */ @@ -3268,10 +3258,10 @@ char *php_strerror(int errnum) /* {{{ php_stripcslashes */ -PHPAPI void php_stripcslashes(char *str, int *len) +PHPAPI void php_stripcslashes(char *str, php_size_t *len) { char *source, *target, *end; - int nlen = *len, i; + php_size_t nlen = *len, i; char numtmp[4]; for (source=str, end=str+nlen, target=str; source < end; source++) { @@ -3331,13 +3321,13 @@ PHPAPI void php_stripcslashes(char *str, int *len) /* {{{ php_addcslashes */ -PHPAPI zend_string *php_addcslashes(const char *str, int length, int should_free, char *what, int wlength TSRMLS_DC) +PHPAPI zend_string *php_addcslashes(const char *str, php_size_t length, int should_free, char *what, php_size_t wlength TSRMLS_DC) { char flags[256]; char *source, *target; char *end; char c; - int newlen; + php_size_t newlen; zend_string *new_str = STR_ALLOC(4 * (length? length : (length = strlen(str))), 0); if (!wlength) { @@ -3381,7 +3371,7 @@ PHPAPI zend_string *php_addcslashes(const char *str, int length, int should_free /* {{{ php_addslashes */ -PHPAPI zend_string *php_addslashes(char *str, int length, int should_free TSRMLS_DC) +PHPAPI zend_string *php_addslashes(char *str, php_size_t length, int should_free TSRMLS_DC) { /* maximum string length, worst case situation */ char *source, *target; @@ -3708,7 +3698,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec convert_to_string_ex(&tmp_subject); subject = &tmp_subject; } - if (Z_STRLEN_P(subject) == 0) { + if (Z_STRSIZE_P(subject) == 0) { zval_ptr_dtor(&tmp_subject); ZVAL_EMPTY_STRING(result); return; @@ -3725,7 +3715,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } else { /* Set replacement value to the passed one */ replace_value = Z_STRVAL_P(replace); - replace_len = Z_STRLEN_P(replace); + replace_len = Z_STRSIZE_P(replace); } /* For each entry in the search array, get the entry */ @@ -3733,7 +3723,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Make sure we're dealing with strings. */ SEPARATE_ZVAL(search_entry); convert_to_string(search_entry); - if (Z_STRLEN_P(search_entry) == 0) { + if (Z_STRSIZE_P(search_entry) == 0) { if (Z_TYPE_P(replace) == IS_ARRAY) { zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } @@ -3749,7 +3739,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec /* Set replacement value to the one we got from array */ replace_value = Z_STRVAL_P(replace_entry); - replace_len = Z_STRLEN_P(replace_entry); + replace_len = Z_STRSIZE_P(replace_entry); zend_hash_move_forward_ex(Z_ARRVAL_P(replace), &pos); } else { @@ -3759,18 +3749,18 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec } } - if (Z_STRLEN_P(search_entry) == 1) { + if (Z_STRSIZE_P(search_entry) == 1) { php_char_to_str_ex(Z_STRVAL_P(result), - Z_STRLEN_P(result), + Z_STRSIZE_P(result), Z_STRVAL_P(search_entry)[0], replace_value, replace_len, &temp_result, case_sensitivity, replace_count); - } else if (Z_STRLEN_P(search_entry) > 1) { - ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result), - Z_STRVAL_P(search_entry), Z_STRLEN_P(search_entry), + } else if (Z_STRSIZE_P(search_entry) > 1) { + ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRSIZE_P(result), + Z_STRVAL_P(search_entry), Z_STRSIZE_P(search_entry), replace_value, replace_len, case_sensitivity, replace_count)); } @@ -3778,25 +3768,25 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval *subjec Z_STR_P(result) = Z_STR(temp_result); Z_TYPE_INFO_P(result) = Z_TYPE_INFO(temp_result); - if (Z_STRLEN_P(result) == 0) { + if (Z_STRSIZE_P(result) == 0) { zval_ptr_dtor(&tmp_subject); return; } } ZEND_HASH_FOREACH_END(); } else { - if (Z_STRLEN_P(search) == 1) { + if (Z_STRSIZE_P(search) == 1) { php_char_to_str_ex(Z_STRVAL_P(subject), - Z_STRLEN_P(subject), + Z_STRSIZE_P(subject), Z_STRVAL_P(search)[0], Z_STRVAL_P(replace), - Z_STRLEN_P(replace), + Z_STRSIZE_P(replace), result, case_sensitivity, replace_count); - } else if (Z_STRLEN_P(search) > 1) { - ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRLEN_P(subject), - Z_STRVAL_P(search), Z_STRLEN_P(search), - Z_STRVAL_P(replace), Z_STRLEN_P(replace), case_sensitivity, replace_count)); + } else if (Z_STRSIZE_P(search) > 1) { + ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRSIZE_P(subject), + Z_STRVAL_P(search), Z_STRSIZE_P(search), + Z_STRVAL_P(replace), Z_STRSIZE_P(replace), case_sensitivity, replace_count)); } else { ZVAL_DUP(result, subject); } @@ -3812,7 +3802,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit zval *subject, *search, *replace, *subject_entry, *zcount = NULL; zval result; zend_string *string_key; - ulong num_key; + php_uint_t num_key; int count = 0; int argc = ZEND_NUM_ARGS(); @@ -3867,7 +3857,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit } if (argc > 3) { zval_dtor(zcount); - ZVAL_LONG(zcount, count); + ZVAL_INT(zcount, count); } } /* }}} */ @@ -4176,11 +4166,11 @@ PHP_FUNCTION(strip_tags) convert_to_string_ex(allow); // TODO: reimplement to avoid reallocation ??? if (IS_INTERNED(Z_STR_P(allow))) { - allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRLEN_P(allow)); - allowed_tags_len = Z_STRLEN_P(allow); + allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRSIZE_P(allow)); + allowed_tags_len = Z_STRSIZE_P(allow); } else { allowed_tags = Z_STRVAL_P(allow); - allowed_tags_len = Z_STRLEN_P(allow); + allowed_tags_len = Z_STRSIZE_P(allow); } } @@ -4210,8 +4200,8 @@ PHP_FUNCTION(setlocale) } #ifdef HAVE_SETLOCALE - if (Z_TYPE_P(pcategory) == IS_LONG) { - cat = Z_LVAL_P(pcategory); + if (Z_TYPE_P(pcategory) == IS_INT) { + cat = Z_IVAL_P(pcategory); } else { /* FIXME: The following behaviour should be removed. */ char *category; @@ -4272,7 +4262,7 @@ PHP_FUNCTION(setlocale) loc = NULL; } else { loc = Z_STRVAL(tmp); - if (Z_STRLEN(tmp) >= 255) { + if (Z_STRSIZE(tmp) >= 255) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified locale name is too long"); zval_dtor(&tmp); break; @@ -4732,13 +4722,12 @@ PHP_FUNCTION(str_getcsv) Returns the input string repeat mult times */ PHP_FUNCTION(str_repeat) { - char *input_str; /* Input string */ - int input_len; - long mult; /* Multiplier */ + zend_string *input_str; /* Input string */ + php_int_t mult; /* Multiplier */ zend_string *result; /* Resulting string */ size_t result_len; /* Length of the resulting string */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input_str, &input_len, &mult) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Si", &input_str, &mult) == FAILURE) { return; } @@ -4749,22 +4738,22 @@ PHP_FUNCTION(str_repeat) /* Don't waste our time if it's empty */ /* ... or if the multiplier is zero */ - if (input_len == 0 || mult == 0) + if (input_str->len == 0 || mult == 0) RETURN_EMPTY_STRING(); /* Initialize the result string */ - result = STR_SAFE_ALLOC(input_len, mult, 0, 0); - result_len = input_len * mult; + result = STR_SAFE_ALLOC(input_str->len, mult, 0, 0); + result_len = input_str->len * mult; /* Heavy optimization for situations where input string is 1 byte long */ - if (input_len == 1) { - memset(result->val, *(input_str), mult); + if (input_str->len == 1) { + memset(result->val, *(input_str->val), mult); } else { char *s, *e, *ee; - int l=0; - memcpy(result->val, input_str, input_len); + ptrdiff_t l=0; + memcpy(result->val, input_str->val, input_str->len); s = result->val; - e = result->val + input_len; + e = result->val + input_str->len; ee = result->val + result_len; while (e<ee) { @@ -4817,16 +4806,16 @@ PHP_FUNCTION(count_chars) for (inx = 0; inx < 256; inx++) { switch (mymode) { case 0: - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); break; case 1: if (chars[inx] != 0) { - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); } break; case 2: if (chars[inx] == 0) { - add_index_long(return_value, inx, chars[inx]); + add_index_int(return_value, inx, chars[inx]); } break; case 3: @@ -4859,7 +4848,7 @@ static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case) return; } - RETURN_LONG(strnatcmp_ex(s1, s1_len, + RETURN_INT(strnatcmp_ex(s1, s1_len, s2, s2_len, fold_case)); } @@ -4870,7 +4859,7 @@ PHPAPI int string_natural_compare_function_ex(zval *result, zval *op1, zval *op2 zend_string *str1 = zval_get_string(op1); zend_string *str2 = zval_get_string(op2); - ZVAL_LONG(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); + ZVAL_INT(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive)); STR_RELEASE(str1); STR_RELEASE(str2); @@ -4924,14 +4913,14 @@ PHP_FUNCTION(localeconv) len = strlen(currlocdata.grouping); for (i = 0; i < len; i++) { - add_index_long(&grouping, i, currlocdata.grouping[i]); + add_index_int(&grouping, i, currlocdata.grouping[i]); } /* Grab the monetary grouping data out of the array */ len = strlen(currlocdata.mon_grouping); for (i = 0; i < len; i++) { - add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]); + add_index_int(&mon_grouping, i, currlocdata.mon_grouping[i]); } add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point); @@ -4942,21 +4931,21 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep); add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign); add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign); - add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits); - add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits); - add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); - add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); - add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); - add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); - add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn); - add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn); + add_assoc_int( return_value, "int_frac_digits", currlocdata.int_frac_digits); + add_assoc_int( return_value, "frac_digits", currlocdata.frac_digits); + add_assoc_int( return_value, "p_cs_precedes", currlocdata.p_cs_precedes); + add_assoc_int( return_value, "p_sep_by_space", currlocdata.p_sep_by_space); + add_assoc_int( return_value, "n_cs_precedes", currlocdata.n_cs_precedes); + add_assoc_int( return_value, "n_sep_by_space", currlocdata.n_sep_by_space); + add_assoc_int( return_value, "p_sign_posn", currlocdata.p_sign_posn); + add_assoc_int( return_value, "n_sign_posn", currlocdata.n_sign_posn); } #else /* Ok, it doesn't look like we have locale info floating around, so I guess it wouldn't hurt to just go ahead and return the POSIX locale information? */ - add_index_long(&grouping, 0, -1); - add_index_long(&mon_grouping, 0, -1); + add_index_int(&grouping, 0, -1); + add_index_int(&mon_grouping, 0, -1); add_assoc_string(return_value, "decimal_point", "\x2E"); add_assoc_string(return_value, "thousands_sep", ""); @@ -4966,14 +4955,14 @@ PHP_FUNCTION(localeconv) add_assoc_string(return_value, "mon_thousands_sep", ""); add_assoc_string(return_value, "positive_sign", ""); add_assoc_string(return_value, "negative_sign", ""); - add_assoc_long( return_value, "int_frac_digits", CHAR_MAX); - add_assoc_long( return_value, "frac_digits", CHAR_MAX); - add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX); - add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX); - add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX); - add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX); - add_assoc_long( return_value, "p_sign_posn", CHAR_MAX); - add_assoc_long( return_value, "n_sign_posn", CHAR_MAX); + add_assoc_int( return_value, "int_frac_digits", CHAR_MAX); + add_assoc_int( return_value, "frac_digits", CHAR_MAX); + add_assoc_int( return_value, "p_cs_precedes", CHAR_MAX); + add_assoc_int( return_value, "p_sep_by_space", CHAR_MAX); + add_assoc_int( return_value, "n_cs_precedes", CHAR_MAX); + add_assoc_int( return_value, "n_sep_by_space", CHAR_MAX); + add_assoc_int( return_value, "p_sign_posn", CHAR_MAX); + add_assoc_int( return_value, "n_sign_posn", CHAR_MAX); #endif zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping); @@ -5050,7 +5039,7 @@ PHP_FUNCTION(substr_count) } } - RETURN_LONG(count); + RETURN_INT(count); } /* }}} */ @@ -5174,7 +5163,7 @@ PHP_FUNCTION(str_rot13) RETVAL_STRINGL(arg, arglen); - php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52); + php_strtr(Z_STRVAL_P(return_value), Z_STRSIZE_P(return_value), rot13_from, rot13_to, 52); } /* }}} */ @@ -5216,8 +5205,8 @@ PHP_FUNCTION(str_shuffle) } RETVAL_STRINGL(arg, arglen); - if (Z_STRLEN_P(return_value) > 1) { - php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC); + if (Z_STRSIZE_P(return_value) > 1) { + php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRSIZE_P(return_value) TSRMLS_CC); } } /* }}} */ @@ -5253,7 +5242,7 @@ PHP_FUNCTION(str_word_count) break; case 0: if (!str_len) { - RETURN_LONG(0); + RETURN_INT(0); } /* nothing to be done */ break; @@ -5301,7 +5290,7 @@ PHP_FUNCTION(str_word_count) } if (!type) { - RETURN_LONG(word_count); + RETURN_INT(word_count); } } @@ -5433,7 +5422,7 @@ PHP_FUNCTION(substr_compare) if (ZEND_NUM_ARGS() >= 4 && len <= 0) { if (len == 0) { - RETURN_LONG(0L); + RETURN_INT(0L); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "The length must be greater than or equal to zero"); RETURN_FALSE; @@ -5453,9 +5442,9 @@ PHP_FUNCTION(substr_compare) cmp_len = (uint) (len ? len : MAX(s2_len, (s1_len - offset))); if (!cs) { - RETURN_LONG(zend_binary_strncmp(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); + RETURN_INT(zend_binary_strncmp(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); } else { - RETURN_LONG(zend_binary_strncasecmp_l(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); + RETURN_INT(zend_binary_strncasecmp_l(s1 + offset, (s1_len - offset), s2, s2_len, cmp_len)); } } /* }}} */ diff --git a/ext/standard/syslog.c b/ext/standard/syslog.c index acbffe49ad..05c443988e 100644 --- a/ext/standard/syslog.c +++ b/ext/standard/syslog.c @@ -41,59 +41,59 @@ PHP_MINIT_FUNCTION(syslog) { /* error levels */ - REGISTER_LONG_CONSTANT("LOG_EMERG", LOG_EMERG, CONST_CS | CONST_PERSISTENT); /* system unusable */ - REGISTER_LONG_CONSTANT("LOG_ALERT", LOG_ALERT, CONST_CS | CONST_PERSISTENT); /* immediate action required */ - REGISTER_LONG_CONSTANT("LOG_CRIT", LOG_CRIT, CONST_CS | CONST_PERSISTENT); /* critical conditions */ - REGISTER_LONG_CONSTANT("LOG_ERR", LOG_ERR, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_WARNING", LOG_WARNING, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_NOTICE", LOG_NOTICE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_INFO", LOG_INFO, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_DEBUG", LOG_DEBUG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_EMERG", LOG_EMERG, CONST_CS | CONST_PERSISTENT); /* system unusable */ + REGISTER_INT_CONSTANT("LOG_ALERT", LOG_ALERT, CONST_CS | CONST_PERSISTENT); /* immediate action required */ + REGISTER_INT_CONSTANT("LOG_CRIT", LOG_CRIT, CONST_CS | CONST_PERSISTENT); /* critical conditions */ + REGISTER_INT_CONSTANT("LOG_ERR", LOG_ERR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_WARNING", LOG_WARNING, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NOTICE", LOG_NOTICE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_INFO", LOG_INFO, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_DEBUG", LOG_DEBUG, CONST_CS | CONST_PERSISTENT); /* facility: type of program logging the message */ - REGISTER_LONG_CONSTANT("LOG_KERN", LOG_KERN, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_USER", LOG_USER, CONST_CS | CONST_PERSISTENT); /* generic user level */ - REGISTER_LONG_CONSTANT("LOG_MAIL", LOG_MAIL, CONST_CS | CONST_PERSISTENT); /* log to email */ - REGISTER_LONG_CONSTANT("LOG_DAEMON", LOG_DAEMON, CONST_CS | CONST_PERSISTENT); /* other system daemons */ - REGISTER_LONG_CONSTANT("LOG_AUTH", LOG_AUTH, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_SYSLOG", LOG_SYSLOG, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LPR", LOG_LPR, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_KERN", LOG_KERN, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_USER", LOG_USER, CONST_CS | CONST_PERSISTENT); /* generic user level */ + REGISTER_INT_CONSTANT("LOG_MAIL", LOG_MAIL, CONST_CS | CONST_PERSISTENT); /* log to email */ + REGISTER_INT_CONSTANT("LOG_DAEMON", LOG_DAEMON, CONST_CS | CONST_PERSISTENT); /* other system daemons */ + REGISTER_INT_CONSTANT("LOG_AUTH", LOG_AUTH, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_SYSLOG", LOG_SYSLOG, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LPR", LOG_LPR, CONST_CS | CONST_PERSISTENT); #ifdef LOG_NEWS /* No LOG_NEWS on HP-UX */ - REGISTER_LONG_CONSTANT("LOG_NEWS", LOG_NEWS, CONST_CS | CONST_PERSISTENT); /* usenet new */ + REGISTER_INT_CONSTANT("LOG_NEWS", LOG_NEWS, CONST_CS | CONST_PERSISTENT); /* usenet new */ #endif #ifdef LOG_UUCP /* No LOG_UUCP on HP-UX */ - REGISTER_LONG_CONSTANT("LOG_UUCP", LOG_UUCP, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_UUCP", LOG_UUCP, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_CRON /* apparently some systems don't have this one */ - REGISTER_LONG_CONSTANT("LOG_CRON", LOG_CRON, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_CRON", LOG_CRON, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_AUTHPRIV /* AIX doesn't have LOG_AUTHPRIV */ - REGISTER_LONG_CONSTANT("LOG_AUTHPRIV", LOG_AUTHPRIV, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_AUTHPRIV", LOG_AUTHPRIV, CONST_CS | CONST_PERSISTENT); #endif #ifndef PHP_WIN32 - REGISTER_LONG_CONSTANT("LOG_LOCAL0", LOG_LOCAL0, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL1", LOG_LOCAL1, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL2", LOG_LOCAL2, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL3", LOG_LOCAL3, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL4", LOG_LOCAL4, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL5", LOG_LOCAL5, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL6", LOG_LOCAL6, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_LOCAL7", LOG_LOCAL7, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL0", LOG_LOCAL0, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL1", LOG_LOCAL1, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL2", LOG_LOCAL2, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL3", LOG_LOCAL3, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL4", LOG_LOCAL4, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL5", LOG_LOCAL5, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL6", LOG_LOCAL6, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_LOCAL7", LOG_LOCAL7, CONST_CS | CONST_PERSISTENT); #endif /* options */ - REGISTER_LONG_CONSTANT("LOG_PID", LOG_PID, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_CONS", LOG_CONS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_ODELAY", LOG_ODELAY, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("LOG_NDELAY", LOG_NDELAY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_PID", LOG_PID, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_CONS", LOG_CONS, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_ODELAY", LOG_ODELAY, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NDELAY", LOG_NDELAY, CONST_CS | CONST_PERSISTENT); #ifdef LOG_NOWAIT - REGISTER_LONG_CONSTANT("LOG_NOWAIT", LOG_NOWAIT, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("LOG_NOWAIT", LOG_NOWAIT, CONST_CS | CONST_PERSISTENT); #endif #ifdef LOG_PERROR /* AIX doesn't have LOG_PERROR */ - REGISTER_LONG_CONSTANT("LOG_PERROR", LOG_PERROR, CONST_CS | CONST_PERSISTENT); /*log to stderr*/ + REGISTER_INT_CONSTANT("LOG_PERROR", LOG_PERROR, CONST_CS | CONST_PERSISTENT); /*log to stderr*/ #endif BG(syslog_device)=NULL; diff --git a/ext/standard/type.c b/ext/standard/type.c index 2a2988dee5..574744d9ba 100644 --- a/ext/standard/type.c +++ b/ext/standard/type.c @@ -41,7 +41,7 @@ PHP_FUNCTION(gettype) RETVAL_STRING("boolean"); break; - case IS_LONG: + case IS_INT: RETVAL_STRING("integer"); break; @@ -103,9 +103,9 @@ PHP_FUNCTION(settype) ZVAL_DEREF(var); SEPARATE_ZVAL_NOREF(var); if (!strcasecmp(type, "integer")) { - convert_to_long(var); + convert_to_int(var); } else if (!strcasecmp(type, "int")) { - convert_to_long(var); + convert_to_int(var); } else if (!strcasecmp(type, "float")) { convert_to_double(var); } else if (!strcasecmp(type, "double")) { /* deprecated */ @@ -138,25 +138,25 @@ PHP_FUNCTION(settype) PHP_FUNCTION(intval) { zval *num; - long base = 10; + php_int_t base = 10; if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 2) { WRONG_PARAM_COUNT; } #ifndef FAST_ZPP - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &num, &base) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|i", &num, &base) == FAILURE) { return; } #else ZEND_PARSE_PARAMETERS_START(1, 2) Z_PARAM_ZVAL(num) Z_PARAM_OPTIONAL - Z_PARAM_LONG(base) + Z_PARAM_INT(base) ZEND_PARSE_PARAMETERS_END(); #endif RETVAL_ZVAL(num, 1, 0); - convert_to_long_base(return_value, base); + convert_to_int_base(return_value, base); } /* }}} */ @@ -277,7 +277,7 @@ PHP_FUNCTION(is_bool) Returns true if variable is a long (integer) */ PHP_FUNCTION(is_long) { - php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_LONG); + php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_INT); } /* }}} */ @@ -324,13 +324,13 @@ PHP_FUNCTION(is_numeric) } switch (Z_TYPE_P(arg)) { - case IS_LONG: + case IS_INT: case IS_DOUBLE: RETURN_TRUE; break; case IS_STRING: - if (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), NULL, NULL, 0)) { + if (is_numeric_string(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), NULL, NULL, 0)) { RETURN_TRUE; } else { RETURN_FALSE; @@ -364,7 +364,7 @@ PHP_FUNCTION(is_scalar) case IS_FALSE: case IS_TRUE: case IS_DOUBLE: - case IS_LONG: + case IS_INT: case IS_STRING: RETURN_TRUE; break; diff --git a/ext/standard/url.c b/ext/standard/url.c index 3b9b22af90..71c2d8fb0c 100644 --- a/ext/standard/url.c +++ b/ext/standard/url.c @@ -398,7 +398,7 @@ PHP_FUNCTION(parse_url) if (resource->host != NULL) RETVAL_STRING(resource->host); break; case PHP_URL_PORT: - if (resource->port != 0) RETVAL_LONG(resource->port); + if (resource->port != 0) RETVAL_INT(resource->port); break; case PHP_URL_USER: if (resource->user != NULL) RETVAL_STRING(resource->user); @@ -431,7 +431,7 @@ PHP_FUNCTION(parse_url) if (resource->host != NULL) add_assoc_string(return_value, "host", resource->host); if (resource->port != 0) - add_assoc_long(return_value, "port", resource->port); + add_assoc_int(return_value, "port", resource->port); if (resource->user != NULL) add_assoc_string(return_value, "user", resource->user); if (resource->pass != NULL) @@ -769,10 +769,10 @@ no_name_header: } if ((prev_val = zend_hash_str_find(HASH_OF(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) { - add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr)))); + add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRSIZE_P(hdr) - (s - Z_STRVAL_P(hdr)))); } else { /* some headers may occur more then once, therefor we need to remake the string into an array */ convert_to_array(prev_val); - add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr)))); + add_next_index_stringl(prev_val, s, (Z_STRSIZE_P(hdr) - (s - Z_STRVAL_P(hdr)))); } *p = c; diff --git a/ext/standard/url_scanner_ex.c b/ext/standard/url_scanner_ex.c index fc865b64a7..8ed49e6efc 100644 --- a/ext/standard/url_scanner_ex.c +++ b/ext/standard/url_scanner_ex.c @@ -1,5 +1,4 @@ /* Generated by re2c 0.13.5 */ -#line 1 "ext/standard/url_scanner_ex.re" /* +----------------------------------------------------------------------+ | PHP Version 5 | @@ -100,7 +99,6 @@ PHP_INI_BEGIN() STD_PHP_INI_ENTRY("url_rewriter.tags", "a=href,area=href,frame=src,form=,fieldset=", PHP_INI_ALL, OnUpdateTags, url_adapt_state_ex, php_basic_globals, basic_globals) PHP_INI_END() -#line 107 "ext/standard/url_scanner_ex.re" #define YYFILL(n) goto done @@ -119,7 +117,6 @@ static inline void append_modified_url(smart_str *url, smart_str *dest, smart_st scan: -#line 123 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -165,19 +162,13 @@ scan: if (yych <= '9') goto yy6; if (yych >= ';') goto yy4; ++YYCURSOR; -#line 125 "ext/standard/url_scanner_ex.re" { smart_str_append(dest, url); return; } -#line 171 "ext/standard/url_scanner_ex.c" yy4: ++YYCURSOR; -#line 126 "ext/standard/url_scanner_ex.re" { sep = separator; goto scan; } -#line 176 "ext/standard/url_scanner_ex.c" yy6: ++YYCURSOR; -#line 127 "ext/standard/url_scanner_ex.re" { bash = p - 1; goto done; } -#line 181 "ext/standard/url_scanner_ex.c" yy8: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -185,11 +176,8 @@ yy8: if (yybm[0+yych] & 128) { goto yy8; } -#line 128 "ext/standard/url_scanner_ex.re" { goto scan; } -#line 191 "ext/standard/url_scanner_ex.c" } -#line 129 "ext/standard/url_scanner_ex.re" done: @@ -374,7 +362,6 @@ state_plain_begin: state_plain: start = YYCURSOR; -#line 378 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -417,9 +404,7 @@ state_plain: goto yy15; } ++YYCURSOR; -#line 313 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_TAG; goto state_tag; } -#line 423 "ext/standard/url_scanner_ex.c" yy15: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -427,17 +412,13 @@ yy15: if (yybm[0+yych] & 128) { goto yy15; } -#line 314 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain; } -#line 433 "ext/standard/url_scanner_ex.c" } -#line 315 "ext/standard/url_scanner_ex.re" state_tag: start = YYCURSOR; -#line 441 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -488,14 +469,10 @@ yy20: yych = *YYCURSOR; goto yy25; yy21: -#line 320 "ext/standard/url_scanner_ex.re" { handle_tag(STD_ARGS); /* Sets STATE */; passthru(STD_ARGS); if (STATE == STATE_PLAIN) goto state_plain; else goto state_next_arg; } -#line 494 "ext/standard/url_scanner_ex.c" yy22: ++YYCURSOR; -#line 321 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain_begin; } -#line 499 "ext/standard/url_scanner_ex.c" yy24: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -506,7 +483,6 @@ yy25: } goto yy21; } -#line 322 "ext/standard/url_scanner_ex.re" state_next_arg_begin: @@ -515,7 +491,6 @@ state_next_arg_begin: state_next_arg: start = YYCURSOR; -#line 519 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -580,28 +555,20 @@ yy28: ++YYCURSOR; if ((yych = *YYCURSOR) == '>') goto yy39; yy29: -#line 333 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain_begin; } -#line 586 "ext/standard/url_scanner_ex.c" yy30: ++YYCURSOR; yy31: -#line 330 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); handle_form(STD_ARGS); goto state_plain_begin; } -#line 592 "ext/standard/url_scanner_ex.c" yy32: ++YYCURSOR; yych = *YYCURSOR; goto yy38; yy33: -#line 331 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_next_arg; } -#line 600 "ext/standard/url_scanner_ex.c" yy34: ++YYCURSOR; -#line 332 "ext/standard/url_scanner_ex.re" { --YYCURSOR; STATE = STATE_ARG; goto state_arg; } -#line 605 "ext/standard/url_scanner_ex.c" yy36: yych = *++YYCURSOR; goto yy29; @@ -619,13 +586,11 @@ yy39: yych = *YYCURSOR; goto yy31; } -#line 334 "ext/standard/url_scanner_ex.re" state_arg: start = YYCURSOR; -#line 629 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -673,14 +638,10 @@ yy42: yych = *YYCURSOR; goto yy47; yy43: -#line 339 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); handle_arg(STD_ARGS); STATE = STATE_BEFORE_VAL; goto state_before_val; } -#line 679 "ext/standard/url_scanner_ex.c" yy44: ++YYCURSOR; -#line 340 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_NEXT_ARG; goto state_next_arg; } -#line 684 "ext/standard/url_scanner_ex.c" yy46: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -691,13 +652,11 @@ yy47: } goto yy43; } -#line 341 "ext/standard/url_scanner_ex.re" state_before_val: start = YYCURSOR; -#line 701 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -744,17 +703,13 @@ yy50: if (yych == ' ') goto yy57; if (yych == '=') goto yy55; yy51: -#line 347 "ext/standard/url_scanner_ex.re" { --YYCURSOR; goto state_next_arg_begin; } -#line 750 "ext/standard/url_scanner_ex.c" yy52: ++YYCURSOR; yych = *YYCURSOR; goto yy56; yy53: -#line 346 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_VAL; goto state_val; } -#line 758 "ext/standard/url_scanner_ex.c" yy54: yych = *++YYCURSOR; goto yy51; @@ -776,14 +731,12 @@ yy57: YYCURSOR = YYMARKER; goto yy51; } -#line 348 "ext/standard/url_scanner_ex.re" state_val: start = YYCURSOR; -#line 787 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -844,9 +797,7 @@ state_val: yych = *(YYMARKER = ++YYCURSOR); if (yych != '>') goto yy76; yy63: -#line 357 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_next_arg_begin; } -#line 850 "ext/standard/url_scanner_ex.c" yy64: yych = *(YYMARKER = ++YYCURSOR); if (yych == '>') goto yy63; @@ -856,9 +807,7 @@ yy65: yych = *YYCURSOR; goto yy69; yy66: -#line 356 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 0, ' '); goto state_next_arg_begin; } -#line 862 "ext/standard/url_scanner_ex.c" yy67: yych = *++YYCURSOR; goto yy63; @@ -885,9 +834,7 @@ yy72: goto yy63; yy73: ++YYCURSOR; -#line 355 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 1, '\''); goto state_next_arg_begin; } -#line 891 "ext/standard/url_scanner_ex.c" yy75: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -898,11 +845,8 @@ yy76: } if (yych >= '>') goto yy72; ++YYCURSOR; -#line 354 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 1, '"'); goto state_next_arg_begin; } -#line 904 "ext/standard/url_scanner_ex.c" } -#line 358 "ext/standard/url_scanner_ex.re" stop: diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c index 7dce126ac3..f9c94186f1 100644 --- a/ext/standard/user_filters.c +++ b/ext/standard/user_filters.c @@ -113,13 +113,13 @@ PHP_MINIT_FUNCTION(user_filters) return FAILURE; } - REGISTER_LONG_CONSTANT("PSFS_PASS_ON", PSFS_PASS_ON, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FEED_ME", PSFS_FEED_ME, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_ERR_FATAL", PSFS_ERR_FATAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_PASS_ON", PSFS_PASS_ON, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FEED_ME", PSFS_FEED_ME, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_ERR_FATAL", PSFS_ERR_FATAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_NORMAL", PSFS_FLAG_NORMAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_INC", PSFS_FLAG_FLUSH_INC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("PSFS_FLAG_FLUSH_CLOSE", PSFS_FLAG_FLUSH_CLOSE, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_NORMAL", PSFS_FLAG_NORMAL, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_FLUSH_INC", PSFS_FLAG_FLUSH_INC, CONST_CS | CONST_PERSISTENT); + REGISTER_INT_CONSTANT("PSFS_FLAG_FLUSH_CLOSE", PSFS_FLAG_FLUSH_CLOSE, CONST_CS | CONST_PERSISTENT); return SUCCESS; } @@ -203,7 +203,7 @@ php_stream_filter_status_t userfilter_filter( ZEND_REGISTER_RESOURCE(&args[1], buckets_out, le_bucket_brigade); if (bytes_consumed) { - ZVAL_LONG(&args[2], *bytes_consumed); + ZVAL_INT(&args[2], *bytes_consumed); } else { ZVAL_NULL(&args[2]); } @@ -220,14 +220,14 @@ php_stream_filter_status_t userfilter_filter( zval_ptr_dtor(&func_name); if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - convert_to_long(&retval); - ret = Z_LVAL(retval); + convert_to_int(&retval); + ret = Z_IVAL(retval); } else if (call_result == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call filter function"); } if (bytes_consumed) { - *bytes_consumed = Z_LVAL_P(&args[2]); + *bytes_consumed = Z_IVAL_P(&args[2]); } if (buckets_in->head) { @@ -424,7 +424,7 @@ PHP_FUNCTION(stream_bucket_make_writeable) /* add_property_zval increments the refcount which is unwanted here */ zval_ptr_dtor(&zbucket); add_property_stringl(return_value, "data", bucket->buf, bucket->buflen); - add_property_long(return_value, "datalen", bucket->buflen); + add_property_int(return_value, "datalen", bucket->buflen); } } /* }}} */ @@ -453,9 +453,9 @@ static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS) if (!bucket->own_buf) { bucket = php_stream_bucket_make_writeable(bucket TSRMLS_CC); } - if ((int)bucket->buflen != Z_STRLEN_P(pzdata)) { - bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent); - bucket->buflen = Z_STRLEN_P(pzdata); + if ((int)bucket->buflen != Z_STRSIZE_P(pzdata)) { + bucket->buf = perealloc(bucket->buf, Z_STRSIZE_P(pzdata), bucket->is_persistent); + bucket->buflen = Z_STRSIZE_P(pzdata); } memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen); } @@ -525,7 +525,7 @@ PHP_FUNCTION(stream_bucket_new) /* add_property_zval increments the refcount which is unwanted here */ zval_ptr_dtor(&zbucket); add_property_stringl(return_value, "data", bucket->buf, bucket->buflen); - add_property_long(return_value, "datalen", bucket->buflen); + add_property_int(return_value, "datalen", bucket->buflen); } /* }}} */ diff --git a/ext/standard/var.c b/ext/standard/var.c index 96b1ee40ec..aa555c3344 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -54,10 +54,10 @@ static uint zend_obj_num_elements(HashTable *ht) return num; } -static void php_array_element_dump(zval *zv, ulong index, zend_string *key, int level TSRMLS_DC) /* {{{ */ +static void php_array_element_dump(zval *zv, php_uint_t index, zend_string *key, int level TSRMLS_DC) /* {{{ */ { if (key == NULL) { /* numeric key */ - php_printf("%*c[%ld]=>\n", level + 1, ' ', index); + php_printf("%*c[" ZEND_UINT_FMT "]=>\n", level + 1, ' ', index); } else { /* string key */ php_printf("%*c[\"", level + 1, ' '); PHPWRITE(key->val, key->len); @@ -67,12 +67,12 @@ static void php_array_element_dump(zval *zv, ulong index, zend_string *key, int } /* }}} */ -static void php_object_property_dump(zval *zv, ulong index, zend_string *key, int level TSRMLS_DC) /* {{{ */ +static void php_object_property_dump(zval *zv, php_uint_t index, zend_string *key, int level TSRMLS_DC) /* {{{ */ { const char *prop_name, *class_name; if (key == NULL) { /* numeric key */ - php_printf("%*c[%ld]=>\n", level + 1, ' ', index); + php_printf("%*c[" ZEND_UINT_FMT "]=>\n", level + 1, ' ', index); } else { /* string key */ int unmangle = zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name); php_printf("%*c[", level + 1, ' '); @@ -100,7 +100,7 @@ PHPAPI void php_var_dump(zval *struc, int level TSRMLS_DC) /* {{{ */ zend_string *class_name; int is_temp; int is_ref = 0; - ulong num; + php_uint_t num; zend_string *key; zval *val; @@ -119,15 +119,15 @@ again: case IS_NULL: php_printf("%sNULL\n", COMMON); break; - case IS_LONG: - php_printf("%sint(%ld)\n", COMMON, Z_LVAL_P(struc)); + case IS_INT: + php_printf("%sint(" ZEND_INT_FMT ")\n", COMMON, Z_IVAL_P(struc)); break; case IS_DOUBLE: php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc)); break; case IS_STRING: - php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc)); - PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_printf("%sstring(%d) \"", COMMON, Z_STRSIZE_P(struc)); + PHPWRITE(Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); PUTS("\"\n"); break; case IS_ARRAY: @@ -171,7 +171,7 @@ again: php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0); } if (myht) { - ulong num; + php_uint_t num; zend_string *key; zval *val; @@ -227,10 +227,10 @@ PHP_FUNCTION(var_dump) } /* }}} */ -static void zval_array_element_dump(zval *zv, ulong index, zend_string *key, int level TSRMLS_DC) /* {{{ */ +static void zval_array_element_dump(zval *zv, php_uint_t index, zend_string *key, int level TSRMLS_DC) /* {{{ */ { if (key == NULL) { /* numeric key */ - php_printf("%*c[%ld]=>\n", level + 1, ' ', index); + php_printf("%*c[" ZEND_UINT_FMT "]=>\n", level + 1, ' ', index); } else { /* string key */ php_printf("%*c[\"", level + 1, ' '); PHPWRITE(key->val, key->len); @@ -240,12 +240,12 @@ static void zval_array_element_dump(zval *zv, ulong index, zend_string *key, int } /* }}} */ -static void zval_object_property_dump(zval *zv, ulong index, zend_string *key, int level TSRMLS_DC) /* {{{ */ +static void zval_object_property_dump(zval *zv, php_uint_t index, zend_string *key, int level TSRMLS_DC) /* {{{ */ { const char *prop_name, *class_name; if (key == NULL) { /* numeric key */ - php_printf("%*c[%ld]=>\n", level + 1, ' ', index); + php_printf("%*c[" ZEND_UINT_FMT "]=>\n", level + 1, ' ', index); } else { /* string key */ zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name); php_printf("%*c[", level + 1, ' '); @@ -271,7 +271,7 @@ PHPAPI void php_debug_zval_dump(zval *struc, int level TSRMLS_DC) /* {{{ */ zend_string *class_name; int is_temp = 0; int is_ref = 0; - ulong index; + php_uint_t index; zend_string *key; zval *val; @@ -290,15 +290,15 @@ again: case IS_NULL: php_printf("%sNULL\n", COMMON); break; - case IS_LONG: - php_printf("%slong(%ld)\n", COMMON, Z_LVAL_P(struc)); + case IS_INT: + php_printf("%slong(" ZEND_INT_FMT ")\n", COMMON, Z_IVAL_P(struc)); break; case IS_DOUBLE: php_printf("%sdouble(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc)); break; case IS_STRING: - php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc)); - PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_printf("%sstring(%d) \"", COMMON, Z_STRSIZE_P(struc)); + PHPWRITE(Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); php_printf("\" refcount(%u)\n", IS_INTERNED(Z_STR_P(struc)) ? 1 : Z_REFCOUNT_P(struc)); break; case IS_ARRAY: @@ -354,7 +354,7 @@ again: break; case IS_RESOURCE: { const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(struc) TSRMLS_CC); - php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown", Z_REFCOUNT_P(struc)); + php_printf("%sresource(" ZEND_INT_FMT ") of type (%s) refcount(%u)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown", Z_REFCOUNT_P(struc)); break; } case IS_REFERENCE: @@ -398,11 +398,11 @@ PHP_FUNCTION(debug_zval_dump) efree(tmp_spaces); \ } while(0); -static void php_array_element_export(zval *zv, ulong index, zend_string *key, int level, smart_str *buf TSRMLS_DC) /* {{{ */ +static void php_array_element_export(zval *zv, php_uint_t index, zend_string *key, int level, smart_str *buf TSRMLS_DC) /* {{{ */ { if (key == NULL) { /* numeric key */ buffer_append_spaces(buf, level+1); - smart_str_append_long(buf, (long) index); + smart_str_append_int(buf, (long) index); smart_str_appendl(buf, " => ", 4); } else { /* string key */ @@ -426,7 +426,7 @@ static void php_array_element_export(zval *zv, ulong index, zend_string *key, in } /* }}} */ -static void php_object_element_export(zval *zv, ulong index, zend_string *key, int level, smart_str *buf TSRMLS_DC) /* {{{ */ +static void php_object_element_export(zval *zv, php_uint_t index, zend_string *key, int level, smart_str *buf TSRMLS_DC) /* {{{ */ { buffer_append_spaces(buf, level + 2); if (key != NULL) { @@ -443,7 +443,7 @@ static void php_object_element_export(zval *zv, ulong index, zend_string *key, i smart_str_appendc(buf, '\''); STR_RELEASE(pname_esc); } else { - smart_str_append_long(buf, (long) index); + smart_str_append_int(buf, (long) index); } smart_str_appendl(buf, " => ", 4); php_var_export_ex(zv, level + 2, buf TSRMLS_CC); @@ -459,7 +459,7 @@ PHPAPI void php_var_export_ex(zval *struc, int level, smart_str *buf TSRMLS_DC) int tmp_len; zend_string *class_name; zend_string *ztmp, *ztmp2; - ulong index; + php_uint_t index; zend_string *key; zval *val; @@ -474,8 +474,8 @@ again: case IS_NULL: smart_str_appendl(buf, "NULL", 4); break; - case IS_LONG: - smart_str_append_long(buf, Z_LVAL_P(struc)); + case IS_INT: + smart_str_append_int(buf, Z_IVAL_P(struc)); break; case IS_DOUBLE: tmp_len = spprintf(&tmp_str, 0,"%.*H", PG(serialize_precision), Z_DVAL_P(struc)); @@ -483,7 +483,7 @@ again: efree(tmp_str); break; case IS_STRING: - ztmp = php_addcslashes(Z_STRVAL_P(struc), Z_STRLEN_P(struc), 0, "'\\", 2 TSRMLS_CC); + ztmp = php_addcslashes(Z_STRVAL_P(struc), Z_STRSIZE_P(struc), 0, "'\\", 2 TSRMLS_CC); ztmp2 = php_str_to_str_ex(ztmp->val, ztmp->len, "\0", 1, "' . \"\\0\" . '", 12, 0, NULL); smart_str_appendc(buf, '\''); @@ -613,16 +613,16 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var } if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) { p = smart_str_print_long(id + sizeof(id) - 1, - (long) Z_OBJ_P(var)); + (php_int_t) Z_OBJ_P(var)); *(--p) = 'O'; len = id + sizeof(id) - 1 - p; } else if (var_ptr != var) { p = smart_str_print_long(id + sizeof(id) - 1, - (long) Z_REF_P(var_ptr)); + (php_int_t) Z_REF_P(var_ptr)); *(--p) = 'R'; len = id + sizeof(id) - 1 - p; } else { - p = smart_str_print_long(id + sizeof(id) - 1, (long) var); + p = smart_str_print_long(id + sizeof(id) - 1, (php_int_t) var); len = id + sizeof(id) - 1 - p; } @@ -631,29 +631,29 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var if (var == var_ptr) { /* we still need to bump up the counter, since non-refs will * be counted separately by unserializer */ - ZVAL_LONG(&var_no, -1); + ZVAL_INT(&var_no, -1); zend_hash_next_index_insert(var_hash, &var_no); } #if 0 - fprintf(stderr, "- had var (%d): %lu\n", Z_TYPE_P(var), **(ulong**)var_old); + fprintf(stderr, "- had var (%d): %lu\n", Z_TYPE_P(var), **(php_uint_t**)var_old); #endif return FAILURE; } /* +1 because otherwise hash will think we are trying to store NULL pointer */ - ZVAL_LONG(&var_no, zend_hash_num_elements(var_hash) + 1); + ZVAL_INT(&var_no, zend_hash_num_elements(var_hash) + 1); zend_hash_str_add(var_hash, p, len, &var_no); #if 0 - fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), Z_LVAL(var_no)); + fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), Z_IVAL(var_no)); #endif return SUCCESS; } /* }}} */ -static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */ +static inline void php_var_serialize_long(smart_str *buf, php_int_t val) /* {{{ */ { smart_str_appendl(buf, "i:", 2); - smart_str_append_long(buf, val); + smart_str_append_int(buf, val); smart_str_appendc(buf, ';'); } /* }}} */ @@ -661,7 +661,7 @@ static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */ static inline void php_var_serialize_string(smart_str *buf, char *str, int len) /* {{{ */ { smart_str_appendl(buf, "s:", 2); - smart_str_append_long(buf, len); + smart_str_append_int(buf, len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, str, len); smart_str_appendl(buf, "\";", 2); @@ -674,7 +674,7 @@ static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc PHP_SET_CLASS_ATTRIBUTES(struc); smart_str_appendl(buf, "O:", 2); - smart_str_append_long(buf, (int)class_name->len); + smart_str_append_int(buf, (int)class_name->len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, class_name->val, class_name->len); smart_str_appendl(buf, "\":", 2); @@ -695,7 +695,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt if (incomplete_class) { --count; } - smart_str_append_long(buf, count); + smart_str_append_int(buf, count); smart_str_appendl(buf, ":{", 2); if (count > 0) { @@ -728,7 +728,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt continue; } } - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, d, var_hash TSRMLS_CC); } else { zend_class_entry *ce; @@ -737,7 +737,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt zend_string *prot_name, *priv_name; do { - priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRSIZE_P(name), ce->type & ZEND_INTERNAL_CLASS); if ((d = zend_hash_find(propers, priv_name)) != NULL) { if (Z_TYPE_P(d) == IS_INDIRECT) { d = Z_INDIRECT_P(d); @@ -751,7 +751,7 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt break; } STR_FREE(priv_name); - prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRSIZE_P(name), ce->type & ZEND_INTERNAL_CLASS); if ((d = zend_hash_find(propers, prot_name)) != NULL) { if (Z_TYPE_P(d) == IS_INDIRECT) { d = Z_INDIRECT_P(d); @@ -766,12 +766,12 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt break; } STR_FREE(prot_name); - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_P(name)); } while (0); } else { - php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); + php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRSIZE_P(name)); php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); } } @@ -797,12 +797,12 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var php_add_var_hash(var_hash, struc, &var_already TSRMLS_CC) == FAILURE) { if (Z_ISREF_P(struc)) { smart_str_appendl(buf, "R:", 2); - smart_str_append_long(buf, Z_LVAL(var_already)); + smart_str_append_int(buf, Z_IVAL(var_already)); smart_str_appendc(buf, ';'); return; } else if (Z_TYPE_P(struc) == IS_OBJECT) { smart_str_appendl(buf, "r:", 2); - smart_str_append_long(buf, Z_LVAL(var_already)); + smart_str_append_int(buf, Z_IVAL(var_already)); smart_str_appendc(buf, ';'); return; } @@ -822,8 +822,8 @@ again: smart_str_appendl(buf, "N;", 2); return; - case IS_LONG: - php_var_serialize_long(buf, Z_LVAL_P(struc)); + case IS_INT: + php_var_serialize_long(buf, Z_IVAL_P(struc)); return; case IS_DOUBLE: { @@ -839,7 +839,7 @@ again: } case IS_STRING: - php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRSIZE_P(struc)); return; case IS_OBJECT: { @@ -859,12 +859,12 @@ again: if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) { smart_str_appendl(buf, "C:", 2); - smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name->len); + smart_str_append_int(buf, (int)Z_OBJCE_P(struc)->name->len); smart_str_appendl(buf, ":\"", 2); smart_str_appendl(buf, Z_OBJCE_P(struc)->name->val, Z_OBJCE_P(struc)->name->len); smart_str_appendl(buf, "\":", 2); - smart_str_append_long(buf, (int)serialized_length); + smart_str_append_int(buf, (int)serialized_length); smart_str_appendl(buf, ":{", 2); smart_str_appendl(buf, serialized_data, serialized_length); smart_str_appendc(buf, '}'); @@ -923,12 +923,12 @@ again: if (i > 0 && incomplete_class) { --i; } - smart_str_append_long(buf, i); + smart_str_append_int(buf, i); smart_str_appendl(buf, ":{", 2); if (i > 0) { zend_string *key; zval *data; - ulong index; + php_uint_t index; ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) { @@ -1031,7 +1031,7 @@ PHP_FUNCTION(unserialize) PHP_VAR_UNSERIALIZE_DESTROY(var_hash); zval_dtor(return_value); if (!EG(exception)) { - php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len); + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset " ZEND_INT_FMT " of %d bytes", (php_int_t)((char*)p - buf), buf_len); } RETURN_FALSE; } @@ -1048,7 +1048,7 @@ PHP_FUNCTION(memory_get_usage) { RETURN_FALSE; } - RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC)); + RETURN_INT(zend_memory_usage(real_usage TSRMLS_CC)); } /* }}} */ @@ -1061,7 +1061,7 @@ PHP_FUNCTION(memory_get_peak_usage) { RETURN_FALSE; } - RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC)); + RETURN_INT(zend_memory_peak_usage(real_usage TSRMLS_CC)); } /* }}} */ diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c index b6fcd79c2d..810f3c8f8c 100644 --- a/ext/standard/var_unserializer.c +++ b/ext/standard/var_unserializer.c @@ -1,5 +1,4 @@ /* Generated by re2c 0.13.5 */ -#line 1 "ext/standard/var_unserializer.re" /* +----------------------------------------------------------------------+ | PHP Version 5 | @@ -30,13 +29,13 @@ typedef struct { zval *data[VAR_ENTRIES_MAX]; - long used_slots; + php_int_t used_slots; void *next; } var_entries; typedef struct { zval data[VAR_ENTRIES_MAX]; - long used_slots; + php_int_t used_slots; void *next; } var_dtor_entries; @@ -119,7 +118,7 @@ PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval *rva PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nzval) { - long i; + php_int_t i; var_entries *var_hash = (*var_hashx)->first; #if VAR_ENTRIES_DBG fprintf(stderr, "var_replace(%ld): %d\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(nzval)); @@ -136,7 +135,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nz } } -static zval *var_access(php_unserialize_data_t *var_hashx, long id) +static zval *var_access(php_unserialize_data_t *var_hashx, php_int_t id) { var_entries *var_hash = (*var_hashx)->first; #if VAR_ENTRIES_DBG @@ -158,7 +157,7 @@ static zval *var_access(php_unserialize_data_t *var_hashx, long id) PHPAPI void var_destroy(php_unserialize_data_t *var_hashx) { void *next; - long i; + php_int_t i; var_entries *var_hash = (*var_hashx)->first; var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor; #if VAR_ENTRIES_DBG @@ -233,15 +232,14 @@ static zend_string *unserialize_str(const unsigned char **p, size_t len, size_t #define YYMARKER marker -#line 241 "ext/standard/var_unserializer.re" -static inline long parse_iv2(const unsigned char *p, const unsigned char **q) +static inline php_int_t parse_iv2(const unsigned char *p, const unsigned char **q) { char cursor; - long result = 0; + php_int_t result = 0; int neg = 0; switch (*p) { @@ -266,7 +264,7 @@ static inline long parse_iv2(const unsigned char *p, const unsigned char **q) return result; } -static inline long parse_iv(const unsigned char *p) +static inline php_int_t parse_iv(const unsigned char *p) { return parse_iv2(p, NULL); } @@ -296,7 +294,7 @@ static inline size_t parse_uiv(const unsigned char *p) #define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC #define UNSERIALIZE_PASSTHRU rval, p, max, var_hash TSRMLS_CC -static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops) +static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, php_int_t elements, int objprops) { while (elements-- > 0) { zval key, *data, d, *old_data; @@ -307,7 +305,7 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long return 0; } - if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) { + if (Z_TYPE(key) != IS_INT && Z_TYPE(key) != IS_STRING) { zval_dtor(&key); return 0; } @@ -317,12 +315,12 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long if (!objprops) { switch (Z_TYPE(key)) { - case IS_LONG: - if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) { + case IS_INT: + if ((old_data = zend_hash_index_find(ht, Z_IVAL(key))) != NULL) { //??? update hash var_push_dtor(var_hash, old_data); } - data = zend_hash_index_update(ht, Z_LVAL(key), &d); + data = zend_hash_index_update(ht, Z_IVAL(key), &d); break; case IS_STRING: if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) { @@ -380,14 +378,14 @@ static inline int finish_nested_data(UNSERIALIZE_PARAMETER) static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { - long datalen; + php_int_t datalen; datalen = parse_iv2((*p) + 2, p); (*p) += 2; if (datalen < 0 || (*p) + datalen >= max) { - zend_error(E_WARNING, "Insufficient data for unserializing - %ld required, %ld present", datalen, (long)(max - (*p))); + zend_error(E_WARNING, "Insufficient data for unserializing - %ld required, %ld present", datalen, (php_int_t)(max - (*p))); return 0; } @@ -403,9 +401,9 @@ static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) return finish_nested_data(UNSERIALIZE_PASSTHRU); } -static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) +static inline php_int_t object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { - long elements; + php_int_t elements; elements = parse_iv2((*p) + 2, p); @@ -426,7 +424,7 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) #ifdef PHP_WIN32 # pragma optimize("", off) #endif -static inline int object_common2(UNSERIALIZE_PARAMETER, long elements) +static inline int object_common2(UNSERIALIZE_PARAMETER, php_int_t elements) { zval retval; zval fname; @@ -481,7 +479,6 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) start = cursor; -#line 485 "ext/standard/var_unserializer.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -541,9 +538,7 @@ yy2: yych = *(YYMARKER = ++YYCURSOR); if (yych == ':') goto yy95; yy3: -#line 826 "ext/standard/var_unserializer.re" { return 0; } -#line 547 "ext/standard/var_unserializer.c" yy4: yych = *(YYMARKER = ++YYCURSOR); if (yych == ':') goto yy89; @@ -586,13 +581,11 @@ yy13: goto yy3; yy14: ++YYCURSOR; -#line 820 "ext/standard/var_unserializer.re" { /* this is the case where we have less data than planned */ php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unexpected end of serialized data"); return 0; /* not sure if it should be 0 or 1 here? */ } -#line 596 "ext/standard/var_unserializer.c" yy16: yych = *++YYCURSOR; goto yy3; @@ -622,10 +615,9 @@ yy20: yych = *++YYCURSOR; if (yych != '"') goto yy18; ++YYCURSOR; -#line 681 "ext/standard/var_unserializer.re" { size_t len, len2, len3, maxlen; - long elements; + php_int_t elements; char *str; zend_string *class_name; zend_class_entry *ce; @@ -761,7 +753,6 @@ yy20: return object_common2(UNSERIALIZE_PASSTHRU, elements); } -#line 765 "ext/standard/var_unserializer.c" yy25: yych = *++YYCURSOR; if (yych <= ',') { @@ -786,7 +777,6 @@ yy27: yych = *++YYCURSOR; if (yych != '"') goto yy18; ++YYCURSOR; -#line 673 "ext/standard/var_unserializer.re" { //??? INIT_PZVAL(rval); @@ -794,7 +784,6 @@ yy27: return object_common2(UNSERIALIZE_PASSTHRU, object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR)); } -#line 798 "ext/standard/var_unserializer.c" yy32: yych = *++YYCURSOR; if (yych == '+') goto yy33; @@ -815,9 +804,8 @@ yy34: yych = *++YYCURSOR; if (yych != '{') goto yy18; ++YYCURSOR; -#line 652 "ext/standard/var_unserializer.re" { - long elements = parse_iv(start + 2); + php_int_t elements = parse_iv(start + 2); /* use iv() not uiv() in order to check data range */ *p = YYCURSOR; @@ -836,7 +824,6 @@ yy34: return finish_nested_data(UNSERIALIZE_PASSTHRU); } -#line 840 "ext/standard/var_unserializer.c" yy39: yych = *++YYCURSOR; if (yych == '+') goto yy40; @@ -857,7 +844,6 @@ yy41: yych = *++YYCURSOR; if (yych != '"') goto yy18; ++YYCURSOR; -#line 624 "ext/standard/var_unserializer.re" { size_t len, maxlen; zend_string *str; @@ -885,7 +871,6 @@ yy41: ZVAL_STR(rval, str); return 1; } -#line 889 "ext/standard/var_unserializer.c" yy46: yych = *++YYCURSOR; if (yych == '+') goto yy47; @@ -906,7 +891,6 @@ yy48: yych = *++YYCURSOR; if (yych != '"') goto yy18; ++YYCURSOR; -#line 597 "ext/standard/var_unserializer.re" { size_t len, maxlen; char *str; @@ -933,7 +917,6 @@ yy48: ZVAL_STRINGL(rval, str, len); return 1; } -#line 937 "ext/standard/var_unserializer.c" yy53: yych = *++YYCURSOR; if (yych <= '/') { @@ -1021,16 +1004,14 @@ yy61: } yy63: ++YYCURSOR; -#line 588 "ext/standard/var_unserializer.re" { -#if SIZEOF_LONG == 4 +#if SIZEOF_ZEND_INT == 4 use_double: #endif *p = YYCURSOR; ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL)); return 1; } -#line 1034 "ext/standard/var_unserializer.c" yy65: yych = *++YYCURSOR; if (yych <= ',') { @@ -1089,7 +1070,6 @@ yy73: yych = *++YYCURSOR; if (yych != ';') goto yy18; ++YYCURSOR; -#line 572 "ext/standard/var_unserializer.re" { *p = YYCURSOR; @@ -1105,7 +1085,6 @@ yy73: return 1; } -#line 1109 "ext/standard/var_unserializer.c" yy76: yych = *++YYCURSOR; if (yych == 'N') goto yy73; @@ -1132,19 +1111,18 @@ yy79: if (yych <= '9') goto yy79; if (yych != ';') goto yy18; ++YYCURSOR; -#line 546 "ext/standard/var_unserializer.re" { -#if SIZEOF_LONG == 4 +#if SIZEOF_ZEND_INT == 4 int digits = YYCURSOR - start - 3; if (start[2] == '-' || start[2] == '+') { digits--; } - /* Use double for large long values that were serialized on a 64-bit system */ - if (digits >= MAX_LENGTH_OF_LONG - 1) { - if (digits == MAX_LENGTH_OF_LONG - 1) { - int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1); + /* Use double for large php_int_t values that were serialized on a 64-bit system */ + if (digits >= MAX_LENGTH_OF_ZEND_INT - 1) { + if (digits == MAX_LENGTH_OF_ZEND_INT - 1) { + int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_ZEND_INT, int_min_digits, MAX_LENGTH_OF_ZEND_INT - 1); if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) { goto use_double; @@ -1155,10 +1133,9 @@ yy79: } #endif *p = YYCURSOR; - ZVAL_LONG(rval, parse_iv(start + 2)); + ZVAL_INT(rval, parse_iv(start + 2)); return 1; } -#line 1162 "ext/standard/var_unserializer.c" yy83: yych = *++YYCURSOR; if (yych <= '/') goto yy18; @@ -1166,22 +1143,18 @@ yy83: yych = *++YYCURSOR; if (yych != ';') goto yy18; ++YYCURSOR; -#line 540 "ext/standard/var_unserializer.re" { *p = YYCURSOR; ZVAL_BOOL(rval, parse_iv(start + 2)); return 1; } -#line 1176 "ext/standard/var_unserializer.c" yy87: ++YYCURSOR; -#line 534 "ext/standard/var_unserializer.re" { *p = YYCURSOR; ZVAL_NULL(rval); return 1; } -#line 1185 "ext/standard/var_unserializer.c" yy89: yych = *++YYCURSOR; if (yych <= ',') { @@ -1204,9 +1177,8 @@ yy91: if (yych <= '9') goto yy91; if (yych != ';') goto yy18; ++YYCURSOR; -#line 511 "ext/standard/var_unserializer.re" { - long id; + php_int_t id; *p = YYCURSOR; if (!var_hash) return 0; @@ -1227,7 +1199,6 @@ yy91: return 1; } -#line 1231 "ext/standard/var_unserializer.c" yy95: yych = *++YYCURSOR; if (yych <= ',') { @@ -1250,9 +1221,8 @@ yy97: if (yych <= '9') goto yy97; if (yych != ';') goto yy18; ++YYCURSOR; -#line 489 "ext/standard/var_unserializer.re" { - long id; + php_int_t id; *p = YYCURSOR; if (!var_hash) return 0; @@ -1272,9 +1242,7 @@ yy97: return 1; } -#line 1276 "ext/standard/var_unserializer.c" } -#line 828 "ext/standard/var_unserializer.re" return 0; diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re index 5636429c8b..40876563a8 100644 --- a/ext/standard/var_unserializer.re +++ b/ext/standard/var_unserializer.re @@ -28,13 +28,13 @@ typedef struct { zval *data[VAR_ENTRIES_MAX]; - long used_slots; + php_int_t used_slots; void *next; } var_entries; typedef struct { zval data[VAR_ENTRIES_MAX]; - long used_slots; + php_int_t used_slots; void *next; } var_dtor_entries; @@ -117,7 +117,7 @@ PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval *rva PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nzval) { - long i; + php_int_t i; var_entries *var_hash = (*var_hashx)->first; #if VAR_ENTRIES_DBG fprintf(stderr, "var_replace(%ld): %d\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(nzval)); @@ -134,7 +134,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nz } } -static zval *var_access(php_unserialize_data_t *var_hashx, long id) +static zval *var_access(php_unserialize_data_t *var_hashx, php_int_t id) { var_entries *var_hash = (*var_hashx)->first; #if VAR_ENTRIES_DBG @@ -156,7 +156,7 @@ static zval *var_access(php_unserialize_data_t *var_hashx, long id) PHPAPI void var_destroy(php_unserialize_data_t *var_hashx) { void *next; - long i; + php_int_t i; var_entries *var_hash = (*var_hashx)->first; var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor; #if VAR_ENTRIES_DBG @@ -242,10 +242,10 @@ object = [OC]; -static inline long parse_iv2(const unsigned char *p, const unsigned char **q) +static inline php_int_t parse_iv2(const unsigned char *p, const unsigned char **q) { char cursor; - long result = 0; + php_int_t result = 0; int neg = 0; switch (*p) { @@ -270,7 +270,7 @@ static inline long parse_iv2(const unsigned char *p, const unsigned char **q) return result; } -static inline long parse_iv(const unsigned char *p) +static inline php_int_t parse_iv(const unsigned char *p) { return parse_iv2(p, NULL); } @@ -300,7 +300,7 @@ static inline size_t parse_uiv(const unsigned char *p) #define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC #define UNSERIALIZE_PASSTHRU rval, p, max, var_hash TSRMLS_CC -static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops) +static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, php_int_t elements, int objprops) { while (elements-- > 0) { zval key, *data, d, *old_data; @@ -311,7 +311,7 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long return 0; } - if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) { + if (Z_TYPE(key) != IS_INT && Z_TYPE(key) != IS_STRING) { zval_dtor(&key); return 0; } @@ -321,12 +321,12 @@ static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long if (!objprops) { switch (Z_TYPE(key)) { - case IS_LONG: - if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) { + case IS_INT: + if ((old_data = zend_hash_index_find(ht, Z_IVAL(key))) != NULL) { //??? update hash var_push_dtor(var_hash, old_data); } - data = zend_hash_index_update(ht, Z_LVAL(key), &d); + data = zend_hash_index_update(ht, Z_IVAL(key), &d); break; case IS_STRING: if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) { @@ -384,14 +384,14 @@ static inline int finish_nested_data(UNSERIALIZE_PARAMETER) static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { - long datalen; + php_int_t datalen; datalen = parse_iv2((*p) + 2, p); (*p) += 2; if (datalen < 0 || (*p) + datalen >= max) { - zend_error(E_WARNING, "Insufficient data for unserializing - %ld required, %ld present", datalen, (long)(max - (*p))); + zend_error(E_WARNING, "Insufficient data for unserializing - %ld required, %ld present", datalen, (php_int_t)(max - (*p))); return 0; } @@ -407,9 +407,9 @@ static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) return finish_nested_data(UNSERIALIZE_PASSTHRU); } -static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) +static inline php_int_t object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) { - long elements; + php_int_t elements; elements = parse_iv2((*p) + 2, p); @@ -430,7 +430,7 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce) #ifdef PHP_WIN32 # pragma optimize("", off) #endif -static inline int object_common2(UNSERIALIZE_PARAMETER, long elements) +static inline int object_common2(UNSERIALIZE_PARAMETER, php_int_t elements) { zval retval; zval fname; @@ -487,7 +487,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) /*!re2c "R:" iv ";" { - long id; + php_int_t id; *p = YYCURSOR; if (!var_hash) return 0; @@ -509,7 +509,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) } "r:" iv ";" { - long id; + php_int_t id; *p = YYCURSOR; if (!var_hash) return 0; @@ -544,17 +544,17 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) } "i:" iv ";" { -#if SIZEOF_LONG == 4 +#if SIZEOF_ZEND_INT == 4 int digits = YYCURSOR - start - 3; if (start[2] == '-' || start[2] == '+') { digits--; } - /* Use double for large long values that were serialized on a 64-bit system */ - if (digits >= MAX_LENGTH_OF_LONG - 1) { - if (digits == MAX_LENGTH_OF_LONG - 1) { - int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1); + /* Use double for large php_int_t values that were serialized on a 64-bit system */ + if (digits >= MAX_LENGTH_OF_ZEND_INT - 1) { + if (digits == MAX_LENGTH_OF_ZEND_INT - 1) { + int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_ZEND_INT, int_min_digits, MAX_LENGTH_OF_ZEND_INT - 1); if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) { goto use_double; @@ -565,7 +565,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) } #endif *p = YYCURSOR; - ZVAL_LONG(rval, parse_iv(start + 2)); + ZVAL_INT(rval, parse_iv(start + 2)); return 1; } @@ -586,7 +586,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER) } "d:" (iv | nv | nvexp) ";" { -#if SIZEOF_LONG == 4 +#if SIZEOF_ZEND_INT == 4 use_double: #endif *p = YYCURSOR; @@ -650,7 +650,7 @@ use_double: } "a:" uiv ":" "{" { - long elements = parse_iv(start + 2); + php_int_t elements = parse_iv(start + 2); /* use iv() not uiv() in order to check data range */ *p = YYCURSOR; @@ -680,7 +680,7 @@ use_double: object ":" uiv ":" ["] { size_t len, len2, len3, maxlen; - long elements; + php_int_t elements; char *str; zend_string *class_name; zend_class_entry *ce; diff --git a/ext/standard/versioning.c b/ext/standard/versioning.c index 9eb3829a08..85085b0b97 100644 --- a/ext/standard/versioning.c +++ b/ext/standard/versioning.c @@ -221,7 +221,7 @@ PHP_FUNCTION(version_compare) } compare = php_version_compare(v1, v2); if (argc == 2) { - RETURN_LONG(compare); + RETURN_INT(compare); } if (!strncmp(op, "<", op_len) || !strncmp(op, "lt", op_len)) { RETURN_BOOL(compare == -1); diff --git a/main/SAPI.c b/main/SAPI.c index f2a0b26779..9d8a19dc6d 100644 --- a/main/SAPI.c +++ b/main/SAPI.c @@ -290,7 +290,7 @@ SAPI_API SAPI_POST_READER_FUNC(sapi_read_standard_form_data) } if ((SG(post_max_size) > 0) && (SG(read_post_bytes) > SG(post_max_size))) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Actual POST length does not match Content-Length, and exceeds %ld bytes", SG(post_max_size)); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Actual POST length does not match Content-Length, and exceeds " ZEND_INT_FMT " bytes", SG(post_max_size)); break; } @@ -1004,7 +1004,7 @@ SAPI_API int sapi_flush(TSRMLS_D) } } -SAPI_API struct stat *sapi_get_stat(TSRMLS_D) +SAPI_API zend_stat_t *sapi_get_stat(TSRMLS_D) { if (sapi_module.get_stat) { return sapi_module.get_stat(TSRMLS_C); diff --git a/main/SAPI.h b/main/SAPI.h index ac3db56bad..4e67a481c5 100644 --- a/main/SAPI.h +++ b/main/SAPI.h @@ -31,6 +31,7 @@ #include "win32/php_stdint.h" #endif #include <sys/stat.h> +#include "php.h" #define SAPI_OPTION_NO_CHDIR 1 #define SAPI_POST_BLOCK_SIZE 0x4000 @@ -81,7 +82,7 @@ typedef struct { const char *request_method; char *query_string; char *cookie_data; - long content_length; + zend_int_t content_length; char *path_translated; char *request_uri; @@ -124,11 +125,11 @@ typedef struct _sapi_globals_struct { int64_t read_post_bytes; unsigned char post_read; unsigned char headers_sent; - struct stat global_stat; + zend_stat_t global_stat; char *default_mimetype; char *default_charset; HashTable *rfc1867_uploaded_files; - long post_max_size; + zend_int_t post_max_size; int options; zend_bool sapi_started; double global_request_time; @@ -169,7 +170,7 @@ END_EXTERN_C() typedef struct { char *line; /* If you allocated this, you need to free it yourself */ uint line_len; - long response_code; /* long due to zend_parse_parameters compatibility */ + zend_int_t response_code; /* long due to zend_parse_parameters compatibility */ } sapi_header_line; typedef enum { /* Parameter: */ @@ -200,7 +201,7 @@ SAPI_API int sapi_register_treat_data(void (*treat_data)(int arg, char *str, zva SAPI_API int sapi_register_input_filter(unsigned int (*input_filter)(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC), unsigned int (*input_filter_init)(TSRMLS_D) TSRMLS_DC); SAPI_API int sapi_flush(TSRMLS_D); -SAPI_API struct stat *sapi_get_stat(TSRMLS_D); +SAPI_API zend_stat_t *sapi_get_stat(TSRMLS_D); SAPI_API char *sapi_getenv(char *name, size_t name_len TSRMLS_DC); SAPI_API char *sapi_get_default_content_type(TSRMLS_D); @@ -227,9 +228,9 @@ struct _sapi_module_struct { int (*activate)(TSRMLS_D); int (*deactivate)(TSRMLS_D); - int (*ub_write)(const char *str, unsigned int str_length TSRMLS_DC); + php_size_t (*ub_write)(const char *str, php_size_t str_length TSRMLS_DC); void (*flush)(void *server_context TSRMLS_DC); - struct stat *(*get_stat)(TSRMLS_D); + zend_stat_t *(*get_stat)(TSRMLS_D); char *(*getenv)(char *name, size_t name_len TSRMLS_DC); void (*sapi_error)(int type, const char *error_msg, ...); @@ -238,7 +239,7 @@ struct _sapi_module_struct { int (*send_headers)(sapi_headers_struct *sapi_headers TSRMLS_DC); void (*send_header)(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC); - int (*read_post)(char *buffer, uint count_bytes TSRMLS_DC); + php_size_t (*read_post)(char *buffer, php_size_t count_bytes TSRMLS_DC); char *(*read_cookies)(TSRMLS_D); void (*register_server_variables)(zval *track_vars_array TSRMLS_DC); @@ -265,7 +266,7 @@ struct _sapi_module_struct { int (*get_target_uid)(uid_t * TSRMLS_DC); int (*get_target_gid)(gid_t * TSRMLS_DC); - unsigned int (*input_filter)(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC); + unsigned int (*input_filter)(int arg, char *var, char **val, php_size_t val_len, php_size_t *new_val_len TSRMLS_DC); void (*ini_defaults)(HashTable *configuration_hash); int phpinfo_as_text; @@ -299,7 +300,7 @@ struct _sapi_post_entry { #define SAPI_POST_HANDLER_FUNC(post_handler) void post_handler(char *content_type_dup, void *arg TSRMLS_DC) #define SAPI_TREAT_DATA_FUNC(treat_data) void treat_data(int arg, char *str, zval* destArray TSRMLS_DC) -#define SAPI_INPUT_FILTER_FUNC(input_filter) unsigned int input_filter(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC) +#define SAPI_INPUT_FILTER_FUNC(input_filter) unsigned int input_filter(int arg, char *var, char **val, php_size_t val_len, php_size_t *new_val_len TSRMLS_DC) BEGIN_EXTERN_C() SAPI_API SAPI_POST_READER_FUNC(sapi_read_standard_form_data); diff --git a/main/main.c b/main/main.c index 1fd314b582..8f954706cf 100644 --- a/main/main.c +++ b/main/main.c @@ -160,7 +160,9 @@ static php_win32_disable_functions(TSRMLS_D) */ static PHP_INI_MH(OnSetPrecision) { - int i = atoi(new_value); + php_int_t i; + + ZEND_ATOI(i, new_value); if (i >= 0) { EG(precision) = i; return SUCCESS; @@ -279,7 +281,7 @@ static void php_binary_init(TSRMLS_D) if ((envpath = getenv("PATH")) != NULL) { char *search_dir, search_path[MAXPATHLEN]; char *last = NULL; - struct stat s; + php_stat_t s; path = estrdup(envpath); search_dir = php_strtok_r(path, ":", &last); @@ -316,11 +318,11 @@ static PHP_INI_MH(OnUpdateTimeout) { if (stage==PHP_INI_STAGE_STARTUP) { /* Don't set a timeout on startup, only per-request */ - EG(timeout_seconds) = atoi(new_value); + ZEND_ATOI(EG(timeout_seconds), new_value); return SUCCESS; } zend_unset_timeout(TSRMLS_C); - EG(timeout_seconds) = atoi(new_value); + ZEND_ATOI(EG(timeout_seconds), new_value); zend_set_timeout(EG(timeout_seconds), 0); return SUCCESS; } @@ -347,7 +349,7 @@ static int php_get_display_errors_mode(char *value, int value_length) } else if (value_length == 6 && !strcasecmp(value, "stdout")) { mode = PHP_DISPLAY_ERRORS_STDOUT; } else { - mode = atoi(value); + ZEND_ATOI(mode, value); if (mode && mode != PHP_DISPLAY_ERRORS_STDOUT && mode != PHP_DISPLAY_ERRORS_STDERR) { mode = PHP_DISPLAY_ERRORS_STDOUT; } @@ -707,7 +709,7 @@ PHPAPI void php_log_err(char *log_message TSRMLS_DC) /* {{{ php_write wrapper for modules to use PHPWRITE */ -PHPAPI int php_write(void *buf, uint size TSRMLS_DC) +PHPAPI php_size_t php_write(void *buf, php_size_t size TSRMLS_DC) { return PHPWRITE(buf, size); } @@ -715,12 +717,12 @@ PHPAPI int php_write(void *buf, uint size TSRMLS_DC) /* {{{ php_printf */ -PHPAPI int php_printf(const char *format, ...) +PHPAPI php_size_t php_printf(const char *format, ...) { va_list args; - int ret; + php_size_t ret; char *buffer; - int size; + php_size_t size; TSRMLS_FETCH(); va_start(args, format); @@ -1263,7 +1265,7 @@ static void php_error_cb(int type, const char *error_filename, const uint error_ */ PHPAPI char *php_get_current_user(TSRMLS_D) { - struct stat *pstat; + php_stat_t *pstat; if (SG(request_info).current_user) { return SG(request_info).current_user; @@ -1326,16 +1328,16 @@ PHPAPI char *php_get_current_user(TSRMLS_D) Sets the maximum time a script can run */ PHP_FUNCTION(set_time_limit) { - long new_timeout; + php_int_t new_timeout; char *new_timeout_str; int new_timeout_strlen; zend_string *key; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &new_timeout) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &new_timeout) == FAILURE) { return; } - new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, "%ld", new_timeout); + new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, ZEND_INT_FMT, new_timeout); key = STR_INIT("max_execution_time", sizeof("max_execution_time")-1, 0); if (zend_alter_ini_entry_ex(key, new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == SUCCESS) { @@ -1921,7 +1923,7 @@ PHPAPI void php_com_initialize(TSRMLS_D) /* {{{ php_output_wrapper */ -static int php_output_wrapper(const char *str, uint str_length) +static php_size_t php_output_wrapper(const char *str, php_size_t str_length) { TSRMLS_FETCH(); return php_output_write(str, str_length TSRMLS_CC); @@ -2178,17 +2180,17 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod /* Register constants */ REGISTER_MAIN_STRINGL_CONSTANT("PHP_VERSION", PHP_VERSION, sizeof(PHP_VERSION)-1, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_MAJOR_VERSION", PHP_MAJOR_VERSION, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_MINOR_VERSION", PHP_MINOR_VERSION, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_RELEASE_VERSION", PHP_RELEASE_VERSION, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_MAJOR_VERSION", PHP_MAJOR_VERSION, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_MINOR_VERSION", PHP_MINOR_VERSION, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_RELEASE_VERSION", PHP_RELEASE_VERSION, CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("PHP_EXTRA_VERSION", PHP_EXTRA_VERSION, sizeof(PHP_EXTRA_VERSION) - 1, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_VERSION_ID", PHP_VERSION_ID, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_VERSION_ID", PHP_VERSION_ID, CONST_PERSISTENT | CONST_CS); #ifdef ZTS - REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 1, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_ZTS", 1, CONST_PERSISTENT | CONST_CS); #else - REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 0, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_ZTS", 0, CONST_PERSISTENT | CONST_CS); #endif - REGISTER_MAIN_LONG_CONSTANT("PHP_DEBUG", PHP_DEBUG, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_DEBUG", PHP_DEBUG, CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("PHP_OS", php_os, strlen(php_os), CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("PHP_SAPI", sapi_module.name, strlen(sapi_module.name), CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("DEFAULT_INCLUDE_PATH", PHP_INCLUDE_PATH, sizeof(PHP_INCLUDE_PATH)-1, CONST_PERSISTENT | CONST_CS); @@ -2208,23 +2210,23 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod REGISTER_MAIN_STRINGL_CONSTANT("PHP_CONFIG_FILE_SCAN_DIR", PHP_CONFIG_FILE_SCAN_DIR, sizeof(PHP_CONFIG_FILE_SCAN_DIR)-1, CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("PHP_SHLIB_SUFFIX", PHP_SHLIB_SUFFIX, sizeof(PHP_SHLIB_SUFFIX)-1, CONST_PERSISTENT | CONST_CS); REGISTER_MAIN_STRINGL_CONSTANT("PHP_EOL", PHP_EOL, sizeof(PHP_EOL)-1, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_MAXPATHLEN", MAXPATHLEN, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_INT_MAX", LONG_MAX, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_INT_MIN", LONG_MIN, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_INT_SIZE", sizeof(long), CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_MAXPATHLEN", MAXPATHLEN, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_INT_MAX", PHP_INT_MAX, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_INT_MIN", PHP_INT_MIN, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_INT_SIZE", SIZEOF_ZEND_INT, CONST_PERSISTENT | CONST_CS); #ifdef PHP_WIN32 - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MAJOR", EG(windows_version_info).dwMajorVersion, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MINOR", EG(windows_version_info).dwMinorVersion, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_BUILD", EG(windows_version_info).dwBuildNumber, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PLATFORM", EG(windows_version_info).dwPlatformId, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MAJOR", EG(windows_version_info).wServicePackMajor, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MINOR", EG(windows_version_info).wServicePackMinor, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SUITEMASK", EG(windows_version_info).wSuiteMask, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PRODUCTTYPE", EG(windows_version_info).wProductType, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_DOMAIN_CONTROLLER", VER_NT_DOMAIN_CONTROLLER, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_SERVER", VER_NT_SERVER, CONST_PERSISTENT | CONST_CS); - REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_WORKSTATION", VER_NT_WORKSTATION, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_MAJOR", EG(windows_version_info).dwMajorVersion, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_MINOR", EG(windows_version_info).dwMinorVersion, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_BUILD", EG(windows_version_info).dwBuildNumber, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_PLATFORM", EG(windows_version_info).dwPlatformId, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SP_MAJOR", EG(windows_version_info).wServicePackMajor, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SP_MINOR", EG(windows_version_info).wServicePackMinor, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SUITEMASK", EG(windows_version_info).wSuiteMask, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_PRODUCTTYPE", EG(windows_version_info).wProductType, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_DOMAIN_CONTROLLER", VER_NT_DOMAIN_CONTROLLER, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_SERVER", VER_NT_SERVER, CONST_PERSISTENT | CONST_CS); + REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_WORKSTATION", VER_NT_WORKSTATION, CONST_PERSISTENT | CONST_CS); #endif php_binary_init(TSRMLS_C); @@ -2372,9 +2374,9 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod const char **p = directives[i].directives; while(*p) { - long value; + php_int_t value; - if (cfg_get_long((char*)*p, &value) == SUCCESS && value) { + if (cfg_get_int((char*)*p, &value) == SUCCESS && value) { zend_error(directives[i].error_level, directives[i].phrase, *p); } diff --git a/main/network.c b/main/network.c index 74855064d7..14db63a21b 100644 --- a/main/network.c +++ b/main/network.c @@ -507,7 +507,7 @@ bound: } /* }}} */ -PHPAPI int php_network_parse_network_address_with_port(const char *addr, long addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC) +PHPAPI int php_network_parse_network_address_with_port(const char *addr, php_int_t addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC) { char *colon; char *tmp; @@ -1108,7 +1108,7 @@ PHPAPI php_stream *_php_stream_sock_open_host(const char *host, unsigned short p int socktype, struct timeval *timeout, const char *persistent_id STREAMS_DC TSRMLS_DC) { char *res; - long reslen; + php_int_t reslen; php_stream *stream; reslen = spprintf(&res, 0, "tcp://%s:%d", host, port); diff --git a/main/output.c b/main/output.c index 41b2c65cdf..f2cd4d4fbe 100644 --- a/main/output.c +++ b/main/output.c @@ -199,20 +199,20 @@ PHPAPI void php_output_deactivate(TSRMLS_D) /* {{{ void php_output_register_constants() */ PHPAPI void php_output_register_constants(TSRMLS_D) { - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_WRITE", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FLUSH", PHP_OUTPUT_HANDLER_FLUSH, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEAN", PHP_OUTPUT_HANDLER_CLEAN, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FINAL", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_WRITE", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FLUSH", PHP_OUTPUT_HANDLER_FLUSH, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CLEAN", PHP_OUTPUT_HANDLER_CLEAN, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FINAL", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEANABLE", PHP_OUTPUT_HANDLER_CLEANABLE, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FLUSHABLE", PHP_OUTPUT_HANDLER_FLUSHABLE, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_REMOVABLE", PHP_OUTPUT_HANDLER_REMOVABLE, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STDFLAGS", PHP_OUTPUT_HANDLER_STDFLAGS, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STARTED", PHP_OUTPUT_HANDLER_STARTED, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_DISABLED", PHP_OUTPUT_HANDLER_DISABLED, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CLEANABLE", PHP_OUTPUT_HANDLER_CLEANABLE, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FLUSHABLE", PHP_OUTPUT_HANDLER_FLUSHABLE, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_REMOVABLE", PHP_OUTPUT_HANDLER_REMOVABLE, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_STDFLAGS", PHP_OUTPUT_HANDLER_STDFLAGS, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_STARTED", PHP_OUTPUT_HANDLER_STARTED, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_DISABLED", PHP_OUTPUT_HANDLER_DISABLED, CONST_CS | CONST_PERSISTENT); } /* }}} */ @@ -404,7 +404,7 @@ PHPAPI int php_output_get_contents(zval *p TSRMLS_DC) PHPAPI int php_output_get_length(zval *p TSRMLS_DC) { if (OG(active)) { - ZVAL_LONG(p, OG(active)->buffer.used); + ZVAL_INT(p, OG(active)->buffer.used); return SUCCESS; } else { ZVAL_NULL(p); @@ -501,8 +501,8 @@ PHPAPI php_output_handler *php_output_handler_create_user(zval *output_handler, handler = php_output_handler_create_internal(ZEND_STRL(php_output_default_handler_name), php_output_handler_default_func, chunk_size, flags TSRMLS_CC); break; case IS_STRING: - if (Z_STRLEN_P(output_handler) && (alias = php_output_handler_alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler) TSRMLS_CC))) { - handler = alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler), chunk_size, flags TSRMLS_CC); + if (Z_STRSIZE_P(output_handler) && (alias = php_output_handler_alias(Z_STRVAL_P(output_handler), Z_STRSIZE_P(output_handler) TSRMLS_CC))) { + handler = alias(Z_STRVAL_P(output_handler), Z_STRSIZE_P(output_handler), chunk_size, flags TSRMLS_CC); break; } default: @@ -973,7 +973,7 @@ static inline php_output_handler_status_t php_output_handler_op(php_output_handl zval retval, ob_data, ob_mode; ZVAL_STRINGL(&ob_data, handler->buffer.data, handler->buffer.used); - ZVAL_LONG(&ob_mode, (long) context->op); + ZVAL_INT(&ob_mode, (long) context->op); zend_fcall_info_argn(&handler->func.user->fci TSRMLS_CC, 2, &ob_data, &ob_mode); #define PHP_OUTPUT_USER_SUCCESS(retval) ((Z_TYPE(retval) != IS_UNDEF) && !(Z_TYPE(retval) == IS_FALSE)) @@ -982,9 +982,9 @@ static inline php_output_handler_status_t php_output_handler_op(php_output_handl status = PHP_OUTPUT_HANDLER_NO_DATA; if (Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) { convert_to_string_ex(&retval); - if (Z_STRLEN(retval)) { - context->out.data = estrndup(Z_STRVAL(retval), Z_STRLEN(retval)); - context->out.used = Z_STRLEN(retval); + if (Z_STRSIZE(retval)) { + context->out.data = estrndup(Z_STRVAL(retval), Z_STRSIZE(retval)); + context->out.used = Z_STRSIZE(retval); context->out.free = 1; status = PHP_OUTPUT_HANDLER_SUCCESS; } @@ -1197,12 +1197,12 @@ static inline zval *php_output_handler_status(php_output_handler *handler, zval array_init(entry); add_assoc_str(entry, "name", STR_COPY(handler->name)); - add_assoc_long(entry, "type", (long) (handler->flags & 0xf)); - add_assoc_long(entry, "flags", (long) handler->flags); - add_assoc_long(entry, "level", (long) handler->level); - add_assoc_long(entry, "chunk_size", (long) handler->size); - add_assoc_long(entry, "buffer_size", (long) handler->buffer.size); - add_assoc_long(entry, "buffer_used", (long) handler->buffer.used); + add_assoc_int(entry, "type", (php_int_t) (handler->flags & 0xf)); + add_assoc_int(entry, "flags", (php_int_t) handler->flags); + add_assoc_int(entry, "level", (php_int_t) handler->level); + add_assoc_int(entry, "chunk_size", (php_int_t) handler->size); + add_assoc_int(entry, "buffer_size", (php_int_t) handler->buffer.size); + add_assoc_int(entry, "buffer_used", (php_int_t) handler->buffer.used); return entry; } @@ -1316,8 +1316,8 @@ static int php_output_handler_devnull_func(void **handler_context, php_output_co PHP_FUNCTION(ob_start) { zval *output_handler = NULL; - long chunk_size = 0; - long flags = PHP_OUTPUT_HANDLER_STDFLAGS; + php_int_t chunk_size = 0; + php_int_t flags = PHP_OUTPUT_HANDLER_STDFLAGS; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z/ll", &output_handler, &chunk_size, &flags) == FAILURE) { return; @@ -1475,7 +1475,7 @@ PHP_FUNCTION(ob_get_level) return; } - RETURN_LONG(php_output_get_level(TSRMLS_C)); + RETURN_INT(php_output_get_level(TSRMLS_C)); } /* }}} */ @@ -1539,7 +1539,7 @@ PHP_FUNCTION(ob_get_status) Turn implicit flush on/off and is equivalent to calling flush() after every output call */ PHP_FUNCTION(ob_implicit_flush) { - long flag = 1; + php_int_t flag = 1; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flag) == FAILURE) { return; diff --git a/main/php.h b/main/php.h index f9cfd2d7f2..68e94869e0 100644 --- a/main/php.h +++ b/main/php.h @@ -66,6 +66,14 @@ # define PHP_EOL "\n" #endif +#define php_size_t zend_size_t +#define php_int_t zend_int_t +#define php_uint_t zend_uint_t +#define PHP_INT_MAX ZEND_INT_MAX +#define PHP_INT_MIN ZEND_INT_MIN +#define PHP_UINT_MAX ZEND_UINT_MAX +#define PHP_SIZE_MAX ZEND_SIZE_MAX + #ifdef NETWARE /* For php_get_uname() function */ #define PHP_UNAME "NetWare" @@ -280,8 +288,8 @@ ssize_t pread(int, void *, size_t, off64_t); BEGIN_EXTERN_C() void phperror(char *error); -PHPAPI int php_write(void *buf, uint size TSRMLS_DC); -PHPAPI int php_printf(const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 1, +PHPAPI php_size_t php_write(void *buf, php_size_t size TSRMLS_DC); +PHPAPI php_size_t php_printf(const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 1, 2); PHPAPI int php_get_module_initialized(void); PHPAPI void php_log_err(char *log_message TSRMLS_DC); diff --git a/main/php_globals.h b/main/php_globals.h index 9baabf757c..defb220c76 100644 --- a/main/php_globals.h +++ b/main/php_globals.h @@ -56,7 +56,7 @@ typedef struct _arg_separators { struct _php_core_globals { zend_bool implicit_flush; - long output_buffering; + zend_int_t output_buffering; zend_bool sql_safe_mode; zend_bool enable_dl; @@ -64,16 +64,16 @@ struct _php_core_globals { char *output_handler; char *unserialize_callback_func; - long serialize_precision; + zend_int_t serialize_precision; - long memory_limit; - long max_input_time; + zend_int_t memory_limit; + zend_int_t max_input_time; zend_bool track_errors; zend_bool display_errors; zend_bool display_startup_errors; zend_bool log_errors; - long log_errors_max_len; + zend_int_t log_errors_max_len; zend_bool ignore_repeated_errors; zend_bool ignore_repeated_source; zend_bool report_memleaks; @@ -88,7 +88,7 @@ struct _php_core_globals { char *sys_temp_dir; char *upload_tmp_dir; - long upload_max_filesize; + zend_int_t upload_max_filesize; char *error_append_string; char *error_prepend_string; @@ -126,7 +126,7 @@ struct _php_core_globals { zend_bool html_errors; zend_bool xmlrpc_errors; - long xmlrpc_error_number; + zend_int_t xmlrpc_error_number; zend_bool activated_auto_globals[8]; @@ -149,12 +149,12 @@ struct _php_core_globals { #ifdef PHP_WIN32 zend_bool com_initialized; #endif - long max_input_nesting_level; - long max_input_vars; + zend_int_t max_input_nesting_level; + zend_int_t max_input_vars; zend_bool in_user_include; char *user_ini_filename; - long user_ini_cache_ttl; + zend_int_t user_ini_cache_ttl; char *request_order; diff --git a/main/php_ini.c b/main/php_ini.c index cdd4a61fb5..54944483d2 100644 --- a/main/php_ini.c +++ b/main/php_ini.c @@ -233,10 +233,10 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t /* PHP and Zend extensions are not added into configuration hash! */ if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), PHP_EXTENSION_TOKEN)) { /* load PHP extension */ - extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2)); + extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRSIZE_P(arg2)); zend_llist_add_element(&extension_lists.functions, &extension_name); } else if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */ - extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2)); + extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRSIZE_P(arg2)); zend_llist_add_element(&extension_lists.engine, &extension_name); /* All other entries are added into either configuration_hash or active ini section array */ @@ -267,7 +267,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t } /* arg3 is possible option offset name */ - if (arg3 && Z_STRLEN_P(arg3) > 0) { + if (arg3 && Z_STRSIZE_P(arg3) > 0) { entry = zend_symtable_update(Z_ARRVAL_P(find_arr), Z_STR_P(arg3), arg2); } else { entry = zend_hash_next_index_insert(Z_ARRVAL_P(find_arr), arg2); @@ -287,7 +287,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t if (!strncasecmp(Z_STRVAL_P(arg1), "PATH", sizeof("PATH") - 1)) { key = Z_STRVAL_P(arg1); key = key + sizeof("PATH") - 1; - key_len = Z_STRLEN_P(arg1) - sizeof("PATH") + 1; + key_len = Z_STRSIZE_P(arg1) - sizeof("PATH") + 1; is_special_section = 1; has_per_dir_config = 1; @@ -298,7 +298,7 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t } else if (!strncasecmp(Z_STRVAL_P(arg1), "HOST", sizeof("HOST") - 1)) { key = Z_STRVAL_P(arg1); key = key + sizeof("HOST") - 1; - key_len = Z_STRLEN_P(arg1) - sizeof("HOST") + 1; + key_len = Z_STRSIZE_P(arg1) - sizeof("HOST") + 1; is_special_section = 1; has_per_host_config = 1; zend_str_tolower(key, key_len); /* host names are case-insensitive. */ @@ -545,7 +545,7 @@ int php_init_config(TSRMLS_D) /* Check if php_ini_file_name is a file and can be opened */ if (php_ini_file_name && php_ini_file_name[0]) { - struct stat statbuf; + php_stat_t statbuf; if (!VCWD_STAT(php_ini_file_name, &statbuf)) { if (!((statbuf.st_mode & S_IFMT) == S_IFDIR)) { @@ -598,7 +598,7 @@ int php_init_config(TSRMLS_D) if (php_ini_opened_path) { efree(php_ini_opened_path); } - php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRLEN(tmp)); + php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRSIZE(tmp)); } } @@ -614,7 +614,7 @@ int php_init_config(TSRMLS_D) if (!sapi_module.php_ini_ignore && php_ini_scanned_path_len) { struct dirent **namelist; int ndir, i; - struct stat sb; + php_stat_t sb; char ini_file[MAXPATHLEN]; char *p; zend_file_handle fh2; @@ -744,7 +744,7 @@ void php_ini_register_extensions(TSRMLS_D) */ PHPAPI int php_parse_user_ini_file(const char *dirname, char *ini_filename, HashTable *target_hash TSRMLS_DC) { - struct stat sb; + php_stat_t sb; char ini_file[MAXPATHLEN]; zend_file_handle fh; @@ -778,7 +778,7 @@ PHPAPI void php_ini_activate_config(HashTable *source_hash, int modify_type, int { zend_string *str; zval *data; - ulong num_index; + zend_uint_t num_index; /* Walk through config hash and alter matching ini entries using the values found in the hash */ for (zend_hash_internal_pointer_reset(source_hash); @@ -786,7 +786,7 @@ PHPAPI void php_ini_activate_config(HashTable *source_hash, int modify_type, int zend_hash_move_forward(source_hash) ) { data = zend_hash_get_current_data(source_hash); - zend_alter_ini_entry_ex(str, Z_STRVAL_P(data), Z_STRLEN_P(data), modify_type, stage, 0 TSRMLS_CC); + zend_alter_ini_entry_ex(str, Z_STRVAL_P(data), Z_STRSIZE_P(data), modify_type, stage, 0 TSRMLS_CC); } } /* }}} */ @@ -873,9 +873,9 @@ PHPAPI zval *cfg_get_entry(const char *name, uint name_length) } /* }}} */ -/* {{{ cfg_get_long +/* {{{ cfg_get_int */ -PHPAPI int cfg_get_long(const char *varname, long *result) +PHPAPI int cfg_get_int(const char *varname, zend_int_t *result) { zval *tmp, var; @@ -884,8 +884,8 @@ PHPAPI int cfg_get_long(const char *varname, long *result) return FAILURE; } ZVAL_DUP(&var, tmp); - convert_to_long(&var); - *result = Z_LVAL(var); + convert_to_int(&var); + *result = Z_IVAL(var); return SUCCESS; } /* }}} */ diff --git a/main/php_ini.h b/main/php_ini.h index 4159e7591f..491ad1cbd8 100644 --- a/main/php_ini.h +++ b/main/php_ini.h @@ -29,7 +29,7 @@ int php_init_config(TSRMLS_D); int php_shutdown_config(void); void php_ini_register_extensions(TSRMLS_D); PHPAPI zval *cfg_get_entry(const char *name, uint name_length); -PHPAPI int cfg_get_long(const char *varname, long *result); +PHPAPI int cfg_get_int(const char *varname, zend_int_t *result); PHPAPI int cfg_get_double(const char *varname, double *result); PHPAPI int cfg_get_string(const char *varname, char **result); PHPAPI int php_parse_user_ini_file(const char *dirname, char *ini_filename, HashTable *target_hash TSRMLS_DC); @@ -83,7 +83,7 @@ END_EXTERN_C() #define php_alter_ini_entry zend_alter_ini_entry -#define php_ini_long zend_ini_long +#define php_ini_long zend_ini_int #define php_ini_double zend_ini_double #define php_ini_string zend_ini_string diff --git a/main/php_network.h b/main/php_network.h index 3a0062c437..cc6e1c54e7 100644 --- a/main/php_network.h +++ b/main/php_network.h @@ -306,7 +306,7 @@ PHPAPI void php_network_populate_name_from_sockaddr( TSRMLS_DC); PHPAPI int php_network_parse_network_address_with_port(const char *addr, - long addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC); + php_int_t addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC); END_EXTERN_C() #define php_stream_sock_open_from_socket(socket, persistent) _php_stream_sock_open_from_socket((socket), (persistent) STREAMS_CC TSRMLS_CC) diff --git a/main/php_streams.h b/main/php_streams.h index 38215a67b0..229f8f49e0 100644 --- a/main/php_streams.h +++ b/main/php_streams.h @@ -103,8 +103,18 @@ typedef struct _php_stream_filter php_stream_filter; #include "streams/php_stream_context.h" #include "streams/php_stream_filter_api.h" +#ifdef _WIN64 +# define php_fstat _fstat64 +# define php_stat_fn _stat64 +typedef struct __stat64 php_stat_t; +#else +# define php_fstat fstat +# define php_stat_fn stat +typedef struct stat php_stat_t; +#endif + typedef struct _php_stream_statbuf { - struct stat sb; /* regular info */ + zend_stat_t sb; /* regular info */ /* extended info to go here some day: content-type etc. etc. */ } php_stream_statbuf; @@ -123,7 +133,7 @@ typedef struct _php_stream_ops { const char *label; /* label for this ops structure */ /* these are optional */ - int (*seek)(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC); + int (*seek)(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset TSRMLS_DC); int (*cast)(php_stream *stream, int castas, void **ret TSRMLS_DC); int (*stat)(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC); int (*set_option)(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC); @@ -209,11 +219,11 @@ struct _php_stream { int flags; /* PHP_STREAM_FLAG_XXX */ /* buffer */ - off_t position; /* of underlying stream */ + zend_off_t position; /* of underlying stream */ unsigned char *readbuf; size_t readbuflen; - off_t readpos; - off_t writepos; + zend_off_t readpos; + zend_off_t writepos; /* how much data to read when filling buffer */ size_t chunk_size; @@ -279,11 +289,11 @@ PHPAPI int _php_stream_free(php_stream *stream, int close_options TSRMLS_DC); #define php_stream_close(stream) _php_stream_free((stream), PHP_STREAM_FREE_CLOSE TSRMLS_CC) #define php_stream_pclose(stream) _php_stream_free((stream), PHP_STREAM_FREE_CLOSE_PERSISTENT TSRMLS_CC) -PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC); +PHPAPI int _php_stream_seek(php_stream *stream, zend_off_t offset, int whence TSRMLS_DC); #define php_stream_rewind(stream) _php_stream_seek((stream), 0L, SEEK_SET TSRMLS_CC) #define php_stream_seek(stream, offset, whence) _php_stream_seek((stream), (offset), (whence) TSRMLS_CC) -PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC); +PHPAPI zend_off_t _php_stream_tell(php_stream *stream TSRMLS_DC); #define php_stream_tell(stream) _php_stream_tell((stream) TSRMLS_CC) PHPAPI size_t _php_stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC); diff --git a/main/php_variables.c b/main/php_variables.c index 3bb6d65aa5..8a38e97d60 100644 --- a/main/php_variables.c +++ b/main/php_variables.c @@ -43,7 +43,7 @@ PHPAPI void php_register_variable(char *var, char *strval, zval *track_vars_arra } /* binary-safe version */ -PHPAPI void php_register_variable_safe(char *var, char *strval, int str_len, zval *track_vars_array TSRMLS_DC) +PHPAPI void php_register_variable_safe(char *var, char *strval, php_size_t str_len, zval *track_vars_array TSRMLS_DC) { zval new_entry; assert(strval != NULL); @@ -141,7 +141,7 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars /* do not output the error message to the screen, this helps us to to avoid "information disclosure" */ if (!PG(display_errors)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded %ld. To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level)); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded " ZEND_INT_FMT ". To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level)); } free_alloca(var_orig, use_heap); return; @@ -246,7 +246,7 @@ static zend_bool add_post_var(zval *arr, post_var_data_t *var, zend_bool eof TSR char *ksep, *vsep; size_t klen, vlen; /* FIXME: string-size_t */ - unsigned int new_vlen; + php_size_t new_vlen; if (var->ptr >= var->end) { return 0; @@ -442,13 +442,13 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data) } if (++count > PG(max_input_vars)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded %ld. To increase the limit change max_input_vars in php.ini.", PG(max_input_vars)); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded " ZEND_INT_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars)); break; } if (val) { /* have a value */ - int val_len; - unsigned int new_val_len; + php_size_t val_len; + php_size_t new_val_len; *val++ = '\0'; php_url_decode(var, strlen(var)); @@ -459,8 +459,8 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data) } efree(val); } else { - int val_len; - unsigned int new_val_len; + php_size_t val_len; + php_size_t new_val_len; php_url_decode(var, strlen(var)); val_len = 0; @@ -562,9 +562,9 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC) /* prepare argc */ if (SG(request_info).argc) { - ZVAL_LONG(&argc, SG(request_info).argc); + ZVAL_INT(&argc, SG(request_info).argc); } else { - ZVAL_LONG(&argc, count); + ZVAL_INT(&argc, count); } if (SG(request_info).argc) { @@ -608,7 +608,7 @@ static inline void php_register_server_variables(TSRMLS_D) zval request_time_float, request_time_long; ZVAL_DOUBLE(&request_time_float, sapi_get_request_time(TSRMLS_C)); php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC); - ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float))); + ZVAL_INT(&request_time_long, zend_dval_to_ival(Z_DVAL(request_time_float))); php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC); } @@ -621,7 +621,7 @@ static void php_autoglobal_merge(HashTable *dest, HashTable *src TSRMLS_DC) { zval *src_entry, *dest_entry; zend_string *string_key; - ulong num_key; + php_uint_t num_key; int globals_check = (dest == (&EG(symbol_table).ht)); ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) { diff --git a/main/php_variables.h b/main/php_variables.h index 2331c582e6..c33308b5a2 100644 --- a/main/php_variables.h +++ b/main/php_variables.h @@ -38,7 +38,7 @@ void php_startup_auto_globals(TSRMLS_D); extern PHPAPI void (*php_import_environment_variables)(zval *array_ptr TSRMLS_DC); PHPAPI void php_register_variable(char *var, char *val, zval *track_vars_array TSRMLS_DC); /* binary-safe version */ -PHPAPI void php_register_variable_safe(char *var, char *val, int val_len, zval *track_vars_array TSRMLS_DC); +PHPAPI void php_register_variable_safe(char *var, char *val, php_size_t val_len, zval *track_vars_array TSRMLS_DC); PHPAPI void php_register_variable_ex(char *var, zval *val, zval *track_vars_array TSRMLS_DC); PHPAPI int php_hash_environment(TSRMLS_D); diff --git a/main/rfc1867.c b/main/rfc1867.c index 3347a69ac8..2d76d6c975 100644 --- a/main/rfc1867.c +++ b/main/rfc1867.c @@ -58,7 +58,7 @@ static php_rfc1867_basename_t php_rfc1867_basename = NULL; PHPAPI int (*php_rfc1867_callback)(unsigned int event, void *event_data, void **extra TSRMLS_DC) = NULL; -static void safe_php_register_variable(char *var, char *strval, int val_len, zval *track_vars_array, zend_bool override_protection TSRMLS_DC); +static void safe_php_register_variable(char *var, char *strval, php_size_t val_len, zval *track_vars_array, zend_bool override_protection TSRMLS_DC); /* The longest property name we use in an uploaded file array */ #define MAX_SIZE_OF_INDEX sizeof("[tmp_name]") @@ -78,14 +78,14 @@ static void safe_php_register_variable(char *var, char *strval, int val_len, zva void php_rfc1867_register_constants(TSRMLS_D) /* {{{ */ { - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_OK", UPLOAD_ERROR_OK, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_INI_SIZE", UPLOAD_ERROR_A, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_FORM_SIZE", UPLOAD_ERROR_B, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_PARTIAL", UPLOAD_ERROR_C, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_FILE", UPLOAD_ERROR_D, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_TMP_DIR", UPLOAD_ERROR_E, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_CANT_WRITE", UPLOAD_ERROR_F, CONST_CS | CONST_PERSISTENT); - REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_EXTENSION", UPLOAD_ERROR_X, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_OK", UPLOAD_ERROR_OK, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_INI_SIZE", UPLOAD_ERROR_A, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_FORM_SIZE", UPLOAD_ERROR_B, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_PARTIAL", UPLOAD_ERROR_C, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_NO_FILE", UPLOAD_ERROR_D, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_NO_TMP_DIR", UPLOAD_ERROR_E, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_CANT_WRITE", UPLOAD_ERROR_F, CONST_CS | CONST_PERSISTENT); + REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_EXTENSION", UPLOAD_ERROR_X, CONST_CS | CONST_PERSISTENT); } /* }}} */ @@ -161,7 +161,7 @@ static zend_bool is_protected_variable(char *varname TSRMLS_DC) /* {{{ */ } /* }}} */ -static void safe_php_register_variable(char *var, char *strval, int val_len, zval *track_vars_array, zend_bool override_protection TSRMLS_DC) /* {{{ */ +static void safe_php_register_variable(char *var, char *strval, php_size_t val_len, zval *track_vars_array, zend_bool override_protection TSRMLS_DC) /* {{{ */ { if (override_protection || !is_protected_variable(var TSRMLS_CC)) { php_register_variable_safe(var, strval, val_len, track_vars_array TSRMLS_CC); @@ -611,9 +611,9 @@ static void *php_ap_memstr(char *haystack, int haystacklen, char *needle, int ne } /* read until a boundary condition */ -static int multipart_buffer_read(multipart_buffer *self, char *buf, int bytes, int *end TSRMLS_DC) +static int multipart_buffer_read(multipart_buffer *self, char *buf, php_size_t bytes, int *end TSRMLS_DC) { - int len, max; + php_size_t len, max; char *bound; /* fill buffer if needed */ @@ -657,7 +657,7 @@ static int multipart_buffer_read(multipart_buffer *self, char *buf, int bytes, i XXX: this is horrible memory-usage-wise, but we only expect to do this on small pieces of form data. */ -static char *multipart_buffer_read_body(multipart_buffer *self, unsigned int *len TSRMLS_DC) +static char *multipart_buffer_read_body(multipart_buffer *self, php_size_t *len TSRMLS_DC) { char buf[FILLUNIT], *out=NULL; int total_bytes=0, read_bytes=0; @@ -701,7 +701,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ php_rfc1867_getword_t getword; php_rfc1867_getword_conf_t getword_conf; php_rfc1867_basename_t _basename; - long count = 0; + php_int_t count = 0; if (php_rfc1867_encoding_translation(TSRMLS_C) && internal_encoding) { getword = php_rfc1867_getword; @@ -714,7 +714,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ } if (SG(post_max_size) > 0 && SG(request_info).content_length > SG(post_max_size)) { - sapi_module.sapi_error(E_WARNING, "POST Content-Length of %ld bytes exceeds the limit of %ld bytes", SG(request_info).content_length, SG(post_max_size)); + sapi_module.sapi_error(E_WARNING, "POST Content-Length of " ZEND_INT_FMT " bytes exceeds the limit of " ZEND_INT_FMT " bytes", SG(request_info).content_length, SG(post_max_size)); return; } @@ -787,7 +787,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ char buff[FILLUNIT]; char *cd = NULL, *param = NULL, *filename = NULL, *tmp = NULL; size_t blen = 0, wlen = 0; - off_t offset; + zend_off_t offset; zend_llist_clean(&header); @@ -850,9 +850,9 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ /* Normal form variable, safe to read all data into memory */ if (!filename && param) { - unsigned int value_len; + php_size_t value_len; char *value = multipart_buffer_read_body(mbuff, &value_len TSRMLS_CC); - unsigned int new_val_len; /* Dummy variable */ + php_size_t new_val_len; /* Dummy variable */ if (!value) { value = estrdup(""); @@ -889,7 +889,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ safe_php_register_variable(param, value, new_val_len, array_ptr, 0 TSRMLS_CC); } else { if (count == PG(max_input_vars) + 1) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded %ld. To increase the limit change max_input_vars in php.ini.", PG(max_input_vars)); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded " ZEND_INT_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars)); } if (php_rfc1867_callback != NULL) { @@ -1034,14 +1034,14 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ } } - if (PG(upload_max_filesize) > 0 && (long)(total_bytes+blen) > PG(upload_max_filesize)) { + if (PG(upload_max_filesize) > 0 && (php_int_t)(total_bytes+blen) > PG(upload_max_filesize)) { #if DEBUG_FILE_UPLOAD - sapi_module.sapi_error(E_NOTICE, "upload_max_filesize of %ld bytes exceeded - file [%s=%s] not saved", PG(upload_max_filesize), param, filename); + sapi_module.sapi_error(E_NOTICE, "upload_max_filesize of " ZEND_INT_FMT " bytes exceeded - file [%s=%s] not saved", PG(upload_max_filesize), param, filename); #endif cancel_upload = UPLOAD_ERROR_A; - } else if (max_file_size && ((long)(total_bytes+blen) > max_file_size)) { + } else if (max_file_size && ((php_int_t)(total_bytes+blen) > max_file_size)) { #if DEBUG_FILE_UPLOAD - sapi_module.sapi_error(E_NOTICE, "MAX_FILE_SIZE of %ld bytes exceeded - file [%s=%s] not saved", max_file_size, param, filename); + sapi_module.sapi_error(E_NOTICE, "MAX_FILE_SIZE of " ZEND_INT_FMT " bytes exceeded - file [%s=%s] not saved", max_file_size, param, filename); #endif cancel_upload = UPLOAD_ERROR_B; } else if (blen > 0) { @@ -1224,13 +1224,13 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ int size_overflow = 0; char file_size_buf[65]; - ZVAL_LONG(&error_type, cancel_upload); + ZVAL_INT(&error_type, cancel_upload); /* Add $foo[error] */ if (cancel_upload) { - ZVAL_LONG(&file_size, 0); + ZVAL_INT(&file_size, 0); } else { - if (total_bytes > LONG_MAX) { + if (total_bytes > ZEND_INT_MAX) { #ifdef PHP_WIN32 if (_i64toa_s(total_bytes, file_size_buf, 65, 10)) { file_size_buf[0] = '0'; @@ -1245,7 +1245,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ size_overflow = 1; } else { - ZVAL_LONG(&file_size, total_bytes); + ZVAL_INT(&file_size, total_bytes); } } diff --git a/main/rfc1867.h b/main/rfc1867.h index 1d47165851..b76e3598f5 100644 --- a/main/rfc1867.h +++ b/main/rfc1867.h @@ -51,7 +51,7 @@ typedef struct _multipart_event_file_start { typedef struct _multipart_event_file_data { size_t post_bytes_processed; - off_t offset; + zend_off_t offset; char *data; size_t length; size_t *newlength; diff --git a/main/snprintf.c b/main/snprintf.c index 914cac7133..7a55034341 100644 --- a/main/snprintf.c +++ b/main/snprintf.c @@ -312,7 +312,7 @@ PHPAPI char *php_gcvt(double value, int ndigit, char dec_point, char exponent, c */ /* char * ap_php_conv_10() {{{ */ char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned, - register bool_int * is_negative, char *buf_end, register int *len) + register bool_int * is_negative, char *buf_end, register php_size_t *len) { register char *p = buf_end; register u_wide_int magnitude; @@ -370,7 +370,7 @@ char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned, */ /* PHPAPI char * php_conv_fp() {{{ */ PHPAPI char * php_conv_fp(register char format, register double num, - boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, int *len) + boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, php_size_t *len) { register char *s = buf; register char *p, *p_orig; @@ -438,7 +438,7 @@ PHPAPI char * php_conv_fp(register char format, register double num, if (format != 'F') { char temp[EXPONENT_LENGTH]; /* for exponent conversion */ - int t_len; + php_size_t t_len; bool_int exponent_is_negative; *s++ = format; /* either e or E */ @@ -474,7 +474,7 @@ PHPAPI char * php_conv_fp(register char format, register double num, * which is a pointer to the END of the buffer + 1 (i.e. if the buffer * is declared as buf[ 100 ], buf_end should be &buf[ 100 ]) */ -char * ap_php_conv_p2(register u_wide_int num, register int nbits, char format, char *buf_end, register int *len) /* {{{ */ +char * ap_php_conv_p2(register u_wide_int num, register int nbits, char format, char *buf_end, register php_size_t *len) /* {{{ */ { register int mask = (1 << nbits) - 1; register char *p = buf_end; @@ -584,10 +584,11 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / char *sp; char *bep; int cc = 0; - int i; + php_size_t i; char *s = NULL; - int s_len, free_zcopy; + php_size_t s_len; + int free_zcopy; zval *zvp, zcopy; int min_width = 0; @@ -758,6 +759,10 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / modifier = LM_SIZE_T; #endif break; + case 'p': + fmt++; + modifier = LM_PHP_INT_T; + break; case 'h': fmt++; if (*fmt == 'h') { @@ -788,7 +793,7 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / if (free_zcopy) { zvp = &zcopy; } - s_len = Z_STRLEN_P(zvp); + s_len = Z_STRSIZE_P(zvp); s = Z_STRVAL_P(zvp); if (adjust_precision && precision < s_len) { s_len = precision; @@ -823,6 +828,9 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / i_num = (wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + i_num = (wide_int) va_arg(ap, php_uint_t); + break; } /* * The rest also applies to other integer formats, so fall @@ -865,6 +873,9 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / i_num = (wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + i_num = (wide_int) va_arg(ap, php_int_t); + break; } } s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative, @@ -911,6 +922,9 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / ui_num = (u_wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + ui_num = (u_wide_int) va_arg(ap, php_uint_t); + break; } s = ap_php_conv_p2(ui_num, 3, *fmt, &num_buf[NUM_BUF_SIZE], &s_len); FIX_PRECISION(adjust_precision, precision, s, s_len); @@ -950,6 +964,9 @@ static int format_converter(register buffy * odp, const char *fmt, va_list ap) / ui_num = (u_wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + ui_num = (u_wide_int) va_arg(ap, php_uint_t); + break; } s = ap_php_conv_p2(ui_num, 4, *fmt, &num_buf[NUM_BUF_SIZE], &s_len); FIX_PRECISION(adjust_precision, precision, s, s_len); diff --git a/main/snprintf.h b/main/snprintf.h index 10f0e24fa5..ae179cf6f5 100644 --- a/main/snprintf.h +++ b/main/snprintf.h @@ -87,7 +87,7 @@ PHPAPI int ap_php_asprintf(char **buf, const char *format, ...); PHPAPI int php_sprintf (char* s, const char* format, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3); PHPAPI char * php_gcvt(double value, int ndigit, char dec_point, char exponent, char *buf); PHPAPI char * php_conv_fp(register char format, register double num, - boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, int *len); + boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, php_size_t *len); END_EXTERN_C() @@ -137,7 +137,8 @@ typedef enum { #endif LM_SIZE_T, LM_LONG, - LM_LONG_DOUBLE + LM_LONG_DOUBLE, + LM_PHP_INT_T } length_modifier_e; #ifdef PHP_WIN32 @@ -153,10 +154,10 @@ typedef WIDE_INT wide_int; typedef unsigned WIDE_INT u_wide_int; extern char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned, - register bool_int * is_negative, char *buf_end, register int *len); + register bool_int * is_negative, char *buf_end, register php_size_t *len); extern char * ap_php_conv_p2(register u_wide_int num, register int nbits, - char format, char *buf_end, register int *len); + char format, char *buf_end, register php_size_t *len); /* The maximum precision that's allowed for float conversion. Does not include * decimal separator, exponent, sign, terminator. Currently does not affect diff --git a/main/spprintf.c b/main/spprintf.c index 079089c0fc..5c0310fd9d 100644 --- a/main/spprintf.c +++ b/main/spprintf.c @@ -198,7 +198,8 @@ static size_t strnlen(const char *s, size_t maxlen) { static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt, va_list ap) /* {{{ */ { char *s = NULL; - int s_len, free_zcopy; + php_size_t s_len; + int free_zcopy; zval *zvp, zcopy; int min_width = 0; @@ -366,6 +367,16 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt modifier = LM_SIZE_T; #endif break; + case 'p': { + char __next = *(fmt+1); + if ('d' == __next || 'u' == __next || 'x' == __next || 'o' == __next) { + fmt++; + modifier = LM_PHP_INT_T; + } else { + modifier = LM_STD; + } + } + break; case 'h': fmt++; if (*fmt == 'h') { @@ -396,7 +407,7 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt if (free_zcopy) { zvp = &zcopy; } - s_len = Z_STRLEN_P(zvp); + s_len = Z_STRSIZE_P(zvp); s = Z_STRVAL_P(zvp); if (adjust_precision && precision < s_len) { s_len = precision; @@ -431,6 +442,9 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt i_num = (wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + i_num = (wide_int) va_arg(ap, php_uint_t); + break; } /* * The rest also applies to other integer formats, so fall @@ -473,6 +487,9 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt i_num = (wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + i_num = (wide_int) va_arg(ap, php_int_t); + break; } } s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative, @@ -518,6 +535,9 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt ui_num = (u_wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + ui_num = (u_wide_int) va_arg(ap, php_uint_t); + break; } s = ap_php_conv_p2(ui_num, 3, *fmt, &num_buf[NUM_BUF_SIZE], &s_len); @@ -558,6 +578,9 @@ static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt ui_num = (u_wide_int) va_arg(ap, ptrdiff_t); break; #endif + case LM_PHP_INT_T: + ui_num = (u_wide_int) va_arg(ap, php_uint_t); + break; } s = ap_php_conv_p2(ui_num, 4, *fmt, &num_buf[NUM_BUF_SIZE], &s_len); @@ -796,10 +819,10 @@ skip_output: /* * This is the general purpose conversion function. */ -PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */ +PHPAPI php_size_t vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */ { smart_string buf = {0}; - int result; + php_size_t result; xbuf_format_converter(&buf, 1, format, ap); @@ -821,9 +844,9 @@ PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap } /* }}} */ -PHPAPI int spprintf(char **pbuf, size_t max_len, const char *format, ...) /* {{{ */ +PHPAPI php_size_t spprintf(char **pbuf, size_t max_len, const char *format, ...) /* {{{ */ { - int cc; + php_size_t cc; va_list ap; va_start(ap, format); diff --git a/main/spprintf.h b/main/spprintf.h index ae26a3b9ec..612bcbf5db 100644 --- a/main/spprintf.h +++ b/main/spprintf.h @@ -37,9 +37,9 @@ There is also snprintf: See difference explained in snprintf.h #include "snprintf.h" BEGIN_EXTERN_C() -PHPAPI int spprintf( char **pbuf, size_t max_len, const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4); +PHPAPI php_size_t spprintf( char **pbuf, size_t max_len, const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4); -PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) PHP_ATTRIBUTE_FORMAT(printf, 3, 0); +PHPAPI php_size_t vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) PHP_ATTRIBUTE_FORMAT(printf, 3, 0); PHPAPI zend_string *vstrpprintf(size_t max_len, const char *format, va_list ap); diff --git a/main/streams/cast.c b/main/streams/cast.c index 78073c6187..4780d46eea 100644 --- a/main/streams/cast.c +++ b/main/streams/cast.c @@ -76,7 +76,7 @@ static int stream_cookie_writer(void *cookie, const char *buffer, int size) return php_stream_write((php_stream *)cookie, (char *)buffer, size); } -static PHP_FPOS_T stream_cookie_seeker(void *cookie, off_t position, int whence) +static PHP_FPOS_T stream_cookie_seeker(void *cookie, zend_off_t position, int whence) { TSRMLS_FETCH(); @@ -114,7 +114,7 @@ static int stream_cookie_seeker(void *cookie, __off64_t *position, int whence) { TSRMLS_FETCH(); - *position = php_stream_seek((php_stream *)cookie, (off_t)*position, whence); + *position = php_stream_seek((php_stream *)cookie, (zend_off_t)*position, whence); if (*position == -1) { return -1; @@ -122,7 +122,7 @@ static int stream_cookie_seeker(void *cookie, __off64_t *position, int whence) return 0; } # else -static int stream_cookie_seeker(void *cookie, off_t position, int whence) +static int stream_cookie_seeker(void *cookie, zend_off_t position, int whence) { TSRMLS_FETCH(); @@ -206,7 +206,7 @@ PHPAPI int _php_stream_cast(php_stream *stream, int castas, void **ret, int show if (ret && castas != PHP_STREAM_AS_FD_FOR_SELECT) { php_stream_flush(stream); if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) { - off_t dummy; + zend_off_t dummy; stream->ops->seek(stream, stream->position, SEEK_SET, &dummy TSRMLS_CC); stream->readpos = stream->writepos = 0; @@ -246,7 +246,7 @@ PHPAPI int _php_stream_cast(php_stream *stream, int castas, void **ret, int show } if (*ret != NULL) { - off_t pos; + zend_off_t pos; stream->fclose_stdiocast = PHP_STREAM_FCLOSE_FOPENCOOKIE; @@ -254,7 +254,7 @@ PHPAPI int _php_stream_cast(php_stream *stream, int castas, void **ret, int show * the stdio layer to believe it's real location. */ pos = php_stream_tell(stream); if (pos > 0) { - fseek(*ret, pos, SEEK_SET); + zend_fseek(*ret, pos, SEEK_SET); } goto exit_success; @@ -334,7 +334,7 @@ exit_success: * will be accessing the stream. Emit a warning so that the end-user will * know that they should try something else */ - php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld bytes of buffered data lost during stream conversion!", (long)(stream->writepos - stream->readpos)); + php_error_docref(NULL TSRMLS_CC, E_WARNING, ZEND_INT_FMT " bytes of buffered data lost during stream conversion!", (php_int_t)(stream->writepos - stream->readpos)); } if (castas == PHP_STREAM_AS_STDIO && ret) { diff --git a/main/streams/glob_wrapper.c b/main/streams/glob_wrapper.c index 5a48584f4e..ceb60d5b07 100644 --- a/main/streams/glob_wrapper.c +++ b/main/streams/glob_wrapper.c @@ -180,7 +180,7 @@ static int php_glob_stream_close(php_stream *stream, int close_handle TSRMLS_DC) } /* {{{ */ -static int php_glob_stream_rewind(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC) /* {{{ */ +static int php_glob_stream_rewind(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC) /* {{{ */ { glob_s_t *pglob = (glob_s_t *)stream->abstract; diff --git a/main/streams/memory.c b/main/streams/memory.c index 5da0c8decd..71e9005fa7 100644 --- a/main/streams/memory.c +++ b/main/streams/memory.c @@ -127,7 +127,7 @@ static int php_stream_memory_flush(php_stream *stream TSRMLS_DC) /* {{{ */ -static int php_stream_memory_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC) +static int php_stream_memory_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC) { php_stream_memory_data *ms = (php_stream_memory_data*)stream->abstract; assert(ms != NULL); @@ -442,7 +442,7 @@ static int php_stream_temp_flush(php_stream *stream TSRMLS_DC) /* {{{ */ -static int php_stream_temp_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC) +static int php_stream_temp_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC) { php_stream_temp_data *ts = (php_stream_temp_data*)stream->abstract; int ret; @@ -468,7 +468,7 @@ static int php_stream_temp_cast(php_stream *stream, int castas, void **ret TSRML php_stream *file; size_t memsize; char *membuf; - off_t pos; + zend_off_t pos; assert(ts != NULL); @@ -584,7 +584,7 @@ PHPAPI php_stream *_php_stream_temp_open(int mode, size_t max_memory_usage, char { php_stream *stream; php_stream_temp_data *ts; - off_t newoffs; + zend_off_t newoffs; if ((stream = php_stream_temp_create_rel(mode, max_memory_usage)) != NULL) { if (length) { @@ -618,7 +618,7 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con php_stream_temp_data *ts; char *comma, *semi, *sep, *key; size_t mlen, dlen, plen, vlen; - off_t newoffs; + zend_off_t newoffs; zval meta; int base64 = 0, ilen; zend_string *base64_comma = NULL; diff --git a/main/streams/mmap.c b/main/streams/mmap.c index 050e95f285..a99c8994aa 100644 --- a/main/streams/mmap.c +++ b/main/streams/mmap.c @@ -51,7 +51,7 @@ PHPAPI int _php_stream_mmap_unmap(php_stream *stream TSRMLS_DC) return php_stream_set_option(stream, PHP_STREAM_OPTION_MMAP_API, PHP_STREAM_MMAP_UNMAP, NULL) == PHP_STREAM_OPTION_RETURN_OK ? 1 : 0; } -PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, off_t readden TSRMLS_DC) +PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, zend_off_t readden TSRMLS_DC) { int ret = 1; diff --git a/main/streams/php_stream_mmap.h b/main/streams/php_stream_mmap.h index b3570be48c..5d200d729a 100644 --- a/main/streams/php_stream_mmap.h +++ b/main/streams/php_stream_mmap.h @@ -74,7 +74,7 @@ PHPAPI char *_php_stream_mmap_range(php_stream *stream, size_t offset, size_t le PHPAPI int _php_stream_mmap_unmap(php_stream *stream TSRMLS_DC); #define php_stream_mmap_unmap(stream) _php_stream_mmap_unmap((stream) TSRMLS_CC) -PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, off_t readden TSRMLS_DC); +PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, zend_off_t readden TSRMLS_DC); #define php_stream_mmap_unmap_ex(stream, readden) _php_stream_mmap_unmap_ex((stream), (readden) TSRMLS_CC) END_EXTERN_C() diff --git a/main/streams/plain_wrapper.c b/main/streams/plain_wrapper.c index 87312b9ef8..d9f058e3cc 100644 --- a/main/streams/plain_wrapper.c +++ b/main/streams/plain_wrapper.c @@ -53,6 +53,12 @@ extern int php_get_uid_by_name(const char *name, uid_t *uid TSRMLS_DC); extern int php_get_gid_by_name(const char *name, gid_t *gid TSRMLS_DC); #endif +#if defined(PHP_WIN32) +# define PLAIN_WRAP_BUF_SIZE(st) (((st) > UINT_MAX) ? UINT_MAX : (unsigned int)(st)) +#else +# define PLAIN_WRAP_BUF_SIZE(st) (st) +#endif + /* parse standard "fopen" modes into open() flags */ PHPAPI int php_stream_parse_fopen_modes(const char *mode, int *open_flags) { @@ -132,7 +138,7 @@ typedef struct { HANDLE file_mapping; #endif - struct stat sb; + php_stat_t sb; } php_stdio_stream_data; #define PHP_STDIOP_GET_FD(anfd, data) anfd = (data)->file ? fileno((data)->file) : (data)->fd @@ -143,7 +149,7 @@ static int do_fstat(php_stdio_stream_data *d, int force) int r; PHP_STDIOP_GET_FD(fd, d); - r = fstat(fd, &d->sb); + r = php_fstat(fd, &d->sb); d->cached_fstat = r == 0; return r; @@ -246,9 +252,9 @@ PHPAPI php_stream *_php_stream_fopen_from_fd(int fd, const char *mode, const cha if (self->is_pipe) { stream->flags |= PHP_STREAM_FLAG_NO_SEEK; } else { - stream->position = lseek(self->fd, 0, SEEK_CUR); + stream->position = zend_lseek(self->fd, 0, SEEK_CUR); #ifdef ESPIPE - if (stream->position == (off_t)-1 && errno == ESPIPE) { + if (stream->position == (zend_off_t)-1 && errno == ESPIPE) { stream->position = 0; stream->flags |= PHP_STREAM_FLAG_NO_SEEK; self->is_pipe = 1; @@ -285,7 +291,7 @@ PHPAPI php_stream *_php_stream_fopen_from_file(FILE *file, const char *mode STRE if (self->is_pipe) { stream->flags |= PHP_STREAM_FLAG_NO_SEEK; } else { - stream->position = ftell(file); + stream->position = zend_ftell(file); } } @@ -342,13 +348,13 @@ static size_t php_stdiop_read(php_stream *stream, char *buf, size_t count TSRMLS assert(data != NULL); if (data->fd >= 0) { - ret = read(data->fd, buf, count); + ret = read(data->fd, buf, PLAIN_WRAP_BUF_SIZE(count)); if (ret == (size_t)-1 && errno == EINTR) { /* Read was interrupted, retry once, If read still fails, giveup with feof==0 so script can retry if desired */ - ret = read(data->fd, buf, count); + ret = read(data->fd, buf, PLAIN_WRAP_BUF_SIZE(count)); } stream->eof = (ret == 0 || (ret == (size_t)-1 && errno != EWOULDBLOCK && errno != EINTR && errno != EBADF)); @@ -356,7 +362,7 @@ static size_t php_stdiop_read(php_stream *stream, char *buf, size_t count TSRMLS } else { #if HAVE_FLUSHIO if (!data->is_pipe && data->last_op == 'w') - fseek(data->file, 0, SEEK_CUR); + zend_fseek(data->file, 0, SEEK_CUR); data->last_op = 'r'; #endif @@ -445,7 +451,7 @@ static int php_stdiop_flush(php_stream *stream TSRMLS_DC) return 0; } -static int php_stdiop_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC) +static int php_stdiop_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset TSRMLS_DC) { php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract; int ret; @@ -458,18 +464,18 @@ static int php_stdiop_seek(php_stream *stream, off_t offset, int whence, off_t * } if (data->fd >= 0) { - off_t result; + zend_off_t result; - result = lseek(data->fd, offset, whence); - if (result == (off_t)-1) + result = zend_lseek(data->fd, offset, whence); + if (result == (zend_off_t)-1) return -1; *newoffset = result; return 0; } else { - ret = fseek(data->file, offset, whence); - *newoffset = ftell(data->file); + ret = zend_fseek(data->file, offset, whence); + *newoffset = zend_ftell(data->file); return ret; } } @@ -831,7 +837,7 @@ static int php_plain_files_dirstream_close(php_stream *stream, int close_handle return closedir((DIR *)stream->abstract); } -static int php_plain_files_dirstream_rewind(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC) +static int php_plain_files_dirstream_rewind(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC) { rewinddir((DIR *)stream->abstract); return 0; @@ -1096,7 +1102,7 @@ static int php_plain_files_rename(php_stream_wrapper *wrapper, const char *url_f #ifndef PHP_WIN32 # ifdef EXDEV if (errno == EXDEV) { - struct stat sb; + php_stat_t sb; if (php_copy_file(url_from, url_to TSRMLS_CC) == SUCCESS) { if (VCWD_STAT(url_from, &sb) == 0) { # if !defined(TSRM_WIN32) && !defined(NETWARE) @@ -1159,7 +1165,7 @@ static int php_plain_files_mkdir(php_stream_wrapper *wrapper, const char *dir, i } else { /* we look for directory separator from the end of string, thus hopefuly reducing our work load */ char *e; - struct stat sb; + php_stat_t sb; int dir_len = strlen(dir); int offset = 0; char buf[MAXPATHLEN]; diff --git a/main/streams/streams.c b/main/streams/streams.c index 89537bdaeb..1a6c4d24a0 100644 --- a/main/streams/streams.c +++ b/main/streams/streams.c @@ -675,7 +675,7 @@ static void php_stream_fill_read_buffer(php_stream *stream, size_t size TSRMLS_D } else { /* is there enough data in the buffer ? */ - if (stream->writepos - stream->readpos < (off_t)size) { + if (stream->writepos - stream->readpos < (zend_off_t)size) { size_t justread = 0; /* reduce buffer memory consumption if possible, to avoid a realloc */ @@ -1269,12 +1269,12 @@ PHPAPI size_t _php_stream_printf(php_stream *stream TSRMLS_DC, const char *fmt, return count; } -PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC) +PHPAPI zend_off_t _php_stream_tell(php_stream *stream TSRMLS_DC) { return stream->position; } -PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC) +PHPAPI int _php_stream_seek(php_stream *stream, zend_off_t offset, int whence TSRMLS_DC) { if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) { /* flush to commit data written to the fopencookie FILE* */ @@ -2136,7 +2136,7 @@ PHPAPI php_stream *_php_stream_open_wrapper_ex(const char *path, const char *mod } if (stream && stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && strchr(mode, 'a') && stream->position == 0) { - off_t newpos = 0; + zend_off_t newpos = 0; /* if opened for append, we need to revise our idea of the initial file position */ if (0 == stream->ops->seek(stream, 0, SEEK_CUR, &newpos TSRMLS_CC)) { diff --git a/main/streams/transports.c b/main/streams/transports.c index 7792e24fef..7f1d13faaa 100644 --- a/main/streams/transports.c +++ b/main/streams/transports.c @@ -163,8 +163,8 @@ PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, in if (PHP_STREAM_CONTEXT(stream) && (zbacklog = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "socket", "backlog")) != NULL) { zval *ztmp = zbacklog; - convert_to_long_ex(ztmp); - backlog = Z_LVAL_P(ztmp); + convert_to_int_ex(ztmp); + backlog = Z_IVAL_P(ztmp); if (ztmp != zbacklog) { zval_ptr_dtor(ztmp); } diff --git a/main/streams/userspace.c b/main/streams/userspace.c index c41826155c..82ff445c4f 100644 --- a/main/streams/userspace.c +++ b/main/streams/userspace.c @@ -86,35 +86,35 @@ PHP_MINIT_FUNCTION(user_streams) if (le_protocols == FAILURE) return FAILURE; - REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS|CONST_PERSISTENT); - - REGISTER_LONG_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_CS|CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS|CONST_PERSISTENT); + + REGISTER_INT_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_CS|CONST_PERSISTENT); + REGISTER_INT_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_CS|CONST_PERSISTENT); return SUCCESS; } @@ -367,7 +367,7 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char * /* call it's stream_open method - set up params first */ ZVAL_STRING(&args[0], filename); ZVAL_STRING(&args[1], mode); - ZVAL_LONG(&args[2], options); + ZVAL_INT(&args[2], options); ZVAL_NEW_REF(&args[3], &EG(uninitialized_zval)); ZVAL_STRING(&zfuncname, USERSTREAM_OPEN); @@ -385,7 +385,7 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char * /* if the opened path is set, copy it out */ if (Z_ISREF(args[3]) && Z_TYPE_P(Z_REFVAL(args[3])) == IS_STRING && opened_path) { - *opened_path = estrndup(Z_STRVAL_P(Z_REFVAL(args[3])), Z_STRLEN_P(Z_REFVAL(args[3]))); + *opened_path = estrndup(Z_STRVAL_P(Z_REFVAL(args[3])), Z_STRSIZE_P(Z_REFVAL(args[3]))); } /* set wrapper data to be a reference to our object */ @@ -443,7 +443,7 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char /* call it's dir_open method - set up params first */ ZVAL_STRING(&args[0], filename); - ZVAL_LONG(&args[1], options); + ZVAL_INT(&args[1], options); ZVAL_STRING(&zfuncname, USERSTREAM_DIR_OPEN); @@ -490,7 +490,7 @@ PHP_FUNCTION(stream_wrapper_register) zend_string *protocol, *classname; struct php_user_stream_wrapper * uwrap; zend_resource *rsrc; - long flags = 0; + php_int_t flags = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &protocol, &classname, &flags) == FAILURE) { RETURN_FALSE; @@ -608,8 +608,8 @@ static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t didwrite = 0; if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { - convert_to_long(&retval); - didwrite = Z_LVAL(retval); + convert_to_int(&retval); + didwrite = Z_IVAL(retval); } else if (call_result == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!", us->wrapper->classname); @@ -617,9 +617,9 @@ static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t /* don't allow strange buffer overruns due to bogus return */ if (didwrite > count) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote %ld bytes more data than requested (%ld written, %ld max)", + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote " ZEND_INT_FMT " bytes more data than requested (" ZEND_INT_FMT " written, " ZEND_INT_FMT " max)", us->wrapper->classname, - (long)(didwrite - count), (long)didwrite, (long)count); + (php_int_t)(didwrite - count), (php_int_t)didwrite, (php_int_t)count); didwrite = count; } @@ -641,7 +641,7 @@ static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count ZVAL_STRINGL(&func_name, USERSTREAM_READ, sizeof(USERSTREAM_READ)-1); - ZVAL_LONG(&args[0], count); + ZVAL_INT(&args[0], count); call_result = call_user_function_ex(NULL, Z_ISUNDEF(us->object)? NULL : &us->object, @@ -652,10 +652,10 @@ static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { convert_to_string(&retval); - didread = Z_STRLEN(retval); + didread = Z_STRSIZE(retval); if (didread > count) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read %ld bytes more data than requested (%ld read, %ld max) - excess data will be lost", - us->wrapper->classname, (long)(didread - count), (long)didread, (long)count); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read " ZEND_INT_FMT " bytes more data than requested (" ZEND_INT_FMT " read, " ZEND_INT_FMT " max) - excess data will be lost", + us->wrapper->classname, (php_int_t)(didread - count), (php_int_t)didread, (php_int_t)count); didread = count; } if (didread > 0) @@ -763,8 +763,8 @@ static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, o ZVAL_STRINGL(&func_name, USERSTREAM_SEEK, sizeof(USERSTREAM_SEEK)-1); - ZVAL_LONG(&args[0], offset); - ZVAL_LONG(&args[1], whence); + ZVAL_INT(&args[0], offset); + ZVAL_INT(&args[1], whence); call_result = call_user_function_ex(NULL, Z_ISUNDEF(us->object)? NULL : &us->object, @@ -807,8 +807,8 @@ static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, o &retval, 0, NULL, 0, NULL TSRMLS_CC); - if (call_result == SUCCESS && Z_TYPE(retval) == IS_LONG) { - *newoffs = Z_LVAL(retval); + if (call_result == SUCCESS && Z_TYPE(retval) == IS_INT) { + *newoffs = Z_IVAL(retval); ret = 0; } else if (call_result == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", us->wrapper->classname); @@ -831,8 +831,8 @@ static int statbuf_from_array(zval *array, php_stream_statbuf *ssb TSRMLS_DC) #define STAT_PROP_ENTRY_EX(name, name2) \ if (NULL != (elem = zend_hash_str_find(Z_ARRVAL_P(array), #name, sizeof(#name)-1))) { \ SEPARATE_ZVAL(elem); \ - convert_to_long(elem); \ - ssb->sb.st_##name2 = Z_LVAL_P(elem); \ + convert_to_int(elem); \ + ssb->sb.st_##name2 = Z_IVAL_P(elem); \ } #define STAT_PROP_ENTRY(name) STAT_PROP_ENTRY_EX(name,name) @@ -927,20 +927,20 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value break; case PHP_STREAM_OPTION_LOCKING: - ZVAL_LONG(&args[0], 0); + ZVAL_INT(&args[0], 0); if (value & LOCK_NB) { - Z_LVAL_P(&args[0]) |= PHP_LOCK_NB; + Z_IVAL_P(&args[0]) |= PHP_LOCK_NB; } switch(value & ~LOCK_NB) { case LOCK_SH: - Z_LVAL_P(&args[0]) |= PHP_LOCK_SH; + Z_IVAL_P(&args[0]) |= PHP_LOCK_SH; break; case LOCK_EX: - Z_LVAL_P(&args[0]) |= PHP_LOCK_EX; + Z_IVAL_P(&args[0]) |= PHP_LOCK_EX; break; case LOCK_UN: - Z_LVAL_P(&args[0]) |= PHP_LOCK_UN; + Z_IVAL_P(&args[0]) |= PHP_LOCK_UN; break; } @@ -987,7 +987,7 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value case PHP_STREAM_TRUNCATE_SET_SIZE: { ptrdiff_t new_size = *(ptrdiff_t*) ptrparam; if (new_size >= 0 && new_size <= (ptrdiff_t)LONG_MAX) { - ZVAL_LONG(&args[0], (long)new_size); + ZVAL_INT(&args[0], (long)new_size); call_result = call_user_function_ex(NULL, Z_ISUNDEF(us->object)? NULL : &us->object, &func_name, @@ -1025,28 +1025,28 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1); - ZVAL_LONG(&args[0], option); + ZVAL_INT(&args[0], option); ZVAL_NULL(&args[1]); ZVAL_NULL(&args[2]); switch(option) { case PHP_STREAM_OPTION_READ_BUFFER: case PHP_STREAM_OPTION_WRITE_BUFFER: - ZVAL_LONG(&args[1], value); + ZVAL_INT(&args[1], value); if (ptrparam) { - ZVAL_LONG(&args[2], *(long *)ptrparam); + ZVAL_INT(&args[2], *(long *)ptrparam); } else { - ZVAL_LONG(&args[2], BUFSIZ); + ZVAL_INT(&args[2], BUFSIZ); } break; case PHP_STREAM_OPTION_READ_TIMEOUT: { struct timeval tv = *(struct timeval*)ptrparam; - ZVAL_LONG(&args[1], tv.tv_sec); - ZVAL_LONG(&args[2], tv.tv_usec); + ZVAL_INT(&args[1], tv.tv_sec); + ZVAL_INT(&args[2], tv.tv_usec); break; } case PHP_STREAM_OPTION_BLOCKING: - ZVAL_LONG(&args[1], value); + ZVAL_INT(&args[1], value); break; default: break; @@ -1189,8 +1189,8 @@ static int user_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url, int /* call the mkdir method */ ZVAL_STRING(&args[0], url); - ZVAL_LONG(&args[1], mode); - ZVAL_LONG(&args[2], options); + ZVAL_INT(&args[1], mode); + ZVAL_INT(&args[2], options); ZVAL_STRING(&zfuncname, USERSTREAM_MKDIR); @@ -1237,7 +1237,7 @@ static int user_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, /* call the rmdir method */ ZVAL_STRING(&args[0], url); - ZVAL_LONG(&args[1], options); + ZVAL_INT(&args[1], options); ZVAL_STRING(&zfuncname, USERSTREAM_RMDIR); @@ -1280,14 +1280,14 @@ static int user_wrapper_metadata(php_stream_wrapper *wrapper, const char *url, i array_init(&args[2]); if(value) { struct utimbuf *newtime = (struct utimbuf *)value; - add_index_long(&args[2], 0, newtime->modtime); - add_index_long(&args[2], 1, newtime->actime); + add_index_int(&args[2], 0, newtime->modtime); + add_index_int(&args[2], 1, newtime->actime); } break; case PHP_STREAM_META_GROUP: case PHP_STREAM_META_OWNER: case PHP_STREAM_META_ACCESS: - ZVAL_LONG(&args[2], *(long *)value); + ZVAL_INT(&args[2], *(long *)value); break; case PHP_STREAM_META_GROUP_NAME: case PHP_STREAM_META_OWNER_NAME: @@ -1308,7 +1308,7 @@ static int user_wrapper_metadata(php_stream_wrapper *wrapper, const char *url, i /* call the mkdir method */ ZVAL_STRING(&args[0], url); - ZVAL_LONG(&args[1], option); + ZVAL_INT(&args[1], option); ZVAL_STRING(&zfuncname, USERSTREAM_METADATA); @@ -1356,7 +1356,7 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, const char *url, i /* call it's stat_url method - set up params first */ ZVAL_STRING(&args[0], url); - ZVAL_LONG(&args[1], flags); + ZVAL_INT(&args[1], flags); ZVAL_STRING(&zfuncname, USERSTREAM_STATURL); @@ -1414,7 +1414,7 @@ static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t cou if (call_result == SUCCESS && Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) { convert_to_string(&retval); - PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRLEN(retval)); + PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRSIZE(retval)); didread = sizeof(php_stream_dirent); } else if (call_result == FAILURE) { @@ -1489,10 +1489,10 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr T switch(castas) { case PHP_STREAM_AS_FD_FOR_SELECT: - ZVAL_LONG(&args[0], PHP_STREAM_AS_FD_FOR_SELECT); + ZVAL_INT(&args[0], PHP_STREAM_AS_FD_FOR_SELECT); break; default: - ZVAL_LONG(&args[0], PHP_STREAM_AS_STDIO); + ZVAL_INT(&args[0], PHP_STREAM_AS_STDIO); break; } diff --git a/main/streams/xp_socket.c b/main/streams/xp_socket.c index dad78beb13..d2aaef0bc3 100644 --- a/main/streams/xp_socket.c +++ b/main/streams/xp_socket.c @@ -39,6 +39,13 @@ # define MSG_PEEK 0 #endif +#ifdef PHP_WIN32 +/* send/recv family on windows expects int */ +# define XP_SOCK_BUF_SIZE(sz) (((sz) > INT_MAX) ? INT_MAX : (int)(sz)) +#else +# define XP_SOCK_BUF_SIZE(sz) (sz) +#endif + php_stream_ops php_stream_generic_socket_ops; PHPAPI php_stream_ops php_stream_socket_ops; php_stream_ops php_stream_udp_socket_ops; @@ -67,7 +74,7 @@ static size_t php_sockop_write(php_stream *stream, const char *buf, size_t count ptimeout = &sock->timeout; retry: - didwrite = send(sock->socket, buf, count, (sock->is_blocked && ptimeout) ? MSG_DONTWAIT : 0); + didwrite = send(sock->socket, buf, XP_SOCK_BUF_SIZE(count), (sock->is_blocked && ptimeout) ? MSG_DONTWAIT : 0); if (didwrite <= 0) { long err = php_socket_errno(); @@ -95,8 +102,8 @@ retry: } while (err == EINTR); } estr = php_socket_strerror(err, NULL, 0); - php_error_docref(NULL TSRMLS_CC, E_NOTICE, "send of %ld bytes failed with errno=%ld %s", - (long)count, err, estr); + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "send of " ZEND_INT_FMT " bytes failed with errno=%ld %s", + (php_int_t)count, err, estr); efree(estr); } @@ -144,7 +151,7 @@ static void php_sock_stream_wait_for_data(php_stream *stream, php_netstream_data static size_t php_sockop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC) { php_netstream_data_t *sock = (php_netstream_data_t*)stream->abstract; - int nr_bytes = 0; + ssize_t nr_bytes = 0; if (!sock || sock->socket == -1) { return 0; @@ -156,7 +163,7 @@ static size_t php_sockop_read(php_stream *stream, char *buf, size_t count TSRMLS return 0; } - nr_bytes = recv(sock->socket, buf, count, (sock->is_blocked && sock->timeout.tv_sec != -1) ? MSG_DONTWAIT : 0); + nr_bytes = recv(sock->socket, buf, XP_SOCK_BUF_SIZE(count), (sock->is_blocked && sock->timeout.tv_sec != -1) ? MSG_DONTWAIT : 0); stream->eof = (nr_bytes == 0 || (nr_bytes == -1 && php_socket_errno() != EWOULDBLOCK)); @@ -230,7 +237,7 @@ static int php_sockop_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC #if ZEND_WIN32 return 0; #else - return fstat(sock->socket, &ssb->sb); + return php_fstat(sock->socket, &ssb->sb); #endif } @@ -240,7 +247,8 @@ static inline int sock_sendto(php_netstream_data_t *sock, const char *buf, size_ { int ret; if (addr) { - ret = sendto(sock->socket, buf, buflen, flags, addr, addrlen); + ret = sendto(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, addr, XP_SOCK_BUF_SIZE(addrlen)); + return (ret == SOCK_CONN_ERR) ? -1 : ret; } return ((ret = send(sock->socket, buf, buflen, flags)) == SOCK_CONN_ERR) ? -1 : ret; @@ -257,12 +265,12 @@ static inline int sock_recvfrom(php_netstream_data_t *sock, char *buf, size_t bu int want_addr = textaddr || addr; if (want_addr) { - ret = recvfrom(sock->socket, buf, buflen, flags, (struct sockaddr*)&sa, &sl); + ret = recvfrom(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, (struct sockaddr*)&sa, &sl); ret = (ret == SOCK_CONN_ERR) ? -1 : ret; php_network_populate_name_from_sockaddr((struct sockaddr*)&sa, sl, textaddr, addr, addrlen TSRMLS_CC); } else { - ret = recv(sock->socket, buf, buflen, flags); + ret = recv(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags); ret = (ret == SOCK_CONN_ERR) ? -1 : ret; } @@ -694,7 +702,7 @@ static inline int php_tcp_sockop_connect(php_stream *stream, php_netstream_data_ efree(host); return -1; } - bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC); + bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC); } #ifdef SO_BROADCAST diff --git a/sapi/cgi/config.w32 b/sapi/cgi/config.w32 index 8d1d431da4..55a2fba48f 100644 --- a/sapi/cgi/config.w32 +++ b/sapi/cgi/config.w32 @@ -4,7 +4,7 @@ ARG_ENABLE('cgi', 'Build CGI version of PHP', 'yes'); if (PHP_CGI == "yes") { - ADD_FLAG("LDFLAGS_CGI", "/stack:8388608"); + ADD_FLAG("LDFLAGS_CGI", "/stack:67108864"); SAPI('cgi', 'cgi_main.c fastcgi.c', 'php-cgi.exe'); ADD_FLAG('LIBS_CGI', 'ws2_32.lib kernel32.lib advapi32.lib'); } diff --git a/sapi/cli/cli.h b/sapi/cli/cli.h index dc85893a0b..8840ac01cc 100644 --- a/sapi/cli/cli.h +++ b/sapi/cli/cli.h @@ -30,11 +30,11 @@ #endif -extern PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS_DC); +extern PHP_CLI_API size_t sapi_cli_single_write(const char *str, php_size_t str_length TSRMLS_DC); typedef struct { - size_t (*cli_shell_write)(const char *str, uint str_length TSRMLS_DC); - int (*cli_shell_ub_write)(const char *str, uint str_length TSRMLS_DC); + php_size_t (*cli_shell_write)(const char *str, php_size_t str_length TSRMLS_DC); + php_size_t (*cli_shell_ub_write)(const char *str, php_size_t str_length TSRMLS_DC); int (*cli_shell_run)(TSRMLS_D); } cli_shell_callbacks_t; diff --git a/sapi/cli/config.w32 b/sapi/cli/config.w32 index adcbb2b496..438c9e6d62 100644 --- a/sapi/cli/config.w32 +++ b/sapi/cli/config.w32 @@ -11,11 +11,11 @@ if (PHP_CLI == "yes") { if (PHP_CRT_DEBUG == "yes") { ADD_FLAG("CFLAGS_CLI", "/D PHP_WIN32_DEBUG_HEAP"); } - ADD_FLAG("LDFLAGS_CLI", "/stack:8388608"); + ADD_FLAG("LDFLAGS_CLI", "/stack:67108864"); } if (PHP_CLI_WIN32 == "yes") { SAPI('cli_win32', 'cli_win32.c php_cli_process_title.c ps_title.c', 'php-win.exe'); - ADD_FLAG("LDFLAGS_CLI_WIN32", "/stack:8388608"); + ADD_FLAG("LDFLAGS_CLI_WIN32", "/stack:67108864"); } diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c index ec76f37715..bdc4629c08 100644 --- a/sapi/cli/php_cli.c +++ b/sapi/cli/php_cli.c @@ -252,16 +252,16 @@ static inline int sapi_cli_select(int fd TSRMLS_DC) return ret != -1; } -PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +PHP_CLI_API size_t sapi_cli_single_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { #ifdef PHP_WRITE_STDOUT - long ret; + php_int_t ret; #else - size_t ret; + php_size_t ret; #endif if (cli_shell_callbacks.cli_shell_write) { - size_t shell_wrote; + php_size_t shell_wrote; shell_wrote = cli_shell_callbacks.cli_shell_write(str, str_length TSRMLS_CC); if (shell_wrote > -1) { return shell_wrote; @@ -285,10 +285,10 @@ PHP_CLI_API size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS } /* }}} */ -static int sapi_cli_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_ub_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { const char *ptr = str; - uint remaining = str_length; + php_size_t remaining = str_length; size_t ret; if (!str_length) { @@ -296,7 +296,7 @@ static int sapi_cli_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ } if (cli_shell_callbacks.cli_shell_ub_write) { - int ub_wrote; + php_size_t ub_wrote; ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length TSRMLS_CC); if (ub_wrote > -1) { return ub_wrote; @@ -338,7 +338,7 @@ static char *script_filename = ""; static void sapi_cli_register_variables(zval *track_vars_array TSRMLS_DC) /* {{{ */ { - unsigned int len; + php_size_t len; char *docroot = ""; /* In CGI mode, we consider the environment to be a part of the server @@ -1033,7 +1033,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */ if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) { exit_status=254; } - ZVAL_LONG(&argi, index); + ZVAL_INT(&argi, index); zend_hash_str_update(&EG(symbol_table).ht, "argi", sizeof("argi")-1, &argi); while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) { len = strlen(input); @@ -1042,7 +1042,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */ } ZVAL_STRINGL(&argn, input, len); zend_hash_str_update(&EG(symbol_table).ht, "argn", sizeof("argn")-1, &argn); - Z_LVAL(argi) = ++index; + Z_IVAL(argi) = ++index; if (exec_run) { if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) { exit_status=254; diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c index 09cfd02ec9..f381e4ba2b 100644 --- a/sapi/cli/php_cli_server.c +++ b/sapi/cli/php_cli_server.c @@ -139,7 +139,7 @@ typedef struct php_cli_server_request { size_t content_len; const char *ext; size_t ext_len; - struct stat sb; + php_stat_t sb; } php_cli_server_request; typedef struct php_cli_server_chunk { @@ -436,7 +436,7 @@ PHP_FUNCTION(apache_request_headers) /* {{{ */ static void add_response_header(sapi_header_struct *h, zval *return_value TSRMLS_DC) /* {{{ */ { char *s, *p; - int len; + ptrdiff_t len; ALLOCA_FLAG(use_heap) if (h->header_len > 0) { @@ -539,7 +539,7 @@ static int sapi_cli_server_startup(sapi_module_struct *sapi_module) /* {{{ */ return SUCCESS; } /* }}} */ -static int sapi_cli_server_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_server_ub_write(const char *str, php_size_t str_length TSRMLS_DC) /* {{{ */ { php_cli_server_client *client = SG(server_context); if (!client) { @@ -619,7 +619,7 @@ static char *sapi_cli_server_read_cookies(TSRMLS_D) /* {{{ */ return val; } /* }}} */ -static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* {{{ */ +static php_size_t sapi_cli_server_read_post(char *buf, php_size_t count_bytes TSRMLS_DC) /* {{{ */ { php_cli_server_client *client = SG(server_context); if (client->request.content) { @@ -635,7 +635,7 @@ static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* { static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val TSRMLS_DC) /* {{{ */ { char *new_val = (char *)val; - uint new_val_len; + php_size_t new_val_len; if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len TSRMLS_CC)) { php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array TSRMLS_CC); } @@ -789,7 +789,7 @@ static int php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */ return SUCCESS; } /* }}} */ -static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, int fd) /* {{{ */ +static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */ { if (mode & POLLIN) { PHP_SAFE_FD_SET(fd, &poller->rfds); @@ -802,7 +802,7 @@ static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, i } } /* }}} */ -static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, int fd) /* {{{ */ +static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */ { if (mode & POLLIN) { PHP_SAFE_FD_CLR(fd, &poller->rfds); @@ -830,7 +830,7 @@ static int php_cli_server_poller_poll(php_cli_server_poller *poller, struct time return php_select(poller->max_fd + 1, &poller->active.rfds, &poller->active.wfds, NULL, tv); } /* }}} */ -static int php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, int(*callback)(void *, int fd, int events)) /* {{{ */ +static int php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, int(*callback)(void *, php_socket_t fd, int events)) /* {{{ */ { int retval = SUCCESS; #ifdef PHP_WIN32 @@ -1209,7 +1209,7 @@ static void php_cli_server_logf(const char *format TSRMLS_DC, ...) /* {{{ */ static int php_network_listen_socket(const char *host, int *port, int socktype, int *af, socklen_t *socklen, zend_string **errstr TSRMLS_DC) /* {{{ */ { - int retval = SOCK_ERR; + php_socket_t retval = SOCK_ERR; int err = 0; struct sockaddr *sa = NULL, **p, **sal; @@ -1377,7 +1377,7 @@ static void php_cli_server_request_dtor(php_cli_server_request *req) /* {{{ */ static void php_cli_server_request_translate_vpath(php_cli_server_request *request, const char *document_root, size_t document_root_len) /* {{{ */ { - struct stat sb; + php_stat_t sb; static const char *index_files[] = { "index.php", "index.html", NULL }; char *buf = safe_pemalloc(1, request->vpath_len, 1 + document_root_len + 1 + sizeof("index.html"), 1); char *p = buf, *prev_path = NULL, *q, *vpath; @@ -1414,7 +1414,7 @@ static void php_cli_server_request_translate_vpath(php_cli_server_request *reque *p = '\0'; q = p; while (q > buf) { - if (!stat(buf, &sb)) { + if (!php_stat_fn(buf, &sb)) { if (sb.st_mode & S_IFDIR) { const char **file = index_files; if (q[-1] != DEFAULT_SLASH) { @@ -1423,7 +1423,7 @@ static void php_cli_server_request_translate_vpath(php_cli_server_request *reque while (*file) { size_t l = strlen(*file); memmove(q, *file, l + 1); - if (!stat(buf, &sb) && (sb.st_mode & S_IFREG)) { + if (!php_stat_fn(buf, &sb) && (sb.st_mode & S_IFREG)) { q += l; break; } @@ -1785,7 +1785,7 @@ static void destroy_request_info(sapi_request_info *request_info) /* {{{ */ { } /* }}} */ -static int php_cli_server_client_ctor(php_cli_server_client *client, php_cli_server *server, int client_sock, struct sockaddr *addr, socklen_t addr_len TSRMLS_DC) /* {{{ */ +static int php_cli_server_client_ctor(php_cli_server_client *client, php_cli_server *server, php_socket_t client_sock, struct sockaddr *addr, socklen_t addr_len TSRMLS_DC) /* {{{ */ { client->server = server; client->sock = client_sock; @@ -2361,7 +2361,7 @@ typedef struct php_cli_server_do_event_for_each_fd_callback_params { int(*whandler)(php_cli_server*, php_cli_server_client* TSRMLS_DC); } php_cli_server_do_event_for_each_fd_callback_params; -static int php_cli_server_do_event_for_each_fd_callback(void *_params, int fd, int event) /* {{{ */ +static int php_cli_server_do_event_for_each_fd_callback(void *_params, php_socket_t fd, int event) /* {{{ */ { php_cli_server_do_event_for_each_fd_callback_params *params = _params; #ifdef ZTS @@ -2487,9 +2487,9 @@ int do_cli_server(int argc, char **argv TSRMLS_DC) /* {{{ */ } if (document_root) { - struct stat sb; + php_stat_t sb; - if (stat(document_root, &sb)) { + if (php_stat_fn(document_root, &sb)) { fprintf(stderr, "Directory %s does not exist.\n", document_root); return 1; } diff --git a/win32/glob.c b/win32/glob.c index 8111daba1c..95160f9963 100644 --- a/win32/glob.c +++ b/win32/glob.c @@ -146,10 +146,10 @@ typedef char Char; static int compare(const void *, const void *); static int g_Ctoc(const Char *, char *, u_int); -static int g_lstat(Char *, struct stat *, glob_t *); +static int g_lstat(Char *, php_stat_t *, glob_t *); static DIR *g_opendir(Char *, glob_t *); static Char *g_strchr(Char *, int); -static int g_stat(Char *, struct stat *, glob_t *); +static int g_stat(Char *, php_stat_t *, glob_t *); static int glob0(const Char *, glob_t *); static int glob1(Char *, Char *, glob_t *, size_t *); static int glob2(Char *, Char *, Char *, Char *, Char *, Char *, @@ -559,7 +559,7 @@ glob2(pathbuf, pathbuf_last, pathend, pathend_last, pattern, glob_t *pglob; size_t *limitp; { - struct stat sb; + php_stat_t sb; Char *p, *q; int anymeta; @@ -856,7 +856,7 @@ g_opendir(str, pglob) static int g_lstat(fn, sb, pglob) register Char *fn; - struct stat *sb; + php_stat_t *sb; glob_t *pglob; { char buf[MAXPATHLEN]; @@ -871,7 +871,7 @@ g_lstat(fn, sb, pglob) static int g_stat(fn, sb, pglob) register Char *fn; - struct stat *sb; + php_stat_t *sb; glob_t *pglob; { char buf[MAXPATHLEN]; diff --git a/win32/glob.h b/win32/glob.h index 3f7a57a0b3..a03fda9199 100644 --- a/win32/glob.h +++ b/win32/glob.h @@ -47,7 +47,7 @@ # include <sys/cdefs.h> #endif -struct stat; +php_stat_t; typedef struct { int gl_pathc; /* Count of total paths so far. */ int gl_matchc; /* Count of paths matching pattern. */ @@ -65,8 +65,8 @@ typedef struct { void (*gl_closedir)(void *); struct dirent *(*gl_readdir)(void *); void *(*gl_opendir)(const char *); - int (*gl_lstat)(const char *, struct stat *); - int (*gl_stat)(const char *, struct stat *); + int (*gl_lstat)(const char *, php_stat_t *); + int (*gl_stat)(const char *, php_stat_t *); } glob_t; /* Flags */ diff --git a/win32/php_stdint.h b/win32/php_stdint.h index 0d63615c6b..4e9b869483 100644 --- a/win32/php_stdint.h +++ b/win32/php_stdint.h @@ -130,6 +130,7 @@ typedef uint64_t uintmax_t; #if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 // 7.18.2.1 Limits of exact-width integer types +#if _MSC_VER >= 1700 && !defined(_INTSAFE_H_INCLUDED_) #define INT8_MIN ((int8_t)_I8_MIN) #define INT8_MAX _I8_MAX #define INT16_MIN ((int16_t)_I16_MIN) @@ -142,6 +143,7 @@ typedef uint64_t uintmax_t; #define UINT16_MAX _UI16_MAX #define UINT32_MAX _UI32_MAX #define UINT64_MAX _UI64_MAX +#endif // 7.18.2.2 Limits of minimum-width integer types #define INT_LEAST8_MIN INT8_MIN diff --git a/win32/registry.c b/win32/registry.c index ade09aa486..75854910e0 100644 --- a/win32/registry.c +++ b/win32/registry.c @@ -240,18 +240,18 @@ void UpdateIniFromRegistry(char *path TSRMLS_DC) if (pht != NULL) { HashTable *ht = pht; zend_string *index; - ulong num; + php_uint_t num; zval *data; ZEND_HASH_FOREACH_KEY_VAL(ht, num, index, data) { - zend_alter_ini_entry(index, Z_STRVAL_P(data), Z_STRLEN_P(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE); + zend_alter_ini_entry(index, Z_STRVAL_P(data), Z_STRSIZE_P(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE); } ZEND_HASH_FOREACH_END(); /* for (zend_hash_internal_pointer_reset_ex(ht, &pos); zend_hash_get_current_data_ex(ht, (void**)&data, &pos) == SUCCESS && zend_hash_get_current_key_ex(ht, &index, &index_len, &num, 0, &pos) == HASH_KEY_IS_STRING; zend_hash_move_forward_ex(ht, &pos)) { - zend_alter_ini_entry(index, index_len, Z_STRVAL_PP(data), Z_STRLEN_PP(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE); + zend_alter_ini_entry(index, index_len, Z_STRVAL_PP(data), Z_STRSIZE_PP(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE); } break; */ diff --git a/win32/sendmail.c b/win32/sendmail.c index c191e0f3aa..85a2e5b4c5 100644 --- a/win32/sendmail.c +++ b/win32/sendmail.c @@ -360,6 +360,9 @@ PHPAPI char *GetSMErrorText(int index) } } +PHPAPI zend_string *php_str_to_str(char *haystack, int length, char *needle, + int needle_len, char *str, int str_len); + /********************************************************************* // Name: SendText diff --git a/win32/winutil.c b/win32/winutil.c index 22e2d45304..9984d3addc 100644 --- a/win32/winutil.c +++ b/win32/winutil.c @@ -22,7 +22,7 @@ #include "php.h" #include <wincrypt.h> -PHPAPI char *php_win32_error_to_msg(int error) +PHPAPI char *php_win32_error_to_msg(HRESULT error) { char *buf = NULL; diff --git a/win32/winutil.h b/win32/winutil.h index 773063e5f6..e0193d33f3 100644 --- a/win32/winutil.h +++ b/win32/winutil.h @@ -16,7 +16,7 @@ +----------------------------------------------------------------------+ */ -PHPAPI char *php_win32_error_to_msg(int error); +PHPAPI char *php_win32_error_to_msg(HRESULT error); #define php_win_err() php_win32_error_to_msg(GetLastError()) int php_win32_check_trailing_space(const char * path, const int path_len); |