clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 09:57:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'weltling/master'

Browse Source 
* weltling/master: (725 commits)
  fix zpp
  fixed array_pad()
  fix zpp
  fix zpp
  fix zpp
  fix zpp and a bit more
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fix zpp
  fixed the test
  ...
This commit is contained in:
Anatol Belski 2014-08-22 08:58:03 +02:00
commit 79f888a602
511 changed files with 11688 additions and 11459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
TSRM/TSRM.h
View File

@ -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

2
Zend/Zend.m4
View File

@ -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)

20
Zend/zend.c
View File

@ -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(&params[0], type);
ZVAL_INT(&params[0], type);
if (error_filename) {
ZVAL_STRING(&params[2], error_filename);
@ -1166,7 +1166,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
ZVAL_NULL(&params[2]);
}
ZVAL_LONG(&params[3], error_lineno);
ZVAL_INT(&params[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++) {

30
Zend/zend.h
View File

@ -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()

202
Zend/zend_API.c
View File

@ -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) {
@ -3717,7 +3779,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;
@ -3726,11 +3788,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);
}
/* }}} */
@ -3781,11 +3843,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);
}
/* }}} */
@ -3851,7 +3913,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;
@ -3860,11 +3922,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);
}
/* }}} */
@ -3953,7 +4015,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;
@ -3962,11 +4024,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);
}
/* }}} */
@ -4070,10 +4132,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:

110
Zend/zend_API.h
View File

@ -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_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_long(zval *arg, long n);
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)
@ -547,7 +547,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 { \
@ -598,7 +598,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)
@ -614,7 +614,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; }
@ -899,28 +899,28 @@ 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))) { \
if (UNEXPECTED(!_z_param_int(_arg, &dest, &is_null, check_null, 0))) { \
_expected_type = Z_EXPECTED_LONG; \
error_code = ZPP_ERROR_WRONG_ARG; \
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))) { \
if (UNEXPECTED(!_z_param_int(_arg, &dest, &is_null, check_null, 1))) { \
_expected_type = Z_EXPECTED_LONG; \
error_code = ZPP_ERROR_WRONG_ARG; \
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) \
@ -1073,33 +1073,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_int(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;
@ -1125,10 +1125,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)) {

54
Zend/zend_alloc.c
View File

@ -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

19
Zend/zend_alloc.h
View File

@ -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 */

10
Zend/zend_ast.c
View File

@ -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);

90
Zend/zend_builtin_functions.c
View File

@ -364,7 +364,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));
}
/* }}} */
@ -403,10 +403,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);
}
}
/* }}} */
@ -417,10 +417,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;
}
@ -438,7 +438,7 @@ ZEND_FUNCTION(func_get_arg)
arg_count = ex->num_args;
if (requested_offset >= arg_count) {
zend_error(E_WARNING, "func_get_arg(): Argument %ld not passed to function", requested_offset);
zend_error(E_WARNING, "func_get_arg(): Argument " ZEND_INT_FMT " not passed to function", requested_offset);
RETURN_FALSE;
}
@ -534,7 +534,7 @@ ZEND_FUNCTION(strlen)
ZEND_PARSE_PARAMETERS_END();
#endif
RETVAL_LONG(s->len);
RETVAL_INT(s->len);
}
/* }}} */
@ -543,14 +543,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));
}
/* }}} */
@ -559,11 +558,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;
}
@ -572,7 +570,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));
}
/* }}} */
@ -581,14 +579,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));
}
/* }}} */
@ -597,11 +594,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;
}
@ -610,7 +606,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));
}
/* }}} */
@ -620,7 +616,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;
@ -666,7 +662,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);
@ -694,7 +690,7 @@ ZEND_FUNCTION(error_reporting)
STR_RELEASE(key);
}
RETVAL_LONG(old_error_reporting);
RETVAL_INT(old_error_reporting);
}
/* }}} */
@ -736,7 +732,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:
@ -1478,9 +1474,9 @@ 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) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &leakbytes) == FAILURE) {
return;
}
@ -1546,11 +1542,11 @@ 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;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &message, &message_len, &error_type) == FAILURE) {
return;
}
@ -1578,9 +1574,9 @@ 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) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|i", &error_handler, &error_type) == FAILURE) {
return;
}
@ -1886,11 +1882,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;
@ -1917,7 +1913,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
@ -1948,7 +1944,7 @@ ZEND_FUNCTION(get_resources)
{
zend_string *type = NULL;
zend_string *key;
ulong index;
zend_uint_t index;
zval *val;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S", &type) == FAILURE) {
@ -2169,10 +2165,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;
}
@ -2410,7 +2406,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
@ -2429,7 +2425,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;
@ -2557,10 +2553,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;
}

398
Zend/zend_compile.c
View File

File diff suppressed because it is too large Load Diff

16
Zend/zend_compile.h
View File

@ -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;

48
Zend/zend_constants.c
View File

@ -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_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_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_INT_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("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);
}
}
}

12
Zend/zend_constants.h
View File

@ -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

70
Zend/zend_exceptions.c
View File

@ -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_ex(&message);
convert_to_string_ex(&file);
convert_to_long_ex(&line);
convert_to_int_ex(&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_ex(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_ex(str);
convert_to_string_ex(file);
convert_to_long_ex(line);
convert_to_int_ex(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);
}

56
Zend/zend_execute.c
View File

@ -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 {

12
Zend/zend_execute.h
View File

@ -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);

22
Zend/zend_execute_API.c
View File

@ -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;

2
Zend/zend_generators.h
View File

@ -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;

6
Zend/zend_globals.h
View File

@ -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;

62
Zend/zend_hash.c
View File

@ -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;

70
Zend/zend_hash.h
View File

@ -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);

18
Zend/zend_ini.c
View File

@ -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;

6
Zend/zend_ini.h
View File

@ -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))

18
Zend/zend_ini_parser.y
View File

@ -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 {

4
Zend/zend_ini_scanner.c
View File

@ -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++ = '\\';

4
Zend/zend_ini_scanner.l
View File

@ -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++ = '\\';

145
Zend/zend_int.h Normal file
View File

@ -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:
*/

8
Zend/zend_interfaces.c
View File

@ -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 */

2
Zend/zend_iterators.h
View File

@ -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 {

50
Zend/zend_language_parser.y
View File

@ -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:

78
Zend/zend_language_scanner.c
View File

@ -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);
}

74
Zend/zend_language_scanner.l
View File

@ -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;

37
Zend/zend_multiply.h
View File

@ -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; \

32
Zend/zend_object_handlers.c
View File

@ -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);

2
Zend/zend_object_handlers.h
View File

@ -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);

2
Zend/zend_objects.c
View File

@ -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) {

6
Zend/zend_opcode.c
View File

@ -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 */

660
Zend/zend_operators.c
View File

File diff suppressed because it is too large Load Diff

308
Zend/zend_operators.h
View File

@ -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

2
Zend/zend_qsort.c
View File

@ -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;

9
Zend/zend_stream.c
View File

@ -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) {

19
Zend/zend_stream.h
View File

@ -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

4
Zend/zend_string.c
View File

@ -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;

14
Zend/zend_string.h
View File

@ -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) {

8
Zend/zend_ts_hash.c
View File

@ -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;

8
Zend/zend_ts_hash.h
View File

@ -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);

45
Zend/zend_types.h
View File

@ -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) { \

4
Zend/zend_variables.c
View File

@ -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:

54
Zend/zend_virtual_cwd.c
View File

@ -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);
@ -593,8 +593,8 @@ static inline unsigned long realpath_cache_key(const char *path, int path_len TS
return 0;
}
for (h = 2166136261U; bucket_key < e;) {
h *= 16777619;
for (h = Z_UI(2166136261); bucket_key < e;) {
h *= Z_UI(16777619);
h ^= *bucket_key++;
}
HeapFree(GetProcessHeap(), 0, (LPVOID)bucket_key_start);
@ -602,13 +602,13 @@ 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;) {
h *= 16777619;
for (h = Z_UI(2166136261); path < e;) {
h *= Z_UI(16777619);
h ^= *path++;
}
@ -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) {
@ -756,12 +756,12 @@ CWD_API realpath_cache_bucket* realpath_cache_lookup(const char *path, int path_
}
/* }}} */
CWD_API int realpath_cache_size(TSRMLS_D)
CWD_API zend_int_t realpath_cache_size(TSRMLS_D)
{
return CWDG(realpath_cache_size);
}
CWD_API int realpath_cache_max_buckets(TSRMLS_D)
CWD_API zend_int_t realpath_cache_max_buckets(TSRMLS_D)
{
return (sizeof(CWDG(realpath_cache)) / sizeof(CWDG(realpath_cache)[0]));
}
@ -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;

18
Zend/zend_virtual_cwd.h
View File

@ -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;
@ -246,8 +246,8 @@ extern virtual_cwd_globals cwd_globals;
CWD_API void realpath_cache_clean(TSRMLS_D);
CWD_API void realpath_cache_del(const char *path, int path_len TSRMLS_DC);
CWD_API realpath_cache_bucket* realpath_cache_lookup(const char *path, int path_len, time_t t TSRMLS_DC);
CWD_API int realpath_cache_size(TSRMLS_D);
CWD_API int realpath_cache_max_buckets(TSRMLS_D);
CWD_API zend_int_t realpath_cache_size(TSRMLS_D);
CWD_API zend_int_t realpath_cache_max_buckets(TSRMLS_D);
CWD_API realpath_cache_bucket** realpath_cache_get_buckets(TSRMLS_D);
/* The actual macros to be used in programs using TSRM

128
Zend/zend_vm_def.h
View File

@ -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));
@ -3630,7 +3630,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);
}
@ -3641,7 +3641,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);
}
@ -3653,7 +3653,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;
@ -3815,7 +3815,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 {
@ -3823,7 +3823,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 {
@ -3886,7 +3886,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);
@ -3938,15 +3938,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;
@ -4049,8 +4049,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));
@ -4146,7 +4146,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 {
@ -4159,7 +4159,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 {
@ -4329,7 +4329,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);
@ -4345,11 +4345,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;
@ -4610,12 +4610,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;
}
@ -4674,7 +4674,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));
@ -4695,15 +4695,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;
@ -4769,7 +4769,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
HANDLE_EXCEPTION();
}
} else {
ZVAL_LONG(key, iter->index);
ZVAL_INT(key, iter->index);
}
}
break;
@ -4874,7 +4874,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();
@ -4896,14 +4896,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();
@ -4948,20 +4948,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;
@ -5025,8 +5025,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);
}
@ -5042,9 +5042,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)) {
@ -5090,13 +5090,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)) {
@ -5465,14 +5465,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);
}
@ -5726,15 +5726,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)) {
@ -5873,15 +5873,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;
@ -5889,7 +5889,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):
@ -5912,7 +5912,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:

896
Zend/zend_vm_execute.h
View File

File diff suppressed because it is too large Load Diff

38
ext/bcmath/bcmath.c
View File

@ -206,12 +206,12 @@ static void php_str2num(bc_num *num, char *str TSRMLS_DC)
PHP_FUNCTION(bcadd)
{
char *left, *right;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second, result;
int left_len, right_len;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -244,11 +244,11 @@ PHP_FUNCTION(bcsub)
{
char *left, *right;
int left_len, right_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -281,11 +281,11 @@ PHP_FUNCTION(bcmul)
{
char *left, *right;
int left_len, right_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -318,11 +318,11 @@ PHP_FUNCTION(bcdiv)
{
char *left, *right;
int left_len, right_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -396,10 +396,10 @@ PHP_FUNCTION(bcpowmod)
char *left, *right, *modulous;
int left_len, right_len, modulous_len;
bc_num first, second, mod, result;
long scale = BCG(bc_precision);
php_int_t scale = BCG(bc_precision);
int scale_int;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &left, &left_len, &right, &right_len, &modulous, &modulous_len, &scale) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|i", &left, &left_len, &right, &right_len, &modulous, &modulous_len, &scale) == FAILURE) {
return;
}
@ -436,11 +436,11 @@ PHP_FUNCTION(bcpow)
{
char *left, *right;
int left_len, right_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second, result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -473,11 +473,11 @@ PHP_FUNCTION(bcsqrt)
{
char *left;
int left_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num result;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "s|l", &left, &left_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "s|i", &left, &left_len, &scale_param) == FAILURE) {
return;
}
@ -508,11 +508,11 @@ PHP_FUNCTION(bccomp)
{
char *left, *right;
int left_len, right_len;
long scale_param = 0;
php_int_t scale_param = 0;
bc_num first, second;
int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
if (zend_parse_parameters(argc TSRMLS_CC, "ss|i", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
return;
}
@ -525,7 +525,7 @@ PHP_FUNCTION(bccomp)
bc_str2num(&first, left, scale TSRMLS_CC);
bc_str2num(&second, right, scale TSRMLS_CC);
RETVAL_LONG(bc_compare(first, second));
RETVAL_INT(bc_compare(first, second));
bc_free_num(&first);
bc_free_num(&second);
@ -537,9 +537,9 @@ PHP_FUNCTION(bccomp)
Sets default scale parameter for all bc math functions */
PHP_FUNCTION(bcscale)
{
long new_scale;
php_int_t new_scale;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &new_scale) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &new_scale) == FAILURE) {
return;
}

2
ext/bcmath/php_bcmath.h
View File

@ -45,7 +45,7 @@ ZEND_BEGIN_MODULE_GLOBALS(bcmath)
bc_num _zero_;
bc_num _one_;
bc_num _two_;
long bc_precision;
php_int_t bc_precision;
ZEND_END_MODULE_GLOBALS(bcmath)
#ifdef ZTS

26
ext/bz2/bz2.c
View File

@ -343,11 +343,11 @@ static PHP_MINFO_FUNCTION(bz2)
static PHP_FUNCTION(bzread)
{
zval *bz;
long len = 1024;
php_int_t len = 1024;
php_stream *stream;
zend_string *data;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &bz, &len)) {
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|i", &bz, &len)) {
RETURN_FALSE;
}
@ -393,7 +393,7 @@ static PHP_FUNCTION(bzopen)
/* If it's not a resource its a string containing the filename to open */
if (Z_TYPE_P(file) == IS_STRING) {
if (Z_STRLEN_P(file) == 0) {
if (Z_STRSIZE_P(file) == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "filename cannot be empty");
RETURN_FALSE;
}
@ -406,7 +406,7 @@ static PHP_FUNCTION(bzopen)
} else if (Z_TYPE_P(file) == IS_RESOURCE) {
/* If it is a resource, than its a stream resource */
php_socket_t fd;
int stream_mode_len;
php_size_t stream_mode_len;
php_stream_from_zval(stream, file);
stream_mode_len = strlen(stream->mode);
@ -490,8 +490,8 @@ static PHP_FUNCTION(bzerror)
static PHP_FUNCTION(bzcompress)
{
char *source; /* Source data to compress */
long zblock_size = 0; /* Optional block size to use */
long zwork_factor = 0;/* Optional work factor to use */
php_int_t zblock_size = 0; /* Optional block size to use */
php_int_t zwork_factor = 0;/* Optional work factor to use */
zend_string *dest = NULL; /* Destination to place the compressed data into */
int error, /* Error Container */
block_size = 4, /* Block size for compression algorithm */
@ -502,7 +502,7 @@ static PHP_FUNCTION(bzcompress)
argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ii", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
return;
}
@ -527,7 +527,7 @@ static PHP_FUNCTION(bzcompress)
error = BZ2_bzBuffToBuffCompress(dest->val, &dest_len, source, source_len, block_size, 0, work_factor);
if (error != BZ_OK) {
STR_FREE(dest);
RETURN_LONG(error);
RETURN_INT(error);
} else {
/* Copy the buffer, we have perhaps allocate a lot more than we need,
so we erealloc() the buffer to the proper size */
@ -544,7 +544,7 @@ static PHP_FUNCTION(bzdecompress)
{
char *source, *dest;
int source_len, error;
long small = 0;
php_int_t small = 0;
#if defined(PHP_WIN32)
unsigned __int64 size = 0;
#else
@ -552,7 +552,7 @@ static PHP_FUNCTION(bzdecompress)
#endif
bz_stream bzs;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &small)) {
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &source, &source_len, &small)) {
RETURN_FALSE;
}
@ -586,7 +586,7 @@ static PHP_FUNCTION(bzdecompress)
efree(dest);
} else { /* real error */
efree(dest);
RETVAL_LONG(error);
RETVAL_INT(error);
}
BZ2_bzDecompressEnd(&bzs);
@ -621,7 +621,7 @@ static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
/* Determine what to return */
switch (opt) {
case PHP_BZ_ERRNO:
RETURN_LONG(errnum);
RETURN_INT(errnum);
break;
case PHP_BZ_ERRSTR:
RETURN_STRING((char*)errstr);
@ -629,7 +629,7 @@ static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
case PHP_BZ_ERRBOTH:
array_init(return_value);
add_assoc_long (return_value, "errno", errnum);
add_assoc_int (return_value, "errno", errnum);
add_assoc_string(return_value, "errstr", (char*)errstr);
break;
}

