/* 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
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)
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);
+int (*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) /* {{{ */
{
zval *tmp;
zend_string *string_key;
- ulong num_key;
+ zend_uint_t num_key;
int i;
for (i = 0; i < indent; i++) {
{
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) {
}
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));
va_end(usr_copy);
#endif
- ZVAL_LONG(¶ms[0], type);
+ ZVAL_INT(¶ms[0], type);
if (error_filename) {
ZVAL_STRING(¶ms[2], error_filename);
ZVAL_NULL(¶ms[2]);
}
- ZVAL_LONG(¶ms[3], error_lineno);
+ ZVAL_INT(¶ms[3], error_lineno);
symbol_table = zend_rebuild_symbol_table(TSRMLS_C);
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++) {
#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
#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);
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);
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 int (*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);
#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()
case IS_FALSE:
case IS_TRUE:
return "boolean";
- case IS_LONG:
+ case IS_INT:
return "integer";
case IS_DOUBLE:
return "double";
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;
}
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;
}
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;
}
case IS_FALSE:
case IS_TRUE:
case IS_LONG:
- convert_to_long_ex(arg);
- *p = Z_LVAL_P(arg);
+ 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 == 'L') {
+ 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 == 'L') {
+ 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:
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;
}
}
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);
}
/* 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";
}
}
/* break omitted intentionally */
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_FALSE:
case IS_TRUE:
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:
}
/* }}} */
-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;
}
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
}
/* }}} */
-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;
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");
}
/* }}} */
-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 */
}
/* }}} */
-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;
/* 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);
}
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);
}
}
/* 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");
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;
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));
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) {
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) {
}
/* }}} */
-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;
}
/* }}} */
-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);
}
/* }}} */
}
/* }}} */
-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);
}
/* }}} */
}
/* }}} */
-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;
}
/* }}} */
-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);
}
/* }}} */
}
/* }}} */
-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;
}
/* }}} */
-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);
}
/* }}} */
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:
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);
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);
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);
/* 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);
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)
#define add_next_index_unset(__arg) add_next_index_null(__arg)
#define add_property_unset(__arg, __key) add_property_null(__arg, __key)
-ZEND_API int add_index_long(zval *arg, ulong idx, long n);
-ZEND_API int add_index_null(zval *arg, ulong idx);
-ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
-ZEND_API int add_index_resource(zval *arg, ulong idx, zend_resource *r);
-ZEND_API int add_index_double(zval *arg, ulong idx, double d);
-ZEND_API int add_index_str(zval *arg, ulong idx, zend_string *str);
-ZEND_API int add_index_string(zval *arg, ulong idx, const char *str);
-ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length);
-ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
-
-ZEND_API int add_next_index_long(zval *arg, long n);
+ZEND_API int add_index_int(zval *arg, zend_uint_t idx, zend_int_t n);
+ZEND_API int add_index_null(zval *arg, zend_uint_t idx);
+ZEND_API int add_index_bool(zval *arg, zend_uint_t idx, int b);
+ZEND_API int add_index_resource(zval *arg, zend_uint_t idx, zend_resource *r);
+ZEND_API int add_index_double(zval *arg, zend_uint_t idx, double d);
+ZEND_API int add_index_str(zval *arg, zend_uint_t idx, zend_string *str);
+ZEND_API int add_index_string(zval *arg, zend_uint_t idx, const char *str);
+ZEND_API int add_index_stringl(zval *arg, zend_uint_t idx, const char *str, uint length);
+ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value);
+
+ZEND_API int add_next_index_int(zval *arg, zend_int_t n);
ZEND_API int add_next_index_null(zval *arg);
ZEND_API int add_next_index_bool(zval *arg, int b);
ZEND_API int add_next_index_resource(zval *arg, zend_resource *r);
#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);
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)
#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 { \
#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)
#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; }
return 1;
}
-static zend_always_inline int _z_param_long(zval *arg, long *dest, zend_bool *is_null, int check_null, int strict)
+static zend_always_inline int _z_param_long(zval *arg, zend_int_t *dest, zend_bool *is_null, int check_null, int strict)
{
if (check_null) {
*is_null = 0;
}
- if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
- 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 (EXPECTED(Z_TYPE_P(arg) == IS_INT)) {
+ 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 = Z_LVAL_P(arg);
+ *dest = Z_IVAL_P(arg);
}
} else if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) {
- *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;
}
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)) {
return 1;
}
-static zend_always_inline int _z_param_string(zval *arg, char **dest, int *dest_len, int check_null TSRMLS_DC)
+static zend_always_inline int _z_param_string(zval *arg, char **dest, zend_size_t *dest_len, int check_null TSRMLS_DC)
{
zend_string *str;
#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); \
*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;
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;
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) {
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)) {
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;
}
#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);
}
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);
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];
}
#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
}
#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;
}
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();
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
}
-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
#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;
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;
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 */
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);
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");
}
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);
Returns number of freed zvals */
ZEND_FUNCTION(gc_collect_cycles)
{
- RETURN_LONG(gc_collect_cycles(TSRMLS_C));
+ RETURN_INT(gc_collect_cycles(TSRMLS_C));
}
/* }}} */
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);
}
}
/* }}} */
ZEND_PARSE_PARAMETERS_END();
#endif
- RETVAL_LONG(s->len);
+ RETVAL_INT(s->len);
}
/* }}} */
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));
}
/* }}} */
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;
}
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));
}
/* }}} */
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));
}
/* }}} */
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;
}
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));
}
/* }}} */
ZEND_FUNCTION(each)
{
zval *array, *entry, tmp;
- ulong num_key;
+ zend_uint_t num_key;
HashTable *target_hash;
zend_string *key;
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);
STR_RELEASE(key);
}
- RETVAL_LONG(old_error_reporting);
+ RETVAL_INT(old_error_reporting);
}
/* }}} */
repeat:
switch (Z_TYPE_P(val)) {
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_STRING:
case IS_FALSE:
Cause an intentional memory leak, for testing/debugging purposes */
ZEND_FUNCTION(leak)
{
- long leakbytes=3;
+ zend_int_t leakbytes=3;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) {
return;
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;
{
zval *error_handler;
zend_string *error_handler_name = NULL;
- long error_type = E_ALL;
+ zend_int_t error_type = E_ALL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
return;
}
(*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;
#ifdef ZTS
ZEND_FUNCTION(zend_thread_id)
{
- RETURN_LONG((long)tsrm_thread_id());
+ RETURN_INT((long)tsrm_thread_id());
}
#endif
#endif
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
}
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;
static void init_compiler_declarables(TSRMLS_D) /* {{{ */
{
- ZVAL_LONG(&CG(declarables).ticks, 0);
+ ZVAL_INT(&CG(declarables).ticks, 0);
}
/* }}} */
static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{{ */{
int i = 0;
- ulong hash_value = STR_HASH_VAL(name);
+ zend_uint_t hash_value = STR_HASH_VAL(name);
while (i < op_array->last_var) {
if (op_array->vars[i]->val == name->val ||
ret = zend_add_literal(op_array, zv TSRMLS_CC);
}
- lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
- zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+ lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0);
+ zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv));
ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
ret = zend_add_literal(op_array, zv TSRMLS_CC);
}
- lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
- zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+ lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0);
+ zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv));
ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
- ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv));
+ ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRSIZE_P(zv));
if (ns_separator != NULL) {
ns_separator += 1;
- lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv));
+ lc_len = Z_STRSIZE_P(zv) - (ns_separator - Z_STRVAL_P(zv));
lc_name = STR_ALLOC(lc_len, 0);
zend_str_tolower_copy(lc_name->val, ns_separator, lc_len);
ZVAL_NEW_STR(&c, lc_name);
}
if (Z_STRVAL_P(zv)[0] == '\\') {
- lc_name = STR_ALLOC(Z_STRLEN_P(zv) - 1, 0);
- zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1);
+ lc_name = STR_ALLOC(Z_STRSIZE_P(zv) - 1, 0);
+ zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRSIZE_P(zv) - 1);
} else {
- lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
- zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+ lc_name = STR_ALLOC(Z_STRSIZE_P(zv), 0);
+ zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRSIZE_P(zv));
}
ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
/* skip leading '\\' */
if (Z_STRVAL_P(zv)[0] == '\\') {
- name_len = Z_STRLEN_P(zv) - 1;
+ name_len = Z_STRSIZE_P(zv) - 1;
name = Z_STRVAL_P(zv) + 1;
} else {
- name_len = Z_STRLEN_P(zv);
+ name_len = Z_STRSIZE_P(zv);
name = Z_STRVAL_P(zv);
}
ns_separator = zend_memrchr(name, '\\', name_len);
op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
} while (0)
-#define LITERAL_LONG(op, val) do { \
+#define LITERAL_INT(op, val) do { \
zval _c; \
- ZVAL_LONG(&_c, val); \
+ ZVAL_INT(&_c, val); \
op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
} while (0)
-#define LITERAL_LONG_EX(op_array, op, val) do { \
+#define LITERAL_INT_EX(op_array, op, val) do { \
zval _c; \
- ZVAL_LONG(&_c, val); \
+ ZVAL_INT(&_c, val); \
op.constant = zend_add_literal(op_array, &_c TSRMLS_CC); \
} while (0)
}
if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
- !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
+ !(Z_STRSIZE(varname->u.constant) == (sizeof("this")-1) &&
!memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
(CG(active_op_array)->last == 0 ||
CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
zend_op opline;
if (class_name->op_type == IS_CONST &&
- ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
+ ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) {
zend_resolve_class_name(class_name TSRMLS_CC);
class_node = *class_name;
} else {
SET_NODE(opline.op1, parent);
SET_NODE(opline.op2, dim);
if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
- ulong index;
+ zend_uint_t index;
if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline.op2.constant)), index)) {
zval_dtor(&CONSTANT(opline.op2.constant));
- ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
+ ZVAL_INT(&CONSTANT(opline.op2.constant), index);
}
}
char *method_type;
if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
- Z_LVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
+ Z_IVAL(modifiers->u.constant) |= ZEND_ACC_ABSTRACT;
method_type = "Interface";
} else {
method_type = "Abstract";
}
- if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
- if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
+ if (Z_IVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
+ if(Z_IVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
}
- if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
+ if (Z_IVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_RAISE_ABSTRACT_ERROR;
zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
}
} else {
- if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
+ if (Z_IVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
}
}
&& (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
&& ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER)
&& (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
- && (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
+ && (Z_STRSIZE(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
&& !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) {
return 1;
} else {
{
zend_op *opline;
- if (Z_STRLEN(op2->u.constant) > 1) {
+ if (Z_STRSIZE(op2->u.constant) > 1) {
opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_STRING;
- } else if (Z_STRLEN(op2->u.constant) == 1) {
+ } else if (Z_STRSIZE(op2->u.constant) == 1) {
int ch = *Z_STRVAL(op2->u.constant);
/* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */
STR_FREE(Z_STR(op2->u.constant));
- ZVAL_LONG(&op2->u.constant, ch);
+ ZVAL_INT(&op2->u.constant, ch);
opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_ADD_CHAR;
} else { /* String can be empty after a variable at the end of a heredoc */
int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier) /* {{{ */
{
- if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
- && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
+ if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_PPP_MASK)
+ && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_PPP_MASK)) {
zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
}
- if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
- && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
+ if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_ABSTRACT)
+ && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_ABSTRACT)) {
zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
}
- if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
- && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
+ if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_STATIC)
+ && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_STATIC)) {
zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
}
- if ((Z_LVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
- && (Z_LVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
+ if ((Z_IVAL(current_access_type->u.constant) & ZEND_ACC_FINAL)
+ && (Z_IVAL(new_modifier->u.constant) & ZEND_ACC_FINAL)) {
zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
}
- if (((Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
+ if (((Z_IVAL(current_access_type->u.constant) | Z_IVAL(new_modifier->u.constant)) & (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) == (ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL)) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
}
- return (Z_LVAL(current_access_type->u.constant) | Z_LVAL(new_modifier->u.constant));
+ return (Z_IVAL(current_access_type->u.constant) | Z_IVAL(new_modifier->u.constant));
}
/* }}} */
if (is_method) {
if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
- if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
+ if ((Z_IVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
}
- Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
+ Z_IVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
}
- fn_flags = Z_LVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
+ fn_flags = Z_IVAL(fn_flags_znode->u.constant); /* must be done *after* the above check */
} else {
fn_flags = 0;
}
ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
op_array.function_name = Z_STR(tmp.u.constant);
- lcname = STR_ALLOC(Z_STRLEN(tmp.u.constant), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
+ lcname = STR_ALLOC(Z_STRSIZE(tmp.u.constant), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRSIZE(tmp.u.constant));
} else {
lcname = STR_ALLOC(name->len, 0);
zend_str_tolower_copy(lcname->val, name->val, name->len);
if (CG(current_import_function) &&
(ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) {
- char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+ char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name));
- if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) ||
- memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) {
+ if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(function_name->u.constant) ||
+ memcmp(tmp, lcname->val, Z_STRSIZE(function_name->u.constant))) {
zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
}
efree(tmp);
if (EX_VAR_TO_NUM(var.u.op.var) != CG(active_op_array)->num_args) {
zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter %s", Z_STRVAL(varname->u.constant));
} else if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL &&
- Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
+ Z_STRSIZE(varname->u.constant) == sizeof("this")-1 &&
!memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
if (CG(active_op_array)->scope &&
(CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) == 0) {
}
CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
- cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
- cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
+ cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRSIZE(varname->u.constant));
+ cur_arg_info->name_len = Z_STRSIZE(varname->u.constant);
cur_arg_info->type_hint = 0;
cur_arg_info->pass_by_reference = pass_by_reference;
cur_arg_info->allow_null = 1;
}
} else {
cur_arg_info->type_hint = IS_OBJECT;
- if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
+ if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRSIZE(class_type->u.constant))) {
zend_resolve_class_name(class_type TSRMLS_CC);
}
Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC);
}
// TODO: for now we have to copy it ???
#if 1
- cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
- cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
+ cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRSIZE(class_type->u.constant));
+ cur_arg_info->class_name_len = Z_STRSIZE(class_type->u.constant);
STR_RELEASE(Z_STR(class_type->u.constant));
#else
cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
- cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
+ cur_arg_info->class_name_len = Z_STRSIZE(class_type->u.constant);
#endif
if (op == ZEND_RECV_INIT) {
if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
zend_uint op_number;
zend_function *function;
zend_string *lcname;
- char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
+ char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRSIZE(function_name->u.constant));
zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC);
return 1;
}
- lcname = STR_ALLOC(Z_STRLEN(function_name->u.constant), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
+ lcname = STR_ALLOC(Z_STRSIZE(function_name->u.constant), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRSIZE(function_name->u.constant));
if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
(function->type == ZEND_INTERNAL_FUNCTION))) {
last_op_number = get_next_op_number(CG(active_op_array))-1;
last_op = &CG(active_op_array)->opcodes[last_op_number];
- if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRLEN(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1)
- && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRLEN(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
+ if ((last_op->op2_type == IS_CONST) && (Z_TYPE(CONSTANT(last_op->op2.constant)) == IS_STRING) && (Z_STRSIZE(CONSTANT(last_op->op2.constant)) == sizeof(ZEND_CLONE_FUNC_NAME)-1)
+ && !zend_binary_strcasecmp(Z_STRVAL(CONSTANT(last_op->op2.constant)), Z_STRSIZE(CONSTANT(last_op->op2.constant)), ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1)) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot call __clone() method on objects - use 'clone $obj' instead");
}
}
last_op->opcode = ZEND_INIT_METHOD_CALL;
last_op->result_type = IS_UNUSED;
- Z_LVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
+ Z_IVAL(left_bracket->u.constant) = ZEND_INIT_FCALL_BY_NAME;
} else {
zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
opline->opcode = ZEND_INIT_FCALL_BY_NAME;
int len;
zval *ns;
zend_string *lookup_name;
- char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
+ char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRSIZE(element_name->u.constant));
if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
/* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
- memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRLEN(element_name->u.constant));
- --Z_STRLEN(element_name->u.constant);
+ memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+1, Z_STRSIZE(element_name->u.constant));
+ --Z_STRSIZE(element_name->u.constant);
return;
}
}
if (current_import_sub) {
- len = Z_STRLEN(element_name->u.constant);
+ len = Z_STRSIZE(element_name->u.constant);
if (case_sensitive) {
lookup_name = STR_INIT(Z_STRVAL(element_name->u.constant), len, 0);
} else {
tmp.op_type = IS_CONST;
ZVAL_DUP(&tmp.u.constant, ns);
len += 1;
- Z_STRLEN(element_name->u.constant) -= len;
- memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
+ Z_STRSIZE(element_name->u.constant) -= len;
+ memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRSIZE(element_name->u.constant)+1);
zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
*element_name = tmp;
STR_FREE(lookup_name);
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
tmp = *element_name;
- Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0);
+ Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRSIZE(element_name->u.constant) + Z_STRSIZE(CG(current_namespace)), 0);
Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
- memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
- memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1);
- memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
+ memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace)));
+ memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRSIZE(CG(current_namespace))]), "\\", sizeof("\\")-1);
+ memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRSIZE(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRSIZE(element_name->u.constant)+1);
STR_RELEASE(Z_STR(element_name->u.constant));
*element_name = tmp;
}
int lctype;
znode constant_name;
- lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+ lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant));
lctype = zend_get_class_fetch_type(lcname, strlen(lcname));
switch (lctype) {
case ZEND_FETCH_CLASS_SELF:
znode tmp;
int len;
- compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRLEN(class_name->u.constant));
+ compound = memchr(Z_STRVAL(class_name->u.constant), '\\', Z_STRSIZE(class_name->u.constant));
if (compound) {
/* This is a compound class name that contains namespace prefix */
if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
/* The STRING name has "\" prefix */
- memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant));
+ memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRSIZE(class_name->u.constant));
Z_STR(class_name->u.constant) = STR_REALLOC(
Z_STR(class_name->u.constant),
- Z_STRLEN(class_name->u.constant) - 1, 0);
+ Z_STRSIZE(class_name->u.constant) - 1, 0);
Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
- if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
+ if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) {
zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant));
}
} else {
tmp.op_type = IS_CONST;
ZVAL_DUP(&tmp.u.constant, ns);
len += 1;
- Z_STRLEN(class_name->u.constant) -= len;
- memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
+ Z_STRSIZE(class_name->u.constant) -= len;
+ memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRSIZE(class_name->u.constant)+1);
zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
*class_name = tmp;
STR_FREE(lcname);
}
} else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
/* this is a plain name (without \) */
- lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+ lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant));
if (CG(current_import) &&
(ns = zend_hash_find(CG(current_import), lcname)) != NULL) {
void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
{
- long fetch_class_op_number;
+ zend_int_t fetch_class_op_number;
zend_op *opline;
fetch_class_op_number = get_next_op_number(CG(active_op_array));
if (class_name->op_type == IS_CONST) {
int fetch_type;
- fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+ fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant));
switch (fetch_type) {
case ZEND_FETCH_CLASS_SELF:
case ZEND_FETCH_CLASS_PARENT:
void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
{
zend_label *dest;
- long current, distance;
+ zend_int_t current, distance;
zval *label;
if (pass2) {
SET_UNUSED(opline->op2);
} else {
/* Set real break distance */
- ZVAL_LONG(label, distance);
+ ZVAL_INT(label, distance);
}
if (pass2) {
}
if (is_class_member) {
- int old_len = Z_STRLEN(result->u.constant);
- length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant);
+ int old_len = Z_STRSIZE(result->u.constant);
+ length = sizeof("::")-1 + old_len + Z_STRSIZE(name->u.constant);
Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1);
- memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
+ memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant)+1);
STR_RELEASE(Z_STR(name->u.constant));
} else {
- int old_len = Z_STRLEN(result->u.constant);
- length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant);
+ int old_len = Z_STRSIZE(result->u.constant);
+ length = sizeof("\\")-1 + old_len + Z_STRSIZE(name->u.constant);
Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1);
- memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
+ memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant)+1);
STR_RELEASE(Z_STR(name->u.constant));
}
}
if (Z_TYPE(method_name->u.constant) != IS_STRING) {
zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
}
- lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRLEN(method_name->u.constant));
- if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRLEN(method_name->u.constant) &&
+ lcname = zend_str_tolower_dup(Z_STRVAL(method_name->u.constant), Z_STRSIZE(method_name->u.constant));
+ if ((sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == Z_STRSIZE(method_name->u.constant) &&
memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) == 0) {
zval_dtor(&method_name->u.constant);
method_name->op_type = IS_UNUSED;
}
if (class_name->op_type == IS_CONST &&
- ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
+ ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) {
zend_resolve_class_name(class_name TSRMLS_CC);
class_node = *class_name;
op_number = get_next_op_number(CG(active_op_array));
*func_ptr = NULL;
if (opline->op1_type == IS_CONST && Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING) {
function_name = &CONSTANT(opline->op1.constant);
- lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
+ lcname = STR_ALLOC(Z_STRSIZE_P(function_name), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRSIZE_P(function_name));
if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
(function->type == ZEND_INTERNAL_FUNCTION))) {
if (opline->opcode != ZEND_SEND_VAL ||
opline->op1_type != IS_CONST ||
Z_TYPE(CONSTANT(opline->op1.constant)) != IS_STRING
- || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL
- || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRLEN(CONSTANT(opline->op1.constant))) != NULL) {
+ || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), '\\', Z_STRSIZE(CONSTANT(opline->op1.constant))) != NULL
+ || zend_memrchr(Z_STRVAL(CONSTANT(opline->op1.constant)), ':', Z_STRSIZE(CONSTANT(opline->op1.constant))) != NULL) {
return 0;
}
opline->extended_value = 0;
GET_CACHE_SLOT(opline->op1.constant);
/* lowcase constant name */
- lc_name = STR_ALLOC(Z_STRLEN(CONSTANT(opline->op1.constant)), 0);
- zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
+ lc_name = STR_ALLOC(Z_STRSIZE(CONSTANT(opline->op1.constant)), 0);
+ zend_str_tolower_copy(lc_name->val, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRSIZE(CONSTANT(opline->op1.constant)));
ZVAL_NEW_STR(&c, lc_name);
zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
opline->result.var = get_temporary_variable(CG(active_op_array));
if (fcall->arg_num != 0) {
zend_error(E_WARNING, "Clone method does not require arguments");
}
- opline = &CG(active_op_array)->opcodes[Z_LVAL(function_name->u.constant)];
+ opline = &CG(active_op_array)->opcodes[Z_IVAL(function_name->u.constant)];
} else {
zend_uint call_flags = 0;
} else if (func->common.function_name->len == sizeof("is_long")-1 &&
memcmp(func->common.function_name->val, "is_long", sizeof("is_long")-1) == 0) {
if (fcall->arg_num == 1) {
- if (zend_do_convert_type_check(opline, result, IS_LONG TSRMLS_CC)) {
+ if (zend_do_convert_type_check(opline, result, IS_INT TSRMLS_CC)) {
zend_stack_del_top(&CG(function_call_stack));
return;
}
void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var, znode *first_catch TSRMLS_DC) /* {{{ */
{
- long catch_op_number;
+ zend_int_t catch_op_number;
zend_op *opline;
znode catch_class;
if (class_name->op_type == IS_CONST &&
- ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
+ ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant))) {
zend_resolve_class_name(class_name TSRMLS_CC);
catch_class = *class_name;
} else {
++idx;
while (op < end) {
if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
- && op->op1.num == (long)idx)
+ && op->op1.num == (zend_int_t)idx)
{
precv = op;
}
zval *zv = precv->op2.zv;
if (Z_TYPE_P(zv) == IS_CONSTANT) {
- REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN_P(zv));
- memcpy(offset, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
- offset += Z_STRLEN_P(zv);
+ REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRSIZE_P(zv));
+ memcpy(offset, Z_STRVAL_P(zv), Z_STRSIZE_P(zv));
+ offset += Z_STRSIZE_P(zv);
} else if (Z_TYPE_P(zv) == IS_FALSE) {
memcpy(offset, "false", 5);
offset += 5;
offset += 4;
} else if (Z_TYPE_P(zv) == IS_STRING) {
*(offset++) = '\'';
- REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
- memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
- offset += MIN(Z_STRLEN_P(zv), 10);
- if (Z_STRLEN_P(zv) > 10) {
+ REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRSIZE_P(zv), 10));
+ memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRSIZE_P(zv), 10));
+ offset += MIN(Z_STRSIZE_P(zv), 10);
+ if (Z_STRSIZE_P(zv) > 10) {
*(offset++) = '.';
*(offset++) = '.';
*(offset++) = '.';
not_compatible = (FAILURE == compare_function(&compare_result,
&ce->default_static_members_table[coliding_prop->offset],
&ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
- || (Z_LVAL(compare_result) != 0);
+ || (Z_IVAL(compare_result) != 0);
} else {
not_compatible = (FAILURE == compare_function(&compare_result,
&ce->default_properties_table[coliding_prop->offset],
&ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
- || (Z_LVAL(compare_result) != 0);
+ || (Z_IVAL(compare_result) != 0);
}
} else {
/* the flags are not identical, thus, we assume properties are not compatible */
zend_class_entry *ce = CG(active_class_entry);
zend_trait_alias *trait_alias;
- if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
+ if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_STATIC) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
return;
- } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
+ } else if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_ABSTRACT) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
return;
- } else if (Z_LVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
+ } else if (Z_IVAL(modifiers->u.constant) == ZEND_ACC_FINAL) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
return;
}
trait_alias = emalloc(sizeof(zend_trait_alias));
trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
- trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
+ trait_alias->modifiers = Z_IVAL(modifiers->u.constant);
if (alias) {
trait_alias->alias = Z_STR(alias->u.constant);
} else {
if (expr) {
if (expr->op_type != IS_CONST) {
zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand is no longer supported", op == ZEND_BRK ? "break" : "continue");
- } else if (Z_TYPE(expr->u.constant) != IS_LONG || Z_LVAL(expr->u.constant) < 1) {
+ } else if (Z_TYPE(expr->u.constant) != IS_INT || Z_IVAL(expr->u.constant) < 1) {
zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers", op == ZEND_BRK ? "break" : "continue");
}
SET_NODE(opline->op2, expr);
} else {
- LITERAL_LONG(opline->op2, 1);
+ LITERAL_INT(opline->op2, 1);
opline->op2_type = IS_CONST;
}
}
return;
}
- lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+ lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant));
if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) {
STR_FREE(lcname);
zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
*class_name = tmp;
STR_FREE(lcname);
- lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+ lcname = STR_ALLOC(Z_STRSIZE(class_name->u.constant), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRSIZE(class_name->u.constant));
}
if (error) {
- char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+ char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name));
- if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) ||
- memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) {
+ if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(class_name->u.constant) ||
+ memcmp(tmp, lcname->val, Z_STRSIZE(class_name->u.constant))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
}
efree(tmp);
CG(active_class_entry)->name->val);
}
- switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
+ switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRSIZE(interface_name->u.constant))) {
case ZEND_FETCH_CLASS_SELF:
case ZEND_FETCH_CLASS_PARENT:
case ZEND_FETCH_CLASS_STATIC:
}
- switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRLEN(trait_name->u.constant))) {
+ switch (zend_get_class_fetch_type(Z_STRVAL(trait_name->u.constant), Z_STRSIZE(trait_name->u.constant))) {
case ZEND_FETCH_CLASS_SELF:
case ZEND_FETCH_CLASS_PARENT:
case ZEND_FETCH_CLASS_STATIC:
cfilename = zend_get_compiled_filename(TSRMLS_C);
name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0);
- zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
+ zend_register_int_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC);
STR_FREE(name);
if (CG(in_namespace)) {
char *lookup_name;
if (Z_STRVAL_P(const_name)[0] == '\\') {
- if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) {
- lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
- if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) {
+ if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRSIZE_P(const_name)-1)) == NULL) {
+ lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRSIZE_P(const_name)-1);
+ if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRSIZE_P(const_name)-1)) != NULL) {
if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
efree(lookup_name);
return c;
return NULL;
}
} else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) {
- lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
- if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) {
+ lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRSIZE_P(const_name));
+ if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRSIZE_P(const_name))) != NULL) {
if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
efree(lookup_name);
return c;
zend_op *opline;
int type;
char *compound;
- ulong fetch_type = 0;
+ zend_uint_t fetch_type = 0;
if (constant_container) {
switch (mode) {
case ZEND_CT:
/* this is a class constant */
- type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant));
+ type = zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRSIZE(constant_container->u.constant));
if (ZEND_FETCH_CLASS_STATIC == type) {
zend_error(E_ERROR, "\"static::\" is not allowed in compile-time constants");
break;
case ZEND_RT:
if (constant_container->op_type == IS_CONST &&
- ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRLEN(constant_container->u.constant))) {
+ ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(constant_container->u.constant), Z_STRSIZE(constant_container->u.constant))) {
zend_resolve_class_name(constant_container TSRMLS_CC);
} else {
zend_do_fetch_class(&tmp, constant_container TSRMLS_CC);
/* only one that did not contain \ from the start can be converted to string if unknown */
switch (mode) {
case ZEND_CT:
- compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
+ compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRSIZE(constant_name->u.constant));
/* this is a namespace constant, or an unprefixed constant */
if (zend_constant_ct_subst(result, &constant_name->u.constant, 0 TSRMLS_CC)) {
Z_CONST_FLAGS(result->u.constant) = fetch_type;
break;
case ZEND_RT:
- compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
+ compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRSIZE(constant_name->u.constant));
zend_resolve_const_name(constant_name, &check_namespace TSRMLS_CC);
if (offset) {
SET_NODE(opline->op2, offset);
if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
- ulong index;
+ zend_uint_t index;
opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
zval_dtor(&CONSTANT(opline->op2.constant));
- ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
+ ZVAL_INT(&CONSTANT(opline->op2.constant), index);
}
}
} else {
if (offset) {
SET_NODE(opline->op2, offset);
if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
- ulong index;
+ zend_uint_t index;
init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
if (ZEND_HANDLE_NUMERIC(Z_STR(CONSTANT(opline->op2.constant)), index)) {
zval_dtor(&CONSTANT(opline->op2.constant));
- ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
+ ZVAL_INT(&CONSTANT(opline->op2.constant), index);
}
}
} else {
while (i > 0 && constant_array) {
if (opline->op2_type == IS_CONST) {
switch (Z_TYPE(CONSTANT(opline->op2.constant))) {
- case IS_LONG:
- num = Z_LVAL(CONSTANT(opline->op2.constant));
+ case IS_INT:
+ num = Z_IVAL(CONSTANT(opline->op2.constant));
num_index:
zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant));
if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
break;
case IS_DOUBLE:
- num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant)));
+ num = zend_dval_to_ival(Z_DVAL(CONSTANT(opline->op2.constant)));
goto num_index;
case IS_FALSE:
num = 0;
opline->result.var = get_temporary_variable(CG(active_op_array));
SET_NODE(opline->op1, &last_container);
opline->op2_type = IS_CONST;
- LITERAL_LONG(opline->op2, *((int *) dimension->data));
+ LITERAL_INT(opline->op2, *((int *) dimension->data));
GET_NODE(&last_container, opline->result);
dimension = dimension->next;
}
{
znode value;
- if (Z_STRLEN(varname->u.constant) == sizeof("this") - 1 &&
+ if (Z_STRSIZE(varname->u.constant) == sizeof("this") - 1 &&
memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1) == 0) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
return;
if (varname->op_type == IS_CONST &&
!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
- !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
+ !(Z_STRSIZE(varname->u.constant) == (sizeof("this")-1) &&
!memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1))) {
opline->opcode = ZEND_BIND_GLOBAL;
SET_NODE(opline->op2, varname);
int i;
zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
- for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
+ for (i=1; i<Z_IVAL(num_references->u.constant); i++) {
fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
*variable = *result;
}
void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
{
- if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
- convert_to_long(&val->u.constant);
+ if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRSIZE(var->u.constant), "ticks", sizeof("ticks")-1)) {
+ convert_to_int(&val->u.constant);
CG(declarables).ticks = val->u.constant;
- } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
+ } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRSIZE(var->u.constant), "encoding", sizeof("encoding")-1)) {
if (Z_TYPE(val->u.constant) == IS_CONSTANT) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding");
}
{
zend_declarables *declarables = zend_stack_top(&CG(declare_stack));
/* We should restore if there was more than (current - start) - (ticks?1:0) opcodes */
- if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_LVAL(CG(declarables).ticks))?1:0)) {
+ if ((get_next_op_number(CG(active_op_array)) - declare_token->u.op.opline_num) - ((Z_IVAL(CG(declarables).ticks))?1:0)) {
CG(declarables) = *declarables;
}
}
opline->opcode = ZEND_TICKS;
SET_UNUSED(opline->op1);
SET_UNUSED(opline->op2);
- opline->extended_value = Z_LVAL(CG(declarables).ticks);
+ opline->extended_value = Z_IVAL(CG(declarables).ticks);
}
/* }}} */
}
again:
- Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
+ Z_TYPE_INFO(zendlval->u.constant) = IS_INT;
retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
switch (retval) {
case T_COMMENT:
if (prefix) {
*result = *prefix;
if (Z_TYPE(result->u.constant) == IS_STRING &&
- Z_STRLEN(result->u.constant) == 0) {
+ Z_STRSIZE(result->u.constant) == 0) {
/* namespace\ */
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
znode tmp;
}
if (name) {
- lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant));
- if (((Z_STRLEN(name->u.constant) == sizeof("self")-1) &&
+ lcname = zend_str_tolower_dup(Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant));
+ if (((Z_STRSIZE(name->u.constant) == sizeof("self")-1) &&
!memcmp(lcname, "self", sizeof("self")-1)) ||
- ((Z_STRLEN(name->u.constant) == sizeof("parent")-1) &&
+ ((Z_STRSIZE(name->u.constant) == sizeof("parent")-1) &&
!memcmp(lcname, "parent", sizeof("parent")-1))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", Z_STRVAL(name->u.constant));
}
/* The form "use A\B" is eqivalent to "use A\B as B".
So we extract the last part of compound name to use as a new_name */
name = &tmp;
- p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
+ p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRSIZE(ns));
if (p) {
ZVAL_STRING(name, p+1);
} else {
}
}
- lcname = STR_ALLOC(Z_STRLEN_P(name), 0);
- zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
+ lcname = STR_ALLOC(Z_STRSIZE_P(name), 0);
+ zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRSIZE_P(name));
- if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
+ if (((Z_STRSIZE_P(name) == sizeof("self")-1) &&
!memcmp(lcname->val, "self", sizeof("self")-1)) ||
- ((Z_STRLEN_P(name) == sizeof("parent")-1) &&
+ ((Z_STRSIZE_P(name) == sizeof("parent")-1) &&
!memcmp(lcname->val, "parent", sizeof("parent")-1))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
}
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
/* Prefix import name with current namespace name to avoid conflicts with classes */
- zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
+ zend_string *c_ns_name = STR_ALLOC(Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name), 0);
- zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
- c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
- memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1);
+ zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace)));
+ c_ns_name->val[Z_STRSIZE(CG(current_namespace))] = '\\';
+ memcpy(c_ns_name->val+Z_STRSIZE(CG(current_namespace))+1, lcname->val, Z_STRSIZE_P(name)+1);
if (zend_hash_exists(CG(class_table), c_ns_name)) {
- char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+ char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns));
- if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
- memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
+ if (Z_STRSIZE(ns) != Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name) ||
+ memcmp(tmp2, c_ns_name->val, Z_STRSIZE(ns))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
}
efree(tmp2);
} else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL &&
ce->type == ZEND_USER_CLASS &&
ce->info.user.filename == CG(compiled_filename)) {
- char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+ char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns));
- if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
- memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) {
+ if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) ||
+ memcmp(c_tmp, lcname->val, Z_STRSIZE(ns))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
}
efree(c_tmp);
/* The form "use A\B" is eqivalent to "use A\B as B".
So we extract the last part of compound name to use as a new_name */
name = &tmp;
- p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
+ p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRSIZE(ns));
if (p) {
ZVAL_STRING(name, p+1);
} else {
if (case_sensitive) {
lookup_name = STR_COPY(Z_STR_P(name));
} else {
- lookup_name = STR_ALLOC(Z_STRLEN_P(name), 0);
- zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
+ lookup_name = STR_ALLOC(Z_STRSIZE_P(name), 0);
+ zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRSIZE_P(name));
}
if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
/* Prefix import name with current namespace name to avoid conflicts with functions/consts */
- zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
+ zend_string *c_ns_name = STR_ALLOC(Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name), 0);
- zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
- c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
- memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1);
+ zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace)));
+ c_ns_name->val[Z_STRSIZE(CG(current_namespace))] = '\\';
+ memcpy(c_ns_name->val+Z_STRSIZE(CG(current_namespace))+1, lookup_name, Z_STRSIZE_P(name)+1);
if (zend_hash_exists(lookup_table, c_ns_name)) {
- char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+ char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns));
- if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
- memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
+ if (Z_STRSIZE(ns) != Z_STRSIZE(CG(current_namespace)) + 1 + Z_STRSIZE_P(name) ||
+ memcmp(tmp2, c_ns_name->val, Z_STRSIZE(ns))) {
zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
}
efree(tmp2);
zend_function *function;
if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) {
- char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+ char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns));
- if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
- memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
+ if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) ||
+ memcmp(c_tmp, lookup_name->val, Z_STRSIZE(ns))) {
zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
}
efree(c_tmp);
zend_string *filename;
if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) {
- char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
+ char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRSIZE(ns));
- if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
- memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
+ if (Z_STRSIZE(ns) != Z_STRSIZE_P(name) ||
+ memcmp(c_tmp, lookup_name->val, Z_STRSIZE(ns))) {
zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
}
efree(c_tmp);
znode tmp;
tmp.op_type = IS_CONST;
- ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRLEN(CG(current_namespace)), 0));
- zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
+ ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRSIZE(CG(current_namespace)), 0));
+ zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRSIZE(CG(current_namespace)));
zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
*name = tmp;
}
if (CG(current_import_const) &&
(ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) {
- char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
+ char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRSIZE_P(ns_name));
- if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) ||
- memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
+ if (Z_STRSIZE_P(ns_name) != Z_STRSIZE(name->u.constant) ||
+ memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRSIZE(name->u.constant))) {
zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant));
}
efree(tmp);
#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() \
{ \
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;
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;
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 210728972157Ui64
+# else
+# define THIS_HASHVAL 210728972157ULL
+# endif
#else
-#define THIS_HASHVAL 2090759133UL
+#define THIS_HASHVAL 275574653UL
#endif
/* method flags (types) */
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;
void zend_register_standard_constants(TSRMLS_D)
{
- REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
-
- REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
-
- REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
+
+ REGISTER_MAIN_INT_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
+
+ REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
/* true/false constants */
{
REGISTER_MAIN_BOOL_CONSTANT("TRUE", 1, CONST_PERSISTENT | CONST_CT_SUBST);
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;
(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);
}
}
}
#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)
ZEND_API zval *zend_get_constant_ex(zend_string *name, zend_class_entry *scope, ulong 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);
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;
}
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) {
}
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);
}
}
/* }}} */
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)
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;
break;
case IS_RESOURCE: {
long lval = Z_RES_HANDLE_P(arg);
- char s_tmp[MAX_LENGTH_OF_LONG + 1];
+ 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: {
+ long 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(", ");
}
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);
} 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;
} 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);
ulong 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;
convert_to_string(&message);
convert_to_string(&file);
- convert_to_long(&line);
+ convert_to_int(&line);
fci.size = sizeof(fci);
fci.function_table = &Z_OBJCE_P(exception)->function_table;
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);
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);
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);
}
/* }}} */
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);
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;
}
/* }}} */
line = zend_read_property(default_exception_ce, &zv, "line", sizeof("line")-1, 1 TSRMLS_CC);
convert_to_string(file);
- file = (Z_STRLEN_P(file) > 0) ? file : NULL;
- line = (Z_TYPE_P(line) == IS_LONG) ? line : NULL;
+ file = (Z_STRSIZE_P(file) > 0) ? file : NULL;
+ line = (Z_TYPE_P(line) == IS_INT) ? line : NULL;
} else {
file = NULL;
line = NULL;
}
- zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val);
+ zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_IVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val);
}
str = zend_read_property(default_exception_ce, &exception, "string", sizeof("string")-1, 1 TSRMLS_CC);
convert_to_string(str);
convert_to_string(file);
- convert_to_long(line);
+ convert_to_int(line);
- zend_error_va(severity, (Z_STRLEN_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_LVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str));
+ zend_error_va(severity, (Z_STRSIZE_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_IVAL_P(line), "Uncaught %s\n thrown", Z_STRVAL_P(str));
} else {
zend_error(severity, "Uncaught exception '%s'", ce_exception->name->val);
}
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");
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);
}
}
-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;
}
}
-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;
}
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);
}
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;
}
{
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));
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));
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);
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) {
offset = zval_get_long(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));
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) {
offset = zval_get_long(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);
}
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 {
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);
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;
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);
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));
} 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));
}
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;
}
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);
}
}
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 */
#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();
/* 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;
zend_llist open_files;
- long catch_begin;
+ zend_int_t catch_begin;
struct _zend_ini_parser_param *ini_parser_param;
zval This;
- long precision;
+ zend_int_t precision;
int ticks_count;
zend_class_entry *exception_class;
/* timeout support */
- int timeout_seconds;
+ zend_int_t timeout_seconds;
int lambda_count;
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;
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;
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;
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;
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;
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;
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 :( */
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;
}
ZVAL_COPY_VALUE(&p->val, pData);
HANDLE_UNBLOCK_INTERRUPTIONS();
- if ((long)h >= (long)ht->nNextFreeElement) {
+ if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) {
ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
}
return &p->val;
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;
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);
}
ZEND_API int zend_hash_del(HashTable *ht, zend_string *key)
{
- ulong h;
+ zend_uint_t h;
uint nIndex;
uint idx;
Bucket *p;
ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key)
{
- ulong h;
+ zend_uint_t h;
uint nIndex;
uint idx;
Bucket *p;
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;
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;
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;
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);
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);
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;
}
-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;
/* 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;
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;
ZVAL_STR(key, p->key);
STR_ADDREF(p->key);
} else {
- ZVAL_LONG(key, p->h);
+ ZVAL_INT(key, p->h);
}
}
}
if (p->key) {
return HASH_KEY_IS_STRING;
} else {
- return HASH_KEY_IS_LONG;
+ return HASH_KEY_IS_INT;
}
}
return HASH_KEY_NON_EXISTENT;
#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 */
#define HASH_MASK_CONSISTENCY 0x60
typedef struct _zend_hash_key {
- ulong h;
+ zend_uint_t h;
zend_string *key;
} zend_hash_key;
#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);
#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);
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);
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);
#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;
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;
}
++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;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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;
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;
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;
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);
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;
}
}
* 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();
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);
}
}
ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
{
- long *p;
+ zend_int_t *p;
#ifndef ZTS
char *base = (char *) mh_arg2;
#else
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;
ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
{
- long *p, tmp;
+ zend_int_t *p, tmp;
#ifndef ZTS
char *base = (char *) mh_arg2;
#else
return FAILURE;
}
- p = (long *) (base+(size_t) mh_arg1);
+ p = (zend_int_t *) (base+(size_t) mh_arg1);
*p = tmp;
return SUCCESS;
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);
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))
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));
*/
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;
}
/* }}} */
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);
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);
}
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 {
/* 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 == '\\') {
case '\\':
case '$':
*t++ = *s;
- Z_STRLEN_P(lval)--;
+ Z_STRSIZE_P(lval)--;
break;
default:
*t++ = '\\';
/* 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 == '\\') {
case '\\':
case '$':
*t++ = *s;
- Z_STRLEN_P(lval)--;
+ Z_STRSIZE_P(lval)--;
break;
default:
*t++ = '\\';
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | 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:
+ */
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
/* }}} */
zend_error(E_WARNING, "Nothing returned from %s::key()", iter->ce->name->val);
}
- ZVAL_LONG(key, 0);
+ ZVAL_INT(key, 0);
}
}
/* }}} */
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 */
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 {
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); }
;
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); }
;
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:
| 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); }
| 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); }
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; }
;
ctor_arguments:
- /* empty */ { Z_LVAL($$.u.constant) = 0; }
+ /* empty */ { Z_IVAL($$.u.constant) = 0; }
| function_call_parameter_list { $$ = $1; }
;
| 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); }
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:
;
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:
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);
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));
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);
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;
}
/* 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++;
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
#else
*t++ = '\e';
#endif
- Z_STRLEN_P(zendlval)--;
+ Z_STRSIZE_P(zendlval)--;
break;
case '"':
case '`':
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;
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;
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);
yyleng = YYCURSOR - SCNG(yy_text);
#line 2153 "Zend/zend_language_scanner.l"
{
- Z_LVAL_P(zendlval) = (long) '{';
+ Z_IVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
yyleng = YYCURSOR - SCNG(yy_text);
#line 2153 "Zend/zend_language_scanner.l"
{
- Z_LVAL_P(zendlval) = (long) '{';
+ Z_IVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
yyleng = YYCURSOR - SCNG(yy_text);
#line 2153 "Zend/zend_language_scanner.l"
{
- Z_LVAL_P(zendlval) = (long) '{';
+ Z_IVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
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));
/* 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++;
case '\\':
case '\'':
*t++ = *s;
- Z_STRLEN_P(zendlval)--;
+ Z_STRSIZE_P(zendlval)--;
break;
default:
*t++ = '\\';
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);
}
--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 {
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 {
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"
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);
}
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);
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));
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);
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;
}
/* 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++;
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
#else
*t++ = '\e';
#endif
- Z_STRLEN_P(zendlval)--;
+ Z_STRSIZE_P(zendlval)--;
break;
case '"':
case '`':
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;
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;
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);
--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 {
}
<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));
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 {
}
<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);
}
}
<ST_IN_SCRIPTING>"__LINE__" {
- ZVAL_LONG(zendlval, CG(zend_lineno));
+ ZVAL_INT(zendlval, CG(zend_lineno));
return T_LINE;
}
/* 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++;
case '\\':
case '\'':
*t++ = *s;
- Z_STRLEN_P(zendlval)--;
+ Z_STRSIZE_P(zendlval)--;
break;
default:
*t++ = '\\';
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);
}
<ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"{$" {
- Z_LVAL_P(zendlval) = (long) '{';
+ Z_IVAL_P(zendlval) = (long) '{';
yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
yyless(1);
return T_CURLY_OPEN;
#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) \
#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) \
#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) \
#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" \
else (lval) = __tmpvar; \
} while (0)
+#elif defined(ZEND_WIN32)
+
+#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_LONG == 4 && defined(HAVE_ZEND_LONG64)
-#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval) do { \
+#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 { \
#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; \
}
/* }}} */
-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;
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);
}
/* }}} */
/* 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;
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'");
/* 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;
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'");
zval tmp_member;
zval *retval, tmp;
zend_property_info *property_info;
- long *guard;
+ zend_int_t *guard;
zobj = Z_OBJ_P(object);
/* 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;
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'");
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);
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;
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);
/* 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);
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];
}
}
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);
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 */
if (!str_len) {
str_len = strlen(str);
}
- retval = strtol(str, NULL, 0);
+ retval = ZEND_STRTOI(str, NULL, 0);
if (str_len>0) {
switch (str[str_len-1]) {
case 'g':
}
/* }}} */
-ZEND_API long zend_atol(const char *str, int str_len) /* {{{ */
+ZEND_API zend_int_t zend_atol(const char *str, int str_len) /* {{{ */
{
- long retval;
+ zend_int_t retval;
if (!str_len) {
str_len = strlen(str);
}
- retval = strtol(str, NULL, 0);
+ retval = ZEND_STRTOI(str, NULL, 0);
if (str_len>0) {
switch (str[str_len-1]) {
case 'g':
zend_string *str;
str = Z_STR_P(op);
- if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
- ZVAL_LONG(op, 0);
+ if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_IVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
+ ZVAL_INT(op, 0);
}
STR_RELEASE(str);
break;
}
case IS_NULL:
case IS_FALSE:
- ZVAL_LONG(op, 0);
+ ZVAL_INT(op, 0);
break;
case IS_TRUE:
- ZVAL_LONG(op, 1);
+ ZVAL_INT(op, 1);
break;
case IS_RESOURCE:
{
- long l = Z_RES_HANDLE_P(op);
+ zend_int_t l = Z_RES_HANDLE_P(op);
zval_ptr_dtor(op);
- ZVAL_LONG(op, l);
+ ZVAL_INT(op, l);
}
break;
case IS_OBJECT:
- convert_to_long_base(op, 10);
+ convert_to_int_base(op, 10);
break;
}
}
/* {{{ zendi_convert_scalar_to_number */
#define zendi_convert_scalar_to_number(op, holder, result) \
if (op==result) { \
- if (Z_TYPE_P(op) != IS_LONG) { \
+ if (Z_TYPE_P(op) != IS_INT) { \
convert_scalar_to_number(op TSRMLS_CC); \
} \
} else { \
switch (Z_TYPE_P(op)) { \
case IS_STRING: \
{ \
- if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) { \
- ZVAL_LONG(&(holder), 0); \
+ if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRSIZE_P(op), &Z_IVAL(holder), &Z_DVAL(holder), 1)) == 0) { \
+ ZVAL_INT(&(holder), 0); \
} \
(op) = &(holder); \
break; \
} \
case IS_NULL: \
case IS_FALSE: \
- ZVAL_LONG(&(holder), 0); \
+ ZVAL_INT(&(holder), 0); \
(op) = &(holder); \
break; \
case IS_TRUE: \
- ZVAL_LONG(&(holder), 1); \
+ ZVAL_INT(&(holder), 1); \
(op) = &(holder); \
break; \
case IS_RESOURCE: \
- ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op)); \
+ ZVAL_INT(&(holder), Z_RES_HANDLE_P(op)); \
(op) = &(holder); \
break; \
case IS_OBJECT: \
ZVAL_DUP(&(holder), op); \
- convert_to_long_base(&(holder), 10); \
- if (Z_TYPE(holder) == IS_LONG) { \
+ convert_to_int_base(&(holder), 10); \
+ if (Z_TYPE(holder) == IS_INT) { \
(op) = &(holder); \
} \
break; \
/* }}} */
-/* {{{ zendi_convert_to_long */
-#define zendi_convert_to_long(op, holder, result) \
+/* {{{ zendi_convert_to_int */
+#define zendi_convert_to_int(op, holder, result) \
if (op == result) { \
- convert_to_long(op); \
- } else if (Z_TYPE_P(op) != IS_LONG) { \
+ convert_to_int(op); \
+ } else if (Z_TYPE_P(op) != IS_INT) { \
switch (Z_TYPE_P(op)) { \
case IS_NULL: \
case IS_FALSE: \
- ZVAL_LONG(&(holder), 0); \
+ ZVAL_INT(&(holder), 0); \
break; \
case IS_TRUE: \
- ZVAL_LONG(&(holder), 1); \
+ ZVAL_INT(&(holder), 1); \
break; \
case IS_DOUBLE: \
- ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\
+ ZVAL_INT(&holder, zend_dval_to_ival(Z_DVAL_P(op)));\
break; \
case IS_STRING: \
- ZVAL_LONG(&holder, strtol(Z_STRVAL_P(op), NULL, 10));\
+ ZVAL_INT(&holder, ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10));\
break; \
case IS_ARRAY: \
- ZVAL_LONG(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
+ ZVAL_INT(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \
break; \
case IS_OBJECT: \
ZVAL_DUP(&(holder), (op)); \
- convert_to_long_base(&(holder), 10); \
+ convert_to_int_base(&(holder), 10); \
break; \
case IS_RESOURCE: \
- ZVAL_LONG(&holder, Z_RES_HANDLE_P(op)); \
+ ZVAL_INT(&holder, Z_RES_HANDLE_P(op)); \
break; \
default: \
zend_error(E_WARNING, "Cannot convert to ordinal value"); \
- ZVAL_LONG(&holder, 0); \
+ ZVAL_INT(&holder, 0); \
break; \
} \
(op) = &(holder); \
case IS_RESOURCE: \
ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0); \
break; \
- case IS_LONG: \
- ZVAL_BOOL(&holder, Z_LVAL_P(op) ? 1 : 0); \
+ case IS_INT: \
+ ZVAL_BOOL(&holder, Z_IVAL_P(op) ? 1 : 0); \
break; \
case IS_DOUBLE: \
ZVAL_BOOL(&holder, Z_DVAL_P(op) ? 1 : 0); \
break; \
case IS_STRING: \
- if (Z_STRLEN_P(op) == 0 \
- || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \
+ if (Z_STRSIZE_P(op) == 0 \
+ || (Z_STRSIZE_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \
ZVAL_BOOL(&holder, 0); \
} else { \
ZVAL_BOOL(&holder, 1); \
/* }}} */
-ZEND_API void convert_to_long(zval *op) /* {{{ */
+ZEND_API void convert_to_int(zval *op) /* {{{ */
{
- if (Z_TYPE_P(op) != IS_LONG) {
- convert_to_long_base(op, 10);
+ if (Z_TYPE_P(op) != IS_INT) {
+ convert_to_int_base(op, 10);
}
}
/* }}} */
-ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
+ZEND_API void convert_to_int_base(zval *op, int base) /* {{{ */
{
- long tmp;
+ zend_int_t tmp;
switch (Z_TYPE_P(op)) {
case IS_NULL:
case IS_FALSE:
- ZVAL_LONG(op, 0);
+ ZVAL_INT(op, 0);
break;
case IS_TRUE:
- ZVAL_LONG(op, 1);
+ ZVAL_INT(op, 1);
break;
case IS_RESOURCE: {
- long l = Z_RES_HANDLE_P(op);
+ zend_int_t l = Z_RES_HANDLE_P(op);
zval_ptr_dtor(op);
- ZVAL_LONG(op, l);
+ ZVAL_INT(op, l);
}
/* break missing intentionally */
- Z_TYPE_INFO_P(op) = IS_LONG;
+ Z_TYPE_INFO_P(op) = IS_INT;
break;
- case IS_LONG:
+ case IS_INT:
break;
case IS_DOUBLE:
- ZVAL_LONG(op, zend_dval_to_lval(Z_DVAL_P(op)));
+ ZVAL_INT(op, zend_dval_to_ival(Z_DVAL_P(op)));
break;
case IS_STRING:
{
zend_string *str = Z_STR_P(op);
- ZVAL_LONG(op, strtol(str->val, NULL, base));
+ ZVAL_INT(op, strtol(str->val, NULL, base));
STR_RELEASE(str);
}
break;
case IS_ARRAY:
tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
zval_dtor(op);
- ZVAL_LONG(op, tmp);
+ ZVAL_INT(op, tmp);
break;
case IS_OBJECT:
{
zval dst;
TSRMLS_FETCH();
- convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
+ convert_object_to_type(op, &dst, IS_INT, convert_to_int);
zval_dtor(op);
- if (Z_TYPE(dst) == IS_LONG) {
+ if (Z_TYPE(dst) == IS_INT) {
ZVAL_COPY_VALUE(op, &dst);
} else {
zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
- ZVAL_LONG(op, 1);
+ ZVAL_INT(op, 1);
}
return;
}
ZVAL_DOUBLE(op, d);
}
break;
- case IS_LONG:
- ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
+ case IS_INT:
+ ZVAL_DOUBLE(op, (double) Z_IVAL_P(op));
break;
case IS_DOUBLE:
break;
ZVAL_BOOL(op, 0);
break;
case IS_RESOURCE: {
- long l = (Z_RES_HANDLE_P(op) ? 1 : 0);
+ zend_int_t l = (Z_RES_HANDLE_P(op) ? 1 : 0);
zval_ptr_dtor(op);
ZVAL_BOOL(op, l);
}
break;
- case IS_LONG:
- ZVAL_BOOL(op, Z_LVAL_P(op) ? 1 : 0);
+ case IS_INT:
+ ZVAL_BOOL(op, Z_IVAL_P(op) ? 1 : 0);
break;
case IS_DOUBLE:
ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0);
case IS_STRING:
break;
case IS_RESOURCE: {
- char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
+ char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT];
int len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op));
ZVAL_NEW_STR(op, STR_INIT(buf, len, 0));
break;
}
- case IS_LONG: {
- ZVAL_NEW_STR(op, zend_long_to_str(Z_LVAL_P(op)));
+ case IS_INT: {
+ ZVAL_NEW_STR(op, zend_long_to_str(Z_IVAL_P(op)));
break;
}
case IS_DOUBLE: {
}
/* }}} */
-ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
+ZEND_API void multi_convert_to_int_ex(int argc, ...) /* {{{ */
{
zval *arg;
va_list ap;
while (argc--) {
arg = va_arg(ap, zval *);
- convert_to_long_ex(arg);
+ convert_to_int_ex(arg);
}
va_end(ap);
}
/* }}} */
-ZEND_API long _zval_get_long_func(zval *op TSRMLS_DC) /* {{{ */
+ZEND_API zend_int_t _zval_get_long_func(zval *op TSRMLS_DC) /* {{{ */
{
try_again:
switch (Z_TYPE_P(op)) {
return 1;
case IS_RESOURCE:
return Z_RES_HANDLE_P(op);
- case IS_LONG:
- return Z_LVAL_P(op);
+ case IS_INT:
+ return Z_IVAL_P(op);
case IS_DOUBLE:
- return zend_dval_to_lval(Z_DVAL_P(op));
+ return zend_dval_to_ival(Z_DVAL_P(op));
case IS_STRING:
- return strtol(Z_STRVAL_P(op), NULL, 10);
+ return ZEND_STRTOI(Z_STRVAL_P(op), NULL, 10);
case IS_ARRAY:
return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0;
case IS_OBJECT:
{
zval dst;
- convert_object_to_type(op, &dst, IS_LONG, convert_to_long);
- if (Z_TYPE(dst) == IS_LONG) {
- return Z_LVAL(dst);
+ convert_object_to_type(op, &dst, IS_INT, convert_to_int);
+ if (Z_TYPE(dst) == IS_INT) {
+ return Z_IVAL(dst);
} else {
zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
return 1;
return 1.0;
case IS_RESOURCE:
return (double) Z_RES_HANDLE_P(op);
- case IS_LONG:
- return (double) Z_LVAL_P(op);
+ case IS_INT:
+ return (double) Z_IVAL_P(op);
case IS_DOUBLE:
return Z_DVAL_P(op);
case IS_STRING:
case IS_TRUE:
return STR_INIT("1", 1, 0);
case IS_RESOURCE: {
- char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
+ char buf[sizeof("Resource id #") + MAX_LENGTH_OF_ZEND_INT];
int len;
len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op));
return STR_INIT(buf, len, 0);
}
- case IS_LONG: {
- return zend_long_to_str(Z_LVAL_P(op));
+ case IS_INT: {
+ return zend_long_to_str(Z_IVAL_P(op));
}
case IS_DOUBLE: {
return zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(op));
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG): {
- long lval = Z_LVAL_P(op1) + Z_LVAL_P(op2);
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t lval = Z_IVAL_P(op1) + Z_IVAL_P(op2);
/* check for overflow by comparing sign bits */
- if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK)
- && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
+ if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) == (Z_IVAL_P(op2) & LONG_SIGN_MASK)
+ && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
- ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) + (double) Z_IVAL_P(op2));
} else {
- ZVAL_LONG(result, lval);
+ ZVAL_INT(result, lval);
}
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) + Z_DVAL_P(op2));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG): {
- long lval = Z_LVAL_P(op1) - Z_LVAL_P(op2);
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t lval = Z_IVAL_P(op1) - Z_IVAL_P(op2);
/* check for overflow by comparing sign bits */
- if ((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK)
- && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
+ if ((Z_IVAL_P(op1) & LONG_SIGN_MASK) != (Z_IVAL_P(op2) & LONG_SIGN_MASK)
+ && (Z_IVAL_P(op1) & LONG_SIGN_MASK) != (lval & LONG_SIGN_MASK)) {
- ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, (double) Z_IVAL_P(op1) - (double) Z_IVAL_P(op2));
} else {
- ZVAL_LONG(result, lval);
+ ZVAL_INT(result, lval);
}
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) - Z_DVAL_P(op2));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG): {
- long overflow;
+ case TYPE_PAIR(IS_INT, IS_INT): {
+ zend_int_t overflow;
- ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow);
- Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
+ ZEND_SIGNED_MULTIPLY_INT(Z_IVAL_P(op1),Z_IVAL_P(op2), Z_IVAL_P(result),Z_DVAL_P(result),overflow);
+ Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_INT;
return SUCCESS;
}
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, ((double)Z_IVAL_P(op1)) * Z_DVAL_P(op2));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG):
- if (Z_LVAL_P(op2) >= 0) {
- long l1 = 1, l2 = Z_LVAL_P(op1), i = Z_LVAL_P(op2);
+ case TYPE_PAIR(IS_INT, IS_INT):
+ if (Z_IVAL_P(op2) >= 0) {
+ zend_int_t l1 = 1, l2 = Z_IVAL_P(op1), i = Z_IVAL_P(op2);
if (i == 0) {
- ZVAL_LONG(result, 1L);
+ ZVAL_INT(result, 1L);
return SUCCESS;
} else if (l2 == 0) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
while (i >= 1) {
- long overflow;
+ zend_int_t overflow;
double dval = 0.0;
if (i % 2) {
--i;
- ZEND_SIGNED_MULTIPLY_LONG(l1, l2, l1, dval, overflow);
+ ZEND_SIGNED_MULTIPLY_INT(l1, l2, l1, dval, overflow);
if (overflow) {
ZVAL_DOUBLE(result, dval * pow(l2, i));
return SUCCESS;
}
} else {
i /= 2;
- ZEND_SIGNED_MULTIPLY_LONG(l2, l2, l2, dval, overflow);
+ ZEND_SIGNED_MULTIPLY_INT(l2, l2, l2, dval, overflow);
if (overflow) {
ZVAL_DOUBLE(result, (double)l1 * pow(dval, i));
return SUCCESS;
}
}
/* i == 0 */
- ZVAL_LONG(result, l1);
+ ZVAL_INT(result, l1);
} else {
- ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), (double)Z_LVAL_P(op2)));
+ ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), (double)Z_IVAL_P(op2)));
}
return SUCCESS;
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- ZVAL_DOUBLE(result, pow((double)Z_LVAL_P(op1), Z_DVAL_P(op2)));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ ZVAL_DOUBLE(result, pow((double)Z_IVAL_P(op1), Z_DVAL_P(op2)));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_LVAL_P(op2)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ ZVAL_DOUBLE(result, pow(Z_DVAL_P(op1), (double)Z_IVAL_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_POW);
if (Z_TYPE_P(op1) == IS_ARRAY) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op1, op1_copy, result);
}
if (Z_TYPE_P(op2) == IS_ARRAY) {
- ZVAL_LONG(result, 1L);
+ ZVAL_INT(result, 1L);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op2, op2_copy, result);
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG):
- if (Z_LVAL_P(op2) == 0) {
+ case TYPE_PAIR(IS_INT, IS_INT):
+ if (Z_IVAL_P(op2) == 0) {
zend_error(E_WARNING, "Division by zero");
ZVAL_BOOL(result, 0);
return FAILURE; /* division by zero */
- } else if (Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN) {
+ } else if (Z_IVAL_P(op2) == -1 && Z_IVAL_P(op1) == ZEND_INT_MIN) {
/* Prevent overflow error/crash */
- ZVAL_DOUBLE(result, (double) LONG_MIN / -1);
+ ZVAL_DOUBLE(result, (double) ZEND_INT_MIN / -1);
return SUCCESS;
}
- if (Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0) { /* integer */
- ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2));
+ if (Z_IVAL_P(op1) % Z_IVAL_P(op2) == 0) { /* integer */
+ ZVAL_INT(result, Z_IVAL_P(op1) / Z_IVAL_P(op2));
} else {
- ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, ((double) Z_IVAL_P(op1)) / Z_IVAL_P(op2));
}
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- if (Z_LVAL_P(op2) == 0) {
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ if (Z_IVAL_P(op2) == 0) {
zend_error(E_WARNING, "Division by zero");
ZVAL_BOOL(result, 0);
return FAILURE; /* division by zero */
}
- ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_LVAL_P(op2));
+ ZVAL_DOUBLE(result, Z_DVAL_P(op1) / (double)Z_IVAL_P(op2));
return SUCCESS;
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
if (Z_DVAL_P(op2) == 0) {
zend_error(E_WARNING, "Division by zero");
ZVAL_BOOL(result, 0);
return FAILURE; /* division by zero */
}
- ZVAL_DOUBLE(result, (double)Z_LVAL_P(op1) / Z_DVAL_P(op2));
+ ZVAL_DOUBLE(result, (double)Z_IVAL_P(op1) / Z_DVAL_P(op2));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MOD);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- if (Z_LVAL_P(op2) == 0) {
+ if (Z_IVAL_P(op2) == 0) {
zend_error(E_WARNING, "Division by zero");
ZVAL_BOOL(result, 0);
return FAILURE; /* modulus by zero */
}
- if (Z_LVAL_P(op2) == -1) {
+ if (Z_IVAL_P(op2) == -1) {
/* Prevent overflow error/crash if op1==LONG_MIN */
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
- ZVAL_LONG(result, op1_lval % Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval % Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
if ((Z_TYPE_P(op1) != IS_FALSE && Z_TYPE_P(op1) != IS_TRUE) ||
(Z_TYPE_P(op2) != IS_FALSE && Z_TYPE_P(op2) != IS_TRUE)) {
{
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- ZVAL_LONG(result, ~Z_LVAL_P(op1));
+ case IS_INT:
+ ZVAL_INT(result, ~Z_IVAL_P(op1));
return SUCCESS;
case IS_DOUBLE:
- ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1)));
+ ZVAL_INT(result, ~zend_dval_to_ival(Z_DVAL_P(op1)));
return SUCCESS;
case IS_STRING: {
- int i;
+ zend_size_t i;
zval op1_copy = *op1;
- ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN(op1_copy), 0));
- for (i = 0; i < Z_STRLEN(op1_copy); i++) {
+ ZVAL_NEW_STR(result, STR_ALLOC(Z_STRSIZE(op1_copy), 0));
+ for (i = 0; i < Z_STRSIZE(op1_copy); i++) {
Z_STRVAL_P(result)[i] = ~Z_STRVAL(op1_copy)[i];
}
Z_STRVAL_P(result)[i] = 0;
ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
zval *longer, *shorter;
zend_string *str;
- int i;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
shorter = op1;
}
- str = STR_ALLOC(Z_STRLEN_P(longer), 0);
- for (i = 0; i < Z_STRLEN_P(shorter); i++) {
+ str = STR_ALLOC(Z_STRSIZE_P(longer), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
str->val[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i];
}
- memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1);
+ memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRSIZE_P(longer) - i + 1);
if (result==op1) {
STR_RELEASE(Z_STR_P(result));
}
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_OR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval | Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval | Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
zval *longer, *shorter;
zend_string *str;
- int i;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
shorter = op1;
}
- str = STR_ALLOC(Z_STRLEN_P(shorter), 0);
- for (i = 0; i < Z_STRLEN_P(shorter); i++) {
+ str = STR_ALLOC(Z_STRSIZE_P(shorter), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
str->val[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i];
}
str->val[i] = 0;
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_AND);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval & Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval & Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
zval *longer, *shorter;
zend_string *str;
- int i;
+ zend_size_t i;
- if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
+ if (Z_STRSIZE_P(op1) >= Z_STRSIZE_P(op2)) {
longer = op1;
shorter = op2;
} else {
shorter = op1;
}
- str = STR_ALLOC(Z_STRLEN_P(shorter), 0);
- for (i = 0; i < Z_STRLEN_P(shorter); i++) {
+ str = STR_ALLOC(Z_STRSIZE_P(shorter), 0);
+ for (i = 0; i < Z_STRSIZE_P(shorter); i++) {
str->val[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i];
}
str->val[i] = 0;
return SUCCESS;
}
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BW_XOR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval ^ Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval ^ Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SL);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval << Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval << Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
zval op1_copy, op2_copy;
- long op1_lval;
+ zend_int_t op1_lval;
- if (Z_TYPE_P(op1) != IS_LONG || Z_TYPE_P(op2) != IS_LONG) {
+ if (Z_TYPE_P(op1) != IS_INT || Z_TYPE_P(op2) != IS_INT) {
ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SR);
- zendi_convert_to_long(op1, op1_copy, result);
- op1_lval = Z_LVAL_P(op1);
- zendi_convert_to_long(op2, op2_copy, result);
+ zendi_convert_to_int(op1, op1_copy, result);
+ op1_lval = Z_IVAL_P(op1);
+ zendi_convert_to_int(op2, op2_copy, result);
} else {
- op1_lval = Z_LVAL_P(op1);
+ op1_lval = Z_IVAL_P(op1);
}
- ZVAL_LONG(result, op1_lval >> Z_LVAL_P(op2));
+ ZVAL_INT(result, op1_lval >> Z_IVAL_P(op2));
return SUCCESS;
}
/* }}} */
/* must support result==op1 */
ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */
{
- int length = Z_STRLEN_P(op1) + 1;
+ zend_size_t length = Z_STRSIZE_P(op1) + 1;
zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
- buf->val[length - 1] = (char) Z_LVAL_P(op2);
+ buf->val[length - 1] = (char) Z_IVAL_P(op2);
buf->val[length] = 0;
ZVAL_NEW_STR(result, buf);
return SUCCESS;
/* must support result==op1 */
ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */
{
- int op1_len = Z_STRLEN_P(op1);
- int length = op1_len + Z_STRLEN_P(op2);
+ zend_size_t op1_len = Z_STRSIZE_P(op1);
+ zend_size_t length = op1_len + Z_STRSIZE_P(op2);
zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
- memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+ memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRSIZE_P(op2));
buf->val[length] = 0;
ZVAL_NEW_STR(result, buf);
return SUCCESS;
}
if (result==op1 && !IS_INTERNED(Z_STR_P(op1))) { /* special case, perform operations on result */
- uint op1_len = Z_STRLEN_P(op1);
- uint op2_len = Z_STRLEN_P(op2);
- uint res_len = op1_len + op2_len;
+ zend_size_t op1_len = Z_STRSIZE_P(op1);
+ zend_size_t op2_len = Z_STRSIZE_P(op2);
+ zend_size_t res_len = op1_len + op2_len;
- if (Z_STRLEN_P(result) < 0 || (int) (op1_len + op2_len) < 0) {
+ if (Z_STRSIZE_P(result) < 0 || (zend_size_t) (op1_len + op2_len) < 0) {
ZVAL_EMPTY_STRING(result);
zend_error(E_ERROR, "String size overflow");
}
memcpy(Z_STRVAL_P(result) + op1_len, Z_STRVAL_P(op2), op2_len);
Z_STRVAL_P(result)[res_len]=0;
} else {
- int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
+ zend_size_t length = Z_STRSIZE_P(op1) + Z_STRSIZE_P(op2);
zend_string *buf = STR_ALLOC(length, 0);
- memcpy(buf->val, Z_STRVAL_P(op1), Z_STRLEN_P(op1));
- memcpy(buf->val + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+ memcpy(buf->val, Z_STRVAL_P(op1), Z_STRSIZE_P(op1));
+ memcpy(buf->val + Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2));
buf->val[length] = 0;
ZVAL_NEW_STR(result, buf);
}
zend_string *str2 = zval_get_string(op2);
if (case_insensitive) {
- ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
+ ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
} else {
- ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
+ ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
}
STR_RELEASE(str1);
if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
if (Z_STR_P(op1) == Z_STR_P(op2)) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
} else {
- ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)));
+ ZVAL_INT(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2)));
}
} else {
zend_string *str1 = zval_get_string(op1);
zend_string *str2 = zval_get_string(op2);
- ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
+ ZVAL_INT(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
STR_RELEASE(str1);
STR_RELEASE(str2);
if (EXPECTED(Z_TYPE_P(op1) == IS_STRING) &&
EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
if (Z_STR_P(op1) == Z_STR_P(op2)) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
} else {
- ZVAL_LONG(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)));
+ ZVAL_INT(result, zend_binary_strcasecmp_l(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2)));
}
} else {
zend_string *str1 = zval_get_string(op1);
zend_string *str2 = zval_get_string(op2);
- ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
+ ZVAL_INT(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
STR_RELEASE(str1);
STR_RELEASE(str2);
zend_string *str1 = zval_get_string(op1);
zend_string *str2 = zval_get_string(op2);
- ZVAL_LONG(result, strcoll(str1->val, str2->val));
+ ZVAL_INT(result, strcoll(str1->val, str2->val));
STR_RELEASE(str1);
STR_RELEASE(str2);
d1 = zval_get_double(op1);
d2 = zval_get_double(op2);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(d1 - d2));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(d1 - d2));
return SUCCESS;
}
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
- case TYPE_PAIR(IS_LONG, IS_LONG):
- ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
+ case TYPE_PAIR(IS_INT, IS_INT):
+ ZVAL_INT(result, Z_IVAL_P(op1)>Z_IVAL_P(op2)?1:(Z_IVAL_P(op1)<Z_IVAL_P(op2)?-1:0));
return SUCCESS;
- case TYPE_PAIR(IS_DOUBLE, IS_LONG):
- Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
+ case TYPE_PAIR(IS_DOUBLE, IS_INT):
+ Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_IVAL_P(op2);
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
- case TYPE_PAIR(IS_LONG, IS_DOUBLE):
- Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
+ case TYPE_PAIR(IS_INT, IS_DOUBLE):
+ Z_DVAL_P(result) = (double)Z_IVAL_P(op1) - Z_DVAL_P(op2);
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
} else {
Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
}
return SUCCESS;
case TYPE_PAIR(IS_FALSE, IS_NULL):
case TYPE_PAIR(IS_FALSE, IS_FALSE):
case TYPE_PAIR(IS_TRUE, IS_TRUE):
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_TRUE):
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
case TYPE_PAIR(IS_TRUE, IS_NULL):
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_STRING):
if (Z_STR_P(op1) == Z_STR_P(op2)) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
zendi_smart_strcmp(result, op1, op2);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_STRING):
- ZVAL_LONG(result, Z_STRLEN_P(op2) == 0 ? 0 : -1);
+ ZVAL_INT(result, Z_STRSIZE_P(op2) == 0 ? 0 : -1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_NULL):
- ZVAL_LONG(result, Z_STRLEN_P(op1) == 0 ? 0 : 1);
+ ZVAL_INT(result, Z_STRSIZE_P(op1) == 0 ? 0 : 1);
return SUCCESS;
case TYPE_PAIR(IS_OBJECT, IS_NULL):
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_OBJECT):
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
default:
if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) {
if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
/* object handles are identical, apparently this is the same object */
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return SUCCESS;
}
if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) {
- ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC));
+ ZVAL_INT(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2 TSRMLS_CC));
return SUCCESS;
}
}
} else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2)) TSRMLS_CC) == FAILURE) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return SUCCESS;
}
} else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1)) TSRMLS_CC) == FAILURE) {
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return SUCCESS;
}
zend_free_obj_get_result(&tmp_free TSRMLS_CC);
return ret;
} else if (Z_TYPE_P(op1) == IS_OBJECT) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
}
}
if (!converted) {
if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) {
zendi_convert_to_boolean(op2, op2_copy, result);
- ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0);
+ ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) {
zendi_convert_to_boolean(op1, op1_copy, result);
- ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0);
+ ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op1) == IS_TRUE) {
zendi_convert_to_boolean(op2, op2_copy, result);
- ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1);
+ ZVAL_INT(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1);
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_TRUE) {
zendi_convert_to_boolean(op1, op1_copy, result);
- ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1);
+ ZVAL_INT(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1);
return SUCCESS;
} else {
zendi_convert_scalar_to_number(op1, op1_copy, result);
converted = 1;
}
} else if (Z_TYPE_P(op1)==IS_ARRAY) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_ARRAY) {
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
} else if (Z_TYPE_P(op1)==IS_OBJECT) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_OBJECT) {
- ZVAL_LONG(result, -1);
+ ZVAL_INT(result, -1);
return SUCCESS;
} else {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return FAILURE;
}
}
case IS_TRUE:
ZVAL_BOOL(result, 1);
break;
- case IS_LONG:
- ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
+ case IS_INT:
+ ZVAL_BOOL(result, Z_IVAL_P(op1) == Z_IVAL_P(op2));
break;
case IS_RESOURCE:
ZVAL_BOOL(result, Z_RES_P(op1) == Z_RES_P(op2));
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_BOOL(result, 1);
} else {
- ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
- && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
+ ZVAL_BOOL(result, (Z_STRSIZE_P(op1) == Z_STRSIZE_P(op2))
+ && (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op1))));
}
break;
case IS_ARRAY:
if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- ZVAL_BOOL(result, (Z_LVAL_P(result) == 0));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) == 0));
return SUCCESS;
}
/* }}} */
if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) != 0));
return SUCCESS;
}
/* }}} */
if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) < 0));
return SUCCESS;
}
/* }}} */
if (compare_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
return FAILURE;
}
- ZVAL_BOOL(result, (Z_LVAL_P(result) <= 0));
+ ZVAL_BOOL(result, (Z_IVAL_P(result) <= 0));
return SUCCESS;
}
/* }}} */
static void increment_string(zval *str) /* {{{ */
{
int carry=0;
- int pos=Z_STRLEN_P(str)-1;
+ zend_size_t pos=Z_STRSIZE_P(str)-1;
char *s;
zend_string *t;
int last=0; /* Shut up the compiler warning */
int ch;
- if (Z_STRLEN_P(str) == 0) {
+ if (Z_STRSIZE_P(str) == 0) {
STR_RELEASE(Z_STR_P(str));
Z_STR_P(str) = STR_INIT("1", sizeof("1")-1, 0);
Z_TYPE_INFO_P(str) = IS_STRING_EX;
}
if (IS_INTERNED(Z_STR_P(str))) {
- Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+ Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0);
Z_TYPE_INFO_P(str) = IS_STRING_EX;
} else if (Z_REFCOUNT_P(str) > 1) {
Z_DELREF_P(str);
- Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+ Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRSIZE_P(str), 0);
} else {
STR_FORGET_HASH_VAL(Z_STR_P(str));
}
}
if (carry) {
- t = STR_ALLOC(Z_STRLEN_P(str)+1, 0);
- memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRLEN_P(str));
- t->val[Z_STRLEN_P(str) + 1] = '\0';
+ t = STR_ALLOC(Z_STRSIZE_P(str)+1, 0);
+ memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRSIZE_P(str));
+ t->val[Z_STRSIZE_P(str) + 1] = '\0';
switch (last) {
case NUMERIC:
t->val[0] = '1';
{
try_again:
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- if (Z_LVAL_P(op1) == LONG_MAX) {
+ case IS_INT:
+ if (Z_IVAL_P(op1) == ZEND_INT_MAX) {
/* switch to double */
- double d = (double)Z_LVAL_P(op1);
+ double d = (double)Z_IVAL_P(op1);
ZVAL_DOUBLE(op1, d+1);
} else {
- Z_LVAL_P(op1)++;
+ Z_IVAL_P(op1)++;
}
break;
case IS_DOUBLE:
Z_DVAL_P(op1) = Z_DVAL_P(op1) + 1;
break;
case IS_NULL:
- ZVAL_LONG(op1, 1);
+ ZVAL_INT(op1, 1);
break;
case IS_STRING: {
- long lval;
+ zend_int_t lval;
double dval;
- switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
- case IS_LONG:
+ switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) {
+ case IS_INT:
STR_RELEASE(Z_STR_P(op1));
- if (lval == LONG_MAX) {
+ if (lval == ZEND_INT_MAX) {
/* switch to double */
double d = (double)lval;
ZVAL_DOUBLE(op1, d+1);
} else {
- ZVAL_LONG(op1, lval+1);
+ ZVAL_INT(op1, lval+1);
}
break;
case IS_DOUBLE:
int res;
TSRMLS_FETCH();
- ZVAL_LONG(&op2, 1);
+ ZVAL_INT(&op2, 1);
res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, &op2 TSRMLS_CC);
zval_ptr_dtor(&op2);
ZEND_API int decrement_function(zval *op1) /* {{{ */
{
- long lval;
+ zend_int_t lval;
double dval;
try_again:
switch (Z_TYPE_P(op1)) {
- case IS_LONG:
- if (Z_LVAL_P(op1) == LONG_MIN) {
- double d = (double)Z_LVAL_P(op1);
+ case IS_INT:
+ if (Z_IVAL_P(op1) == ZEND_INT_MIN) {
+ double d = (double)Z_IVAL_P(op1);
ZVAL_DOUBLE(op1, d-1);
} else {
- Z_LVAL_P(op1)--;
+ Z_IVAL_P(op1)--;
}
break;
case IS_DOUBLE:
Z_DVAL_P(op1) = Z_DVAL_P(op1) - 1;
break;
case IS_STRING: /* Like perl we only support string increment */
- if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */
+ if (Z_STRSIZE_P(op1) == 0) { /* consider as 0 */
STR_RELEASE(Z_STR_P(op1));
- ZVAL_LONG(op1, -1);
+ ZVAL_INT(op1, -1);
break;
}
- switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
- case IS_LONG:
+ switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRSIZE_P(op1), &lval, &dval, 0)) {
+ case IS_INT:
STR_RELEASE(Z_STR_P(op1));
- if (lval == LONG_MIN) {
+ if (lval == ZEND_INT_MIN) {
double d = (double)lval;
ZVAL_DOUBLE(op1, d-1);
} else {
- ZVAL_LONG(op1, lval-1);
+ ZVAL_INT(op1, lval-1);
}
break;
case IS_DOUBLE:
int res;
TSRMLS_FETCH();
- ZVAL_LONG(&op2, 1);
+ ZVAL_INT(&op2, 1);
res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, &op2 TSRMLS_CC);
zval_ptr_dtor(&op2);
/* }}} */
#endif
-ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length) /* {{{ */
+ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, zend_size_t length) /* {{{ */
{
register unsigned char *str = (unsigned char*)source;
register unsigned char *result = (unsigned char*)dest;
}
/* }}} */
-ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length) /* {{{ */
+ZEND_API char *zend_str_tolower_dup(const char *source, zend_size_t length) /* {{{ */
{
return zend_str_tolower_copy((char *)emalloc(length+1), source, length);
}
/* }}} */
-ZEND_API void zend_str_tolower(char *str, unsigned int length) /* {{{ */
+ZEND_API void zend_str_tolower(char *str, zend_size_t length) /* {{{ */
{
register unsigned char *p = (unsigned char*)str;
register unsigned char *end = p + length;
}
/* }}} */
-ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */
+ZEND_API int zend_binary_strcmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
int retval;
}
retval = memcmp(s1, s2, MIN(len1, len2));
if (!retval) {
- return (len1 - len2);
- } else {
- return retval;
+ if (len1 > len2) {
+ retval = 1;
+ } else if (len1 < len2) {
+ retval = -1;
+ } else {
+ retval = 0;
+ }
}
+
+ return retval;
}
/* }}} */
-ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
int retval;
}
retval = memcmp(s1, s2, MIN(length, MIN(len1, len2)));
if (!retval) {
- return (MIN(length, len1) - MIN(length, len2));
- } else {
- return retval;
+ if (MIN(length, len1) > MIN(length, len2)) {
+ retval = 1;
+ } else if (MIN(length, len1) < MIN(length, len2)) {
+ retval = -1;
+ } else {
+ retval = 0;
+ }
}
+
+ return retval;
}
/* }}} */
-ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */
+ZEND_API int zend_binary_strcasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
}
}
- return len1 - len2;
+ if (len1 > len2) {
+ return 1;
+ } else if (len1 < len2) {
+ return -1;
+ } else {
+ return 0;
+ }
}
/* }}} */
-ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncasecmp(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
}
}
- return MIN(length, len1) - MIN(length, len2);
+ if (MIN(length, len1) > MIN(length, len2)) {
+ return 1;
+ } else if (MIN(length, len1) < MIN(length, len2)) {
+ return -1;
+ } else {
+ return 0;
+ }
}
/* }}} */
-ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2) /* {{{ */
+ZEND_API int zend_binary_strcasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
}
}
- return len1 - len2;
+ if (len1 > len2) {
+ return 1;
+ } else if (len1 < len2) {
+ return -1;
+ } else {
+ return 0;
+ }
}
/* }}} */
-ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length) /* {{{ */
+ZEND_API int zend_binary_strncasecmp_l(const char *s1, zend_size_t len1, const char *s2, zend_size_t len2, zend_size_t length) /* {{{ */
{
- int len;
+ zend_size_t len;
int c1, c2;
if (s1 == s2) {
}
}
- return MIN(length, len1) - MIN(length, len2);
+ if (MIN(length, len1) > MIN(length, len2)) {
+ return 1;
+ } else if (MIN(length, len1) < MIN(length, len2)) {
+ return -1;
+ } else {
+ return 0;
+ }
}
/* }}} */
ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2) /* {{{ */
{
- return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
+ return zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2));
}
/* }}} */
ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3) /* {{{ */
{
- return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3));
+ return zend_binary_strncmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3));
}
/* }}} */
ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2) /* {{{ */
{
- return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
+ return zend_binary_strcasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2));
}
/* }}} */
ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3) /* {{{ */
{
- return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2), Z_LVAL_P(s3));
+ return zend_binary_strncasecmp_l(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2), Z_IVAL_P(s3));
}
/* }}} */
{
int ret1, ret2;
int oflow1, oflow2;
- long lval1 = 0, lval2 = 0;
+ zend_int_t lval1 = 0, lval2 = 0;
double dval1 = 0.0, dval2 = 0.0;
- if ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRLEN_P(s1), &lval1, &dval1, 0, &oflow1)) &&
- (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRLEN_P(s2), &lval2, &dval2, 0, &oflow2))) {
-#if ULONG_MAX == 0xFFFFFFFF
+ if ((ret1=is_numeric_string_ex(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), &lval1, &dval1, 0, &oflow1)) &&
+ (ret2=is_numeric_string_ex(Z_STRVAL_P(s2), Z_STRSIZE_P(s2), &lval2, &dval2, 0, &oflow2))) {
+#if ZEND_UINT_MAX == 0xFFFFFFFF
if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
((oflow1 == 1 && dval1 > 9007199254740991. /*0x1FFFFFFFFFFFFF*/)
|| (oflow1 == -1 && dval1 < -9007199254740991.))) {
if (ret1!=IS_DOUBLE) {
if (oflow2) {
/* 2nd operand is integer > LONG_MAX (oflow2==1) or < LONG_MIN (-1) */
- ZVAL_LONG(result, -1 * oflow2);
+ ZVAL_INT(result, -1 * oflow2);
return;
}
dval1 = (double) lval1;
} else if (ret2!=IS_DOUBLE) {
if (oflow1) {
- ZVAL_LONG(result, oflow1);
+ ZVAL_INT(result, oflow1);
return;
}
dval2 = (double) lval2;
goto string_cmp;
}
Z_DVAL_P(result) = dval1 - dval2;
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
} else { /* they both have to be long's */
- ZVAL_LONG(result, lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0));
+ ZVAL_INT(result, lval1 > lval2 ? 1 : (lval1 < lval2 ? -1 : 0));
}
} else {
string_cmp:
- Z_LVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
- ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result)));
+ Z_IVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRSIZE_P(s1), Z_STRVAL_P(s2), Z_STRSIZE_P(s2));
+ ZVAL_INT(result, ZEND_NORMALIZE_BOOL(Z_IVAL_P(result)));
}
}
/* }}} */
if (compare_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
return 1;
}
- return Z_LVAL(result);
+ return Z_IVAL(result);
}
/* }}} */
ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC) /* {{{ */
{
- ZVAL_LONG(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC));
+ ZVAL_INT(result, ht1 == ht2 ? 0 : zend_hash_compare(ht1, ht2, (compare_func_t) hash_zval_compare_function, 0 TSRMLS_CC));
}
/* }}} */
ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
{
if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) {
- ZVAL_LONG(result, 0);
+ ZVAL_INT(result, 0);
return;
}
if (Z_OBJ_HT_P(o1)->compare_objects == NULL) {
- ZVAL_LONG(result, 1);
+ ZVAL_INT(result, 1);
} else {
- ZVAL_LONG(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC));
+ ZVAL_INT(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC));
}
}
/* }}} */
}
/* }}} */
-ZEND_API zend_string *zend_long_to_str(long num) /* {{{ */
+ZEND_API zend_string *zend_long_to_str(zend_int_t num) /* {{{ */
{
- char buf[MAX_LENGTH_OF_LONG + 1];
+ char buf[MAX_LENGTH_OF_ZEND_INT + 1];
char *res;
- _zend_print_signed_to_buf(buf + sizeof(buf) - 1, num, unsigned long, res);
+ _zend_print_signed_to_buf(buf + sizeof(buf) - 1, num, zend_uint_t, res);
return STR_INIT(res, buf + sizeof(buf) - 1 - res, 0);
}
/* }}} */
-ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, long *lval, double *dval) {
+ZEND_API zend_uchar is_numeric_str_function(const zend_string *str, zend_int_t *lval, double *dval) {
return is_numeric_string_ex(str->val, str->len, lval, dval, -1, NULL);
}
#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);
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;
* 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;
* 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
/* }}} */
* 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,
*
* 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;
/* 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;
}
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);
}
}
}
- 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) {
}
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;
}
}
-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;
}
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;
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_long_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_long(zval *op TSRMLS_DC) {
+ return Z_TYPE_P(op) == IS_INT ? Z_IVAL_P(op) : _zval_get_long_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);
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);
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()
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); \
}
#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)
#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); \
}
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"
"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;
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"
"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;
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"
: "r"(&result->value),
"r"(&op1->value),
"r"(&op2->value),
- "n"(IS_LONG),
+ "n"(IS_INT),
"n"(IS_DOUBLE),
"n"(ZVAL_OFFSETOF_TYPE)
: "eax","cc");
: "r"(&result->value),
"r"(&op1->value),
"r"(&op2->value),
- "n"(IS_LONG),
+ "n"(IS_INT),
"n"(IS_DOUBLE),
"n"(ZVAL_OFFSETOF_TYPE)
: "rax","cc");
* 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;
}
}
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"
: "r"(&result->value),
"r"(&op1->value),
"r"(&op2->value),
- "n"(IS_LONG),
+ "n"(IS_INT),
"n"(IS_DOUBLE),
"n"(ZVAL_OFFSETOF_TYPE)
: "eax","cc");
: "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;
}
}
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;
}
}
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)) {
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) {
}
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;
}
}
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;
}
}
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)) {
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)) {
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)
} \
} while (0)
-ZEND_API zend_string *zend_long_to_str(long num);
+ZEND_API zend_string *zend_long_to_str(zend_int_t num);
#endif
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;
#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>
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;
/* *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) {
#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.
* */
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
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);
}
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;
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);
#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);
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);
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);
}
}
-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;
* -- 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) {
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;
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;
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;
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;
#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) \
/* 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);
#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;
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;
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;
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;
zend_uint nTableMask;
zend_uint nNumUsed;
zend_uint nNumOfElements;
- long nNextFreeElement;
+ zend_int_t nNextFreeElement;
Bucket *arData;
zend_uint *arHash;
dtor_func_t pDestructor;
struct _zend_resource {
zend_refcounted gc;
- long handle; // TODO: may be removed ???
+ zend_int_t handle; // TODO: may be removed ???
int type;
void *ptr;
};
#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
#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))
#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))
(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) { \
free(ref);
break;
}
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_FALSE:
case IS_TRUE:
free(ref);
break;
}
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_FALSE:
case IS_TRUE:
}
/* }}} */
-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;
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] == ':') {
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);
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);
/* }}} */
#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);
}
/* }}} */
#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;) {
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) {
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 ||
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;
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) {
HANDLE hFind;
ALLOCA_FLAG(use_heap_large)
#else
- struct stat st;
+ zend_stat_t st;
#endif
realpath_cache_bucket *bucket;
char *tmp;
}
/* }}} */
-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;
}
/* }}} */
-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;
#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);
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);
#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;
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;
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);
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);
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();
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();
{
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);
}
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));
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);
}
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);
}
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;
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 {
}
/* 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 {
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);
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;
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_long(expr));
break;
case IS_DOUBLE:
ZVAL_DOUBLE(result, zval_get_double(expr));
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 {
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 {
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);
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;
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;
}
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));
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;
HANDLE_EXCEPTION();
}
} else {
- ZVAL_LONG(key, iter->index);
+ ZVAL_INT(key, iter->index);
}
}
break;
zend_free_op free_op1, free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
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();
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;
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);
}
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)) {
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));
+ 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), unsigned long, res);
if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
if (EXPECTED(EG(error_reporting_ini_entry)->modified &&
}
/* 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);
}
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)) {
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;
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):
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:
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)) {
}
/* 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);
}
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));
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);
}
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);
}
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;
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));
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));
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));
{
USE_OPLINE
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
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_long(expr));
break;
case IS_DOUBLE:
ZVAL_DOUBLE(result, zval_get_double(expr));
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 {
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 {
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;
}
zval *ptr = opline->op1.zv;
- if (Z_TYPE_P(ptr) == IS_LONG) {
- EG(exit_status) = Z_LVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_INT) {
+ EG(exit_status) = Z_IVAL_P(ptr);
} else {
zend_print_variable(ptr TSRMLS_CC);
}
SAVE_OPLINE();
value = opline->op1.zv;
if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
+ ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value));
} else {
if (Z_TYPE_P(value) < IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 0);
+ ZVAL_INT(EX_VAR(opline->result.var), 0);
} else if (Z_TYPE_P(value) == IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
} else if (Z_TYPE_P(value) <= IS_DOUBLE) {
zend_string *str = zval_get_string(value);
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else if (Z_TYPE_P(value) == IS_OBJECT) {
zend_string *str;
if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) {
goto strlen_error;
}
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else {
strlen_error:
value = opline->op1.zv;
switch (opline->extended_value) {
case IS_NULL:
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_STRING:
case IS_ARRAY:
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 {
}
/* 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 {
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);
zval *offset = opline->op2.zv;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = NULL;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
{
USE_OPLINE
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
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_long(expr));
break;
case IS_DOUBLE:
ZVAL_DOUBLE(result, zval_get_double(expr));
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 {
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 {
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;
}
zend_free_op free_op1;
zval *ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (Z_TYPE_P(ptr) == IS_LONG) {
- EG(exit_status) = Z_LVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_INT) {
+ EG(exit_status) = Z_IVAL_P(ptr);
} else {
zend_print_variable(ptr TSRMLS_CC);
}
static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- char buf[MAX_LENGTH_OF_LONG + 1];
+ char buf[MAX_LENGTH_OF_ZEND_INT + 1];
char *res;
SAVE_OPLINE();
- if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) {
- EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
+ 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), unsigned long, res);
if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
if (EXPECTED(EG(error_reporting_ini_entry)->modified &&
SAVE_OPLINE();
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
+ ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value));
} else {
if (Z_TYPE_P(value) < IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 0);
+ ZVAL_INT(EX_VAR(opline->result.var), 0);
} else if (Z_TYPE_P(value) == IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
} else if (Z_TYPE_P(value) <= IS_DOUBLE) {
zend_string *str = zval_get_string(value);
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else if (Z_TYPE_P(value) == IS_OBJECT) {
zend_string *str;
if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) {
goto strlen_error;
}
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else {
strlen_error:
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
switch (opline->extended_value) {
case IS_NULL:
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_STRING:
case IS_ARRAY:
zval *offset = opline->op2.zv;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = NULL;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
fast_increment_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
fast_decrement_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
fast_increment_function(var_ptr);
ZEND_VM_NEXT_OPCODE();
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
fast_decrement_function(var_ptr);
ZEND_VM_NEXT_OPCODE();
{
USE_OPLINE
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
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_long(expr));
break;
case IS_DOUBLE:
ZVAL_DOUBLE(result, zval_get_double(expr));
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 {
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 {
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;
}
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));
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;
HANDLE_EXCEPTION();
}
} else {
- ZVAL_LONG(key, iter->index);
+ ZVAL_INT(key, iter->index);
}
}
break;
zend_free_op free_op1;
zval *ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (Z_TYPE_P(ptr) == IS_LONG) {
- EG(exit_status) = Z_LVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_INT) {
+ EG(exit_status) = Z_IVAL_P(ptr);
} else {
zend_print_variable(ptr TSRMLS_CC);
}
SAVE_OPLINE();
value = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
+ ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value));
} else {
if (Z_TYPE_P(value) < IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 0);
+ ZVAL_INT(EX_VAR(opline->result.var), 0);
} else if (Z_TYPE_P(value) == IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
} else if (Z_TYPE_P(value) <= IS_DOUBLE) {
zend_string *str = zval_get_string(value);
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else if (Z_TYPE_P(value) == IS_OBJECT) {
zend_string *str;
if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) {
goto strlen_error;
}
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else {
strlen_error:
value = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
switch (opline->extended_value) {
case IS_NULL:
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_STRING:
case IS_ARRAY:
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 {
}
/* 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 {
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);
zval *offset = opline->op2.zv;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op1;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op1;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op1, free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op1, free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op1, free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op1, free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zval *offset = NULL;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op1;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op1;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zval *ptr = NULL;
- if (Z_TYPE_P(ptr) == IS_LONG) {
- EG(exit_status) = Z_LVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_INT) {
+ EG(exit_status) = Z_IVAL_P(ptr);
} else {
zend_print_variable(ptr TSRMLS_CC);
}
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 {
}
/* 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 {
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);
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_unused(TSRMLS_C);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_unused(TSRMLS_C);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_unused(TSRMLS_C);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
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)) {
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_unused(TSRMLS_C);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
fast_increment_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
fast_decrement_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
fast_increment_function(var_ptr);
ZEND_VM_NEXT_OPCODE();
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+ if (EXPECTED(Z_TYPE_P(var_ptr) == IS_INT)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
fast_decrement_function(var_ptr);
ZEND_VM_NEXT_OPCODE();
{
USE_OPLINE
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
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_long(expr));
break;
case IS_DOUBLE:
ZVAL_DOUBLE(result, zval_get_double(expr));
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 {
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 {
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;
}
zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- if (Z_TYPE_P(ptr) == IS_LONG) {
- EG(exit_status) = Z_LVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_INT) {
+ EG(exit_status) = Z_IVAL_P(ptr);
} else {
zend_print_variable(ptr TSRMLS_CC);
}
SAVE_OPLINE();
value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
+ ZVAL_INT(EX_VAR(opline->result.var), Z_STRSIZE_P(value));
} else {
if (Z_TYPE_P(value) < IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 0);
+ ZVAL_INT(EX_VAR(opline->result.var), 0);
} else if (Z_TYPE_P(value) == IS_TRUE) {
- ZVAL_LONG(EX_VAR(opline->result.var), 1);
+ ZVAL_INT(EX_VAR(opline->result.var), 1);
} else if (Z_TYPE_P(value) <= IS_DOUBLE) {
zend_string *str = zval_get_string(value);
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else if (Z_TYPE_P(value) == IS_OBJECT) {
zend_string *str;
if (parse_arg_object_to_str(value, &str, IS_STRING TSRMLS_CC) == FAILURE) {
goto strlen_error;
}
- ZVAL_LONG(EX_VAR(opline->result.var), str->len);
+ ZVAL_INT(EX_VAR(opline->result.var), str->len);
STR_RELEASE(str);
} else {
strlen_error:
value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
switch (opline->extended_value) {
case IS_NULL:
- case IS_LONG:
+ case IS_INT:
case IS_DOUBLE:
case IS_STRING:
case IS_ARRAY:
zval *offset = opline->op2.zv;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zend_free_op free_op2;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zend_free_op free_op2;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
zval *offset = NULL;
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
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)) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
zend_string *str;
- ulong hval;
+ zend_uint_t hval;
add_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index:
zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
break;
zval *container;
zval *offset;
- ulong hval;
+ zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
offset_again:
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
zend_hash_index_del(ht, hval);
break;
- case IS_LONG:
- hval = Z_LVAL_P(offset);
+ case IS_INT:
+ hval = Z_IVAL_P(offset);
num_index_dim:
zend_hash_index_del(ht, hval);
break;
zval *container;
int result;
- ulong hval;
+ zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
}
str_index_prop:
value = zend_hash_find_ind(ht, str);
- } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
- hval = Z_LVAL_P(offset);
+ } else if (EXPECTED(Z_TYPE_P(offset) == IS_INT)) {
+ hval = Z_IVAL_P(offset);
num_index_prop:
value = zend_hash_index_find(ht, hval);
} else {
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
+ hval = zend_dval_to_ival(Z_DVAL_P(offset));
goto num_index_prop;
case IS_NULL:
str = STR_EMPTY_ALLOC();
zval tmp;
result = 0;
- if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+ if (UNEXPECTED(Z_TYPE_P(offset) != IS_INT)) {
if (IS_CV == IS_CV || IS_CV == IS_VAR) {
ZVAL_DEREF(offset);
}
if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
+ && IS_INT == is_numeric_string(Z_STRVAL_P(offset), Z_STRSIZE_P(offset), NULL, NULL, 0))) {
ZVAL_DUP(&tmp, offset);
- convert_to_long(&tmp);
+ convert_to_int(&tmp);
offset = &tmp;
}
}
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+ if (Z_TYPE_P(offset) == IS_INT) {
+ if (offset->value.lval >= 0 && offset->value.lval < Z_STRSIZE_P(container)) {
if ((opline->extended_value & ZEND_ISSET) ||
Z_STRVAL_P(container)[offset->value.lval] != '0') {
result = 1;
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)) {
}
if ((SG(post_max_size) > 0) && (SG(read_post_bytes) > SG(post_max_size))) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Actual POST length does not match Content-Length, and exceeds %ld bytes", SG(post_max_size));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Actual POST length does not match Content-Length, and exceeds " ZEND_INT_FMT " bytes", SG(post_max_size));
break;
}
}
}
-SAPI_API struct stat *sapi_get_stat(TSRMLS_D)
+SAPI_API zend_stat_t *sapi_get_stat(TSRMLS_D)
{
if (sapi_module.get_stat) {
return sapi_module.get_stat(TSRMLS_C);
#include "win32/php_stdint.h"
#endif
#include <sys/stat.h>
+#include "php.h"
#define SAPI_OPTION_NO_CHDIR 1
#define SAPI_POST_BLOCK_SIZE 0x4000
const char *request_method;
char *query_string;
char *cookie_data;
- long content_length;
+ zend_int_t content_length;
char *path_translated;
char *request_uri;
int64_t read_post_bytes;
unsigned char post_read;
unsigned char headers_sent;
- struct stat global_stat;
+ zend_stat_t global_stat;
char *default_mimetype;
char *default_charset;
HashTable *rfc1867_uploaded_files;
- long post_max_size;
+ zend_int_t post_max_size;
int options;
zend_bool sapi_started;
double global_request_time;
typedef struct {
char *line; /* If you allocated this, you need to free it yourself */
uint line_len;
- long response_code; /* long due to zend_parse_parameters compatibility */
+ zend_int_t response_code; /* long due to zend_parse_parameters compatibility */
} sapi_header_line;
typedef enum { /* Parameter: */
SAPI_API int sapi_register_input_filter(unsigned int (*input_filter)(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC), unsigned int (*input_filter_init)(TSRMLS_D) TSRMLS_DC);
SAPI_API int sapi_flush(TSRMLS_D);
-SAPI_API struct stat *sapi_get_stat(TSRMLS_D);
+SAPI_API zend_stat_t *sapi_get_stat(TSRMLS_D);
SAPI_API char *sapi_getenv(char *name, size_t name_len TSRMLS_DC);
SAPI_API char *sapi_get_default_content_type(TSRMLS_D);
int (*activate)(TSRMLS_D);
int (*deactivate)(TSRMLS_D);
- int (*ub_write)(const char *str, unsigned int str_length TSRMLS_DC);
+ php_size_t (*ub_write)(const char *str, php_size_t str_length TSRMLS_DC);
void (*flush)(void *server_context TSRMLS_DC);
- struct stat *(*get_stat)(TSRMLS_D);
+ zend_stat_t *(*get_stat)(TSRMLS_D);
char *(*getenv)(char *name, size_t name_len TSRMLS_DC);
void (*sapi_error)(int type, const char *error_msg, ...);
int (*send_headers)(sapi_headers_struct *sapi_headers TSRMLS_DC);
void (*send_header)(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC);
- int (*read_post)(char *buffer, uint count_bytes TSRMLS_DC);
+ php_size_t (*read_post)(char *buffer, php_size_t count_bytes TSRMLS_DC);
char *(*read_cookies)(TSRMLS_D);
void (*register_server_variables)(zval *track_vars_array TSRMLS_DC);
int (*get_target_uid)(uid_t * TSRMLS_DC);
int (*get_target_gid)(gid_t * TSRMLS_DC);
- unsigned int (*input_filter)(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC);
+ unsigned int (*input_filter)(int arg, char *var, char **val, php_size_t val_len, php_size_t *new_val_len TSRMLS_DC);
void (*ini_defaults)(HashTable *configuration_hash);
int phpinfo_as_text;
#define SAPI_POST_HANDLER_FUNC(post_handler) void post_handler(char *content_type_dup, void *arg TSRMLS_DC)
#define SAPI_TREAT_DATA_FUNC(treat_data) void treat_data(int arg, char *str, zval* destArray TSRMLS_DC)
-#define SAPI_INPUT_FILTER_FUNC(input_filter) unsigned int input_filter(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC)
+#define SAPI_INPUT_FILTER_FUNC(input_filter) unsigned int input_filter(int arg, char *var, char **val, php_size_t val_len, php_size_t *new_val_len TSRMLS_DC)
BEGIN_EXTERN_C()
SAPI_API SAPI_POST_READER_FUNC(sapi_read_standard_form_data);
*/
static PHP_INI_MH(OnSetPrecision)
{
- int i = atoi(new_value);
+ php_int_t i;
+
+ ZEND_ATOI(i, new_value);
if (i >= 0) {
EG(precision) = i;
return SUCCESS;
if ((envpath = getenv("PATH")) != NULL) {
char *search_dir, search_path[MAXPATHLEN];
char *last = NULL;
- struct stat s;
+ php_stat_t s;
path = estrdup(envpath);
search_dir = php_strtok_r(path, ":", &last);
{
if (stage==PHP_INI_STAGE_STARTUP) {
/* Don't set a timeout on startup, only per-request */
- EG(timeout_seconds) = atoi(new_value);
+ ZEND_ATOI(EG(timeout_seconds), new_value);
return SUCCESS;
}
zend_unset_timeout(TSRMLS_C);
- EG(timeout_seconds) = atoi(new_value);
+ ZEND_ATOI(EG(timeout_seconds), new_value);
zend_set_timeout(EG(timeout_seconds), 0);
return SUCCESS;
}
} else if (value_length == 6 && !strcasecmp(value, "stdout")) {
mode = PHP_DISPLAY_ERRORS_STDOUT;
} else {
- mode = atoi(value);
+ ZEND_ATOI(mode, value);
if (mode && mode != PHP_DISPLAY_ERRORS_STDOUT && mode != PHP_DISPLAY_ERRORS_STDERR) {
mode = PHP_DISPLAY_ERRORS_STDOUT;
}
/* {{{ php_write
wrapper for modules to use PHPWRITE */
-PHPAPI int php_write(void *buf, uint size TSRMLS_DC)
+PHPAPI php_size_t php_write(void *buf, php_size_t size TSRMLS_DC)
{
return PHPWRITE(buf, size);
}
/* {{{ php_printf
*/
-PHPAPI int php_printf(const char *format, ...)
+PHPAPI php_size_t php_printf(const char *format, ...)
{
va_list args;
- int ret;
+ php_size_t ret;
char *buffer;
- int size;
+ php_size_t size;
TSRMLS_FETCH();
va_start(args, format);
*/
PHPAPI char *php_get_current_user(TSRMLS_D)
{
- struct stat *pstat;
+ php_stat_t *pstat;
if (SG(request_info).current_user) {
return SG(request_info).current_user;
Sets the maximum time a script can run */
PHP_FUNCTION(set_time_limit)
{
- long new_timeout;
+ php_int_t new_timeout;
char *new_timeout_str;
int new_timeout_strlen;
zend_string *key;
return;
}
- new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, "%ld", new_timeout);
+ new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, ZEND_INT_FMT, new_timeout);
key = STR_INIT("max_execution_time", sizeof("max_execution_time")-1, 0);
if (zend_alter_ini_entry_ex(key, new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == SUCCESS) {
/* {{{ php_output_wrapper
*/
-static int php_output_wrapper(const char *str, uint str_length)
+static php_size_t php_output_wrapper(const char *str, php_size_t str_length)
{
TSRMLS_FETCH();
return php_output_write(str, str_length TSRMLS_CC);
/* Register constants */
REGISTER_MAIN_STRINGL_CONSTANT("PHP_VERSION", PHP_VERSION, sizeof(PHP_VERSION)-1, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_MAJOR_VERSION", PHP_MAJOR_VERSION, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_MINOR_VERSION", PHP_MINOR_VERSION, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_RELEASE_VERSION", PHP_RELEASE_VERSION, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_MAJOR_VERSION", PHP_MAJOR_VERSION, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_MINOR_VERSION", PHP_MINOR_VERSION, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_RELEASE_VERSION", PHP_RELEASE_VERSION, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_EXTRA_VERSION", PHP_EXTRA_VERSION, sizeof(PHP_EXTRA_VERSION) - 1, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_VERSION_ID", PHP_VERSION_ID, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_VERSION_ID", PHP_VERSION_ID, CONST_PERSISTENT | CONST_CS);
#ifdef ZTS
- REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 1, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_ZTS", 1, CONST_PERSISTENT | CONST_CS);
#else
- REGISTER_MAIN_LONG_CONSTANT("PHP_ZTS", 0, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_ZTS", 0, CONST_PERSISTENT | CONST_CS);
#endif
- REGISTER_MAIN_LONG_CONSTANT("PHP_DEBUG", PHP_DEBUG, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_DEBUG", PHP_DEBUG, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_OS", php_os, strlen(php_os), CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_SAPI", sapi_module.name, strlen(sapi_module.name), CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("DEFAULT_INCLUDE_PATH", PHP_INCLUDE_PATH, sizeof(PHP_INCLUDE_PATH)-1, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_CONFIG_FILE_SCAN_DIR", PHP_CONFIG_FILE_SCAN_DIR, sizeof(PHP_CONFIG_FILE_SCAN_DIR)-1, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_SHLIB_SUFFIX", PHP_SHLIB_SUFFIX, sizeof(PHP_SHLIB_SUFFIX)-1, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_STRINGL_CONSTANT("PHP_EOL", PHP_EOL, sizeof(PHP_EOL)-1, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_MAXPATHLEN", MAXPATHLEN, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_INT_MAX", LONG_MAX, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_INT_MIN", LONG_MIN, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_INT_SIZE", sizeof(long), CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_MAXPATHLEN", MAXPATHLEN, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_INT_MAX", PHP_INT_MAX, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_INT_MIN", PHP_INT_MIN, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_INT_SIZE", SIZEOF_ZEND_INT, CONST_PERSISTENT | CONST_CS);
#ifdef PHP_WIN32
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MAJOR", EG(windows_version_info).dwMajorVersion, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_MINOR", EG(windows_version_info).dwMinorVersion, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_BUILD", EG(windows_version_info).dwBuildNumber, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PLATFORM", EG(windows_version_info).dwPlatformId, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MAJOR", EG(windows_version_info).wServicePackMajor, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SP_MINOR", EG(windows_version_info).wServicePackMinor, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_SUITEMASK", EG(windows_version_info).wSuiteMask, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_VERSION_PRODUCTTYPE", EG(windows_version_info).wProductType, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_DOMAIN_CONTROLLER", VER_NT_DOMAIN_CONTROLLER, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_SERVER", VER_NT_SERVER, CONST_PERSISTENT | CONST_CS);
- REGISTER_MAIN_LONG_CONSTANT("PHP_WINDOWS_NT_WORKSTATION", VER_NT_WORKSTATION, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_MAJOR", EG(windows_version_info).dwMajorVersion, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_MINOR", EG(windows_version_info).dwMinorVersion, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_BUILD", EG(windows_version_info).dwBuildNumber, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_PLATFORM", EG(windows_version_info).dwPlatformId, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SP_MAJOR", EG(windows_version_info).wServicePackMajor, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SP_MINOR", EG(windows_version_info).wServicePackMinor, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_SUITEMASK", EG(windows_version_info).wSuiteMask, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_VERSION_PRODUCTTYPE", EG(windows_version_info).wProductType, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_DOMAIN_CONTROLLER", VER_NT_DOMAIN_CONTROLLER, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_SERVER", VER_NT_SERVER, CONST_PERSISTENT | CONST_CS);
+ REGISTER_MAIN_INT_CONSTANT("PHP_WINDOWS_NT_WORKSTATION", VER_NT_WORKSTATION, CONST_PERSISTENT | CONST_CS);
#endif
php_binary_init(TSRMLS_C);
const char **p = directives[i].directives;
while(*p) {
- long value;
+ php_int_t value;
- if (cfg_get_long((char*)*p, &value) == SUCCESS && value) {
+ if (cfg_get_int((char*)*p, &value) == SUCCESS && value) {
zend_error(directives[i].error_level, directives[i].phrase, *p);
}
}
/* }}} */
-PHPAPI int php_network_parse_network_address_with_port(const char *addr, long addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC)
+PHPAPI int php_network_parse_network_address_with_port(const char *addr, php_int_t addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC)
{
char *colon;
char *tmp;
int socktype, struct timeval *timeout, const char *persistent_id STREAMS_DC TSRMLS_DC)
{
char *res;
- long reslen;
+ php_int_t reslen;
php_stream *stream;
reslen = spprintf(&res, 0, "tcp://%s:%d", host, port);
/* {{{ void php_output_register_constants() */
PHPAPI void php_output_register_constants(TSRMLS_D)
{
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_WRITE", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FLUSH", PHP_OUTPUT_HANDLER_FLUSH, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEAN", PHP_OUTPUT_HANDLER_CLEAN, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FINAL", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_WRITE", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FLUSH", PHP_OUTPUT_HANDLER_FLUSH, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CLEAN", PHP_OUTPUT_HANDLER_CLEAN, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FINAL", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_WRITE, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_END", PHP_OUTPUT_HANDLER_FINAL, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CLEANABLE", PHP_OUTPUT_HANDLER_CLEANABLE, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_FLUSHABLE", PHP_OUTPUT_HANDLER_FLUSHABLE, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_REMOVABLE", PHP_OUTPUT_HANDLER_REMOVABLE, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STDFLAGS", PHP_OUTPUT_HANDLER_STDFLAGS, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_STARTED", PHP_OUTPUT_HANDLER_STARTED, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_DISABLED", PHP_OUTPUT_HANDLER_DISABLED, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_CLEANABLE", PHP_OUTPUT_HANDLER_CLEANABLE, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_FLUSHABLE", PHP_OUTPUT_HANDLER_FLUSHABLE, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_REMOVABLE", PHP_OUTPUT_HANDLER_REMOVABLE, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_STDFLAGS", PHP_OUTPUT_HANDLER_STDFLAGS, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_STARTED", PHP_OUTPUT_HANDLER_STARTED, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("PHP_OUTPUT_HANDLER_DISABLED", PHP_OUTPUT_HANDLER_DISABLED, CONST_CS | CONST_PERSISTENT);
}
/* }}} */
PHPAPI int php_output_get_length(zval *p TSRMLS_DC)
{
if (OG(active)) {
- ZVAL_LONG(p, OG(active)->buffer.used);
+ ZVAL_INT(p, OG(active)->buffer.used);
return SUCCESS;
} else {
ZVAL_NULL(p);
handler = php_output_handler_create_internal(ZEND_STRL(php_output_default_handler_name), php_output_handler_default_func, chunk_size, flags TSRMLS_CC);
break;
case IS_STRING:
- if (Z_STRLEN_P(output_handler) && (alias = php_output_handler_alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler) TSRMLS_CC))) {
- handler = alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler), chunk_size, flags TSRMLS_CC);
+ if (Z_STRSIZE_P(output_handler) && (alias = php_output_handler_alias(Z_STRVAL_P(output_handler), Z_STRSIZE_P(output_handler) TSRMLS_CC))) {
+ handler = alias(Z_STRVAL_P(output_handler), Z_STRSIZE_P(output_handler), chunk_size, flags TSRMLS_CC);
break;
}
default:
zval retval, ob_data, ob_mode;
ZVAL_STRINGL(&ob_data, handler->buffer.data, handler->buffer.used);
- ZVAL_LONG(&ob_mode, (long) context->op);
+ ZVAL_INT(&ob_mode, (long) context->op);
zend_fcall_info_argn(&handler->func.user->fci TSRMLS_CC, 2, &ob_data, &ob_mode);
#define PHP_OUTPUT_USER_SUCCESS(retval) ((Z_TYPE(retval) != IS_UNDEF) && !(Z_TYPE(retval) == IS_FALSE))
status = PHP_OUTPUT_HANDLER_NO_DATA;
if (Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) {
convert_to_string_ex(&retval);
- if (Z_STRLEN(retval)) {
- context->out.data = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
- context->out.used = Z_STRLEN(retval);
+ if (Z_STRSIZE(retval)) {
+ context->out.data = estrndup(Z_STRVAL(retval), Z_STRSIZE(retval));
+ context->out.used = Z_STRSIZE(retval);
context->out.free = 1;
status = PHP_OUTPUT_HANDLER_SUCCESS;
}
array_init(entry);
add_assoc_str(entry, "name", STR_COPY(handler->name));
- add_assoc_long(entry, "type", (long) (handler->flags & 0xf));
- add_assoc_long(entry, "flags", (long) handler->flags);
- add_assoc_long(entry, "level", (long) handler->level);
- add_assoc_long(entry, "chunk_size", (long) handler->size);
- add_assoc_long(entry, "buffer_size", (long) handler->buffer.size);
- add_assoc_long(entry, "buffer_used", (long) handler->buffer.used);
+ add_assoc_int(entry, "type", (php_int_t) (handler->flags & 0xf));
+ add_assoc_int(entry, "flags", (php_int_t) handler->flags);
+ add_assoc_int(entry, "level", (php_int_t) handler->level);
+ add_assoc_int(entry, "chunk_size", (php_int_t) handler->size);
+ add_assoc_int(entry, "buffer_size", (php_int_t) handler->buffer.size);
+ add_assoc_int(entry, "buffer_used", (php_int_t) handler->buffer.used);
return entry;
}
PHP_FUNCTION(ob_start)
{
zval *output_handler = NULL;
- long chunk_size = 0;
- long flags = PHP_OUTPUT_HANDLER_STDFLAGS;
+ php_int_t chunk_size = 0;
+ php_int_t flags = PHP_OUTPUT_HANDLER_STDFLAGS;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z/ll", &output_handler, &chunk_size, &flags) == FAILURE) {
return;
return;
}
- RETURN_LONG(php_output_get_level(TSRMLS_C));
+ RETURN_INT(php_output_get_level(TSRMLS_C));
}
/* }}} */
Turn implicit flush on/off and is equivalent to calling flush() after every output call */
PHP_FUNCTION(ob_implicit_flush)
{
- long flag = 1;
+ php_int_t flag = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flag) == FAILURE) {
return;
# define PHP_EOL "\n"
#endif
+#define php_size_t zend_size_t
+#define php_int_t zend_int_t
+#define php_uint_t zend_uint_t
+#define PHP_INT_MAX ZEND_INT_MAX
+#define PHP_INT_MIN ZEND_INT_MIN
+#define PHP_UINT_MAX ZEND_UINT_MAX
+#define PHP_SIZE_MAX ZEND_SIZE_MAX
+
#ifdef NETWARE
/* For php_get_uname() function */
#define PHP_UNAME "NetWare"
BEGIN_EXTERN_C()
void phperror(char *error);
-PHPAPI int php_write(void *buf, uint size TSRMLS_DC);
-PHPAPI int php_printf(const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 1,
+PHPAPI php_size_t php_write(void *buf, php_size_t size TSRMLS_DC);
+PHPAPI php_size_t php_printf(const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 1,
2);
PHPAPI int php_get_module_initialized(void);
PHPAPI void php_log_err(char *log_message TSRMLS_DC);
struct _php_core_globals {
zend_bool implicit_flush;
- long output_buffering;
+ zend_int_t output_buffering;
zend_bool sql_safe_mode;
zend_bool enable_dl;
char *output_handler;
char *unserialize_callback_func;
- long serialize_precision;
+ zend_int_t serialize_precision;
- long memory_limit;
- long max_input_time;
+ zend_int_t memory_limit;
+ zend_int_t max_input_time;
zend_bool track_errors;
zend_bool display_errors;
zend_bool display_startup_errors;
zend_bool log_errors;
- long log_errors_max_len;
+ zend_int_t log_errors_max_len;
zend_bool ignore_repeated_errors;
zend_bool ignore_repeated_source;
zend_bool report_memleaks;
char *sys_temp_dir;
char *upload_tmp_dir;
- long upload_max_filesize;
+ zend_int_t upload_max_filesize;
char *error_append_string;
char *error_prepend_string;
zend_bool html_errors;
zend_bool xmlrpc_errors;
- long xmlrpc_error_number;
+ zend_int_t xmlrpc_error_number;
zend_bool activated_auto_globals[8];
#ifdef PHP_WIN32
zend_bool com_initialized;
#endif
- long max_input_nesting_level;
- long max_input_vars;
+ zend_int_t max_input_nesting_level;
+ zend_int_t max_input_vars;
zend_bool in_user_include;
char *user_ini_filename;
- long user_ini_cache_ttl;
+ zend_int_t user_ini_cache_ttl;
char *request_order;
/* PHP and Zend extensions are not added into configuration hash! */
if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), PHP_EXTENSION_TOKEN)) { /* load PHP extension */
- extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
+ extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRSIZE_P(arg2));
zend_llist_add_element(&extension_lists.functions, &extension_name);
} else if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */
- extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
+ extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRSIZE_P(arg2));
zend_llist_add_element(&extension_lists.engine, &extension_name);
/* All other entries are added into either configuration_hash or active ini section array */
}
/* arg3 is possible option offset name */
- if (arg3 && Z_STRLEN_P(arg3) > 0) {
+ if (arg3 && Z_STRSIZE_P(arg3) > 0) {
entry = zend_symtable_update(Z_ARRVAL_P(find_arr), Z_STR_P(arg3), arg2);
} else {
entry = zend_hash_next_index_insert(Z_ARRVAL_P(find_arr), arg2);
if (!strncasecmp(Z_STRVAL_P(arg1), "PATH", sizeof("PATH") - 1)) {
key = Z_STRVAL_P(arg1);
key = key + sizeof("PATH") - 1;
- key_len = Z_STRLEN_P(arg1) - sizeof("PATH") + 1;
+ key_len = Z_STRSIZE_P(arg1) - sizeof("PATH") + 1;
is_special_section = 1;
has_per_dir_config = 1;
} else if (!strncasecmp(Z_STRVAL_P(arg1), "HOST", sizeof("HOST") - 1)) {
key = Z_STRVAL_P(arg1);
key = key + sizeof("HOST") - 1;
- key_len = Z_STRLEN_P(arg1) - sizeof("HOST") + 1;
+ key_len = Z_STRSIZE_P(arg1) - sizeof("HOST") + 1;
is_special_section = 1;
has_per_host_config = 1;
zend_str_tolower(key, key_len); /* host names are case-insensitive. */
/* Check if php_ini_file_name is a file and can be opened */
if (php_ini_file_name && php_ini_file_name[0]) {
- struct stat statbuf;
+ php_stat_t statbuf;
if (!VCWD_STAT(php_ini_file_name, &statbuf)) {
if (!((statbuf.st_mode & S_IFMT) == S_IFDIR)) {
if (php_ini_opened_path) {
efree(php_ini_opened_path);
}
- php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
+ php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRSIZE(tmp));
}
}
if (!sapi_module.php_ini_ignore && php_ini_scanned_path_len) {
struct dirent **namelist;
int ndir, i;
- struct stat sb;
+ php_stat_t sb;
char ini_file[MAXPATHLEN];
char *p;
zend_file_handle fh2;
*/
PHPAPI int php_parse_user_ini_file(const char *dirname, char *ini_filename, HashTable *target_hash TSRMLS_DC)
{
- struct stat sb;
+ php_stat_t sb;
char ini_file[MAXPATHLEN];
zend_file_handle fh;
{
zend_string *str;
zval *data;
- ulong num_index;
+ zend_uint_t num_index;
/* Walk through config hash and alter matching ini entries using the values found in the hash */
for (zend_hash_internal_pointer_reset(source_hash);
zend_hash_move_forward(source_hash)
) {
data = zend_hash_get_current_data(source_hash);
- zend_alter_ini_entry_ex(str, Z_STRVAL_P(data), Z_STRLEN_P(data), modify_type, stage, 0 TSRMLS_CC);
+ zend_alter_ini_entry_ex(str, Z_STRVAL_P(data), Z_STRSIZE_P(data), modify_type, stage, 0 TSRMLS_CC);
}
}
/* }}} */
}
/* }}} */
-/* {{{ cfg_get_long
+/* {{{ cfg_get_int
*/
-PHPAPI int cfg_get_long(const char *varname, long *result)
+PHPAPI int cfg_get_int(const char *varname, zend_int_t *result)
{
zval *tmp, var;
return FAILURE;
}
ZVAL_DUP(&var, tmp);
- convert_to_long(&var);
- *result = Z_LVAL(var);
+ convert_to_int(&var);
+ *result = Z_IVAL(var);
return SUCCESS;
}
/* }}} */
int php_shutdown_config(void);
void php_ini_register_extensions(TSRMLS_D);
PHPAPI zval *cfg_get_entry(const char *name, uint name_length);
-PHPAPI int cfg_get_long(const char *varname, long *result);
+PHPAPI int cfg_get_int(const char *varname, zend_int_t *result);
PHPAPI int cfg_get_double(const char *varname, double *result);
PHPAPI int cfg_get_string(const char *varname, char **result);
PHPAPI int php_parse_user_ini_file(const char *dirname, char *ini_filename, HashTable *target_hash TSRMLS_DC);
#define php_alter_ini_entry zend_alter_ini_entry
-#define php_ini_long zend_ini_long
+#define php_ini_long zend_ini_int
#define php_ini_double zend_ini_double
#define php_ini_string zend_ini_string
TSRMLS_DC);
PHPAPI int php_network_parse_network_address_with_port(const char *addr,
- long addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC);
+ php_int_t addrlen, struct sockaddr *sa, socklen_t *sl TSRMLS_DC);
END_EXTERN_C()
#define php_stream_sock_open_from_socket(socket, persistent) _php_stream_sock_open_from_socket((socket), (persistent) STREAMS_CC TSRMLS_CC)
#include "streams/php_stream_context.h"
#include "streams/php_stream_filter_api.h"
+#ifdef _WIN64
+# define php_fstat _fstat64
+# define php_stat_fn _stat64
+typedef struct __stat64 php_stat_t;
+#else
+# define php_fstat fstat
+# define php_stat_fn stat
+typedef struct stat php_stat_t;
+#endif
+
typedef struct _php_stream_statbuf {
- struct stat sb; /* regular info */
+ zend_stat_t sb; /* regular info */
/* extended info to go here some day: content-type etc. etc. */
} php_stream_statbuf;
const char *label; /* label for this ops structure */
/* these are optional */
- int (*seek)(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC);
+ int (*seek)(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset TSRMLS_DC);
int (*cast)(php_stream *stream, int castas, void **ret TSRMLS_DC);
int (*stat)(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC);
int (*set_option)(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC);
int flags; /* PHP_STREAM_FLAG_XXX */
/* buffer */
- off_t position; /* of underlying stream */
+ zend_off_t position; /* of underlying stream */
unsigned char *readbuf;
size_t readbuflen;
- off_t readpos;
- off_t writepos;
+ zend_off_t readpos;
+ zend_off_t writepos;
/* how much data to read when filling buffer */
size_t chunk_size;
#define php_stream_close(stream) _php_stream_free((stream), PHP_STREAM_FREE_CLOSE TSRMLS_CC)
#define php_stream_pclose(stream) _php_stream_free((stream), PHP_STREAM_FREE_CLOSE_PERSISTENT TSRMLS_CC)
-PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC);
+PHPAPI int _php_stream_seek(php_stream *stream, zend_off_t offset, int whence TSRMLS_DC);
#define php_stream_rewind(stream) _php_stream_seek((stream), 0L, SEEK_SET TSRMLS_CC)
#define php_stream_seek(stream, offset, whence) _php_stream_seek((stream), (offset), (whence) TSRMLS_CC)
-PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC);
+PHPAPI zend_off_t _php_stream_tell(php_stream *stream TSRMLS_DC);
#define php_stream_tell(stream) _php_stream_tell((stream) TSRMLS_CC)
PHPAPI size_t _php_stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC);
/* do not output the error message to the screen,
this helps us to to avoid "information disclosure" */
if (!PG(display_errors)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded %ld. To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded " ZEND_INT_FMT ". To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level));
}
free_alloca(var_orig, use_heap);
return;
char *ksep, *vsep;
size_t klen, vlen;
/* FIXME: string-size_t */
- unsigned int new_vlen;
+ php_size_t new_vlen;
if (var->ptr >= var->end) {
return 0;
}
if (++count > PG(max_input_vars)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded %ld. To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded " ZEND_INT_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
break;
}
if (val) { /* have a value */
- int val_len;
- unsigned int new_val_len;
+ php_size_t val_len;
+ php_size_t new_val_len;
*val++ = '\0';
php_url_decode(var, strlen(var));
}
efree(val);
} else {
- int val_len;
- unsigned int new_val_len;
+ php_size_t val_len;
+ php_size_t new_val_len;
php_url_decode(var, strlen(var));
val_len = 0;
/* prepare argc */
if (SG(request_info).argc) {
- ZVAL_LONG(&argc, SG(request_info).argc);
+ ZVAL_INT(&argc, SG(request_info).argc);
} else {
- ZVAL_LONG(&argc, count);
+ ZVAL_INT(&argc, count);
}
if (SG(request_info).argc) {
zval request_time_float, request_time_long;
ZVAL_DOUBLE(&request_time_float, sapi_get_request_time(TSRMLS_C));
php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
- ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float)));
+ ZVAL_INT(&request_time_long, zend_dval_to_ival(Z_DVAL(request_time_float)));
php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
}
{
zval *src_entry, *dest_entry;
zend_string *string_key;
- ulong num_key;
+ php_uint_t num_key;
int globals_check = (dest == (&EG(symbol_table).ht));
ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
void php_rfc1867_register_constants(TSRMLS_D) /* {{{ */
{
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_OK", UPLOAD_ERROR_OK, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_INI_SIZE", UPLOAD_ERROR_A, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_FORM_SIZE", UPLOAD_ERROR_B, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_PARTIAL", UPLOAD_ERROR_C, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_FILE", UPLOAD_ERROR_D, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_NO_TMP_DIR", UPLOAD_ERROR_E, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_CANT_WRITE", UPLOAD_ERROR_F, CONST_CS | CONST_PERSISTENT);
- REGISTER_MAIN_LONG_CONSTANT("UPLOAD_ERR_EXTENSION", UPLOAD_ERROR_X, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_OK", UPLOAD_ERROR_OK, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_INI_SIZE", UPLOAD_ERROR_A, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_FORM_SIZE", UPLOAD_ERROR_B, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_PARTIAL", UPLOAD_ERROR_C, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_NO_FILE", UPLOAD_ERROR_D, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_NO_TMP_DIR", UPLOAD_ERROR_E, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_CANT_WRITE", UPLOAD_ERROR_F, CONST_CS | CONST_PERSISTENT);
+ REGISTER_MAIN_INT_CONSTANT("UPLOAD_ERR_EXTENSION", UPLOAD_ERROR_X, CONST_CS | CONST_PERSISTENT);
}
/* }}} */
php_rfc1867_getword_t getword;
php_rfc1867_getword_conf_t getword_conf;
php_rfc1867_basename_t _basename;
- long count = 0;
+ php_int_t count = 0;
if (php_rfc1867_encoding_translation(TSRMLS_C) && internal_encoding) {
getword = php_rfc1867_getword;
}
if (SG(post_max_size) > 0 && SG(request_info).content_length > SG(post_max_size)) {
- sapi_module.sapi_error(E_WARNING, "POST Content-Length of %ld bytes exceeds the limit of %ld bytes", SG(request_info).content_length, SG(post_max_size));
+ sapi_module.sapi_error(E_WARNING, "POST Content-Length of " ZEND_INT_FMT " bytes exceeds the limit of " ZEND_INT_FMT " bytes", SG(request_info).content_length, SG(post_max_size));
return;
}
char buff[FILLUNIT];
char *cd = NULL, *param = NULL, *filename = NULL, *tmp = NULL;
size_t blen = 0, wlen = 0;
- off_t offset;
+ zend_off_t offset;
zend_llist_clean(&header);
/* Normal form variable, safe to read all data into memory */
if (!filename && param) {
- unsigned int value_len;
+ php_size_t value_len;
char *value = multipart_buffer_read_body(mbuff, &value_len TSRMLS_CC);
- unsigned int new_val_len; /* Dummy variable */
+ php_size_t new_val_len; /* Dummy variable */
if (!value) {
value = estrdup("");
safe_php_register_variable(param, value, new_val_len, array_ptr, 0 TSRMLS_CC);
} else {
if (count == PG(max_input_vars) + 1) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded %ld. To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variables exceeded " ZEND_INT_FMT ". To increase the limit change max_input_vars in php.ini.", PG(max_input_vars));
}
if (php_rfc1867_callback != NULL) {
}
}
- if (PG(upload_max_filesize) > 0 && (long)(total_bytes+blen) > PG(upload_max_filesize)) {
+ if (PG(upload_max_filesize) > 0 && (php_int_t)(total_bytes+blen) > PG(upload_max_filesize)) {
#if DEBUG_FILE_UPLOAD
- sapi_module.sapi_error(E_NOTICE, "upload_max_filesize of %ld bytes exceeded - file [%s=%s] not saved", PG(upload_max_filesize), param, filename);
+ sapi_module.sapi_error(E_NOTICE, "upload_max_filesize of " ZEND_INT_FMT " bytes exceeded - file [%s=%s] not saved", PG(upload_max_filesize), param, filename);
#endif
cancel_upload = UPLOAD_ERROR_A;
- } else if (max_file_size && ((long)(total_bytes+blen) > max_file_size)) {
+ } else if (max_file_size && ((php_int_t)(total_bytes+blen) > max_file_size)) {
#if DEBUG_FILE_UPLOAD
- sapi_module.sapi_error(E_NOTICE, "MAX_FILE_SIZE of %ld bytes exceeded - file [%s=%s] not saved", max_file_size, param, filename);
+ sapi_module.sapi_error(E_NOTICE, "MAX_FILE_SIZE of " ZEND_INT_FMT " bytes exceeded - file [%s=%s] not saved", max_file_size, param, filename);
#endif
cancel_upload = UPLOAD_ERROR_B;
} else if (blen > 0) {
int size_overflow = 0;
char file_size_buf[65];
- ZVAL_LONG(&error_type, cancel_upload);
+ ZVAL_INT(&error_type, cancel_upload);
/* Add $foo[error] */
if (cancel_upload) {
- ZVAL_LONG(&file_size, 0);
+ ZVAL_INT(&file_size, 0);
} else {
- if (total_bytes > LONG_MAX) {
+ if (total_bytes > ZEND_INT_MAX) {
#ifdef PHP_WIN32
if (_i64toa_s(total_bytes, file_size_buf, 65, 10)) {
file_size_buf[0] = '0';
size_overflow = 1;
} else {
- ZVAL_LONG(&file_size, total_bytes);
+ ZVAL_INT(&file_size, total_bytes);
}
}
typedef struct _multipart_event_file_data {
size_t post_bytes_processed;
- off_t offset;
+ zend_off_t offset;
char *data;
size_t length;
size_t *newlength;
*/
/* char * ap_php_conv_10() {{{ */
char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned,
- register bool_int * is_negative, char *buf_end, register int *len)
+ register bool_int * is_negative, char *buf_end, register php_size_t *len)
{
register char *p = buf_end;
register u_wide_int magnitude;
*/
/* PHPAPI char * php_conv_fp() {{{ */
PHPAPI char * php_conv_fp(register char format, register double num,
- boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, int *len)
+ boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, php_size_t *len)
{
register char *s = buf;
register char *p, *p_orig;
if (format != 'F') {
char temp[EXPONENT_LENGTH]; /* for exponent conversion */
- int t_len;
+ php_size_t t_len;
bool_int exponent_is_negative;
*s++ = format; /* either e or E */
* which is a pointer to the END of the buffer + 1 (i.e. if the buffer
* is declared as buf[ 100 ], buf_end should be &buf[ 100 ])
*/
-char * ap_php_conv_p2(register u_wide_int num, register int nbits, char format, char *buf_end, register int *len) /* {{{ */
+char * ap_php_conv_p2(register u_wide_int num, register int nbits, char format, char *buf_end, register php_size_t *len) /* {{{ */
{
register int mask = (1 << nbits) - 1;
register char *p = buf_end;
char *sp;
char *bep;
int cc = 0;
- int i;
+ php_size_t i;
char *s = NULL;
- int s_len, free_zcopy;
+ php_size_t s_len;
+ int free_zcopy;
zval *zvp, zcopy;
int min_width = 0;
modifier = LM_SIZE_T;
#endif
break;
+ case 'p':
+ fmt++;
+ modifier = LM_PHP_INT_T;
+ break;
case 'h':
fmt++;
if (*fmt == 'h') {
if (free_zcopy) {
zvp = &zcopy;
}
- s_len = Z_STRLEN_P(zvp);
+ s_len = Z_STRSIZE_P(zvp);
s = Z_STRVAL_P(zvp);
if (adjust_precision && precision < s_len) {
s_len = precision;
i_num = (wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ i_num = (wide_int) va_arg(ap, php_uint_t);
+ break;
}
/*
* The rest also applies to other integer formats, so fall
i_num = (wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ i_num = (wide_int) va_arg(ap, php_int_t);
+ break;
}
}
s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative,
ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ ui_num = (u_wide_int) va_arg(ap, php_uint_t);
+ break;
}
s = ap_php_conv_p2(ui_num, 3, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
FIX_PRECISION(adjust_precision, precision, s, s_len);
ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ ui_num = (u_wide_int) va_arg(ap, php_uint_t);
+ break;
}
s = ap_php_conv_p2(ui_num, 4, *fmt, &num_buf[NUM_BUF_SIZE], &s_len);
FIX_PRECISION(adjust_precision, precision, s, s_len);
PHPAPI int php_sprintf (char* s, const char* format, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
PHPAPI char * php_gcvt(double value, int ndigit, char dec_point, char exponent, char *buf);
PHPAPI char * php_conv_fp(register char format, register double num,
- boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, int *len);
+ boolean_e add_dp, int precision, char dec_point, bool_int * is_negative, char *buf, php_size_t *len);
END_EXTERN_C()
#endif
LM_SIZE_T,
LM_LONG,
- LM_LONG_DOUBLE
+ LM_LONG_DOUBLE,
+ LM_PHP_INT_T
} length_modifier_e;
#ifdef PHP_WIN32
typedef unsigned WIDE_INT u_wide_int;
extern char * ap_php_conv_10(register wide_int num, register bool_int is_unsigned,
- register bool_int * is_negative, char *buf_end, register int *len);
+ register bool_int * is_negative, char *buf_end, register php_size_t *len);
extern char * ap_php_conv_p2(register u_wide_int num, register int nbits,
- char format, char *buf_end, register int *len);
+ char format, char *buf_end, register php_size_t *len);
/* The maximum precision that's allowed for float conversion. Does not include
* decimal separator, exponent, sign, terminator. Currently does not affect
static void xbuf_format_converter(void *xbuf, zend_bool is_char, const char *fmt, va_list ap) /* {{{ */
{
char *s = NULL;
- int s_len, free_zcopy;
+ php_size_t s_len;
+ int free_zcopy;
zval *zvp, zcopy;
int min_width = 0;
modifier = LM_SIZE_T;
#endif
break;
+ case 'p': {
+ char __next = *(fmt+1);
+ if ('d' == __next || 'u' == __next || 'x' == __next || 'o' == __next) {
+ fmt++;
+ modifier = LM_PHP_INT_T;
+ } else {
+ modifier = LM_STD;
+ }
+ }
+ break;
case 'h':
fmt++;
if (*fmt == 'h') {
if (free_zcopy) {
zvp = &zcopy;
}
- s_len = Z_STRLEN_P(zvp);
+ s_len = Z_STRSIZE_P(zvp);
s = Z_STRVAL_P(zvp);
if (adjust_precision && precision < s_len) {
s_len = precision;
i_num = (wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ i_num = (wide_int) va_arg(ap, php_uint_t);
+ break;
}
/*
* The rest also applies to other integer formats, so fall
i_num = (wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ i_num = (wide_int) va_arg(ap, php_int_t);
+ break;
}
}
s = ap_php_conv_10(i_num, (*fmt) == 'u', &is_negative,
ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ ui_num = (u_wide_int) va_arg(ap, php_uint_t);
+ break;
}
s = ap_php_conv_p2(ui_num, 3, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
ui_num = (u_wide_int) va_arg(ap, ptrdiff_t);
break;
#endif
+ case LM_PHP_INT_T:
+ ui_num = (u_wide_int) va_arg(ap, php_uint_t);
+ break;
}
s = ap_php_conv_p2(ui_num, 4, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
/*
* This is the general purpose conversion function.
*/
-PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */
+PHPAPI php_size_t vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */
{
smart_string buf = {0};
- int result;
+ php_size_t result;
xbuf_format_converter(&buf, 1, format, ap);
}
/* }}} */
-PHPAPI int spprintf(char **pbuf, size_t max_len, const char *format, ...) /* {{{ */
+PHPAPI php_size_t spprintf(char **pbuf, size_t max_len, const char *format, ...) /* {{{ */
{
- int cc;
+ php_size_t cc;
va_list ap;
va_start(ap, format);
#include "snprintf.h"
BEGIN_EXTERN_C()
-PHPAPI int spprintf( char **pbuf, size_t max_len, const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
+PHPAPI php_size_t spprintf( char **pbuf, size_t max_len, const char *format, ...) PHP_ATTRIBUTE_FORMAT(printf, 3, 4);
-PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) PHP_ATTRIBUTE_FORMAT(printf, 3, 0);
+PHPAPI php_size_t vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) PHP_ATTRIBUTE_FORMAT(printf, 3, 0);
PHPAPI zend_string *vstrpprintf(size_t max_len, const char *format, va_list ap);
return php_stream_write((php_stream *)cookie, (char *)buffer, size);
}
-static PHP_FPOS_T stream_cookie_seeker(void *cookie, off_t position, int whence)
+static PHP_FPOS_T stream_cookie_seeker(void *cookie, zend_off_t position, int whence)
{
TSRMLS_FETCH();
{
TSRMLS_FETCH();
- *position = php_stream_seek((php_stream *)cookie, (off_t)*position, whence);
+ *position = php_stream_seek((php_stream *)cookie, (zend_off_t)*position, whence);
if (*position == -1) {
return -1;
return 0;
}
# else
-static int stream_cookie_seeker(void *cookie, off_t position, int whence)
+static int stream_cookie_seeker(void *cookie, zend_off_t position, int whence)
{
TSRMLS_FETCH();
if (ret && castas != PHP_STREAM_AS_FD_FOR_SELECT) {
php_stream_flush(stream);
if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
- off_t dummy;
+ zend_off_t dummy;
stream->ops->seek(stream, stream->position, SEEK_SET, &dummy TSRMLS_CC);
stream->readpos = stream->writepos = 0;
}
if (*ret != NULL) {
- off_t pos;
+ zend_off_t pos;
stream->fclose_stdiocast = PHP_STREAM_FCLOSE_FOPENCOOKIE;
* the stdio layer to believe it's real location. */
pos = php_stream_tell(stream);
if (pos > 0) {
- fseek(*ret, pos, SEEK_SET);
+ zend_fseek(*ret, pos, SEEK_SET);
}
goto exit_success;
* will be accessing the stream. Emit a warning so that the end-user will
* know that they should try something else */
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld bytes of buffered data lost during stream conversion!", (long)(stream->writepos - stream->readpos));
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, ZEND_INT_FMT " bytes of buffered data lost during stream conversion!", (php_int_t)(stream->writepos - stream->readpos));
}
if (castas == PHP_STREAM_AS_STDIO && ret) {
}
/* {{{ */
-static int php_glob_stream_rewind(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC) /* {{{ */
+static int php_glob_stream_rewind(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC) /* {{{ */
{
glob_s_t *pglob = (glob_s_t *)stream->abstract;
/* {{{ */
-static int php_stream_memory_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
+static int php_stream_memory_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC)
{
php_stream_memory_data *ms = (php_stream_memory_data*)stream->abstract;
assert(ms != NULL);
/* {{{ */
-static int php_stream_temp_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
+static int php_stream_temp_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC)
{
php_stream_temp_data *ts = (php_stream_temp_data*)stream->abstract;
int ret;
php_stream *file;
size_t memsize;
char *membuf;
- off_t pos;
+ zend_off_t pos;
assert(ts != NULL);
{
php_stream *stream;
php_stream_temp_data *ts;
- off_t newoffs;
+ zend_off_t newoffs;
if ((stream = php_stream_temp_create_rel(mode, max_memory_usage)) != NULL) {
if (length) {
php_stream_temp_data *ts;
char *comma, *semi, *sep, *key;
size_t mlen, dlen, plen, vlen;
- off_t newoffs;
+ zend_off_t newoffs;
zval meta;
int base64 = 0, ilen;
zend_string *base64_comma = NULL;
return php_stream_set_option(stream, PHP_STREAM_OPTION_MMAP_API, PHP_STREAM_MMAP_UNMAP, NULL) == PHP_STREAM_OPTION_RETURN_OK ? 1 : 0;
}
-PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, off_t readden TSRMLS_DC)
+PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, zend_off_t readden TSRMLS_DC)
{
int ret = 1;
PHPAPI int _php_stream_mmap_unmap(php_stream *stream TSRMLS_DC);
#define php_stream_mmap_unmap(stream) _php_stream_mmap_unmap((stream) TSRMLS_CC)
-PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, off_t readden TSRMLS_DC);
+PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, zend_off_t readden TSRMLS_DC);
#define php_stream_mmap_unmap_ex(stream, readden) _php_stream_mmap_unmap_ex((stream), (readden) TSRMLS_CC)
END_EXTERN_C()
extern int php_get_gid_by_name(const char *name, gid_t *gid TSRMLS_DC);
#endif
+#if defined(PHP_WIN32)
+# define PLAIN_WRAP_BUF_SIZE(st) (((st) > UINT_MAX) ? UINT_MAX : (unsigned int)(st))
+#else
+# define PLAIN_WRAP_BUF_SIZE(st) (st)
+#endif
+
/* parse standard "fopen" modes into open() flags */
PHPAPI int php_stream_parse_fopen_modes(const char *mode, int *open_flags)
{
HANDLE file_mapping;
#endif
- struct stat sb;
+ php_stat_t sb;
} php_stdio_stream_data;
#define PHP_STDIOP_GET_FD(anfd, data) anfd = (data)->file ? fileno((data)->file) : (data)->fd
int r;
PHP_STDIOP_GET_FD(fd, d);
- r = fstat(fd, &d->sb);
+ r = php_fstat(fd, &d->sb);
d->cached_fstat = r == 0;
return r;
if (self->is_pipe) {
stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
} else {
- stream->position = lseek(self->fd, 0, SEEK_CUR);
+ stream->position = zend_lseek(self->fd, 0, SEEK_CUR);
#ifdef ESPIPE
- if (stream->position == (off_t)-1 && errno == ESPIPE) {
+ if (stream->position == (zend_off_t)-1 && errno == ESPIPE) {
stream->position = 0;
stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
self->is_pipe = 1;
if (self->is_pipe) {
stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
} else {
- stream->position = ftell(file);
+ stream->position = zend_ftell(file);
}
}
assert(data != NULL);
if (data->fd >= 0) {
- ret = read(data->fd, buf, count);
+ ret = read(data->fd, buf, PLAIN_WRAP_BUF_SIZE(count));
if (ret == (size_t)-1 && errno == EINTR) {
/* Read was interrupted, retry once,
If read still fails, giveup with feof==0
so script can retry if desired */
- ret = read(data->fd, buf, count);
+ ret = read(data->fd, buf, PLAIN_WRAP_BUF_SIZE(count));
}
stream->eof = (ret == 0 || (ret == (size_t)-1 && errno != EWOULDBLOCK && errno != EINTR && errno != EBADF));
} else {
#if HAVE_FLUSHIO
if (!data->is_pipe && data->last_op == 'w')
- fseek(data->file, 0, SEEK_CUR);
+ zend_fseek(data->file, 0, SEEK_CUR);
data->last_op = 'r';
#endif
return 0;
}
-static int php_stdiop_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC)
+static int php_stdiop_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset TSRMLS_DC)
{
php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
int ret;
}
if (data->fd >= 0) {
- off_t result;
+ zend_off_t result;
- result = lseek(data->fd, offset, whence);
- if (result == (off_t)-1)
+ result = zend_lseek(data->fd, offset, whence);
+ if (result == (zend_off_t)-1)
return -1;
*newoffset = result;
return 0;
} else {
- ret = fseek(data->file, offset, whence);
- *newoffset = ftell(data->file);
+ ret = zend_fseek(data->file, offset, whence);
+ *newoffset = zend_ftell(data->file);
return ret;
}
}
return closedir((DIR *)stream->abstract);
}
-static int php_plain_files_dirstream_rewind(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
+static int php_plain_files_dirstream_rewind(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC)
{
rewinddir((DIR *)stream->abstract);
return 0;
#ifndef PHP_WIN32
# ifdef EXDEV
if (errno == EXDEV) {
- struct stat sb;
+ php_stat_t sb;
if (php_copy_file(url_from, url_to TSRMLS_CC) == SUCCESS) {
if (VCWD_STAT(url_from, &sb) == 0) {
# if !defined(TSRM_WIN32) && !defined(NETWARE)
} else {
/* we look for directory separator from the end of string, thus hopefuly reducing our work load */
char *e;
- struct stat sb;
+ php_stat_t sb;
int dir_len = strlen(dir);
int offset = 0;
char buf[MAXPATHLEN];
} else {
/* is there enough data in the buffer ? */
- if (stream->writepos - stream->readpos < (off_t)size) {
+ if (stream->writepos - stream->readpos < (zend_off_t)size) {
size_t justread = 0;
/* reduce buffer memory consumption if possible, to avoid a realloc */
return count;
}
-PHPAPI off_t _php_stream_tell(php_stream *stream TSRMLS_DC)
+PHPAPI zend_off_t _php_stream_tell(php_stream *stream TSRMLS_DC)
{
return stream->position;
}
-PHPAPI int _php_stream_seek(php_stream *stream, off_t offset, int whence TSRMLS_DC)
+PHPAPI int _php_stream_seek(php_stream *stream, zend_off_t offset, int whence TSRMLS_DC)
{
if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
/* flush to commit data written to the fopencookie FILE* */
}
if (stream && stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && strchr(mode, 'a') && stream->position == 0) {
- off_t newpos = 0;
+ zend_off_t newpos = 0;
/* if opened for append, we need to revise our idea of the initial file position */
if (0 == stream->ops->seek(stream, 0, SEEK_CUR, &newpos TSRMLS_CC)) {
if (PHP_STREAM_CONTEXT(stream) && (zbacklog = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), "socket", "backlog")) != NULL) {
zval *ztmp = zbacklog;
- convert_to_long_ex(ztmp);
- backlog = Z_LVAL_P(ztmp);
+ convert_to_int_ex(ztmp);
+ backlog = Z_IVAL_P(ztmp);
if (ztmp != zbacklog) {
zval_ptr_dtor(ztmp);
}
if (le_protocols == FAILURE)
return FAILURE;
- REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS|CONST_PERSISTENT);
-
- REGISTER_LONG_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_CS|CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_CS|CONST_PERSISTENT);
+
+ REGISTER_INT_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_CS|CONST_PERSISTENT);
+ REGISTER_INT_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_CS|CONST_PERSISTENT);
return SUCCESS;
}
/* call it's stream_open method - set up params first */
ZVAL_STRING(&args[0], filename);
ZVAL_STRING(&args[1], mode);
- ZVAL_LONG(&args[2], options);
+ ZVAL_INT(&args[2], options);
ZVAL_NEW_REF(&args[3], &EG(uninitialized_zval));
ZVAL_STRING(&zfuncname, USERSTREAM_OPEN);
/* if the opened path is set, copy it out */
if (Z_ISREF(args[3]) && Z_TYPE_P(Z_REFVAL(args[3])) == IS_STRING && opened_path) {
- *opened_path = estrndup(Z_STRVAL_P(Z_REFVAL(args[3])), Z_STRLEN_P(Z_REFVAL(args[3])));
+ *opened_path = estrndup(Z_STRVAL_P(Z_REFVAL(args[3])), Z_STRSIZE_P(Z_REFVAL(args[3])));
}
/* set wrapper data to be a reference to our object */
/* call it's dir_open method - set up params first */
ZVAL_STRING(&args[0], filename);
- ZVAL_LONG(&args[1], options);
+ ZVAL_INT(&args[1], options);
ZVAL_STRING(&zfuncname, USERSTREAM_DIR_OPEN);
zend_string *protocol, *classname;
struct php_user_stream_wrapper * uwrap;
zend_resource *rsrc;
- long flags = 0;
+ php_int_t flags = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &protocol, &classname, &flags) == FAILURE) {
RETURN_FALSE;
didwrite = 0;
if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
- convert_to_long(&retval);
- didwrite = Z_LVAL(retval);
+ convert_to_int(&retval);
+ didwrite = Z_IVAL(retval);
} else if (call_result == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!",
us->wrapper->classname);
/* don't allow strange buffer overruns due to bogus return */
if (didwrite > count) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote %ld bytes more data than requested (%ld written, %ld max)",
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " wrote " ZEND_INT_FMT " bytes more data than requested (" ZEND_INT_FMT " written, " ZEND_INT_FMT " max)",
us->wrapper->classname,
- (long)(didwrite - count), (long)didwrite, (long)count);
+ (php_int_t)(didwrite - count), (php_int_t)didwrite, (php_int_t)count);
didwrite = count;
}
ZVAL_STRINGL(&func_name, USERSTREAM_READ, sizeof(USERSTREAM_READ)-1);
- ZVAL_LONG(&args[0], count);
+ ZVAL_INT(&args[0], count);
call_result = call_user_function_ex(NULL,
Z_ISUNDEF(us->object)? NULL : &us->object,
if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
convert_to_string(&retval);
- didread = Z_STRLEN(retval);
+ didread = Z_STRSIZE(retval);
if (didread > count) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read %ld bytes more data than requested (%ld read, %ld max) - excess data will be lost",
- us->wrapper->classname, (long)(didread - count), (long)didread, (long)count);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read " ZEND_INT_FMT " bytes more data than requested (" ZEND_INT_FMT " read, " ZEND_INT_FMT " max) - excess data will be lost",
+ us->wrapper->classname, (php_int_t)(didread - count), (php_int_t)didread, (php_int_t)count);
didread = count;
}
if (didread > 0)
ZVAL_STRINGL(&func_name, USERSTREAM_SEEK, sizeof(USERSTREAM_SEEK)-1);
- ZVAL_LONG(&args[0], offset);
- ZVAL_LONG(&args[1], whence);
+ ZVAL_INT(&args[0], offset);
+ ZVAL_INT(&args[1], whence);
call_result = call_user_function_ex(NULL,
Z_ISUNDEF(us->object)? NULL : &us->object,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
- if (call_result == SUCCESS && Z_TYPE(retval) == IS_LONG) {
- *newoffs = Z_LVAL(retval);
+ if (call_result == SUCCESS && Z_TYPE(retval) == IS_INT) {
+ *newoffs = Z_IVAL(retval);
ret = 0;
} else if (call_result == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", us->wrapper->classname);
#define STAT_PROP_ENTRY_EX(name, name2) \
if (NULL != (elem = zend_hash_str_find(Z_ARRVAL_P(array), #name, sizeof(#name)-1))) { \
SEPARATE_ZVAL(elem); \
- convert_to_long(elem); \
- ssb->sb.st_##name2 = Z_LVAL_P(elem); \
+ convert_to_int(elem); \
+ ssb->sb.st_##name2 = Z_IVAL_P(elem); \
}
#define STAT_PROP_ENTRY(name) STAT_PROP_ENTRY_EX(name,name)
break;
case PHP_STREAM_OPTION_LOCKING:
- ZVAL_LONG(&args[0], 0);
+ ZVAL_INT(&args[0], 0);
if (value & LOCK_NB) {
- Z_LVAL_P(&args[0]) |= PHP_LOCK_NB;
+ Z_IVAL_P(&args[0]) |= PHP_LOCK_NB;
}
switch(value & ~LOCK_NB) {
case LOCK_SH:
- Z_LVAL_P(&args[0]) |= PHP_LOCK_SH;
+ Z_IVAL_P(&args[0]) |= PHP_LOCK_SH;
break;
case LOCK_EX:
- Z_LVAL_P(&args[0]) |= PHP_LOCK_EX;
+ Z_IVAL_P(&args[0]) |= PHP_LOCK_EX;
break;
case LOCK_UN:
- Z_LVAL_P(&args[0]) |= PHP_LOCK_UN;
+ Z_IVAL_P(&args[0]) |= PHP_LOCK_UN;
break;
}
case PHP_STREAM_TRUNCATE_SET_SIZE: {
ptrdiff_t new_size = *(ptrdiff_t*) ptrparam;
if (new_size >= 0 && new_size <= (ptrdiff_t)LONG_MAX) {
- ZVAL_LONG(&args[0], (long)new_size);
+ ZVAL_INT(&args[0], (long)new_size);
call_result = call_user_function_ex(NULL,
Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1);
- ZVAL_LONG(&args[0], option);
+ ZVAL_INT(&args[0], option);
ZVAL_NULL(&args[1]);
ZVAL_NULL(&args[2]);
switch(option) {
case PHP_STREAM_OPTION_READ_BUFFER:
case PHP_STREAM_OPTION_WRITE_BUFFER:
- ZVAL_LONG(&args[1], value);
+ ZVAL_INT(&args[1], value);
if (ptrparam) {
- ZVAL_LONG(&args[2], *(long *)ptrparam);
+ ZVAL_INT(&args[2], *(long *)ptrparam);
} else {
- ZVAL_LONG(&args[2], BUFSIZ);
+ ZVAL_INT(&args[2], BUFSIZ);
}
break;
case PHP_STREAM_OPTION_READ_TIMEOUT: {
struct timeval tv = *(struct timeval*)ptrparam;
- ZVAL_LONG(&args[1], tv.tv_sec);
- ZVAL_LONG(&args[2], tv.tv_usec);
+ ZVAL_INT(&args[1], tv.tv_sec);
+ ZVAL_INT(&args[2], tv.tv_usec);
break;
}
case PHP_STREAM_OPTION_BLOCKING:
- ZVAL_LONG(&args[1], value);
+ ZVAL_INT(&args[1], value);
break;
default:
break;
/* call the mkdir method */
ZVAL_STRING(&args[0], url);
- ZVAL_LONG(&args[1], mode);
- ZVAL_LONG(&args[2], options);
+ ZVAL_INT(&args[1], mode);
+ ZVAL_INT(&args[2], options);
ZVAL_STRING(&zfuncname, USERSTREAM_MKDIR);
/* call the rmdir method */
ZVAL_STRING(&args[0], url);
- ZVAL_LONG(&args[1], options);
+ ZVAL_INT(&args[1], options);
ZVAL_STRING(&zfuncname, USERSTREAM_RMDIR);
array_init(&args[2]);
if(value) {
struct utimbuf *newtime = (struct utimbuf *)value;
- add_index_long(&args[2], 0, newtime->modtime);
- add_index_long(&args[2], 1, newtime->actime);
+ add_index_int(&args[2], 0, newtime->modtime);
+ add_index_int(&args[2], 1, newtime->actime);
}
break;
case PHP_STREAM_META_GROUP:
case PHP_STREAM_META_OWNER:
case PHP_STREAM_META_ACCESS:
- ZVAL_LONG(&args[2], *(long *)value);
+ ZVAL_INT(&args[2], *(long *)value);
break;
case PHP_STREAM_META_GROUP_NAME:
case PHP_STREAM_META_OWNER_NAME:
/* call the mkdir method */
ZVAL_STRING(&args[0], url);
- ZVAL_LONG(&args[1], option);
+ ZVAL_INT(&args[1], option);
ZVAL_STRING(&zfuncname, USERSTREAM_METADATA);
/* call it's stat_url method - set up params first */
ZVAL_STRING(&args[0], url);
- ZVAL_LONG(&args[1], flags);
+ ZVAL_INT(&args[1], flags);
ZVAL_STRING(&zfuncname, USERSTREAM_STATURL);
if (call_result == SUCCESS && Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) {
convert_to_string(&retval);
- PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRLEN(retval));
+ PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRSIZE(retval));
didread = sizeof(php_stream_dirent);
} else if (call_result == FAILURE) {
switch(castas) {
case PHP_STREAM_AS_FD_FOR_SELECT:
- ZVAL_LONG(&args[0], PHP_STREAM_AS_FD_FOR_SELECT);
+ ZVAL_INT(&args[0], PHP_STREAM_AS_FD_FOR_SELECT);
break;
default:
- ZVAL_LONG(&args[0], PHP_STREAM_AS_STDIO);
+ ZVAL_INT(&args[0], PHP_STREAM_AS_STDIO);
break;
}
# define MSG_PEEK 0
#endif
+#ifdef PHP_WIN32
+/* send/recv family on windows expects int */
+# define XP_SOCK_BUF_SIZE(sz) (((sz) > INT_MAX) ? INT_MAX : (int)(sz))
+#else
+# define XP_SOCK_BUF_SIZE(sz) (sz)
+#endif
+
php_stream_ops php_stream_generic_socket_ops;
PHPAPI php_stream_ops php_stream_socket_ops;
php_stream_ops php_stream_udp_socket_ops;
ptimeout = &sock->timeout;
retry:
- didwrite = send(sock->socket, buf, count, (sock->is_blocked && ptimeout) ? MSG_DONTWAIT : 0);
+ didwrite = send(sock->socket, buf, XP_SOCK_BUF_SIZE(count), (sock->is_blocked && ptimeout) ? MSG_DONTWAIT : 0);
if (didwrite <= 0) {
long err = php_socket_errno();
} while (err == EINTR);
}
estr = php_socket_strerror(err, NULL, 0);
- php_error_docref(NULL TSRMLS_CC, E_NOTICE, "send of %ld bytes failed with errno=%ld %s",
- (long)count, err, estr);
+ php_error_docref(NULL TSRMLS_CC, E_NOTICE, "send of " ZEND_INT_FMT " bytes failed with errno=%ld %s",
+ (php_int_t)count, err, estr);
efree(estr);
}
static size_t php_sockop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
{
php_netstream_data_t *sock = (php_netstream_data_t*)stream->abstract;
- int nr_bytes = 0;
+ ssize_t nr_bytes = 0;
if (!sock || sock->socket == -1) {
return 0;
return 0;
}
- nr_bytes = recv(sock->socket, buf, count, (sock->is_blocked && sock->timeout.tv_sec != -1) ? MSG_DONTWAIT : 0);
+ nr_bytes = recv(sock->socket, buf, XP_SOCK_BUF_SIZE(count), (sock->is_blocked && sock->timeout.tv_sec != -1) ? MSG_DONTWAIT : 0);
stream->eof = (nr_bytes == 0 || (nr_bytes == -1 && php_socket_errno() != EWOULDBLOCK));
#if ZEND_WIN32
return 0;
#else
- return fstat(sock->socket, &ssb->sb);
+ return php_fstat(sock->socket, &ssb->sb);
#endif
}
{
int ret;
if (addr) {
- ret = sendto(sock->socket, buf, buflen, flags, addr, addrlen);
+ ret = sendto(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, addr, XP_SOCK_BUF_SIZE(addrlen));
+
return (ret == SOCK_CONN_ERR) ? -1 : ret;
}
return ((ret = send(sock->socket, buf, buflen, flags)) == SOCK_CONN_ERR) ? -1 : ret;
int want_addr = textaddr || addr;
if (want_addr) {
- ret = recvfrom(sock->socket, buf, buflen, flags, (struct sockaddr*)&sa, &sl);
+ ret = recvfrom(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, (struct sockaddr*)&sa, &sl);
ret = (ret == SOCK_CONN_ERR) ? -1 : ret;
php_network_populate_name_from_sockaddr((struct sockaddr*)&sa, sl,
textaddr, addr, addrlen TSRMLS_CC);
} else {
- ret = recv(sock->socket, buf, buflen, flags);
+ ret = recv(sock->socket, buf, XP_SOCK_BUF_SIZE(buflen), flags);
ret = (ret == SOCK_CONN_ERR) ? -1 : ret;
}
efree(host);
return -1;
}
- bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC);
+ bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRSIZE_P(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC);
}
#ifdef SO_BROADCAST
static int compare(const void *, const void *);
static int g_Ctoc(const Char *, char *, u_int);
-static int g_lstat(Char *, struct stat *, glob_t *);
+static int g_lstat(Char *, php_stat_t *, glob_t *);
static DIR *g_opendir(Char *, glob_t *);
static Char *g_strchr(Char *, int);
-static int g_stat(Char *, struct stat *, glob_t *);
+static int g_stat(Char *, php_stat_t *, glob_t *);
static int glob0(const Char *, glob_t *);
static int glob1(Char *, Char *, glob_t *, size_t *);
static int glob2(Char *, Char *, Char *, Char *, Char *, Char *,
glob_t *pglob;
size_t *limitp;
{
- struct stat sb;
+ php_stat_t sb;
Char *p, *q;
int anymeta;
static int
g_lstat(fn, sb, pglob)
register Char *fn;
- struct stat *sb;
+ php_stat_t *sb;
glob_t *pglob;
{
char buf[MAXPATHLEN];
static int
g_stat(fn, sb, pglob)
register Char *fn;
- struct stat *sb;
+ php_stat_t *sb;
glob_t *pglob;
{
char buf[MAXPATHLEN];
# include <sys/cdefs.h>
#endif
-struct stat;
+php_stat_t;
typedef struct {
int gl_pathc; /* Count of total paths so far. */
int gl_matchc; /* Count of paths matching pattern. */
void (*gl_closedir)(void *);
struct dirent *(*gl_readdir)(void *);
void *(*gl_opendir)(const char *);
- int (*gl_lstat)(const char *, struct stat *);
- int (*gl_stat)(const char *, struct stat *);
+ int (*gl_lstat)(const char *, php_stat_t *);
+ int (*gl_stat)(const char *, php_stat_t *);
} glob_t;
/* Flags */
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
// 7.18.2.1 Limits of exact-width integer types
+#if _MSC_VER >= 1700 && !defined(_INTSAFE_H_INCLUDED_)
#define INT8_MIN ((int8_t)_I8_MIN)
#define INT8_MAX _I8_MAX
#define INT16_MIN ((int16_t)_I16_MIN)
#define UINT16_MAX _UI16_MAX
#define UINT32_MAX _UI32_MAX
#define UINT64_MAX _UI64_MAX
+#endif
// 7.18.2.2 Limits of minimum-width integer types
#define INT_LEAST8_MIN INT8_MIN
if (pht != NULL) {
HashTable *ht = pht;
zend_string *index;
- ulong num;
+ php_uint_t num;
zval *data;
ZEND_HASH_FOREACH_KEY_VAL(ht, num, index, data) {
- zend_alter_ini_entry(index, Z_STRVAL_P(data), Z_STRLEN_P(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
+ zend_alter_ini_entry(index, Z_STRVAL_P(data), Z_STRSIZE_P(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
} ZEND_HASH_FOREACH_END();
/*
for (zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_get_current_data_ex(ht, (void**)&data, &pos) == SUCCESS &&
zend_hash_get_current_key_ex(ht, &index, &index_len, &num, 0, &pos) == HASH_KEY_IS_STRING;
zend_hash_move_forward_ex(ht, &pos)) {
- zend_alter_ini_entry(index, index_len, Z_STRVAL_PP(data), Z_STRLEN_PP(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
+ zend_alter_ini_entry(index, index_len, Z_STRVAL_PP(data), Z_STRSIZE_PP(data), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
}
break;
*/
}
}
+PHPAPI zend_string *php_str_to_str(char *haystack, int length, char *needle,
+ int needle_len, char *str, int str_len);
+
/*********************************************************************
// Name: SendText
#include "php.h"
#include <wincrypt.h>
-PHPAPI char *php_win32_error_to_msg(int error)
+PHPAPI char *php_win32_error_to_msg(HRESULT error)
{
char *buf = NULL;
+----------------------------------------------------------------------+
*/
-PHPAPI char *php_win32_error_to_msg(int error);
+PHPAPI char *php_win32_error_to_msg(HRESULT error);
#define php_win_err() php_win32_error_to_msg(GetLastError())
int php_win32_check_trailing_space(const char * path, const int path_len);
projects / php / commitdiff