16
ext/bz2/bz2_filter.c
View File

@ -380,11 +380,11 @@ static php_stream_filter *php_bz2_filter_create(const char *filtername, zval *fi
zval tmp;
ZVAL_DUP(&tmp, tmpzval);
convert_to_long(&tmp);
if (Z_LVAL(tmp) < 1 || Z_LVAL(tmp) > 9) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for number of blocks to allocate. (%ld)", Z_LVAL_P(tmpzval));
convert_to_int(&tmp);
if (Z_IVAL(tmp) < 1 || Z_IVAL(tmp) > 9) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for number of blocks to allocate. (%ld)", Z_IVAL_P(tmpzval));
} else {
blockSize100k = Z_LVAL(tmp);
blockSize100k = Z_IVAL(tmp);
}
}
@ -393,12 +393,12 @@ static php_stream_filter *php_bz2_filter_create(const char *filtername, zval *fi
zval tmp;
ZVAL_DUP(&tmp, tmpzval);
convert_to_long(&tmp);
convert_to_int(&tmp);
if (Z_LVAL(tmp) < 0 || Z_LVAL(tmp) > 250) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for work factor. (%ld)", Z_LVAL(tmp));
if (Z_IVAL(tmp) < 0 || Z_IVAL(tmp) > 250) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for work factor. (%ld)", Z_IVAL(tmp));
} else {
workFactor = Z_LVAL(tmp);
workFactor = Z_IVAL(tmp);
}
}
}

6
ext/calendar/cal_unix.c
View File

@ -31,7 +31,7 @@ PHP_FUNCTION(unixtojd)
time_t ts = 0;
struct tm *ta, tmbuf;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &ts) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &ts) == FAILURE) {
return;
}
@ -45,7 +45,7 @@ PHP_FUNCTION(unixtojd)
RETURN_FALSE;
}
RETURN_LONG(GregorianToSdn(ta->tm_year+1900, ta->tm_mon+1, ta->tm_mday));
RETURN_INT(GregorianToSdn(ta->tm_year+1900, ta->tm_mon+1, ta->tm_mday));
}
/* }}} */
@ -64,7 +64,7 @@ PHP_FUNCTION(jdtounix)
RETURN_FALSE;
}
RETURN_LONG(uday * 24 * 3600);
RETURN_INT(uday * 24 * 3600);
}
/* }}} */

134
ext/calendar/calendar.c
View File

@ -178,8 +178,8 @@ enum cal_name_type_t {
CAL_NUM_CALS
};
typedef long int (*cal_to_jd_func_t) (int month, int day, int year);
typedef void (*cal_from_jd_func_t) (long int jd, int *year, int *month, int *day);
typedef php_int_t (*cal_to_jd_func_t) (int month, int day, int year);
typedef void (*cal_from_jd_func_t) (php_int_t jd, int *year, int *month, int *day);
typedef char *(*cal_as_string_func_t) (int year, int month, int day);
struct cal_entry_t {
@ -225,31 +225,31 @@ static char alef_bet[25] = "0
PHP_MINIT_FUNCTION(calendar)
{
REGISTER_LONG_CONSTANT("CAL_GREGORIAN", CAL_GREGORIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_JULIAN", CAL_JULIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_JEWISH", CAL_JEWISH, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_FRENCH", CAL_FRENCH, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_NUM_CALS", CAL_NUM_CALS, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_GREGORIAN", CAL_GREGORIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_JULIAN", CAL_JULIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_JEWISH", CAL_JEWISH, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_FRENCH", CAL_FRENCH, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_NUM_CALS", CAL_NUM_CALS, CONST_CS | CONST_PERSISTENT);
/* constants for jddayofweek */
REGISTER_LONG_CONSTANT("CAL_DOW_DAYNO", CAL_DOW_DAYNO, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_DOW_SHORT", CAL_DOW_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_DOW_LONG", CAL_DOW_LONG, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_DOW_DAYNO", CAL_DOW_DAYNO, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_DOW_SHORT", CAL_DOW_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_DOW_LONG", CAL_DOW_LONG, CONST_CS | CONST_PERSISTENT);
/* constants for jdmonthname */
REGISTER_LONG_CONSTANT("CAL_MONTH_GREGORIAN_SHORT", CAL_MONTH_GREGORIAN_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_MONTH_GREGORIAN_LONG", CAL_MONTH_GREGORIAN_LONG, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_MONTH_JULIAN_SHORT", CAL_MONTH_JULIAN_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_MONTH_JULIAN_LONG", CAL_MONTH_JULIAN_LONG, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_MONTH_JEWISH", CAL_MONTH_JEWISH, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_MONTH_FRENCH", CAL_MONTH_FRENCH, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_GREGORIAN_SHORT", CAL_MONTH_GREGORIAN_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_GREGORIAN_LONG", CAL_MONTH_GREGORIAN_LONG, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_JULIAN_SHORT", CAL_MONTH_JULIAN_SHORT, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_JULIAN_LONG", CAL_MONTH_JULIAN_LONG, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_JEWISH", CAL_MONTH_JEWISH, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_MONTH_FRENCH", CAL_MONTH_FRENCH, CONST_CS | CONST_PERSISTENT);
/* constants for easter calculation */
REGISTER_LONG_CONSTANT("CAL_EASTER_DEFAULT", CAL_EASTER_DEFAULT, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_EASTER_ROMAN", CAL_EASTER_ROMAN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_EASTER_ALWAYS_GREGORIAN", CAL_EASTER_ALWAYS_GREGORIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_EASTER_ALWAYS_JULIAN", CAL_EASTER_ALWAYS_JULIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_EASTER_DEFAULT", CAL_EASTER_DEFAULT, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_EASTER_ROMAN", CAL_EASTER_ROMAN, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_EASTER_ALWAYS_GREGORIAN", CAL_EASTER_ALWAYS_GREGORIAN, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_EASTER_ALWAYS_JULIAN", CAL_EASTER_ALWAYS_JULIAN, CONST_CS | CONST_PERSISTENT);
/* constants for Jewish date formatting */
REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_ALAFIM_GERESH", CAL_JEWISH_ADD_ALAFIM_GERESH, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_ALAFIM", CAL_JEWISH_ADD_ALAFIM, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_GERESHAYIM", CAL_JEWISH_ADD_GERESHAYIM, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_JEWISH_ADD_ALAFIM_GERESH", CAL_JEWISH_ADD_ALAFIM_GERESH, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_JEWISH_ADD_ALAFIM", CAL_JEWISH_ADD_ALAFIM, CONST_CS | CONST_PERSISTENT);
REGISTER_INT_CONSTANT("CAL_JEWISH_ADD_GERESHAYIM", CAL_JEWISH_ADD_GERESHAYIM, CONST_CS | CONST_PERSISTENT);
return SUCCESS;
}
@ -279,7 +279,7 @@ static void _php_cal_info(int cal, zval *ret)
add_assoc_zval(ret, "months", &months);
add_assoc_zval(ret, "abbrevmonths", &smonths);
add_assoc_long(ret, "maxdaysinmonth", calendar->max_days_in_month);
add_assoc_int(ret, "maxdaysinmonth", calendar->max_days_in_month);
add_assoc_string(ret, "calname", calendar->name);
add_assoc_string(ret, "calsymbol", calendar->symbol);
@ -289,10 +289,10 @@ static void _php_cal_info(int cal, zval *ret)
Returns information about a particular calendar */
PHP_FUNCTION(cal_info)
{
long cal = -1;
php_int_t cal = -1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &cal) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &cal) == FAILURE) {
RETURN_FALSE;
}
@ -324,16 +324,16 @@ PHP_FUNCTION(cal_info)
Returns the number of days in a month for a given year and calendar */
PHP_FUNCTION(cal_days_in_month)
{
long cal, month, year;
php_int_t cal, month, year;
struct cal_entry_t *calendar;
long sdn_start, sdn_next;
php_int_t sdn_start, sdn_next;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &cal, &month, &year) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &cal, &month, &year) == FAILURE) {
RETURN_FALSE;
}
if (cal < 0 || cal >= CAL_NUM_CALS) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld.", cal);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %pd.", cal);
RETURN_FALSE;
}
@ -360,7 +360,7 @@ PHP_FUNCTION(cal_days_in_month)
}
}
RETURN_LONG(sdn_next - sdn_start);
RETURN_INT(sdn_next - sdn_start);
}
/* }}} */
@ -368,18 +368,18 @@ PHP_FUNCTION(cal_days_in_month)
Converts from a supported calendar to Julian Day Count */
PHP_FUNCTION(cal_to_jd)
{
long cal, month, day, year;
php_int_t cal, month, day, year;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llll", &cal, &month, &day, &year) != SUCCESS) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iiii", &cal, &month, &day, &year) != SUCCESS) {
RETURN_FALSE;
}
if (cal < 0 || cal >= CAL_NUM_CALS) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld.", cal);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %pd.", cal);
RETURN_FALSE;
}
RETURN_LONG(cal_conversion_table[cal].to_jd(year, month, day));
RETURN_INT(cal_conversion_table[cal].to_jd(year, month, day));
}
/* }}} */
@ -387,17 +387,17 @@ PHP_FUNCTION(cal_to_jd)
Converts from Julian Day Count to a supported calendar and return extended information */
PHP_FUNCTION(cal_from_jd)
{
long jd, cal;
php_int_t jd, cal;
int month, day, year, dow;
char date[16];
struct cal_entry_t *calendar;
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "ll", &jd, &cal) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "ii", &jd, &cal) == FAILURE) {
RETURN_FALSE;
}
if (cal < 0 || cal >= CAL_NUM_CALS) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld", cal);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %pd", cal);
RETURN_FALSE;
}
calendar = &cal_conversion_table[cal];
@ -409,13 +409,13 @@ PHP_FUNCTION(cal_from_jd)
snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
add_assoc_string(return_value, "date", date);
add_assoc_long(return_value, "month", month);
add_assoc_long(return_value, "day", day);
add_assoc_long(return_value, "year", year);
add_assoc_int(return_value, "month", month);
add_assoc_int(return_value, "day", day);
add_assoc_int(return_value, "year", year);
/* day of week */
dow = DayOfWeek(jd);
add_assoc_long(return_value, "dow", dow);
add_assoc_int(return_value, "dow", dow);
add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow]);
add_assoc_string(return_value, "dayname", DayNameLong[dow]);
/* month name */
@ -434,11 +434,11 @@ PHP_FUNCTION(cal_from_jd)
Converts a julian day count to a gregorian calendar date */
PHP_FUNCTION(jdtogregorian)
{
long julday;
php_int_t julday;
int year, month, day;
char date[16];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &julday) == FAILURE) {
RETURN_FALSE;
}
@ -453,13 +453,13 @@ PHP_FUNCTION(jdtogregorian)
Converts a gregorian calendar date to julian day count */
PHP_FUNCTION(gregoriantojd)
{
long year, month, day;
php_int_t year, month, day;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &month, &day, &year) == FAILURE) {
RETURN_FALSE;
}
RETURN_LONG(GregorianToSdn(year, month, day));
RETURN_INT(GregorianToSdn(year, month, day));
}
/* }}} */
@ -467,11 +467,11 @@ PHP_FUNCTION(gregoriantojd)
Convert a julian day count to a julian calendar date */
PHP_FUNCTION(jdtojulian)
{
long julday;
php_int_t julday;
int year, month, day;
char date[16];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &julday) == FAILURE) {
RETURN_FALSE;
}
@ -486,13 +486,13 @@ PHP_FUNCTION(jdtojulian)
Converts a julian calendar date to julian day count */
PHP_FUNCTION(juliantojd)
{
long year, month, day;
php_int_t year, month, day;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &month, &day, &year) == FAILURE) {
RETURN_FALSE;
}
RETURN_LONG(JulianToSdn(year, month, day));
RETURN_INT(JulianToSdn(year, month, day));
}
/* }}} */
@ -595,13 +595,13 @@ static char *heb_number_to_chars(int n, int fl, char **ret)
Converts a julian day count to a jewish calendar date */
PHP_FUNCTION(jdtojewish)
{
long julday, fl = 0;
php_int_t julday, fl = 0;
zend_bool heb = 0;
int year, month, day;
char date[16], hebdate[32];
char *dayp, *yearp;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|bl", &julday, &heb, &fl) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i|bi", &julday, &heb, &fl) == FAILURE) {
RETURN_FALSE;
}
@ -634,13 +634,13 @@ PHP_FUNCTION(jdtojewish)
Converts a jewish calendar date to a julian day count */
PHP_FUNCTION(jewishtojd)
{
long year, month, day;
php_int_t year, month, day;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &month, &day, &year) == FAILURE) {
RETURN_FALSE;
}
RETURN_LONG(JewishToSdn(year, month, day));
RETURN_INT(JewishToSdn(year, month, day));
}
/* }}} */
@ -648,11 +648,11 @@ PHP_FUNCTION(jewishtojd)
Converts a julian day count to a french republic calendar date */
PHP_FUNCTION(jdtofrench)
{
long julday;
php_int_t julday;
int year, month, day;
char date[16];
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &julday) == FAILURE) {
RETURN_FALSE;
}
@ -667,13 +667,13 @@ PHP_FUNCTION(jdtofrench)
Converts a french republic calendar date to julian day count */
PHP_FUNCTION(frenchtojd)
{
long year, month, day;
php_int_t year, month, day;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &month, &day, &year) == FAILURE) {
RETURN_FALSE;
}
RETURN_LONG(FrenchToSdn(year, month, day));
RETURN_INT(FrenchToSdn(year, month, day));
}
/* }}} */
@ -681,11 +681,11 @@ PHP_FUNCTION(frenchtojd)
Returns name or number of day of week from julian day count */
PHP_FUNCTION(jddayofweek)
{
long julday, mode = CAL_DOW_DAYNO;
php_int_t julday, mode = CAL_DOW_DAYNO;
int day;
char *daynamel, *daynames;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &julday, &mode) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i|i", &julday, &mode) == FAILURE) {
RETURN_FALSE;
}
@ -702,7 +702,7 @@ PHP_FUNCTION(jddayofweek)
break;
case CAL_DOW_DAYNO:
default:
RETURN_LONG(day);
RETURN_INT(day);
break;
}
}
@ -712,11 +712,11 @@ PHP_FUNCTION(jddayofweek)
Returns name of month for julian day count */
PHP_FUNCTION(jdmonthname)
{
long julday, mode;
php_int_t julday, mode;
char *monthname = NULL;
int month, day, year;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &julday, &mode) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ii", &julday, &mode) == FAILURE) {
RETURN_FALSE;
}

2
ext/calendar/dow.c
View File

@ -32,7 +32,7 @@
#include "sdncal.h"
int DayOfWeek(
long int sdn)
php_int_t sdn)
{
int dow;

10
ext/calendar/easter.c
View File

@ -24,14 +24,14 @@
#include "sdncal.h"
#include <time.h>
static void _cal_easter(INTERNAL_FUNCTION_PARAMETERS, int gm)
static void _cal_easter(INTERNAL_FUNCTION_PARAMETERS, php_int_t gm)
{
/* based on code by Simon Kershaw, <webmaster@ely.anglican.org> */
struct tm te;
long year, golden, solar, lunar, pfm, dom, tmp, easter, result;
long method = CAL_EASTER_DEFAULT;
php_int_t year, golden, solar, lunar, pfm, dom, tmp, easter, result;
php_int_t method = CAL_EASTER_DEFAULT;
/* Default to the current year if year parameter is not given */
{
@ -47,7 +47,7 @@ static void _cal_easter(INTERNAL_FUNCTION_PARAMETERS, int gm)
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"|ll", &year, &method) == FAILURE) {
"|ii", &year, &method) == FAILURE) {
return;
}
@ -115,7 +115,7 @@ static void _cal_easter(INTERNAL_FUNCTION_PARAMETERS, int gm)
} else { /* return the days after March 21 */
result = easter;
}
ZVAL_LONG(return_value, result);
ZVAL_INT(return_value, result);
}
/* {{{ proto int easter_date([int year])

6
ext/calendar/french.c
View File

@ -93,12 +93,12 @@
#define LAST_VALID 2380952
void SdnToFrench(
long int sdn,
php_int_t sdn,
int *pYear,
int *pMonth,
int *pDay)
{
long int temp;
php_int_t temp;
int dayOfYear;
if (sdn < FIRST_VALID || sdn > LAST_VALID) {
@ -114,7 +114,7 @@ void SdnToFrench(
*pDay = dayOfYear % DAYS_PER_MONTH + 1;
}
long int FrenchToSdn(
php_int_t FrenchToSdn(
int year,
int month,
int day)

6
ext/calendar/gregor.c
View File

@ -135,7 +135,7 @@
#define DAYS_PER_400_YEARS 146097
void SdnToGregorian(
long int sdn,
php_int_t sdn,
int *pYear,
int *pMonth,
int *pDay)
@ -144,7 +144,7 @@ void SdnToGregorian(
int year;
int month;
int day;
long int temp;
php_int_t temp;
int dayOfYear;
if (sdn <= 0 ||
@ -190,7 +190,7 @@ fail:
*pDay = 0;
}
long int GregorianToSdn(
php_int_t GregorianToSdn(
int inputYear,
int inputMonth,
int inputDay)

44
ext/calendar/jewish.c
View File

@ -382,12 +382,12 @@ char *JewishMonthHebName[14] =
* (called dehiyyot) delays it. These 4 rules can delay the start of the
* year by as much as 2 days.
*/
static long int Tishri1(
static php_int_t Tishri1(
int metonicYear,
long int moladDay,
long int moladHalakim)
php_int_t moladDay,
php_int_t moladHalakim)
{
long int tishri1;
php_int_t tishri1;
int dow;
int leapYear;
int lastWasLeapYear;
@ -429,10 +429,10 @@ static long int Tishri1(
*/
static void MoladOfMetonicCycle(
int metonicCycle,
long int *pMoladDay,
long int *pMoladHalakim)
php_int_t *pMoladDay,
php_int_t *pMoladHalakim)
{
register unsigned long int r1, r2, d1, d2;
register php_uint_t r1, r2, d1, d2;
/* Start with the time of the first molad after creation. */
r1 = NEW_MOON_OF_CREATION;
@ -468,14 +468,14 @@ static void MoladOfMetonicCycle(
* us to avoid calculating the length of the year in most cases.
*/
static void FindTishriMolad(
long int inputDay,
php_int_t inputDay,
int *pMetonicCycle,
int *pMetonicYear,
long int *pMoladDay,
long int *pMoladHalakim)
php_int_t *pMoladDay,
php_int_t *pMoladHalakim)
{
long int moladDay;
long int moladHalakim;
php_int_t moladDay;
php_int_t moladHalakim;
int metonicCycle;
int metonicYear;
@ -523,8 +523,8 @@ static void FindStartOfYear(
int year,
int *pMetonicCycle,
int *pMetonicYear,
long int *pMoladDay,
long int *pMoladHalakim,
php_int_t *pMoladDay,
php_int_t *pMoladHalakim,
int *pTishri1)
{
*pMetonicCycle = (year - 1) / 19;
@ -546,14 +546,14 @@ static void FindStartOfYear(
* range 1 to 13 inclusive; *pDay will be in the range 1 to 30 inclusive.
*/
void SdnToJewish(
long int sdn,
php_int_t sdn,
int *pYear,
int *pMonth,
int *pDay)
{
long int inputDay;
long int day;
long int halakim;
php_int_t inputDay;
php_int_t day;
php_int_t halakim;
int metonicCycle;
int metonicYear;
int tishri1;
@ -684,18 +684,18 @@ void SdnToJewish(
* value. To verify that a date is valid, convert it to SDN and then back
* and compare with the original.
*/
long int JewishToSdn(
php_int_t JewishToSdn(
int year,
int month,
int day)
{
long int sdn;
php_int_t sdn;
int metonicCycle;
int metonicYear;
int tishri1;
int tishri1After;
long int moladDay;
long int moladHalakim;
php_int_t moladDay;
php_int_t moladHalakim;
int yearLength;
int lengthOfAdarIAndII;

10
ext/calendar/julian.c
View File

@ -11,7 +11,7 @@
*
* void
* SdnToJulian(
* long int sdn,
* php_int_t sdn,
* int *pYear,
* int *pMonth,
* int *pDay);
@ -21,7 +21,7 @@
* will be >= -4713 and != 0; *pMonth will be in the range 1 to 12
* inclusive; *pDay will be in the range 1 to 31 inclusive.
*
* long int
* php_int_t
* JulianToSdn(
* int inputYear,
* int inputMonth,
@ -153,7 +153,7 @@
#define DAYS_PER_4_YEARS 1461
void SdnToJulian(
long int sdn,
php_int_t sdn,
int *pYear,
int *pMonth,
int *pDay)
@ -161,7 +161,7 @@ void SdnToJulian(
int year;
int month;
int day;
long int temp;
php_int_t temp;
int dayOfYear;
if (sdn <= 0) {
@ -212,7 +212,7 @@ fail:
*pDay = 0;
}
long int JulianToSdn(
php_int_t JulianToSdn(
int inputYear,
int inputMonth,
int inputDay)

22
ext/calendar/sdncal.h
View File

@ -53,7 +53,7 @@
*
* int y1, m1, d1;
* int y2, m2, d2;
* long int sdn;
* php_int_t sdn;
* ...
* sdn = GregorianToSdn(y1, m1, d1);
* if (sdn > 0) {
@ -65,19 +65,21 @@
*
**************************************************************************/
#include "php.h"
/* Gregorian calendar conversions. */
void SdnToGregorian(long int sdn, int *pYear, int *pMonth, int *pDay);
long int GregorianToSdn(int year, int month, int day);
void SdnToGregorian(php_int_t sdn, int *pYear, int *pMonth, int *pDay);
php_int_t GregorianToSdn(int year, int month, int day);
extern char *MonthNameShort[13];
extern char *MonthNameLong[13];
/* Julian calendar conversions. */
void SdnToJulian(long int sdn, int *pYear, int *pMonth, int *pDay);
long int JulianToSdn(int year, int month, int day);
void SdnToJulian(php_int_t sdn, int *pYear, int *pMonth, int *pDay);
php_int_t JulianToSdn(int year, int month, int day);
/* Jewish calendar conversions. */
void SdnToJewish(long int sdn, int *pYear, int *pMonth, int *pDay);
long int JewishToSdn(int year, int month, int day);
void SdnToJewish(php_int_t sdn, int *pYear, int *pMonth, int *pDay);
php_int_t JewishToSdn(int year, int month, int day);
extern char *JewishMonthName[14];
extern char *JewishMonthNameLeap[14];
extern char *JewishMonthHebName[14];
@ -85,15 +87,15 @@ extern char *JewishMonthHebNameLeap[14];
extern int monthsPerYear[19];
/* French republic calendar conversions. */
void SdnToFrench(long int sdn, int *pYear, int *pMonth, int *pDay);
long int FrenchToSdn(int inputYear, int inputMonth, int inputDay);
void SdnToFrench(php_int_t sdn, int *pYear, int *pMonth, int *pDay);
php_int_t FrenchToSdn(int inputYear, int inputMonth, int inputDay);
extern char *FrenchMonthName[14];
/* Islamic calendar conversions. */
/* Not implemented yet. */
/* Day of week conversion. 0=Sunday, 6=Saturday */
int DayOfWeek(long int sdn);
int DayOfWeek(php_int_t sdn);
extern char *DayNameShort[7];
extern char *DayNameLong[7];

28
ext/com_dotnet/com_com.c
View File

@ -57,11 +57,11 @@ PHP_FUNCTION(com_create_instance)
obj = CDNO_FETCH(object);
if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
ZEND_NUM_ARGS() TSRMLS_CC, "s|s!ls",
ZEND_NUM_ARGS() TSRMLS_CC, "s|s!is",
&module_name, &module_name_len, &server_name, &server_name_len,
&obj->code_page, &typelib_name, &typelib_name_len) &&
FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
ZEND_NUM_ARGS() TSRMLS_CC, "sa|ls",
ZEND_NUM_ARGS() TSRMLS_CC, "sa|is",
&module_name, &module_name_len, &server_params, &obj->code_page,
&typelib_name, &typelib_name_len)) {
@ -81,7 +81,7 @@ PHP_FUNCTION(com_create_instance)
"Server", sizeof("Server")-1))) {
convert_to_string_ex(tmp);
server_name = Z_STRVAL_P(tmp);
server_name_len = Z_STRLEN_P(tmp);
server_name_len = Z_STRSIZE_P(tmp);
ctx = CLSCTX_REMOTE_SERVER;
}
@ -89,27 +89,27 @@ PHP_FUNCTION(com_create_instance)
"Username", sizeof("Username")-1))) {
convert_to_string_ex(tmp);
user_name = Z_STRVAL_P(tmp);
user_name_len = Z_STRLEN_P(tmp);
user_name_len = Z_STRSIZE_P(tmp);
}
if (NULL != (tmp = zend_hash_str_find(HASH_OF(server_params),
"Password", sizeof("Password")-1))) {
convert_to_string_ex(tmp);
password = Z_STRVAL_P(tmp);
password_len = Z_STRLEN_P(tmp);
password_len = Z_STRSIZE_P(tmp);
}
if (NULL != (tmp = zend_hash_str_find(HASH_OF(server_params),
"Domain", sizeof("Domain")-1))) {
convert_to_string_ex(tmp);
domain_name = Z_STRVAL_P(tmp);
domain_name_len = Z_STRLEN_P(tmp);
domain_name_len = Z_STRSIZE_P(tmp);
}
if (NULL != (tmp = zend_hash_str_find(HASH_OF(server_params),
"Flags", sizeof("Flags")-1))) {
convert_to_long_ex(tmp);
ctx = (CLSCTX)Z_LVAL_P(tmp);
convert_to_int_ex(tmp);
ctx = (CLSCTX)Z_IVAL_P(tmp);
}
}
@ -289,14 +289,14 @@ PHP_FUNCTION(com_get_active_object)
CLSID clsid;
char *module_name;
int module_name_len;
long code_page = COMG(code_page);
php_int_t code_page = COMG(code_page);
IUnknown *unk = NULL;
IDispatch *obj = NULL;
HRESULT res;
OLECHAR *module = NULL;
php_com_initialize(TSRMLS_C);
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l",
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i",
&module_name, &module_name_len, &code_page)) {
php_com_throw_exception(E_INVALIDARG, "Invalid arguments!" TSRMLS_CC);
return;
@ -427,7 +427,7 @@ HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
}
if (obj->id_of_name_cache && NULL != (tmp = zend_hash_str_find(obj->id_of_name_cache, name, namelen))) {
*dispid = Z_LVAL_P(tmp);
*dispid = Z_IVAL_P(tmp);
return S_OK;
}
@ -456,7 +456,7 @@ HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
ALLOC_HASHTABLE(obj->id_of_name_cache);
zend_hash_init(obj->id_of_name_cache, 2, NULL, NULL, 0);
}
ZVAL_LONG(&tmp, *dispid);
ZVAL_INT(&tmp, *dispid);
zend_hash_str_update(obj->id_of_name_cache, name, namelen, &tmp);
}
@ -784,11 +784,11 @@ PHP_FUNCTION(com_print_typeinfo)
Process COM messages, sleeping for up to timeoutms milliseconds */
PHP_FUNCTION(com_message_pump)
{
long timeoutms = 0;
php_int_t timeoutms = 0;
MSG msg;
DWORD result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &timeoutms) == FAILURE)
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &timeoutms) == FAILURE)
RETURN_FALSE;
php_com_initialize(TSRMLS_C);

2
ext/com_dotnet/com_dotnet.c
View File

@ -243,7 +243,7 @@ PHP_FUNCTION(com_dotnet_create_instance)
obj = CDNO_FETCH(object);
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l",
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|i",
&assembly_name, &assembly_name_len,
&datatype_name, &datatype_name_len,
&obj->code_page)) {

18
ext/com_dotnet/com_extension.c
View File

@ -22,6 +22,8 @@
#include "config.h"
#endif
#include <intsafe.h>
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
@ -381,7 +383,13 @@ PHP_MINIT_FUNCTION(com_dotnet)
REGISTER_INI_ENTRIES();
#define COM_CONST(x) REGISTER_LONG_CONSTANT(#x, x, CONST_CS|CONST_PERSISTENT)
#define COM_CONST(x) REGISTER_INT_CONSTANT(#x, x, CONST_CS|CONST_PERSISTENT)
#define COM_ERR_CONST(x) { \
php_int_t __tmp; \
ULongToUIntPtr(x, &__tmp); \
REGISTER_INT_CONSTANT(#x, __tmp, CONST_CS|CONST_PERSISTENT); \
}
COM_CONST(CLSCTX_INPROC_SERVER);
COM_CONST(CLSCTX_INPROC_HANDLER);
@ -441,10 +449,10 @@ PHP_MINIT_FUNCTION(com_dotnet)
#ifdef NORM_IGNOREKASHIDA
COM_CONST(NORM_IGNOREKASHIDA);
#endif
COM_CONST(DISP_E_DIVBYZERO);
COM_CONST(DISP_E_OVERFLOW);
COM_CONST(DISP_E_BADINDEX);
COM_CONST(MK_E_UNAVAILABLE);
COM_ERR_CONST(DISP_E_DIVBYZERO);
COM_ERR_CONST(DISP_E_OVERFLOW);
COM_ERR_CONST(DISP_E_BADINDEX);
COM_ERR_CONST(MK_E_UNAVAILABLE);
return SUCCESS;
}

16
ext/com_dotnet/com_handlers.c
View File

@ -44,7 +44,7 @@ static zval *com_property_read(zval *object, zval *member, int type, void **cahc
convert_to_string_ex(member);
res = php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
res = php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRSIZE_P(member),
DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1 TSRMLS_CC);
if (res == SUCCESS) {
@ -71,7 +71,7 @@ static void com_property_write(zval *object, zval *member, zval *value, void **c
VariantInit(&v);
convert_to_string_ex(member);
if (SUCCESS == php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
if (SUCCESS == php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRSIZE_P(member),
DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &v, 1, value, 0 TSRMLS_CC)) {
VariantClear(&v);
}
@ -98,10 +98,10 @@ static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv T
VariantClear(&v);
}
} else if (V_ISARRAY(&obj->v)) {
convert_to_long(offset);
convert_to_int(offset);
if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {
if (php_com_safearray_get_elem(&obj->v, &v, Z_LVAL_P(offset) TSRMLS_CC)) {
if (php_com_safearray_get_elem(&obj->v, &v, Z_IVAL_P(offset) TSRMLS_CC)) {
php_com_wrap_variant(rv, &v, obj->code_page TSRMLS_CC);
VariantClear(&v);
}
@ -144,8 +144,8 @@ static void com_write_dimension(zval *object, zval *offset, zval *value TSRMLS_D
vt = V_VT(&obj->v) & ~VT_ARRAY;
}
convert_to_long(offset);
indices = Z_LVAL_P(offset);
convert_to_int(offset);
indices = Z_IVAL_P(offset);
VariantInit(&v);
php_com_variant_from_zval(&v, value, obj->code_page TSRMLS_CC);
@ -197,7 +197,7 @@ static int com_property_exists(zval *object, zval *member, int check_empty, void
if (V_VT(&obj->v) == VT_DISPATCH) {
convert_to_string_ex(member);
if (SUCCEEDED(php_com_get_id_of_name(obj, Z_STRVAL_P(member), Z_STRLEN_P(member), &dispid TSRMLS_CC))) {
if (SUCCEEDED(php_com_get_id_of_name(obj, Z_STRVAL_P(member), Z_STRSIZE_P(member), &dispid TSRMLS_CC))) {
/* TODO: distinguish between property and method! */
return 1;
}
@ -491,7 +491,7 @@ static int com_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
}
switch(type) {
case IS_LONG:
case IS_INT:
vt = VT_INT;
break;
case IS_DOUBLE:

6
ext/com_dotnet/com_iterator.c
View File

@ -32,7 +32,7 @@
struct php_com_iterator {
zend_object_iterator iter;
IEnumVARIANT *ev;
ulong key;
php_uint_t key;
VARIANT v; /* cached element */
int code_page;
VARIANT safe_array;
@ -75,10 +75,10 @@ static void com_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
{
struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
if (I->key == (ulong)-1) {
if (I->key == (php_uint_t)-1) {
ZVAL_NULL(key);
} else {
ZVAL_LONG(key, I->key);
ZVAL_INT(key, I->key);
}
}

2
ext/com_dotnet/com_misc.c
View File

@ -36,7 +36,7 @@ void php_com_throw_exception(HRESULT code, char *message TSRMLS_DC)
message = php_win32_error_to_msg(code);
free_msg = 1;
}
zend_throw_exception(php_com_exception_class_entry, message, (long)code TSRMLS_CC);
zend_throw_exception(php_com_exception_class_entry, message, (php_int_t)code TSRMLS_CC);
if (free_msg) {
LocalFree(message);
}

6
ext/com_dotnet/com_persist.c
View File

@ -439,7 +439,7 @@ CPH_METHOD(LoadFromFile)
HRESULT res;
char *filename, *fullpath;
int filename_len;
long flags = 0;
php_int_t flags = 0;
OLECHAR *olefilename;
CPH_FETCH();
@ -448,7 +448,7 @@ CPH_METHOD(LoadFromFile)
res = get_persist_file(helper);
if (helper->ipf) {
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l",
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|i",
&filename, &filename_len, &flags)) {
php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
return;
@ -506,7 +506,7 @@ CPH_METHOD(GetMaxStreamSize)
php_com_throw_exception(res, NULL TSRMLS_CC);
} else {
/* TODO: handle 64 bit properly */
RETURN_LONG((LONG)size.QuadPart);
RETURN_INT((php_int_t)size.QuadPart);
}
}
/* }}} */

30
ext/com_dotnet/com_saproxy.c
View File

@ -113,7 +113,7 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
VariantInit(&v);
res = php_com_do_invoke(proxy->obj, Z_STRVAL(proxy->indices[0]),
Z_STRLEN(proxy->indices[0]), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v,
Z_STRSIZE(proxy->indices[0]), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v,
proxy->dimensions, args, 0 TSRMLS_CC);
if (res == SUCCESS) {
@ -134,7 +134,7 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
/* the SafeArray case */
/* offset/index must be an integer */
convert_to_long(offset);
convert_to_int(offset);
sa = V_ARRAY(&proxy->obj->v);
dims = SafeArrayGetDim(sa);
@ -149,7 +149,7 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
SafeArrayGetLBound(sa, proxy->dimensions, &lbound);
SafeArrayGetUBound(sa, proxy->dimensions, &ubound);
if (Z_LVAL_P(offset) < lbound || Z_LVAL_P(offset) > ubound) {
if (Z_IVAL_P(offset) < lbound || Z_IVAL_P(offset) > ubound) {
php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds" TSRMLS_CC);
return rv;
}
@ -166,12 +166,12 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
/* copy indices from proxy */
for (i = 0; i < dims; i++) {
convert_to_long(&proxy->indices[i]);
indices[i] = Z_LVAL(proxy->indices[i]);
convert_to_int(&proxy->indices[i]);
indices[i] = Z_IVAL(proxy->indices[i]);
}
/* add user-supplied index */
indices[dims-1] = Z_LVAL_P(offset);
indices[dims-1] = Z_IVAL_P(offset);
/* now fetch the value */
if (FAILED(SafeArrayGetVartype(sa, &vt)) || vt == VT_EMPTY) {
@ -225,7 +225,7 @@ static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRM
convert_to_string(&proxy->indices[0]);
VariantInit(&v);
if (SUCCESS == php_com_do_invoke(proxy->obj, Z_STRVAL(proxy->indices[0]),
Z_STRLEN(proxy->indices[0]), DISPATCH_PROPERTYPUT, &v, proxy->dimensions + 1,
Z_STRSIZE(proxy->indices[0]), DISPATCH_PROPERTYPUT, &v, proxy->dimensions + 1,
args, 0 TSRMLS_CC)) {
VariantClear(&v);
}
@ -240,13 +240,13 @@ static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRM
indices = safe_emalloc(dims, sizeof(LONG), 0);
/* copy indices from proxy */
for (i = 0; i < dims; i++) {
convert_to_long(&proxy->indices[i]);
indices[i] = Z_LVAL(proxy->indices[i]);
convert_to_int(&proxy->indices[i]);
indices[i] = Z_IVAL(proxy->indices[i]);
}
/* add user-supplied index */
convert_to_long(offset);
indices[dims-1] = Z_LVAL_P(offset);
convert_to_int(offset);
indices[dims-1] = Z_IVAL_P(offset);
if (FAILED(SafeArrayGetVartype(V_ARRAY(&proxy->obj->v), &vt)) || vt == VT_EMPTY) {
vt = V_VT(&proxy->obj->v) & ~VT_ARRAY;
@ -353,7 +353,7 @@ static int saproxy_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC
return FAILURE;
}
static int saproxy_count_elements(zval *object, long *count TSRMLS_DC)
static int saproxy_count_elements(zval *object, php_int_t *count TSRMLS_DC)
{
php_com_saproxy *proxy = SA_FETCH(object);
LONG ubound, lbound;
@ -516,7 +516,7 @@ static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC
if (I->key == -1) {
ZVAL_NULL(key);
} else {
ZVAL_LONG(key, I->key);
ZVAL_INT(key, I->key);
}
}
@ -560,8 +560,8 @@ zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *objec
I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0);
for (i = 0; i < proxy->dimensions; i++) {
convert_to_long(&proxy->indices[i]);
I->indices[i] = Z_LVAL(proxy->indices[i]);
convert_to_int(&proxy->indices[i]);
I->indices[i] = Z_IVAL(proxy->indices[i]);
}
SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imin);

4
ext/com_dotnet/com_typeinfo.c
View File

@ -208,9 +208,9 @@ PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepa
/* register the constant */
php_com_zval_from_variant(&value, pVarDesc->lpvarValue, codepage TSRMLS_CC);
if (Z_TYPE(value) == IS_LONG) {
if (Z_TYPE(value) == IS_INT) {
c.flags = mode;
ZVAL_LONG(&c.value, Z_LVAL(value));
ZVAL_INT(&c.value, Z_IVAL(value));
c.module_number = 0;
zend_register_constant(&c TSRMLS_CC);
}

68
ext/com_dotnet/com_variant.c
View File

@ -39,8 +39,8 @@ static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
HashPosition pos;
int keytype;
zend_string *strindex;
long intindex = -1;
long max_index = 0;
php_int_t intindex = -1;
php_int_t max_index = 0;
VARIANT *va;
zval *item;
@ -145,9 +145,9 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
safe_array_from_zval(v, z, codepage TSRMLS_CC);
break;
case IS_LONG:
case IS_INT:
V_VT(v) = VT_I4;
V_I4(v) = Z_LVAL_P(z);
V_I4(v) = Z_IVAL_P(z);
break;
case IS_DOUBLE:
@ -157,11 +157,11 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
case IS_STRING:
V_VT(v) = VT_BSTR;
olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRLEN_P(z), codepage TSRMLS_CC);
olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRSIZE_P(z), codepage TSRMLS_CC);
if (CP_UTF8 == codepage) {
V_BSTR(v) = SysAllocStringByteLen((char*)olestring, wcslen(olestring) * sizeof(OLECHAR));
} else {
V_BSTR(v) = SysAllocStringByteLen((char*)olestring, Z_STRLEN_P(z) * sizeof(OLECHAR));
V_BSTR(v) = SysAllocStringByteLen((char*)olestring, Z_STRSIZE_P(z) * sizeof(OLECHAR));
}
efree(olestring);
break;
@ -187,28 +187,28 @@ PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepa
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (long)V_UI1(v));
ZVAL_INT(z, (php_int_t)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (long)V_I1(v));
ZVAL_INT(z, (php_int_t)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (long)V_UI2(v));
ZVAL_INT(z, (php_int_t)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (long)V_I2(v));
ZVAL_INT(z, (php_int_t)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
ZVAL_INT(z, (php_int_t)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
ZVAL_INT(z, (php_int_t)V_I4(v));
break;
case VT_INT:
ZVAL_LONG(z, V_INT(v));
ZVAL_INT(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UINT(v));
ZVAL_INT(z, (php_int_t)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
@ -406,8 +406,8 @@ PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar TSR
/* {{{ com_variant_create_instance - ctor for new VARIANT() */
PHP_FUNCTION(com_variant_create_instance)
{
/* VARTYPE == unsigned short */ long vt = VT_EMPTY;
long codepage = CP_ACP;
/* VARTYPE == unsigned short */ php_int_t vt = VT_EMPTY;
php_int_t codepage = CP_ACP;
zval *object = getThis();
php_com_dotnet_object *obj;
zval *zvalue = NULL;
@ -421,7 +421,7 @@ PHP_FUNCTION(com_variant_create_instance)
obj = CDNO_FETCH(object);
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z!|ll", &zvalue, &vt, &codepage)) {
"z!|ii", &zvalue, &vt, &codepage)) {
php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
return;
}
@ -444,7 +444,7 @@ PHP_FUNCTION(com_variant_create_instance)
but will probably fail (original behavior)
*/
if ((vt & VT_ARRAY) && (V_VT(&obj->v) & VT_ARRAY)) {
long orig_vt = vt;
php_int_t orig_vt = vt;
vt &= ~VT_ARRAY;
if (vt) {
@ -832,7 +832,7 @@ PHP_FUNCTION(variant_round)
zval *zleft = NULL;
php_com_dotnet_object *obj;
int codepage = CP_ACP;
long decimals = 0;
php_int_t decimals = 0;
VariantInit(&left_val);
VariantInit(&vres);
@ -867,8 +867,8 @@ PHP_FUNCTION(variant_cmp)
zval *zleft = NULL, *zright = NULL;
php_com_dotnet_object *obj;
int codepage = CP_ACP;
long lcid = LOCALE_SYSTEM_DEFAULT;
long flags = 0;
php_int_t lcid = LOCALE_SYSTEM_DEFAULT;
php_int_t flags = 0;
/* it is safe to ignore the warning for this line; see the comments in com_handlers.c */
STDAPI VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, DWORD flags);
@ -876,28 +876,28 @@ PHP_FUNCTION(variant_cmp)
VariantInit(&right_val);
if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
ZEND_NUM_ARGS() TSRMLS_CC, "OO|ll", &zleft, php_com_variant_class_entry,
ZEND_NUM_ARGS() TSRMLS_CC, "OO|ii", &zleft, php_com_variant_class_entry,
&zright, php_com_variant_class_entry, &lcid, &flags)) {
obj = CDNO_FETCH(zleft);
vleft = &obj->v;
obj = CDNO_FETCH(zright);
vright = &obj->v;
} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
ZEND_NUM_ARGS() TSRMLS_CC, "Oz!|ll", &zleft, php_com_variant_class_entry,
ZEND_NUM_ARGS() TSRMLS_CC, "Oz!|ii", &zleft, php_com_variant_class_entry,
&zright, &lcid, &flags)) {
obj = CDNO_FETCH(zleft);
vleft = &obj->v;
vright = &right_val;
php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
ZEND_NUM_ARGS() TSRMLS_CC, "z!O|ll", &zleft, &zright, php_com_variant_class_entry,
ZEND_NUM_ARGS() TSRMLS_CC, "z!O|ii", &zleft, &zright, php_com_variant_class_entry,
&lcid, &flags)) {
obj = CDNO_FETCH(zright);
vright = &obj->v;
vleft = &left_val;
php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z!z!|ll", &zleft, &zright, &lcid, &flags)) {
"z!z!|ii", &zleft, &zright, &lcid, &flags)) {
vleft = &left_val;
php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
@ -909,7 +909,7 @@ PHP_FUNCTION(variant_cmp)
return;
}
ZVAL_LONG(return_value, VarCmp(vleft, vright, lcid, flags));
ZVAL_INT(return_value, VarCmp(vleft, vright, lcid, flags));
VariantClear(&left_val);
VariantClear(&right_val);
@ -948,7 +948,7 @@ PHP_FUNCTION(variant_date_to_timestamp)
tmv.tm_isdst = -1;
tzset();
RETVAL_LONG(mktime(&tmv));
RETVAL_INT(mktime(&tmv));
}
VariantClear(&vres);
@ -959,13 +959,13 @@ PHP_FUNCTION(variant_date_to_timestamp)
Returns a variant date representation of a unix timestamp */
PHP_FUNCTION(variant_date_from_timestamp)
{
long timestamp;
php_int_t timestamp;
time_t ttstamp;
SYSTEMTIME systime;
struct tm *tmv;
VARIANT res;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i",
&timestamp)) {
return;
}
@ -1010,7 +1010,7 @@ PHP_FUNCTION(variant_get_type)
}
obj = CDNO_FETCH(zobj);
RETURN_LONG(V_VT(&obj->v));
RETURN_INT(V_VT(&obj->v));
}
/* }}} */
@ -1020,11 +1020,11 @@ PHP_FUNCTION(variant_set_type)
{
zval *zobj;
php_com_dotnet_object *obj;
/* VARTYPE == unsigned short */ long vt;
/* VARTYPE == unsigned short */ php_int_t vt;
HRESULT res;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"Ol", &zobj, php_com_variant_class_entry, &vt)) {
"Oi", &zobj, php_com_variant_class_entry, &vt)) {
return;
}
obj = CDNO_FETCH(zobj);
@ -1055,12 +1055,12 @@ PHP_FUNCTION(variant_cast)
{
zval *zobj;
php_com_dotnet_object *obj;
/* VARTYPE == unsigned short */ long vt;
/* VARTYPE == unsigned short */ php_int_t vt;
VARIANT vres;
HRESULT res;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"Ol", &zobj, php_com_variant_class_entry, &vt)) {
"Oi", &zobj, php_com_variant_class_entry, &vt)) {
return;
}
obj = CDNO_FETCH(zobj);

30
ext/com_dotnet/com_wrapper.c
View File

@ -186,7 +186,7 @@ static HRESULT STDMETHODCALLTYPE disp_getidsofnames(
ret = DISP_E_UNKNOWNNAME;
rgDispId[i] = 0;
} else {
rgDispId[i] = Z_LVAL_P(tmp);
rgDispId[i] = Z_IVAL_P(tmp);
}
efree(name);
@ -231,7 +231,7 @@ static HRESULT STDMETHODCALLTYPE disp_getdispid(
/* Lookup the name in the hash */
if ((tmp = zend_hash_str_find(disp->name_to_dispid, name, namelen)) != NULL) {
trace("found it\n");
*pid = Z_LVAL_P(tmp);
*pid = Z_IVAL_P(tmp);
ret = S_OK;
}
@ -260,7 +260,7 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
if (NULL != (name = zend_hash_index_find(disp->dispid_to_name, id))) {
/* TODO: add support for overloaded objects */
trace("-- Invoke: %d %20s [%d] flags=%08x args=%d\n", id, Z_STRVAL_P(name), Z_STRLEN_P(name), wFlags, pdp->cArgs);
trace("-- Invoke: %d %20s [%d] flags=%08x args=%d\n", id, Z_STRVAL_P(name), Z_STRSIZE_P(name), wFlags, pdp->cArgs);
/* convert args into zvals.
* Args are in reverse order */
@ -283,9 +283,9 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
* and expose it as a COM exception */
if (wFlags & DISPATCH_PROPERTYGET) {
retval = zend_read_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name)+1, 1 TSRMLS_CC);
retval = zend_read_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRSIZE_P(name)+1, 1 TSRMLS_CC);
} else if (wFlags & DISPATCH_PROPERTYPUT) {
zend_update_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name), &params[0] TSRMLS_CC);
zend_update_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRSIZE_P(name), &params[0] TSRMLS_CC);
} else if (wFlags & DISPATCH_METHOD) {
zend_try {
retval = &rv;
@ -385,7 +385,7 @@ static HRESULT STDMETHODCALLTYPE disp_getmembername(
FETCH_DISP("GetMemberName");
if (NULL != (name = zend_hash_index_find(disp->dispid_to_name, id))) {
OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRLEN_P(name), COMG(code_page) TSRMLS_CC);
OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRSIZE_P(name), COMG(code_page) TSRMLS_CC);
*pbstrName = SysAllocString(olestr);
efree(olestr);
return S_OK;
@ -450,7 +450,7 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
zend_string *name = NULL;
zval *tmp, tmp2;
int keytype;
ulong pid;
php_uint_t pid;
if (disp->dispid_to_name == NULL) {
ALLOC_HASHTABLE(disp->dispid_to_name);
@ -466,8 +466,8 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
zend_hash_get_current_key_ex(Z_OBJPROP(disp->object), &name,
&pid, 0, &pos))) {
char namebuf[32];
if (keytype == HASH_KEY_IS_LONG) {
snprintf(namebuf, sizeof(namebuf), "%d", pid);
if (keytype == HASH_KEY_IS_INT) {
snprintf(namebuf, sizeof(namebuf), ZEND_UINT_FMT, pid);
name = STR_INIT(namebuf, strlen(namebuf), 0);
} else {
STR_ADDREF(name);
@ -486,7 +486,7 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
pid = zend_hash_next_free_element(disp->dispid_to_name);
zend_hash_index_update(disp->dispid_to_name, pid, &tmp2);
ZVAL_LONG(&tmp2, pid);
ZVAL_INT(&tmp2, pid);
zend_hash_update(disp->name_to_dispid, name, &tmp2);
STR_RELEASE(name);
@ -501,7 +501,7 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
&name, &pid, 0, &pos))) {
char namebuf[32];
if (keytype == HASH_KEY_IS_LONG) {
if (keytype == HASH_KEY_IS_INT) {
snprintf(namebuf, sizeof(namebuf), "%d", pid);
name = STR_INIT(namebuf, strlen(namebuf), 0);
} else {
@ -521,7 +521,7 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
pid = zend_hash_next_free_element(disp->dispid_to_name);
zend_hash_index_update(disp->dispid_to_name, pid, &tmp2);
ZVAL_LONG(&tmp2, pid);
ZVAL_INT(&tmp2, pid);
zend_hash_update(disp->name_to_dispid, name, &tmp2);
STR_RELEASE(name);
@ -590,7 +590,7 @@ PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *si
zend_string *name = NULL;
zval tmp, *ntmp;
int keytype;
ulong pid;
php_uint_t pid;
disp->dispid_to_name = id_to_name;
@ -604,11 +604,11 @@ PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *si
while (HASH_KEY_NON_EXISTENT != (keytype =
zend_hash_get_current_key_ex(id_to_name, &name, &pid, 0, &pos))) {
if (keytype == HASH_KEY_IS_LONG) {
if (keytype == HASH_KEY_IS_INT) {
ntmp = zend_hash_get_current_data_ex(id_to_name, &pos);
ZVAL_LONG(&tmp, pid);
ZVAL_INT(&tmp, pid);
zend_hash_update(disp->name_to_dispid, Z_STR_P(ntmp), &tmp);
}

2
ext/com_dotnet/php_com_dotnet_internal.h
View File

@ -38,7 +38,7 @@ typedef struct _php_com_dotnet_object {
int modified;
ITypeInfo *typeinfo;
long code_page;
php_int_t code_page;
zend_class_entry *ce;

18
ext/ctype/ctype.c
View File

@ -146,11 +146,11 @@ static PHP_MINFO_FUNCTION(ctype)
zval *c, tmp; \
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &c) == FAILURE) \
return; \
if (Z_TYPE_P(c) == IS_LONG) { \
if (Z_LVAL_P(c) <= 255 && Z_LVAL_P(c) >= 0) { \
RETURN_BOOL(iswhat(Z_LVAL_P(c))); \
} else if (Z_LVAL_P(c) >= -128 && Z_LVAL_P(c) < 0) { \
RETURN_BOOL(iswhat(Z_LVAL_P(c) + 256)); \
if (Z_TYPE_P(c) == IS_INT) { \
if (Z_IVAL_P(c) <= 255 && Z_IVAL_P(c) >= 0) { \
RETURN_BOOL(iswhat(Z_IVAL_P(c))); \
} else if (Z_IVAL_P(c) >= -128 && Z_IVAL_P(c) < 0) { \
RETURN_BOOL(iswhat(Z_IVAL_P(c) + 256)); \
} \
tmp = *c; \
zval_copy_ctor(&tmp); \
@ -159,18 +159,18 @@ static PHP_MINFO_FUNCTION(ctype)
tmp = *c; \
} \
if (Z_TYPE(tmp) == IS_STRING) { \
char *p = Z_STRVAL(tmp), *e = Z_STRVAL(tmp) + Z_STRLEN(tmp); \
char *p = Z_STRVAL(tmp), *e = Z_STRVAL(tmp) + Z_STRSIZE(tmp); \
if (e == p) { \
if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
if (Z_TYPE_P(c) == IS_INT) zval_dtor(&tmp); \
RETURN_FALSE; \
} \
while (p < e) { \
if(!iswhat((int)*(unsigned char *)(p++))) { \
if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
if (Z_TYPE_P(c) == IS_INT) zval_dtor(&tmp); \
RETURN_FALSE; \
} \
} \
if (Z_TYPE_P(c) == IS_LONG) zval_dtor(&tmp); \
if (Z_TYPE_P(c) == IS_INT) zval_dtor(&tmp); \
RETURN_TRUE; \
} else { \
RETURN_FALSE; \

152
ext/curl/interface.c
View File

@ -154,7 +154,7 @@ static void _php_curl_close(zend_resource *rsrc TSRMLS_DC);
#define SAVE_CURL_ERROR(__handle, __err) (__handle)->err.no = (int) __err;
#define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s) - 1, (long) v);
#define CAAL(s, v) add_assoc_int_ex(return_value, s, sizeof(s) - 1, (php_int_t) v);
#define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s) - 1, (double) v);
#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s) - 1, (char *) (v ? v : ""));
#define CAASTR(s, v) add_assoc_str_ex(return_value, s, sizeof(s) - 1, v ? v : STR_EMPTY_ALLOC());
@ -166,7 +166,7 @@ static void _php_curl_close(zend_resource *rsrc TSRMLS_DC);
# define php_curl_ret(__ret) RETVAL_FALSE; return;
#endif
static int php_curl_option_str(php_curl *ch, long option, const char *str, const int len, zend_bool make_copy TSRMLS_DC)
static int php_curl_option_str(php_curl *ch, php_int_t option, const char *str, const int len, zend_bool make_copy TSRMLS_DC)
{
CURLcode error = CURLE_OK;
@ -612,7 +612,7 @@ PHP_MINFO_FUNCTION(curl)
}
/* }}} */
#define REGISTER_CURL_CONSTANT(__c) REGISTER_LONG_CONSTANT(#__c, __c, CONST_CS | CONST_PERSISTENT)
#define REGISTER_CURL_CONSTANT(__c) REGISTER_INT_CONSTANT(#__c, __c, CONST_CS | CONST_PERSISTENT)
/* {{{ PHP_MINIT_FUNCTION
*/
@ -1318,10 +1318,10 @@ static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx)
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_WRITEFUNCTION");
length = -1;
} else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) != IS_LONG) {
convert_to_long_ex(&retval);
if (Z_TYPE(retval) != IS_INT) {
convert_to_int_ex(&retval);
}
length = Z_LVAL(retval);
length = Z_IVAL(retval);
}
zval_ptr_dtor(&argv[0]);
@ -1371,10 +1371,10 @@ static int curl_fnmatch(void *ctx, const char *pattern, const char *string)
if (error == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_FNMATCH_FUNCTION");
} else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) != IS_LONG) {
convert_to_long_ex(&retval);
if (Z_TYPE(retval) != IS_INT) {
convert_to_int_ex(&retval);
}
rval = Z_LVAL(retval);
rval = Z_IVAL(retval);
}
zval_ptr_dtor(&argv[0]);
zval_ptr_dtor(&argv[1]);
@ -1410,10 +1410,10 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double
ZVAL_RES(&argv[0], ch->res);
Z_ADDREF(argv[0]);
ZVAL_LONG(&argv[1], (long)dltotal);
ZVAL_LONG(&argv[2], (long)dlnow);
ZVAL_LONG(&argv[3], (long)ultotal);
ZVAL_LONG(&argv[4], (long)ulnow);
ZVAL_INT(&argv[1], (long)dltotal);
ZVAL_INT(&argv[2], (long)dlnow);
ZVAL_INT(&argv[3], (long)ultotal);
ZVAL_INT(&argv[4], (long)ulnow);
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
@ -1431,10 +1431,10 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double
if (error == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_PROGRESSFUNCTION");
} else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) != IS_LONG) {
convert_to_long_ex(&retval);
if (Z_TYPE(retval) != IS_INT) {
convert_to_int_ex(&retval);
}
if (0 != Z_LVAL(retval)) {
if (0 != Z_IVAL(retval)) {
rval = 1;
}
}
@ -1475,7 +1475,7 @@ static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx)
Z_ADDREF(argv[0]);
ZVAL_RES(&argv[1], t->res);
Z_ADDREF(argv[1]);
ZVAL_LONG(&argv[2], (int)size * nmemb);
ZVAL_INT(&argv[2], (int)size * nmemb);
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
@ -1497,7 +1497,7 @@ static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx)
#endif
} else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) == IS_STRING) {
length = MIN((int) (size * nmemb), Z_STRLEN(retval));
length = MIN((int) (size * nmemb), Z_STRSIZE(retval));
memcpy(data, Z_STRVAL(retval), length);
}
zval_ptr_dtor(&retval);
@ -1562,10 +1562,10 @@ static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_HEADERFUNCTION");
length = -1;
} else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) != IS_LONG) {
convert_to_long_ex(&retval);
if (Z_TYPE(retval) != IS_INT) {
convert_to_int_ex(&retval);
}
length = Z_LVAL(retval);
length = Z_IVAL(retval);
}
zval_ptr_dtor(&argv[0]);
zval_ptr_dtor(&argv[1]);
@ -1616,16 +1616,16 @@ static size_t curl_passwd(void *ctx, char *prompt, char *buf, int buflen)
ZVAL_RES(&argv[0], ch->res);
Z_ADDREF(argv[0]);
ZVAL_STRING(&argv[1], prompt);
ZVAL_LONG(&argv[2], buflen);
ZVAL_INT(&argv[2], buflen);
error = call_user_function(EG(function_table), NULL, func, &retval, 2, argv TSRMLS_CC);
if (error == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_PASSWDFUNCTION");
} else if (Z_TYPE(retval) == IS_STRING) {
if (Z_STRLEN(retval) > buflen) {
if (Z_STRSIZE(retval) > buflen) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Returned password is too long for libcurl to handle");
} else {
memcpy(buf, Z_STRVAL(retval), Z_STRLEN(retval) + 1);
memcpy(buf, Z_STRVAL(retval), Z_STRSIZE(retval) + 1);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "User handler '%s' did not return a string", Z_STRVAL_P(func));
@ -1670,9 +1670,9 @@ static void curl_free_slist(zval *el)
PHP_FUNCTION(curl_version)
{
curl_version_info_data *d;
long uversion = CURLVERSION_NOW;
php_int_t uversion = CURLVERSION_NOW;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &uversion) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &uversion) == FAILURE) {
return;
}
@ -1986,15 +1986,15 @@ PHP_FUNCTION(curl_copy_handle)
}
/* }}} */
static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /* {{{ */
static int _php_curl_setopt(php_curl *ch, php_int_t option, zval *zvalue TSRMLS_DC) /* {{{ */
{
CURLcode error = CURLE_OK;
switch (option) {
/* Long options */
case CURLOPT_SSL_VERIFYHOST:
convert_to_long(zvalue);
if (Z_LVAL_P(zvalue) == 1) {
convert_to_int(zvalue);
if (Z_IVAL_P(zvalue) == 1) {
#if LIBCURL_VERSION_NUM <= 0x071c00 /* 7.28.0 */
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "CURLOPT_SSL_VERIFYHOST with value 1 is deprecated and will be removed as of libcurl 7.28.1. It is recommended to use value 2 instead");
#else
@ -2148,19 +2148,19 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
#if CURLOPT_MUTE != 0
case CURLOPT_MUTE:
#endif
convert_to_long_ex(zvalue);
convert_to_int_ex(zvalue);
#if LIBCURL_VERSION_NUM >= 0x71304
if ((option == CURLOPT_PROTOCOLS || option == CURLOPT_REDIR_PROTOCOLS) &&
(PG(open_basedir) && *PG(open_basedir)) && (Z_LVAL_P(zvalue) & CURLPROTO_FILE)) {
(PG(open_basedir) && *PG(open_basedir)) && (Z_IVAL_P(zvalue) & CURLPROTO_FILE)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLPROTO_FILE cannot be activated when an open_basedir is set");
return 1;
}
#endif
error = curl_easy_setopt(ch->cp, option, Z_LVAL_P(zvalue));
error = curl_easy_setopt(ch->cp, option, Z_IVAL_P(zvalue));
break;
case CURLOPT_SAFE_UPLOAD:
convert_to_long_ex(zvalue);
ch->safe_upload = (Z_LVAL_P(zvalue) != 0);
convert_to_int_ex(zvalue);
ch->safe_upload = (Z_IVAL_P(zvalue) != 0);
break;
/* String options */
@ -2222,7 +2222,7 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
#endif
{
convert_to_string_ex(zvalue);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue), 0 TSRMLS_CC);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue), 0 TSRMLS_CC);
}
/* Curl nullable string options */
@ -2245,7 +2245,7 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
error = curl_easy_setopt(ch->cp, option, NULL);
} else {
convert_to_string_ex(zvalue);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue), 0 TSRMLS_CC);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue), 0 TSRMLS_CC);
}
break;
}
@ -2253,12 +2253,12 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
/* Curl private option */
case CURLOPT_PRIVATE:
convert_to_string_ex(zvalue);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue), 1 TSRMLS_CC);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue), 1 TSRMLS_CC);
/* Curl url option */
case CURLOPT_URL:
convert_to_string_ex(zvalue);
return php_curl_option_url(ch, Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue) TSRMLS_CC);
return php_curl_option_url(ch, Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue) TSRMLS_CC);
/* Curl file handle options */
case CURLOPT_FILE:
@ -2436,16 +2436,16 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
break;
case CURLOPT_FOLLOWLOCATION:
convert_to_long_ex(zvalue);
convert_to_int_ex(zvalue);
#if LIBCURL_VERSION_NUM < 0x071304
if (PG(open_basedir) && *PG(open_basedir)) {
if (Z_LVAL_P(zvalue) != 0) {
if (Z_IVAL_P(zvalue) != 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_FOLLOWLOCATION cannot be activated when an open_basedir is set");
return FAILURE;
}
}
#endif
error = curl_easy_setopt(ch->cp, option, Z_LVAL_P(zvalue));
error = curl_easy_setopt(ch->cp, option, Z_IVAL_P(zvalue));
break;
case CURLOPT_HEADERFUNCTION:
@ -2476,7 +2476,7 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
char *postval;
/* Pretend we have a string_key here */
if (!string_key) {
string_key = zend_long_to_str(num_key);
string_key = zend_int_to_str(num_key);
} else {
STR_ADDREF(string_key);
}
@ -2498,11 +2498,11 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
}
prop = zend_read_property(curl_CURLFile_class, current, "mime", sizeof("mime")-1, 0 TSRMLS_CC);
if (Z_TYPE_P(prop) == IS_STRING && Z_STRLEN_P(prop) > 0) {
if (Z_TYPE_P(prop) == IS_STRING && Z_STRSIZE_P(prop) > 0) {
type = Z_STRVAL_P(prop);
}
prop = zend_read_property(curl_CURLFile_class, current, "postname", sizeof("postname")-1, 0 TSRMLS_CC);
if (Z_TYPE_P(prop) == IS_STRING && Z_STRLEN_P(prop) > 0) {
if (Z_TYPE_P(prop) == IS_STRING && Z_STRSIZE_P(prop) > 0) {
filename = Z_STRVAL_P(prop);
}
error = curl_formadd(&first, &last,
@ -2533,13 +2533,13 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
php_error_docref("curl.curlfile" TSRMLS_CC, E_DEPRECATED,
"The usage of the @filename API for file uploading is deprecated. Please use the CURLFile class instead");
name = estrndup(postval, Z_STRLEN_P(current));
name = estrndup(postval, Z_STRSIZE_P(current));
if ((type = php_memnstr(name, ";type=", sizeof(";type=") - 1,
name + Z_STRLEN_P(current)))) {
name + Z_STRSIZE_P(current)))) {
*type = '\0';
}
if ((filename = php_memnstr(name, ";filename=", sizeof(";filename=") - 1,
name + Z_STRLEN_P(current)))) {
name + Z_STRSIZE_P(current)))) {
*filename = '\0';
}
/* open_basedir check */
@ -2560,7 +2560,7 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
CURLFORM_COPYNAME, string_key->val,
CURLFORM_NAMELENGTH, (long)string_key->len,
CURLFORM_COPYCONTENTS, postval,
CURLFORM_CONTENTSLENGTH, (long)Z_STRLEN_P(current),
CURLFORM_CONTENTSLENGTH, (long)Z_STRSIZE_P(current),
CURLFORM_END);
}
@ -2581,17 +2581,17 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
#if LIBCURL_VERSION_NUM >= 0x071101
convert_to_string_ex(zvalue);
/* with curl 7.17.0 and later, we can use COPYPOSTFIELDS, but we have to provide size before */
error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRLEN_P(zvalue));
error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRSIZE_P(zvalue));
error = curl_easy_setopt(ch->cp, CURLOPT_COPYPOSTFIELDS, Z_STRVAL_P(zvalue));
#else
char *post = NULL;
convert_to_string_ex(zvalue);
post = estrndup(Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue));
post = estrndup(Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue));
zend_llist_add_element(&ch->to_free->str, &post);
curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDS, post);
error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRLEN_P(zvalue));
error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRSIZE_P(zvalue));
#endif
}
break;
@ -2619,8 +2619,8 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
break;
case CURLOPT_RETURNTRANSFER:
convert_to_long_ex(zvalue);
if (Z_LVAL_P(zvalue)) {
convert_to_int_ex(zvalue);
if (Z_IVAL_P(zvalue)) {
ch->handlers->write->method = PHP_CURL_RETURN;
} else {
ch->handlers->write->method = PHP_CURL_STDOUT;
@ -2639,15 +2639,15 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
#if LIBCURL_VERSION_NUM >= 0x070f05 /* Available since 7.15.5 */
case CURLOPT_MAX_RECV_SPEED_LARGE:
case CURLOPT_MAX_SEND_SPEED_LARGE:
convert_to_long_ex(zvalue);
error = curl_easy_setopt(ch->cp, option, (curl_off_t)Z_LVAL_P(zvalue));
convert_to_int_ex(zvalue);
error = curl_easy_setopt(ch->cp, option, (curl_off_t)Z_IVAL_P(zvalue));
break;
#endif
#if LIBCURL_VERSION_NUM >= 0x071301 /* Available since 7.19.1 */
case CURLOPT_POSTREDIR:
convert_to_long_ex(zvalue);
error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, Z_LVAL_P(zvalue) & CURL_REDIR_POST_ALL);
convert_to_int_ex(zvalue);
error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, Z_IVAL_P(zvalue) & CURL_REDIR_POST_ALL);
break;
#endif
@ -2684,16 +2684,16 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
{
convert_to_string_ex(zvalue);
if (Z_STRLEN_P(zvalue) && php_check_open_basedir(Z_STRVAL_P(zvalue) TSRMLS_CC)) {
if (Z_STRSIZE_P(zvalue) && php_check_open_basedir(Z_STRVAL_P(zvalue) TSRMLS_CC)) {
return FAILURE;
}
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue), 0 TSRMLS_CC);
return php_curl_option_str(ch, option, Z_STRVAL_P(zvalue), Z_STRSIZE_P(zvalue), 0 TSRMLS_CC);
}
case CURLINFO_HEADER_OUT:
convert_to_long_ex(zvalue);
if (Z_LVAL_P(zvalue) == 1) {
convert_to_int_ex(zvalue);
if (Z_IVAL_P(zvalue) == 1) {
curl_easy_setopt(ch->cp, CURLOPT_DEBUGFUNCTION, curl_debug);
curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, (void *)ch);
curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 1);
@ -2744,10 +2744,10 @@ static int _php_curl_setopt(php_curl *ch, long option, zval *zvalue TSRMLS_DC) /
PHP_FUNCTION(curl_setopt)
{
zval *zid, *zvalue;
long options;
php_int_t options;
php_curl *ch;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &zid, &options, &zvalue) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "riz", &zid, &options, &zvalue) == FAILURE) {
return;
}
@ -2772,7 +2772,7 @@ PHP_FUNCTION(curl_setopt_array)
{
zval *zid, *arr, *entry;
php_curl *ch;
ulong option;
php_uint_t option;
zend_string *string_key;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za", &zid, &arr) == FAILURE) {
@ -2787,7 +2787,7 @@ PHP_FUNCTION(curl_setopt_array)
"Array keys must be CURLOPT constants or equivalent integer values");
RETURN_FALSE;
}
if (_php_curl_setopt(ch, (long) option, entry TSRMLS_CC) == FAILURE) {
if (_php_curl_setopt(ch, (php_int_t) option, entry TSRMLS_CC) == FAILURE) {
RETURN_FALSE;
}
} ZEND_HASH_FOREACH_END();
@ -2872,9 +2872,9 @@ PHP_FUNCTION(curl_getinfo)
{
zval *zid;
php_curl *ch;
long option = 0;
php_int_t option = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zid, &option) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|i", &zid, &option) == FAILURE) {
return;
}
@ -2882,7 +2882,7 @@ PHP_FUNCTION(curl_getinfo)
if (ZEND_NUM_ARGS() < 2) {
char *s_code;
long l_code;
php_int_t l_code;
double d_code;
#if LIBCURL_VERSION_NUM > 0x071301
struct curl_certinfo *ci = NULL;
@ -3026,10 +3026,10 @@ PHP_FUNCTION(curl_getinfo)
}
case CURLINFO_LONG:
{
long code = 0;
php_int_t code = 0;
if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) {
RETURN_LONG(code);
RETURN_INT(code);
} else {
RETURN_FALSE;
}
@ -3103,7 +3103,7 @@ PHP_FUNCTION(curl_errno)
ZEND_FETCH_RESOURCE(ch, php_curl *, zid, -1, le_curl_name, le_curl);
RETURN_LONG(ch->err.no);
RETURN_INT(ch->err.no);
}
/* }}} */
@ -3217,10 +3217,10 @@ static void _php_curl_close(zend_resource *rsrc TSRMLS_DC)
return string describing error code */
PHP_FUNCTION(curl_strerror)
{
long code;
php_int_t code;
const char *str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &code) == FAILURE) {
return;
}
@ -3363,17 +3363,17 @@ PHP_FUNCTION(curl_unescape)
pause and unpause a connection */
PHP_FUNCTION(curl_pause)
{
long bitmask;
php_int_t bitmask;
zval *zid;
php_curl *ch;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zid, &bitmask) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &zid, &bitmask) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(ch, php_curl *, zid, -1, le_curl_name, le_curl);
RETURN_LONG(curl_easy_pause(ch->cp, bitmask));
RETURN_INT(curl_easy_pause(ch->cp, bitmask));
}
/* }}} */
#endif

36
ext/curl/multi.c
View File

@ -92,7 +92,7 @@ PHP_FUNCTION(curl_multi_add_handle)
zend_llist_add_element(&mh->easyh, &tmp_val);
RETURN_LONG((long)curl_multi_add_handle(mh->multi, ch->cp));
RETURN_INT((php_int_t)curl_multi_add_handle(mh->multi, ch->cp));
}
/* }}} */
@ -140,7 +140,7 @@ PHP_FUNCTION(curl_multi_remove_handle)
ZEND_FETCH_RESOURCE(mh, php_curlm *, z_mh, -1, le_curl_multi_handle_name, le_curl_multi_handle);
ZEND_FETCH_RESOURCE(ch, php_curl *, z_ch, -1, le_curl_name, le_curl);
RETVAL_LONG((long)curl_multi_remove_handle(mh->multi, ch->cp));
RETVAL_INT((php_int_t)curl_multi_remove_handle(mh->multi, ch->cp));
zend_llist_del_element(&mh->easyh, &z_ch, (int (*)(void *, void *))curl_compare_resources);
}
@ -183,9 +183,9 @@ PHP_FUNCTION(curl_multi_select)
curl_multi_fdset(mh->multi, &readfds, &writefds, &exceptfds, &maxfd);
if (maxfd == -1) {
RETURN_LONG(-1);
RETURN_INT(-1);
}
RETURN_LONG(select(maxfd + 1, &readfds, &writefds, &exceptfds, &to));
RETURN_INT(select(maxfd + 1, &readfds, &writefds, &exceptfds, &to));
}
/* }}} */
@ -218,12 +218,12 @@ PHP_FUNCTION(curl_multi_exec)
}
}
convert_to_long_ex(z_still_running);
still_running = Z_LVAL_P(z_still_running);
convert_to_int_ex(z_still_running);
still_running = Z_IVAL_P(z_still_running);
result = curl_multi_perform(mh->multi, &still_running);
ZVAL_LONG(z_still_running, still_running);
ZVAL_INT(z_still_running, still_running);
RETURN_LONG(result);
RETURN_INT(result);
}
/* }}} */
@ -271,12 +271,12 @@ PHP_FUNCTION(curl_multi_info_read)
}
if (zmsgs_in_queue) {
zval_dtor(zmsgs_in_queue);
ZVAL_LONG(zmsgs_in_queue, queued_msgs);
ZVAL_INT(zmsgs_in_queue, queued_msgs);
}
array_init(return_value);
add_assoc_long(return_value, "msg", tmp_msg->msg);
add_assoc_long(return_value, "result", tmp_msg->data.result);
add_assoc_int(return_value, "msg", tmp_msg->msg);
add_assoc_int(return_value, "result", tmp_msg->data.result);
/* find the original easy curl handle */
{
@ -357,10 +357,10 @@ void _php_curl_multi_close(zend_resource *rsrc TSRMLS_DC) /* {{{ */
return string describing error code */
PHP_FUNCTION(curl_multi_strerror)
{
long code;
php_int_t code;
const char *str;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &code) == FAILURE) {
return;
}
@ -375,7 +375,7 @@ PHP_FUNCTION(curl_multi_strerror)
#endif
#if LIBCURL_VERSION_NUM >= 0x070f04 /* 7.15.4 */
static int _php_curl_multi_setopt(php_curlm *mh, long option, zval *zvalue, zval *return_value TSRMLS_DC) /* {{{ */
static int _php_curl_multi_setopt(php_curlm *mh, php_int_t option, zval *zvalue, zval *return_value TSRMLS_DC) /* {{{ */
{
CURLMcode error = CURLM_OK;
@ -386,8 +386,8 @@ static int _php_curl_multi_setopt(php_curlm *mh, long option, zval *zvalue, zval
#if LIBCURL_VERSION_NUM >= 0x071003 /* 7.16.3 */
case CURLMOPT_MAXCONNECTS:
#endif
convert_to_long_ex(zvalue);
error = curl_multi_setopt(mh->multi, option, Z_LVAL_P(zvalue));
convert_to_int_ex(zvalue);
error = curl_multi_setopt(mh->multi, option, Z_IVAL_P(zvalue));
break;
default:
@ -409,10 +409,10 @@ static int _php_curl_multi_setopt(php_curlm *mh, long option, zval *zvalue, zval
PHP_FUNCTION(curl_multi_setopt)
{
zval *z_mh, *zvalue;
long options;
php_int_t options;
php_curlm *mh;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &z_mh, &options, &zvalue) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "riz", &z_mh, &options, &zvalue) == FAILURE) {
return;
}

10
ext/curl/share.c
View File

@ -66,15 +66,15 @@ PHP_FUNCTION(curl_share_close)
}
/* }}} */
static int _php_curl_share_setopt(php_curlsh *sh, long option, zval *zvalue, zval *return_value TSRMLS_DC) /* {{{ */
static int _php_curl_share_setopt(php_curlsh *sh, php_int_t option, zval *zvalue, zval *return_value TSRMLS_DC) /* {{{ */
{
CURLSHcode error = CURLSHE_OK;
switch (option) {
case CURLSHOPT_SHARE:
case CURLSHOPT_UNSHARE:
convert_to_long_ex(zvalue);
error = curl_share_setopt(sh->share, option, Z_LVAL_P(zvalue));
convert_to_int_ex(zvalue);
error = curl_share_setopt(sh->share, option, Z_IVAL_P(zvalue));
break;
default:
@ -96,10 +96,10 @@ static int _php_curl_share_setopt(php_curlsh *sh, long option, zval *zvalue, zva
PHP_FUNCTION(curl_share_setopt)
{
zval *zid, *zvalue;
long options;
php_int_t options;
php_curlsh *sh;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &zid, &options, &zvalue) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "riz", &zid, &options, &zvalue) == FAILURE) {
return;
}

2
ext/date/lib/parse_date.c
View File

@ -1,4 +1,4 @@
/* Generated by re2c 0.13.5 on Mon Aug 18 18:28:27 2014 */
/* Generated by re2c 0.13.5 on Tue Aug 19 08:27:07 2014 */
#line 1 "ext/date/lib/parse_date.re"
/*
+----------------------------------------------------------------------+

6
ext/date/lib/timelib.c
View File

@ -176,13 +176,13 @@ void timelib_error_container_dtor(timelib_error_container *errors)
free(errors);
}
signed long timelib_date_to_int(timelib_time *d, int *error)
php_int_t timelib_date_to_int(timelib_time *d, int *error)
{
timelib_sll ts;
ts = d->sse;
if (ts < LONG_MIN || ts > LONG_MAX) {
if (ts < PHP_INT_MIN || ts > PHP_INT_MAX) {
if (error) {
*error = 1;
}
@ -191,7 +191,7 @@ signed long timelib_date_to_int(timelib_time *d, int *error)
if (error) {
*error = 0;
}
return (signed long) d->sse;
return (php_int_t) d->sse;
}
void timelib_decimal_hour_to_hms(double h, int *hour, int *min, int *sec)

3
ext/date/lib/timelib.h
View File

@ -21,6 +21,7 @@
#ifndef __TIMELIB_H__
#define __TIMELIB_H__
#include "php.h" /* for php_int_t */
#include "timelib_structs.h"
#if HAVE_LIMITS_H
#include <limits.h>
@ -128,7 +129,7 @@ void timelib_time_offset_dtor(timelib_time_offset* t);
void timelib_error_container_dtor(timelib_error_container *errors);
signed long timelib_date_to_int(timelib_time *d, int *error);
php_int_t timelib_date_to_int(timelib_time *d, int *error);
void timelib_dump_date(timelib_time *d, int options);
void timelib_dump_rel_time(timelib_rel_time *d);

324
ext/date/php_date.c
View File

@ -39,24 +39,6 @@ static __inline __int64_t php_date_llabs( __int64_t i ) { return i >= 0 ? i : -i
static inline long long php_date_llabs( long long i ) { return i >= 0 ? i : -i; }
#endif
#ifdef PHP_WIN32
#define DATE_I64_BUF_LEN 65
# define DATE_I64A(i, s, len) _i64toa_s(i, s, len, 10)
# define DATE_A64I(i, s) i = _atoi64(s)
#else
#define DATE_I64_BUF_LEN 65
# define DATE_I64A(i, s, len) \
do { \
int st = snprintf(s, len, "%lld", i); \
s[st] = '\0'; \
} while (0);
#ifdef HAVE_ATOLL
# define DATE_A64I(i, s) i = atoll(s)
#else
# define DATE_A64I(i, s) i = strtoll(s, NULL, 10)
#endif
#endif
/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_date, 0, 0, 1)
ZEND_ARG_INFO(0, format)
@ -860,9 +842,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 +944,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)) {
@ -1217,9 +1199,9 @@ static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
{
char *format;
int format_len;
long ts;
php_int_t ts;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &ts) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &format, &format_len, &ts) == FAILURE) {
RETURN_FALSE;
}
if (ZEND_NUM_ARGS() == 1) {
@ -1373,10 +1355,10 @@ PHP_FUNCTION(idate)
{
char *format;
int format_len;
long ts = 0;
php_int_t ts = 0;
int ret;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &ts) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &format, &format_len, &ts) == FAILURE) {
RETURN_FALSE;
}
@ -1394,7 +1376,7 @@ PHP_FUNCTION(idate)
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unrecognized date format token.");
RETURN_FALSE;
}
RETURN_LONG(ret);
RETURN_INT(ret);
}
/* }}} */
@ -1411,12 +1393,12 @@ PHPAPI void php_date_set_tzdb(timelib_tzdb *tzdb)
/* }}} */
/* {{{ php_parse_date: Backwards compatibility function */
PHPAPI signed long php_parse_date(char *string, signed long *now)
PHPAPI php_int_t php_parse_date(char *string, php_int_t *now)
{
timelib_time *parsed_time;
timelib_error_container *error = NULL;
int error2;
signed long retval;
php_int_t retval;
parsed_time = timelib_strtotime(string, strlen(string), &error, DATE_TIMEZONEDB, php_date_parse_tzfile_wrapper);
if (error->error_count) {
@ -1442,14 +1424,14 @@ PHP_FUNCTION(strtotime)
char *times, *initial_ts;
int time_len, error1, error2;
struct timelib_error_container *error;
long preset_ts = 0, ts;
php_int_t preset_ts = 0, ts;
timelib_time *t, *now;
timelib_tzinfo *tzi;
tzi = get_timezone_info(TSRMLS_C);
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "sl", &times, &time_len, &preset_ts) != FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "si", &times, &time_len, &preset_ts) != FAILURE) {
/* We have an initial timestamp */
now = timelib_time_ctor();
@ -1462,7 +1444,7 @@ PHP_FUNCTION(strtotime)
timelib_unixtime2local(now, t->sse);
timelib_time_dtor(t);
efree(initial_ts);
} else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &times, &time_len, &preset_ts) != FAILURE) {
} else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &times, &time_len, &preset_ts) != FAILURE) {
/* We have no initial timestamp */
now = timelib_time_ctor();
now->tz_info = tzi;
@ -1490,7 +1472,7 @@ PHP_FUNCTION(strtotime)
if (error1 || error2) {
RETURN_FALSE;
} else {
RETURN_LONG(ts);
RETURN_INT(ts);
}
}
/* }}} */
@ -1498,13 +1480,13 @@ PHP_FUNCTION(strtotime)
/* {{{ php_mktime - (gm)mktime helper */
PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
{
long hou = 0, min = 0, sec = 0, mon = 0, day = 0, yea = 0, dst = -1;
php_int_t hou = 0, min = 0, sec = 0, mon = 0, day = 0, yea = 0, dst = -1;
timelib_time *now;
timelib_tzinfo *tzi = NULL;
long ts, adjust_seconds = 0;
php_int_t ts, adjust_seconds = 0;
int error;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lllllll", &hou, &min, &sec, &mon, &day, &yea, &dst) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|iiiiiii", &hou, &min, &sec, &mon, &day, &yea, &dst) == FAILURE) {
RETURN_FALSE;
}
/* Initialize structure with current time */
@ -1582,7 +1564,7 @@ PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
if (error) {
RETURN_FALSE;
} else {
RETURN_LONG(ts);
RETURN_INT(ts);
}
}
/* }}} */
@ -1607,9 +1589,9 @@ PHP_FUNCTION(gmmktime)
Returns true(1) if it is a valid date in gregorian calendar */
PHP_FUNCTION(checkdate)
{
long m, d, y;
php_int_t m, d, y;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &m, &d, &y) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iii", &m, &d, &y) == FAILURE) {
RETURN_FALSE;
}
@ -1626,7 +1608,7 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
{
char *format;
int format_len;
long timestamp = 0;
php_int_t timestamp = 0;
struct tm ta;
int max_reallocs = 5;
size_t buf_len = 256, real_len;
@ -1635,9 +1617,9 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
timelib_time_offset *offset = NULL;
zend_string *buf;
timestamp = (long) time(NULL);
timestamp = (php_int_t) time(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &timestamp) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &format, &format_len, &timestamp) == FAILURE) {
RETURN_FALSE;
}
@ -1737,7 +1719,7 @@ PHP_FUNCTION(gmstrftime)
Return current UNIX timestamp */
PHP_FUNCTION(time)
{
RETURN_LONG((long)time(NULL));
RETURN_INT((php_int_t)time(NULL));
}
/* }}} */
@ -1745,12 +1727,12 @@ PHP_FUNCTION(time)
Returns the results of the C system call localtime as an associative array if the associative_array argument is set to 1 other wise it is a regular array */
PHP_FUNCTION(localtime)
{
long timestamp = (long)time(NULL);
php_int_t timestamp = (php_int_t)time(NULL);
zend_bool associative = 0;
timelib_tzinfo *tzi;
timelib_time *ts;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &timestamp, &associative) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ib", &timestamp, &associative) == FAILURE) {
RETURN_FALSE;
}
@ -1763,25 +1745,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);
@ -1792,11 +1774,11 @@ PHP_FUNCTION(localtime)
Get date/time information */
PHP_FUNCTION(getdate)
{
long timestamp = (long)time(NULL);
php_int_t timestamp = (php_int_t)time(NULL);
timelib_tzinfo *tzi;
timelib_time *ts;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &timestamp) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &timestamp) == FAILURE) {
RETURN_FALSE;
}
@ -1808,17 +1790,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 +1907,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 +2031,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 +2078,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 +2185,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 +2278,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 +2359,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, (php_int_t)intervalobj->diff->f); \
zend_hash_str_update(props, n, sizeof(n)-1, &zv);
PHP_DATE_INTERVAL_ADD_PROPERTY("y", y);
@ -2760,18 +2742,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 +2773,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 +2852,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 +2890,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 +2935,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,24 +3342,24 @@ 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);
}
}
/* }}} */
static void php_date_time_set(zval *object, long h, long i, long s, zval *return_value TSRMLS_DC) /* {{{ */
static void php_date_time_set(zval *object, php_int_t h, php_int_t i, php_int_t s, zval *return_value TSRMLS_DC) /* {{{ */
{
php_date_obj *dateobj;
@ -3395,9 +3377,9 @@ static void php_date_time_set(zval *object, long h, long i, long s, zval *return
PHP_FUNCTION(date_time_set)
{
zval *object;
long h, i, s = 0;
php_int_t h, i, s = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_date, &h, &i, &s) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii|i", &object, date_ce_date, &h, &i, &s) == FAILURE) {
RETURN_FALSE;
}
@ -3412,9 +3394,9 @@ PHP_FUNCTION(date_time_set)
PHP_METHOD(DateTimeImmutable, setTime)
{
zval *object, new_object;
long h, i, s = 0;
php_int_t h, i, s = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_immutable, &h, &i, &s) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii|i", &object, date_ce_immutable, &h, &i, &s) == FAILURE) {
RETURN_FALSE;
}
@ -3425,7 +3407,7 @@ PHP_METHOD(DateTimeImmutable, setTime)
}
/* }}} */
static void php_date_date_set(zval *object, long y, long m, long d, zval *return_value TSRMLS_DC) /* {{{ */
static void php_date_date_set(zval *object, php_int_t y, php_int_t m, php_int_t d, zval *return_value TSRMLS_DC) /* {{{ */
{
php_date_obj *dateobj;
@ -3443,9 +3425,9 @@ static void php_date_date_set(zval *object, long y, long m, long d, zval *return
PHP_FUNCTION(date_date_set)
{
zval *object;
long y, m, d;
php_int_t y, m, d;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &object, date_ce_date, &y, &m, &d) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oiii", &object, date_ce_date, &y, &m, &d) == FAILURE) {
RETURN_FALSE;
}
@ -3460,9 +3442,9 @@ PHP_FUNCTION(date_date_set)
PHP_METHOD(DateTimeImmutable, setDate)
{
zval *object, new_object;
long y, m, d;
php_int_t y, m, d;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &object, date_ce_immutable, &y, &m, &d) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oiii", &object, date_ce_immutable, &y, &m, &d) == FAILURE) {
RETURN_FALSE;
}
@ -3473,7 +3455,7 @@ PHP_METHOD(DateTimeImmutable, setDate)
}
/* }}} */
static void php_date_isodate_set(zval *object, long y, long w, long d, zval *return_value TSRMLS_DC) /* {{{ */
static void php_date_isodate_set(zval *object, php_int_t y, php_int_t w, php_int_t d, zval *return_value TSRMLS_DC) /* {{{ */
{
php_date_obj *dateobj;
@ -3495,9 +3477,9 @@ static void php_date_isodate_set(zval *object, long y, long w, long d, zval *ret
PHP_FUNCTION(date_isodate_set)
{
zval *object;
long y, w, d = 1;
php_int_t y, w, d = 1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_date, &y, &w, &d) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii|i", &object, date_ce_date, &y, &w, &d) == FAILURE) {
RETURN_FALSE;
}
@ -3512,9 +3494,9 @@ PHP_FUNCTION(date_isodate_set)
PHP_METHOD(DateTimeImmutable, setISODate)
{
zval *object, new_object;
long y, w, d = 1;
php_int_t y, w, d = 1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_immutable, &y, &w, &d) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii|i", &object, date_ce_immutable, &y, &w, &d) == FAILURE) {
RETURN_FALSE;
}
@ -3525,7 +3507,7 @@ PHP_METHOD(DateTimeImmutable, setISODate)
}
/* }}} */
static void php_date_timestamp_set(zval *object, long timestamp, zval *return_value TSRMLS_DC) /* {{{ */
static void php_date_timestamp_set(zval *object, php_int_t timestamp, zval *return_value TSRMLS_DC) /* {{{ */
{
php_date_obj *dateobj;
@ -3541,9 +3523,9 @@ static void php_date_timestamp_set(zval *object, long timestamp, zval *return_va
PHP_FUNCTION(date_timestamp_set)
{
zval *object;
long timestamp;
php_int_t timestamp;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &object, date_ce_date, &timestamp) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oi", &object, date_ce_date, &timestamp) == FAILURE) {
RETURN_FALSE;
}
@ -3558,9 +3540,9 @@ PHP_FUNCTION(date_timestamp_set)
PHP_METHOD(DateTimeImmutable, setTimestamp)
{
zval *object, new_object;
long timestamp;
php_int_t timestamp;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &object, date_ce_immutable, &timestamp) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oi", &object, date_ce_immutable, &timestamp) == FAILURE) {
RETURN_FALSE;
}
@ -3578,7 +3560,7 @@ PHP_FUNCTION(date_timestamp_get)
{
zval *object;
php_date_obj *dateobj;
long timestamp;
php_int_t timestamp;
int error;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_interface) == FAILURE) {
@ -3592,7 +3574,7 @@ PHP_FUNCTION(date_timestamp_get)
if (error) {
RETURN_FALSE;
} else {
RETVAL_LONG(timestamp);
RETVAL_INT(timestamp);
}
}
/* }}} */
@ -3605,9 +3587,9 @@ PHP_FUNCTION(date_diff)
zval *object1, *object2;
php_date_obj *dateobj1, *dateobj2;
php_interval_obj *interval;
long absolute = 0;
php_int_t absolute = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &object1, date_ce_interface, &object2, date_ce_interface, &absolute) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|i", &object1, date_ce_interface, &object2, date_ce_interface, &absolute) == FAILURE) {
RETURN_FALSE;
}
dateobj1 = Z_PHPDATE_P(object1);
@ -3692,7 +3674,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;
}
@ -3782,10 +3764,10 @@ PHP_FUNCTION(timezone_name_from_abbr)
char *abbr;
char *tzid;
int abbr_len;
long gmtoffset = -1;
long isdst = -1;
php_int_t gmtoffset = -1;
php_int_t isdst = -1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &abbr, &abbr_len, &gmtoffset, &isdst) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ii", &abbr, &abbr_len, &gmtoffset, &isdst) == FAILURE) {
RETURN_FALSE;
}
tzid = timelib_timezone_id_from_abbr(abbr, gmtoffset, isdst);
@ -3819,14 +3801,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;
}
}
@ -3840,9 +3822,9 @@ PHP_FUNCTION(timezone_transitions_get)
zval *object, element;
php_timezone_obj *tzobj;
unsigned int i, begin = 0, found;
long timestamp_begin = LONG_MIN, timestamp_end = LONG_MAX;
php_int_t timestamp_begin = PHP_INT_MIN, timestamp_end = PHP_INT_MAX;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ll", &object, date_ce_timezone, &timestamp_begin, &timestamp_end) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ii", &object, date_ce_timezone, &timestamp_begin, &timestamp_end) == FAILURE) {
RETURN_FALSE;
}
tzobj = Z_PHPTIMEZONE_P(object);
@ -3853,18 +3835,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);
@ -3873,7 +3855,7 @@ PHP_FUNCTION(timezone_transitions_get)
array_init(return_value);
if (timestamp_begin == LONG_MIN) {
if (timestamp_begin == PHP_INT_MIN) {
add_nominal();
begin = 0;
found = 1;
@ -4023,7 +4005,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 +4044,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 +4101,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; \
} \
@ -4130,7 +4112,7 @@ static int php_date_interval_initialize_from_hash(zval **return_value, php_inter
zval *z_arg = zend_hash_str_find(myht, element, sizeof(element) - 1); \
if (z_arg) { \
zend_string *str = zval_get_string(z_arg); \
DATE_A64I((*intobj)->diff->member, str->val); \
ZEND_ATOI((*intobj)->diff->member, str->val); \
STR_RELEASE(str); \
} else { \
(*intobj)->diff->member = -1LL; \
@ -4248,8 +4230,8 @@ static zend_string *date_interval_format(char *format, int format_len, timelib_r
case 'I': length = slprintf(buffer, 32, "%02d", (int) t->i); break;
case 'i': length = slprintf(buffer, 32, "%d", (int) t->i); break;
case 'S': length = slprintf(buffer, 32, "%02ld", (long) t->s); break;
case 's': length = slprintf(buffer, 32, "%ld", (long) t->s); break;
case 'S': length = slprintf(buffer, 32, "%02" ZEND_INT_FMT_SPEC, (php_int_t) t->s); break;
case 's': length = slprintf(buffer, 32, ZEND_INT_FMT, (php_int_t) t->s); break;
case 'a': {
if ((int) t->days != -99999) {
@ -4301,7 +4283,7 @@ PHP_FUNCTION(date_interval_format)
}
/* }}} */
static int date_period_initialize(timelib_time **st, timelib_time **et, timelib_rel_time **d, long *recurrences, /*const*/ char *format, int format_length TSRMLS_DC) /* {{{ */
static int date_period_initialize(timelib_time **st, timelib_time **et, timelib_rel_time **d, php_int_t *recurrences, /*const*/ char *format, int format_length TSRMLS_DC) /* {{{ */
{
timelib_time *b = NULL, *e = NULL;
timelib_rel_time *p = NULL;
@ -4334,16 +4316,16 @@ PHP_METHOD(DatePeriod, __construct)
php_date_obj *dateobj;
php_interval_obj *intobj;
zval *start, *end = NULL, *interval;
long recurrences = 0, options = 0;
php_int_t recurrences = 0, options = 0;
char *isostr = NULL;
int isostr_len = 0;
timelib_time *clone;
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "OOl|l", &start, date_ce_interface, &interval, date_ce_interval, &recurrences, &options) == FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "OOO|l", &start, date_ce_interface, &interval, date_ce_interval, &end, date_ce_interface, &options) == FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &isostr, &isostr_len, &options) == FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "OOi|i", &start, date_ce_interface, &interval, date_ce_interval, &recurrences, &options) == FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "OOO|i", &start, date_ce_interface, &interval, date_ce_interval, &end, date_ce_interface, &options) == FAILURE) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &isostr, &isostr_len, &options) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "This constructor accepts either (DateTimeInterface, DateInterval, int) OR (DateTimeInterface, DateInterval, DateTime) OR (string) as arguments.");
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
@ -4413,7 +4395,7 @@ PHP_METHOD(DatePeriod, __construct)
}
/* }}} */
static int check_id_allowed(char *id, long what) /* {{{ */
static int check_id_allowed(char *id, php_int_t what) /* {{{ */
{
if (what & PHP_DATE_TIMEZONE_GROUP_AFRICA && strncasecmp(id, "Africa/", 7) == 0) return 1;
if (what & PHP_DATE_TIMEZONE_GROUP_AMERICA && strncasecmp(id, "America/", 8) == 0) return 1;
@ -4437,11 +4419,11 @@ PHP_FUNCTION(timezone_identifiers_list)
const timelib_tzdb *tzdb;
const timelib_tzdb_index_entry *table;
int i, item_count;
long what = PHP_DATE_TIMEZONE_GROUP_ALL;
php_int_t what = PHP_DATE_TIMEZONE_GROUP_ALL;
char *option = NULL;
int option_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ls", &what, &option, &option_len) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|is", &what, &option, &option_len) == FAILURE) {
RETURN_FALSE;
}
@ -4496,7 +4478,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 {
@ -4558,13 +4540,13 @@ static void php_do_date_sunrise_sunset(INTERNAL_FUNCTION_PARAMETERS, int calc_su
double latitude = 0.0, longitude = 0.0, zenith = 0.0, gmt_offset = 0, altitude;
double h_rise, h_set, N;
timelib_sll rise, set, transit;
long time, retformat = 0;
php_int_t time, retformat = 0;
int rs;
timelib_time *t;
timelib_tzinfo *tzi;
zend_string *retstr;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|ldddd", &time, &retformat, &latitude, &longitude, &zenith, &gmt_offset) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i|idddd", &time, &retformat, &latitude, &longitude, &zenith, &gmt_offset) == FAILURE) {
RETURN_FALSE;
}
@ -4617,7 +4599,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;
@ -4657,7 +4639,7 @@ PHP_FUNCTION(date_sunset)
Returns an array with information about sun set/rise and twilight begin/end */
PHP_FUNCTION(date_sun_info)
{
long time;
php_int_t time;
double latitude, longitude;
timelib_time *t, *t2;
timelib_tzinfo *tzi;
@ -4666,7 +4648,7 @@ PHP_FUNCTION(date_sun_info)
int dummy;
double ddummy;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ldd", &time, &latitude, &longitude) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "idd", &time, &latitude, &longitude) == FAILURE) {
RETURN_FALSE;
}
/* Initialize time struct */
@ -4693,12 +4675,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 +4695,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 +4713,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 +4731,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 +4803,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 +4873,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;
}

2
ext/date/php_date.h
View File

@ -203,7 +203,7 @@ ZEND_END_MODULE_GLOBALS(date)
#endif
/* Backwards compatibility wrapper */
PHPAPI signed long php_parse_date(char *string, signed long *now);
PHPAPI php_int_t php_parse_date(char *string, php_int_t *now);
PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt);
PHPAPI int php_idate(char format, time_t ts, int localtime TSRMLS_DC);
#if HAVE_STRFTIME

20
ext/dba/dba.c
View File

@ -217,10 +217,10 @@ static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS
name = zend_hash_get_current_data_ex(Z_ARRVAL_P(key), &pos);
convert_to_string_ex(group);
convert_to_string_ex(name);
if (Z_STRLEN_P(group) == 0) {
if (Z_STRSIZE_P(group) == 0) {
*key_str = Z_STRVAL_P(name);
*key_free = NULL;
return Z_STRLEN_P(name);
return Z_STRSIZE_P(name);
}
len = spprintf(key_str, 0, "[%s]%s", Z_STRVAL_P(group), Z_STRVAL_P(name));
*key_free = *key_str;
@ -232,8 +232,8 @@ static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS
ZVAL_COPY(&tmp, key);
convert_to_string(&tmp);
*key_free = *key_str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
len = Z_STRLEN(tmp);
*key_free = *key_str = estrndup(Z_STRVAL(tmp), Z_STRSIZE(tmp));
len = Z_STRSIZE(tmp);
zval_ptr_dtor(&tmp);
return len;
@ -256,7 +256,7 @@ static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS
zval *key; \
char *key_str, *key_free; \
size_t key_len; \
long skip = 0; \
php_int_t skip = 0; \
switch(ac) { \
case 2: \
if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { \
@ -264,7 +264,7 @@ static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS
} \
break; \
case 3: \
if (zend_parse_parameters(ac TSRMLS_CC, "zlr", &key, &skip, &id) == FAILURE) { \
if (zend_parse_parameters(ac TSRMLS_CC, "zir", &key, &skip, &id) == FAILURE) { \
return; \
} \
break; \
@ -646,7 +646,7 @@ static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
} else if (Z_REFCOUNTED(args[i])) {
Z_ADDREF(args[i]);
}
keylen += Z_STRLEN(args[i]);
keylen += Z_STRSIZE(args[i]);
}
if (persistent) {
@ -658,8 +658,8 @@ static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
keylen = 0;
for(i = 0; i < ac; i++) {
memcpy(key+keylen, Z_STRVAL(args[i]), Z_STRLEN(args[i]));
keylen += Z_STRLEN(args[i]);
memcpy(key+keylen, Z_STRVAL(args[i]), Z_STRSIZE(args[i]));
keylen += Z_STRSIZE(args[i]);
}
/* try to find if we already have this link in our persistent list */
@ -1243,7 +1243,7 @@ PHP_FUNCTION(dba_handlers)
List opened databases */
PHP_FUNCTION(dba_list)
{
ulong numitems, i;
php_uint_t numitems, i;
zend_resource *le;
dba_info *info;

4
ext/dba/dba_db1.c
View File

@ -51,8 +51,8 @@ DBA_OPEN_FUNC(db1)
int filemode = 0644;
if (info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
gmode = 0;

4
ext/dba/dba_db2.c
View File

@ -72,8 +72,8 @@ DBA_OPEN_FUNC(db2)
}
if (info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
if (db_open(info->path, type, gmode, filemode, NULL, NULL, &dbp)) {

4
ext/dba/dba_db3.c
View File

@ -81,8 +81,8 @@ DBA_OPEN_FUNC(db3)
}
if (info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
#ifdef DB_FCNTL_LOCKING

4
ext/dba/dba_db4.c
View File

@ -118,8 +118,8 @@ DBA_OPEN_FUNC(db4)
}
if (info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
if ((err=db_create(&dbp, NULL, 0)) == 0) {

4
ext/dba/dba_dbm.c
View File

@ -60,8 +60,8 @@ DBA_OPEN_FUNC(dbm)
int filemode = 0644;
if(info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
if(info->mode == DBA_TRUNC) {

4
ext/dba/dba_gdbm.c
View File

@ -54,8 +54,8 @@ DBA_OPEN_FUNC(gdbm)
return FAILURE; /* not possible */
if(info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
dbf = gdbm_open(info->path, 0, gmode, filemode, NULL);

4
ext/dba/dba_ndbm.c
View File

@ -59,8 +59,8 @@ DBA_OPEN_FUNC(ndbm)
}
if(info->argc > 0) {
convert_to_long_ex(&info->argv[0]);
filemode = Z_LVAL(info->argv[0]);
convert_to_int_ex(&info->argv[0]);
filemode = Z_IVAL(info->argv[0]);
}
dbf = dbm_open(info->path, gmode, filemode);

2
ext/dba/php_dba.h
View File

@ -126,7 +126,7 @@ typedef struct dba_handler {
DBA_SYNC_FUNC(x); \
DBA_INFO_FUNC(x)
#define VALLEN(p) Z_STRVAL_PP(p), Z_STRLEN_PP(p)
#define VALLEN(p) Z_STRVAL_PP(p), Z_STRSIZE_PP(p)
PHP_FUNCTION(dba_open);
PHP_FUNCTION(dba_popen);

18
ext/dom/characterdata.c
View File

@ -139,7 +139,7 @@ int dom_characterdata_length_read(dom_object *obj, zval *retval TSRMLS_DC)
xmlFree(content);
}
ZVAL_LONG(retval, length);
ZVAL_INT(retval, length);
return SUCCESS;
}
@ -156,11 +156,11 @@ PHP_FUNCTION(dom_characterdata_substring_data)
xmlChar *cur;
xmlChar *substring;
xmlNodePtr node;
long offset, count;
php_int_t offset, count;
int length;
dom_object *intern;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll", &id, dom_characterdata_class_entry, &offset, &count) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii", &id, dom_characterdata_class_entry, &offset, &count) == FAILURE) {
return;
}
@ -239,11 +239,11 @@ PHP_FUNCTION(dom_characterdata_insert_data)
xmlChar *cur, *first, *second;
xmlNodePtr node;
char *arg;
long offset;
php_int_t offset;
int length, arg_len;
dom_object *intern;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ols", &id, dom_characterdata_class_entry, &offset, &arg, &arg_len) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ois", &id, dom_characterdata_class_entry, &offset, &arg, &arg_len) == FAILURE) {
return;
}
@ -286,11 +286,11 @@ PHP_FUNCTION(dom_characterdata_delete_data)
zval *id;
xmlChar *cur, *substring, *second;
xmlNodePtr node;
long offset, count;
php_int_t offset, count;
int length;
dom_object *intern;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll", &id, dom_characterdata_class_entry, &offset, &count) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oii", &id, dom_characterdata_class_entry, &offset, &count) == FAILURE) {
return;
}
@ -342,11 +342,11 @@ PHP_FUNCTION(dom_characterdata_replace_data)
xmlChar *cur, *substring, *second = NULL;
xmlNodePtr node;
char *arg;
long offset, count;
php_int_t offset, count;
int length, arg_len;
dom_object *intern;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olls", &id, dom_characterdata_class_entry, &offset, &count, &arg, &arg_len) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oiis", &id, dom_characterdata_class_entry, &offset, &count, &arg, &arg_len) == FAILURE) {
return;
}

36
ext/dom/document.c
View File

@ -388,7 +388,7 @@ int dom_document_standalone_write(dom_object *obj, zval *newval TSRMLS_DC)
return FAILURE;
}
standalone = zval_get_long(newval);
standalone = zval_get_int(newval);
docp->standalone = ZEND_NORMALIZE_BOOL(standalone);
return SUCCESS;
@ -970,9 +970,9 @@ PHP_FUNCTION(dom_document_import_node)
xmlNodePtr nodep, retnodep;
dom_object *intern, *nodeobj;
int ret;
long recursive = 0;
php_int_t recursive = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &id, dom_document_class_entry, &node, dom_node_class_entry, &recursive) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|i", &id, dom_document_class_entry, &node, dom_node_class_entry, &recursive) == FAILURE) {
return;
}
@ -1465,14 +1465,14 @@ static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) {
dom_object *intern;
char *source;
int source_len, refcount, ret;
long options = 0;
php_int_t options = 0;
id = getThis();
if (id != NULL && ! instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
id = NULL;
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &options) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &source, &source_len, &options) == FAILURE) {
return;
}
@ -1547,9 +1547,9 @@ PHP_FUNCTION(dom_document_save)
dom_object *intern;
dom_doc_propsptr doc_props;
char *file;
long options = 0;
php_int_t options = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l", &id, dom_document_class_entry, &file, &file_len, &options) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|i", &id, dom_document_class_entry, &file, &file_len, &options) == FAILURE) {
return;
}
@ -1575,7 +1575,7 @@ PHP_FUNCTION(dom_document_save)
if (bytes == -1) {
RETURN_FALSE;
}
RETURN_LONG(bytes);
RETURN_INT(bytes);
}
/* }}} end dom_document_save */
@ -1593,9 +1593,9 @@ PHP_FUNCTION(dom_document_savexml)
dom_object *intern, *nodeobj;
dom_doc_propsptr doc_props;
int size, format, saveempty = 0;
long options = 0;
php_int_t options = 0;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|O!l", &id, dom_document_class_entry, &nodep, dom_node_class_entry, &options) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|O!i", &id, dom_document_class_entry, &nodep, dom_node_class_entry, &options) == FAILURE) {
return;
}
@ -1698,11 +1698,11 @@ PHP_FUNCTION(dom_document_xinclude)
zval *id;
xmlDoc *docp;
xmlNodePtr root;
long flags = 0;
php_int_t flags = 0;
int err;
dom_object *intern;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &id, dom_document_class_entry, &flags) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|i", &id, dom_document_class_entry, &flags) == FAILURE) {
return;
}
@ -1723,7 +1723,7 @@ PHP_FUNCTION(dom_document_xinclude)
}
if (err) {
RETVAL_LONG(err);
RETVAL_INT(err);
} else {
RETVAL_FALSE;
}
@ -1772,14 +1772,14 @@ static void _dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type
dom_object *intern;
char *source = NULL, *valid_file = NULL;
int source_len = 0, valid_opts = 0;
long flags = 0;
php_int_t flags = 0;
xmlSchemaParserCtxtPtr parser;
xmlSchemaPtr sptr;
xmlSchemaValidCtxtPtr vptr;
int is_valid;
char resolved_path[MAXPATHLEN + 1];
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op|l", &id, dom_document_class_entry, &source, &source_len, &flags) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Op|i", &id, dom_document_class_entry, &source, &source_len, &flags) == FAILURE) {
return;
}
@ -1963,12 +1963,12 @@ static void dom_load_html(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
dom_doc_propsptr doc_prop;
char *source;
int source_len, refcount, ret;
long options = 0;
php_int_t options = 0;
htmlParserCtxtPtr ctxt;
id = getThis();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &options) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &source, &source_len, &options) == FAILURE) {
return;
}
@ -2087,7 +2087,7 @@ PHP_FUNCTION(dom_document_save_html_file)
if (bytes == -1) {
RETURN_FALSE;
}
RETURN_LONG(bytes);
RETURN_INT(bytes);
}
/* }}} end dom_document_save_html_file */

2
ext/dom/dom_iterators.c
View File

@ -158,7 +158,7 @@ static void php_dom_iterator_current_key(zend_object_iterator *iter, zval *key T
zval *object = &iterator->intern.data;
if (instanceof_function(Z_OBJCE_P(object), dom_nodelist_class_entry TSRMLS_CC)) {
ZVAL_LONG(key, iter->index);
ZVAL_INT(key, iter->index);
} else {
dom_object *intern = Z_DOMOBJ_P(&iterator->curobj);

6
ext/dom/namednodemap.c
View File

@ -113,7 +113,7 @@ int dom_namednodemap_length_read(dom_object *obj, zval *retval TSRMLS_DC)
}
}
ZVAL_LONG(retval, count);
ZVAL_INT(retval, count);
return SUCCESS;
}
@ -200,7 +200,7 @@ Since:
PHP_FUNCTION(dom_namednodemap_item)
{
zval *id;
long index;
php_int_t index;
int ret;
dom_object *intern;
xmlNodePtr itemnode = NULL;
@ -209,7 +209,7 @@ PHP_FUNCTION(dom_namednodemap_item)
xmlNodePtr nodep, curnode;
int count;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &id, dom_namednodemap_class_entry, &index) == FAILURE) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oi", &id, dom_namednodemap_class_entry, &index) == FAILURE) {
return;
}
if (index >= 0) {

Some files were not shown because too many files have changed in this diff Show More