diff options
Diffstat (limited to 'ext/intl/timezone')
| -rw-r--r-- | ext/intl/timezone/timezone_class.cpp | 236 | ||||
| -rw-r--r-- | ext/intl/timezone/timezone_class.h | 23 | ||||
| -rw-r--r-- | ext/intl/timezone/timezone_methods.cpp | 310 | ||||
| -rw-r--r-- | ext/intl/timezone/timezone_methods.h | 2 |
4 files changed, 281 insertions, 290 deletions
diff --git a/ext/intl/timezone/timezone_class.cpp b/ext/intl/timezone/timezone_class.cpp index 374b163851..d1e8e2e0a6 100644 --- a/ext/intl/timezone/timezone_class.cpp +++ b/ext/intl/timezone/timezone_class.cpp @@ -1,6 +1,6 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | @@ -45,7 +45,7 @@ U_CDECL_END /* }}} */ /* {{{ timezone_object_construct */ -U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int owned TSRMLS_DC) +U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int owned) { TimeZone_object *to; @@ -60,25 +60,23 @@ U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int o * Convert from TimeZone to DateTimeZone object */ U_CFUNC zval *timezone_convert_to_datetimezone(const TimeZone *timeZone, intl_error *outside_error, - const char *func TSRMLS_DC) + const char *func, zval *ret) { - zval *ret = NULL; UnicodeString id; char *message = NULL; php_timezone_obj *tzobj; - zval arg = zval_used_for_init; + zval arg; timeZone->getID(id); if (id.isBogus()) { spprintf(&message, 0, "%s: could not obtain TimeZone id", func); intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, - message, 1 TSRMLS_CC); + message, 1); goto error; } - MAKE_STD_ZVAL(ret); object_init_ex(ret, php_date_get_timezone_ce()); - tzobj = (php_timezone_obj *)zend_objects_get_address(ret TSRMLS_CC); + tzobj = Z_PHPTIMEZONE_P(ret); if (id.compare(0, 3, UnicodeString("GMT", sizeof("GMT")-1, US_INV)) == 0) { /* The DateTimeZone constructor doesn't support offset time zones, @@ -88,31 +86,33 @@ U_CFUNC zval *timezone_convert_to_datetimezone(const TimeZone *timeZone, //convert offset from milliseconds to minutes tzobj->tzi.utc_offset = -1 * timeZone->getRawOffset() / (60 * 1000); } else { + zend_string *u8str; /* Call the constructor! */ - Z_TYPE(arg) = IS_STRING; - if (intl_charFromString(id, &Z_STRVAL(arg), &Z_STRLEN(arg), - &INTL_ERROR_CODE(*outside_error)) == FAILURE) { + u8str = intl_charFromString(id, &INTL_ERROR_CODE(*outside_error)); + if (!u8str) { spprintf(&message, 0, "%s: could not convert id to UTF-8", func); intl_errors_set(outside_error, INTL_ERROR_CODE(*outside_error), - message, 1 TSRMLS_CC); + message, 1); goto error; } - zend_call_method_with_1_params(&ret, NULL, NULL, "__construct", - NULL, &arg); + ZVAL_STR(&arg, u8str); + zend_call_method_with_1_params(ret, NULL, NULL, "__construct", NULL, &arg); if (EG(exception)) { spprintf(&message, 0, "%s: DateTimeZone constructor threw exception", func); intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, - message, 1 TSRMLS_CC); - zend_object_store_ctor_failed(ret TSRMLS_CC); + message, 1); + zend_object_store_ctor_failed(Z_OBJ_P(ret)); + zval_ptr_dtor(&arg); goto error; } + zval_ptr_dtor(&arg); } if (0) { error: if (ret) { - zval_ptr_dtor(&ret); + zval_ptr_dtor(ret); } ret = NULL; } @@ -120,117 +120,119 @@ error: if (message) { efree(message); } - if (Z_TYPE(arg) == IS_STRING) { - zval_dtor(&arg); - } return ret; } /* }}} */ /* {{{ timezone_process_timezone_argument * TimeZone argument processor. outside_error may be NULL (for static functions/constructors) */ -U_CFUNC TimeZone *timezone_process_timezone_argument(zval **zv_timezone, +U_CFUNC TimeZone *timezone_process_timezone_argument(zval *zv_timezone, intl_error *outside_error, - const char *func TSRMLS_DC) + const char *func) { - zval local_zv_tz = zval_used_for_init, - *local_zv_tz_p = &local_zv_tz; + zval local_zv_tz; char *message = NULL; TimeZone *timeZone; - if (zv_timezone == NULL || Z_TYPE_PP(zv_timezone) == IS_NULL) { - timelib_tzinfo *tzinfo = get_timezone_info(TSRMLS_C); - ZVAL_STRING(&local_zv_tz, tzinfo->name, 0); - zv_timezone = &local_zv_tz_p; + if (zv_timezone == NULL || Z_TYPE_P(zv_timezone) == IS_NULL) { + timelib_tzinfo *tzinfo = get_timezone_info(); + ZVAL_STRING(&local_zv_tz, tzinfo->name); + zv_timezone = &local_zv_tz; + } else { + ZVAL_NULL(&local_zv_tz); } - if (Z_TYPE_PP(zv_timezone) == IS_OBJECT && - instanceof_function(Z_OBJCE_PP(zv_timezone), TimeZone_ce_ptr TSRMLS_CC)) { - TimeZone_object *to = (TimeZone_object*)zend_objects_get_address( - *zv_timezone TSRMLS_CC); + if (Z_TYPE_P(zv_timezone) == IS_OBJECT && + instanceof_function(Z_OBJCE_P(zv_timezone), TimeZone_ce_ptr)) { + TimeZone_object *to = Z_INTL_TIMEZONE_P(zv_timezone); if (to->utimezone == NULL) { spprintf(&message, 0, "%s: passed IntlTimeZone is not " "properly constructed", func); if (message) { - intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1 TSRMLS_CC); + intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1); efree(message); } + zval_dtor(&local_zv_tz); return NULL; } timeZone = to->utimezone->clone(); if (timeZone == NULL) { spprintf(&message, 0, "%s: could not clone TimeZone", func); if (message) { - intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1 TSRMLS_CC); + intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1); efree(message); } + zval_dtor(&local_zv_tz); return NULL; } - } else if (Z_TYPE_PP(zv_timezone) == IS_OBJECT && - instanceof_function(Z_OBJCE_PP(zv_timezone), php_date_get_timezone_ce() TSRMLS_CC)) { + } else if (Z_TYPE_P(zv_timezone) == IS_OBJECT && + instanceof_function(Z_OBJCE_P(zv_timezone), php_date_get_timezone_ce())) { - php_timezone_obj *tzobj = (php_timezone_obj *)zend_objects_get_address( - *zv_timezone TSRMLS_CC); + php_timezone_obj *tzobj = Z_PHPTIMEZONE_P(zv_timezone); + zval_dtor(&local_zv_tz); return timezone_convert_datetimezone(tzobj->type, tzobj, 0, - outside_error, func TSRMLS_CC); + outside_error, func); } else { UnicodeString id, gottenId; UErrorCode status = U_ZERO_ERROR; /* outside_error may be NULL */ convert_to_string_ex(zv_timezone); - if (intl_stringFromChar(id, Z_STRVAL_PP(zv_timezone), Z_STRLEN_PP(zv_timezone), + if (intl_stringFromChar(id, Z_STRVAL_P(zv_timezone), Z_STRLEN_P(zv_timezone), &status) == FAILURE) { spprintf(&message, 0, "%s: Time zone identifier given is not a " "valid UTF-8 string", func); if (message) { - intl_errors_set(outside_error, status, message, 1 TSRMLS_CC); + intl_errors_set(outside_error, status, message, 1); efree(message); } + zval_dtor(&local_zv_tz); return NULL; } timeZone = TimeZone::createTimeZone(id); if (timeZone == NULL) { spprintf(&message, 0, "%s: could not create time zone", func); if (message) { - intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1 TSRMLS_CC); + intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1); efree(message); } + zval_dtor(&local_zv_tz); return NULL; } if (timeZone->getID(gottenId) != id) { spprintf(&message, 0, "%s: no such time zone: '%s'", - func, Z_STRVAL_PP(zv_timezone)); + func, Z_STRVAL_P(zv_timezone)); if (message) { - intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1 TSRMLS_CC); + intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1); efree(message); } + zval_dtor(&local_zv_tz); delete timeZone; return NULL; } } + zval_dtor(&local_zv_tz); + return timeZone; } /* }}} */ /* {{{ clone handler for TimeZone */ -static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC) +static zend_object *TimeZone_clone_obj(zval *object) { TimeZone_object *to_orig, *to_new; - zend_object_value ret_val; - intl_error_reset(NULL TSRMLS_CC); + zend_object *ret_val; + intl_error_reset(NULL); - to_orig = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC); - intl_error_reset(TIMEZONE_ERROR_P(to_orig) TSRMLS_CC); + to_orig = Z_INTL_TIMEZONE_P(object); + intl_error_reset(TIMEZONE_ERROR_P(to_orig)); - ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC); - to_new = (TimeZone_object*)zend_object_store_get_object_by_handle( - ret_val.handle TSRMLS_CC); + ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object)); + to_new = php_intl_timezone_fetch_object(ret_val); - zend_objects_clone_members(&to_new->zo, ret_val, - &to_orig->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC); + zend_objects_clone_members(&to_new->zo, &to_orig->zo); if (to_orig->utimezone != NULL) { TimeZone *newTimeZone; @@ -238,19 +240,19 @@ static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC) newTimeZone = to_orig->utimezone->clone(); to_new->should_delete = 1; if (!newTimeZone) { - char *err_msg; + zend_string *err_msg; intl_errors_set_code(TIMEZONE_ERROR_P(to_orig), - U_MEMORY_ALLOCATION_ERROR TSRMLS_CC); + U_MEMORY_ALLOCATION_ERROR); intl_errors_set_custom_msg(TIMEZONE_ERROR_P(to_orig), - "Could not clone IntlTimeZone", 0 TSRMLS_CC); - err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig) TSRMLS_CC); - zend_throw_exception(NULL, err_msg, 0 TSRMLS_CC); - efree(err_msg); + "Could not clone IntlTimeZone", 0); + err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig)); + zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0); + zend_string_free(err_msg); } else { to_new->utimezone = newTimeZone; } } else { - zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0 TSRMLS_CC); + zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0); } return ret_val; @@ -259,137 +261,127 @@ static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC) /* {{{ compare_objects handler for TimeZone * Can't be used for >, >=, <, <= comparisons */ -static int TimeZone_compare_objects(zval *object1, zval *object2 TSRMLS_DC) +static int TimeZone_compare_objects(zval *object1, zval *object2) { TimeZone_object *to1, *to2; - to1 = (TimeZone_object*)zend_object_store_get_object(object1 TSRMLS_CC); - to2 = (TimeZone_object*)zend_object_store_get_object(object2 TSRMLS_CC); + to1 = Z_INTL_TIMEZONE_P(object1); + to2 = Z_INTL_TIMEZONE_P(object2); if (to1->utimezone == NULL || to2->utimezone == NULL) { zend_throw_exception(NULL, "Comparison with at least one unconstructed " - "IntlTimeZone operand", 0 TSRMLS_CC); + "IntlTimeZone operand", 0); /* intentionally not returning */ } else { if (*to1->utimezone == *to2->utimezone) { return 0; } } - + return 1; } /* }}} */ /* {{{ get_debug_info handler for TimeZone */ -static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp TSRMLS_DC) +static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp) { - zval zv = zval_used_for_init; + zval zv; TimeZone_object *to; const TimeZone *tz; UnicodeString ustr; - char *str; - int str_len; + zend_string *u8str; + HashTable *debug_info; UErrorCode uec = U_ZERO_ERROR; *is_temp = 1; - - array_init_size(&zv, 4); - to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC); + ALLOC_HASHTABLE(debug_info); + zend_hash_init(debug_info, 8, NULL, ZVAL_PTR_DTOR, 0); + + to = Z_INTL_TIMEZONE_P(object); tz = to->utimezone; if (tz == NULL) { - add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 0); - return Z_ARRVAL(zv); + ZVAL_FALSE(&zv); + zend_hash_str_update(debug_info, "valid", sizeof("valid") - 1, &zv); + return debug_info; } - add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 1); + ZVAL_TRUE(&zv); + zend_hash_str_update(debug_info, "valid", sizeof("valid") - 1, &zv); tz->getID(ustr); - intl_convert_utf16_to_utf8(&str, &str_len, + u8str = intl_convert_utf16_to_utf8( ustr.getBuffer(), ustr.length(), &uec); - if (U_FAILURE(uec)) { - return Z_ARRVAL(zv); + if (!u8str) { + return debug_info; } - add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len, 0); + ZVAL_NEW_STR(&zv, u8str); + zend_hash_str_update(debug_info, "id", sizeof("id") - 1, &zv); int32_t rawOffset, dstOffset; UDate now = Calendar::getNow(); tz->getOffset(now, FALSE, rawOffset, dstOffset, uec); if (U_FAILURE(uec)) { - return Z_ARRVAL(zv); + return debug_info; } - - add_assoc_long_ex(&zv, "rawOffset", sizeof("rawOffset"), (long)rawOffset); - add_assoc_long_ex(&zv, "currentOffset", sizeof("currentOffset"), - (long)(rawOffset + dstOffset)); - return Z_ARRVAL(zv); + ZVAL_LONG(&zv, (zend_long)rawOffset); + zend_hash_str_update(debug_info,"rawOffset", sizeof("rawOffset") - 1, &zv); + ZVAL_LONG(&zv, (zend_long)(rawOffset + dstOffset)); + zend_hash_str_update(debug_info,"currentOffset", sizeof("currentOffset") - 1, &zv); + + return debug_info; } /* }}} */ /* {{{ void TimeZone_object_init(TimeZone_object* to) * Initialize internals of TImeZone_object not specific to zend standard objects. */ -static void TimeZone_object_init(TimeZone_object *to TSRMLS_DC) +static void TimeZone_object_init(TimeZone_object *to) { - intl_error_init(TIMEZONE_ERROR_P(to) TSRMLS_CC); + intl_error_init(TIMEZONE_ERROR_P(to)); to->utimezone = NULL; to->should_delete = 0; } /* }}} */ /* {{{ TimeZone_objects_dtor */ -static void TimeZone_objects_dtor(zend_object *object, - zend_object_handle handle TSRMLS_DC) +static void TimeZone_objects_dtor(zend_object *object) { - zend_objects_destroy_object(object, handle TSRMLS_CC); + zend_objects_destroy_object(object); } /* }}} */ /* {{{ TimeZone_objects_free */ -static void TimeZone_objects_free(zend_object *object TSRMLS_DC) +static void TimeZone_objects_free(zend_object *object) { - TimeZone_object* to = (TimeZone_object*) object; + TimeZone_object* to = php_intl_timezone_fetch_object(object); if (to->utimezone && to->should_delete) { delete to->utimezone; to->utimezone = NULL; } - intl_error_reset(TIMEZONE_ERROR_P(to) TSRMLS_CC); - - zend_object_std_dtor(&to->zo TSRMLS_CC); + intl_error_reset(TIMEZONE_ERROR_P(to)); - efree(to); + zend_object_std_dtor(&to->zo); } /* }}} */ /* {{{ TimeZone_object_create */ -static zend_object_value TimeZone_object_create(zend_class_entry *ce TSRMLS_DC) +static zend_object *TimeZone_object_create(zend_class_entry *ce) { - zend_object_value retval; TimeZone_object* intern; - intern = (TimeZone_object*)ecalloc(1, sizeof(TimeZone_object)); - - zend_object_std_init(&intern->zo, ce TSRMLS_CC); -#if PHP_VERSION_ID < 50399 - zend_hash_copy(intern->zo.properties, &(ce->default_properties), - (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval*)); -#else - object_properties_init((zend_object*) intern, ce); -#endif - TimeZone_object_init(intern TSRMLS_CC); + intern = (TimeZone_object*)ecalloc(1, sizeof(TimeZone_object) + sizeof(zval) * (ce->default_properties_count - 1)); - retval.handle = zend_objects_store_put( - intern, - (zend_objects_store_dtor_t) TimeZone_objects_dtor, - (zend_objects_free_object_storage_t) TimeZone_objects_free, - NULL TSRMLS_CC); + zend_object_std_init(&intern->zo, ce); + object_properties_init(&intern->zo, ce); + TimeZone_object_init(intern); - retval.handlers = &TimeZone_handlers; + intern->zo.handlers = &TimeZone_handlers; - return retval; + return &intern->zo; } /* }}} */ @@ -490,31 +482,35 @@ static zend_function_entry TimeZone_class_functions[] = { /* {{{ timezone_register_IntlTimeZone_class * Initialize 'IntlTimeZone' class */ -U_CFUNC void timezone_register_IntlTimeZone_class(TSRMLS_D) +U_CFUNC void timezone_register_IntlTimeZone_class(void) { zend_class_entry ce; /* Create and register 'IntlTimeZone' class. */ INIT_CLASS_ENTRY(ce, "IntlTimeZone", TimeZone_class_functions); ce.create_object = TimeZone_object_create; - TimeZone_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC); + TimeZone_ce_ptr = zend_register_internal_class(&ce); if (!TimeZone_ce_ptr) { //can't happen now without bigger problems before - php_error_docref0(NULL TSRMLS_CC, E_ERROR, + php_error_docref0(NULL, E_ERROR, "IntlTimeZone: class registration has failed."); return; } memcpy(&TimeZone_handlers, zend_get_std_object_handlers(), sizeof TimeZone_handlers); + TimeZone_handlers.offset = XtOffsetOf(TimeZone_object, zo); TimeZone_handlers.clone_obj = TimeZone_clone_obj; TimeZone_handlers.compare_objects = TimeZone_compare_objects; TimeZone_handlers.get_debug_info = TimeZone_get_debug_info; + TimeZone_handlers.dtor_obj = TimeZone_objects_dtor; + TimeZone_handlers.free_obj = TimeZone_objects_free; + /* Declare 'IntlTimeZone' class constants */ #define TIMEZONE_DECL_LONG_CONST(name, val) \ zend_declare_class_constant_long(TimeZone_ce_ptr, name, sizeof(name) - 1, \ - val TSRMLS_CC) + val) TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT", TimeZone::SHORT); TIMEZONE_DECL_LONG_CONST("DISPLAY_LONG", TimeZone::LONG); diff --git a/ext/intl/timezone/timezone_class.h b/ext/intl/timezone/timezone_class.h index a638f6dbf4..0667c78994 100644 --- a/ext/intl/timezone/timezone_class.h +++ b/ext/intl/timezone/timezone_class.h @@ -1,6 +1,6 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | @@ -32,8 +32,6 @@ typedef void TimeZone; #endif typedef struct { - zend_object zo; - // error handling intl_error err; @@ -42,8 +40,15 @@ typedef struct { //whether to delete the timezone on object free zend_bool should_delete; + + zend_object zo; } TimeZone_object; +static inline TimeZone_object *php_intl_timezone_fetch_object(zend_object *obj) { + return (TimeZone_object *)((char*)(obj) - XtOffsetOf(TimeZone_object, zo)); +} +#define Z_INTL_TIMEZONE_P(zv) php_intl_timezone_fetch_object(Z_OBJ_P(zv)) + #define TIMEZONE_ERROR(to) (to)->err #define TIMEZONE_ERROR_P(to) &(TIMEZONE_ERROR(to)) @@ -51,20 +56,20 @@ typedef struct { #define TIMEZONE_ERROR_CODE_P(co) &(INTL_ERROR_CODE(TIMEZONE_ERROR(to))) #define TIMEZONE_METHOD_INIT_VARS INTL_METHOD_INIT_VARS(TimeZone, to) -#define TIMEZONE_METHOD_FETCH_OBJECT_NO_CHECK INTL_METHOD_FETCH_OBJECT(TimeZone, to) +#define TIMEZONE_METHOD_FETCH_OBJECT_NO_CHECK INTL_METHOD_FETCH_OBJECT(INTL_TIMEZONE, to) #define TIMEZONE_METHOD_FETCH_OBJECT\ TIMEZONE_METHOD_FETCH_OBJECT_NO_CHECK; \ if (to->utimezone == NULL) { \ - intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR, "Found unconstructed IntlTimeZone", 0 TSRMLS_CC); \ + intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR, "Found unconstructed IntlTimeZone", 0); \ RETURN_FALSE; \ } -zval *timezone_convert_to_datetimezone(const TimeZone *timeZone, intl_error *outside_error, const char *func TSRMLS_DC); -TimeZone *timezone_process_timezone_argument(zval **zv_timezone, intl_error *error, const char *func TSRMLS_DC); +zval *timezone_convert_to_datetimezone(const TimeZone *timeZone, intl_error *outside_error, const char *func, zval *ret); +TimeZone *timezone_process_timezone_argument(zval *zv_timezone, intl_error *error, const char *func); -void timezone_object_construct(const TimeZone *zone, zval *object, int owned TSRMLS_DC); +void timezone_object_construct(const TimeZone *zone, zval *object, int owned); -void timezone_register_IntlTimeZone_class(TSRMLS_D); +void timezone_register_IntlTimeZone_class(void); extern zend_class_entry *TimeZone_ce_ptr; extern zend_object_handlers TimeZone_handlers; diff --git a/ext/intl/timezone/timezone_methods.cpp b/ext/intl/timezone/timezone_methods.cpp index 9ca6b44c89..c46b448bbe 100644 --- a/ext/intl/timezone/timezone_methods.cpp +++ b/ext/intl/timezone/timezone_methods.cpp @@ -1,6 +1,6 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | @@ -41,19 +41,18 @@ U_CFUNC PHP_METHOD(IntlTimeZone, __construct) { zend_throw_exception( NULL, "An object of this type cannot be created with the new operator", - 0 TSRMLS_CC ); + 0 ); } U_CFUNC PHP_FUNCTION(intltz_create_time_zone) { char *str_id; - int str_id_len; - intl_error_reset(NULL TSRMLS_CC); + size_t str_id_len; + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", - &str_id, &str_id_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str_id, &str_id_len) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_time_zone: bad arguments", 0 TSRMLS_CC); + "intltz_create_time_zone: bad arguments", 0); RETURN_NULL(); } @@ -61,13 +60,13 @@ U_CFUNC PHP_FUNCTION(intltz_create_time_zone) UnicodeString id = UnicodeString(); if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, - "intltz_create_time_zone: could not convert time zone id to UTF-16", 0 TSRMLS_CC); + "intltz_create_time_zone: could not convert time zone id to UTF-16", 0); RETURN_NULL(); } //guaranteed non-null; GMT if timezone cannot be understood TimeZone *tz = TimeZone::createTimeZone(id); - timezone_object_construct(tz, return_value, 1 TSRMLS_CC); + timezone_object_construct(tz, return_value, 1); } U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone) @@ -75,135 +74,133 @@ U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone) zval *zv_timezone; TimeZone *tz; php_timezone_obj *tzobj; - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", + if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zv_timezone, php_date_get_timezone_ce()) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_from_date_time_zone: bad arguments", 0 TSRMLS_CC); + "intltz_from_date_time_zone: bad arguments", 0); RETURN_NULL(); } - tzobj = (php_timezone_obj *)zend_objects_get_address(zv_timezone TSRMLS_CC); + tzobj = Z_PHPTIMEZONE_P(zv_timezone); if (!tzobj->initialized) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_from_date_time_zone: DateTimeZone object is unconstructed", - 0 TSRMLS_CC); + 0); RETURN_NULL(); } tz = timezone_convert_datetimezone(tzobj->type, tzobj, FALSE, NULL, - "intltz_from_date_time_zone" TSRMLS_CC); + "intltz_from_date_time_zone"); if (tz == NULL) { RETURN_NULL(); } - timezone_object_construct(tz, return_value, 1 TSRMLS_CC); + timezone_object_construct(tz, return_value, 1); } U_CFUNC PHP_FUNCTION(intltz_create_default) { - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_default: bad arguments", 0 TSRMLS_CC); + "intltz_create_default: bad arguments", 0); RETURN_NULL(); } TimeZone *tz = TimeZone::createDefault(); - timezone_object_construct(tz, return_value, 1 TSRMLS_CC); + timezone_object_construct(tz, return_value, 1); } U_CFUNC PHP_FUNCTION(intltz_get_gmt) { - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_gmt: bad arguments", 0 TSRMLS_CC); + "intltz_get_gmt: bad arguments", 0); RETURN_NULL(); } - timezone_object_construct(TimeZone::getGMT(), return_value, 0 TSRMLS_CC); + timezone_object_construct(TimeZone::getGMT(), return_value, 0); } #if U_ICU_VERSION_MAJOR_NUM >= 49 U_CFUNC PHP_FUNCTION(intltz_get_unknown) { - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_unknown: bad arguments", 0 TSRMLS_CC); + "intltz_get_unknown: bad arguments", 0); RETURN_NULL(); } - timezone_object_construct(&TimeZone::getUnknown(), return_value, 0 TSRMLS_CC); + timezone_object_construct(&TimeZone::getUnknown(), return_value, 0); } #endif U_CFUNC PHP_FUNCTION(intltz_create_enumeration) { - zval **arg = NULL; + zval *arg = NULL; StringEnumeration *se = NULL; - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); /* double indirection to have the zend engine destroy the new zval that * results from separation */ - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Z", &arg) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &arg) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_enumeration: bad arguments", 0 TSRMLS_CC); + "intltz_create_enumeration: bad arguments", 0); RETURN_FALSE; } - if (arg == NULL || Z_TYPE_PP(arg) == IS_NULL) { + if (arg == NULL || Z_TYPE_P(arg) == IS_NULL) { se = TimeZone::createEnumeration(); - } else if (Z_TYPE_PP(arg) == IS_LONG) { + } else if (Z_TYPE_P(arg) == IS_LONG) { int_offset: - if (Z_LVAL_PP(arg) < (long)INT32_MIN || - Z_LVAL_PP(arg) > (long)INT32_MAX) { + if (Z_LVAL_P(arg) < (zend_long)INT32_MIN || + Z_LVAL_P(arg) > (zend_long)INT32_MAX) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_enumeration: value is out of range", 0 TSRMLS_CC); + "intltz_create_enumeration: value is out of range", 0); RETURN_FALSE; } else { - se = TimeZone::createEnumeration((int32_t) Z_LVAL_PP(arg)); + se = TimeZone::createEnumeration((int32_t) Z_LVAL_P(arg)); } - } else if (Z_TYPE_PP(arg) == IS_DOUBLE) { + } else if (Z_TYPE_P(arg) == IS_DOUBLE) { double_offset: convert_to_long_ex(arg); goto int_offset; - } else if (Z_TYPE_PP(arg) == IS_OBJECT || Z_TYPE_PP(arg) == IS_STRING) { - long lval; + } else if (Z_TYPE_P(arg) == IS_OBJECT || Z_TYPE_P(arg) == IS_STRING) { + zend_long lval; double dval; convert_to_string_ex(arg); - switch (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &lval, &dval, 0)) { + switch (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &lval, &dval, 0)) { case IS_DOUBLE: SEPARATE_ZVAL(arg); - zval_dtor(*arg); - Z_TYPE_PP(arg) = IS_DOUBLE; - Z_DVAL_PP(arg) = dval; + zval_dtor(arg); + ZVAL_DOUBLE(arg, dval); goto double_offset; case IS_LONG: SEPARATE_ZVAL(arg); - zval_dtor(*arg); - Z_TYPE_PP(arg) = IS_LONG; - Z_LVAL_PP(arg) = lval; + zval_dtor(arg); + ZVAL_LONG(arg, lval); goto int_offset; } /* else call string version */ - se = TimeZone::createEnumeration(Z_STRVAL_PP(arg)); + se = TimeZone::createEnumeration(Z_STRVAL_P(arg)); } else { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_enumeration: invalid argument type", 0 TSRMLS_CC); + "intltz_create_enumeration: invalid argument type", 0); RETURN_FALSE; } if (se) { - IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC); + IntlIterator_from_StringEnumeration(se, return_value); } else { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_enumeration: error obtaining enumeration", 0 TSRMLS_CC); + "intltz_create_enumeration: error obtaining enumeration", 0); RETVAL_FALSE; } } @@ -211,13 +208,13 @@ double_offset: U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids) { char *str_id; - int str_id_len; - intl_error_reset(NULL TSRMLS_CC); + size_t str_id_len; + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str_id, &str_id_len) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_count_equivalent_ids: bad arguments", 0 TSRMLS_CC); + "intltz_count_equivalent_ids: bad arguments", 0); RETURN_FALSE; } @@ -225,59 +222,50 @@ U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids) UnicodeString id = UnicodeString(); if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, - "intltz_count_equivalent_ids: could not convert time zone id to UTF-16", 0 TSRMLS_CC); + "intltz_count_equivalent_ids: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } int32_t result = TimeZone::countEquivalentIDs(id); - RETURN_LONG((long)result); + RETURN_LONG((zend_long)result); } #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48 U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration) { - long zoneType, - offset_arg; - char *region = NULL; - int region_len = 0; - int32_t offset, - *offsetp = NULL; - int arg3isnull = 0; - intl_error_reset(NULL TSRMLS_CC); - - /* must come before zpp because zpp would convert the arg in the stack to 0 */ - if (ZEND_NUM_ARGS() == 3) { - zval **dummy, **zvoffset; - arg3isnull = zend_get_parameters_ex(3, &dummy, &dummy, &zvoffset) - != FAILURE && Z_TYPE_PP(zvoffset) == IS_NULL; - } - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s!l", - &zoneType, ®ion, ®ion_len, &offset_arg) == FAILURE) { + zend_long zoneType, + offset_arg; + char *region = NULL; + size_t region_len = 0; + int32_t offset, + *offsetp = NULL; + zend_bool arg3isnull = 1; + + intl_error_reset(NULL); + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|s!l!", + &zoneType, ®ion, ®ion_len, &offset_arg, &arg3isnull) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_time_zone_id_enumeration: bad arguments", 0 TSRMLS_CC); + "intltz_create_time_zone_id_enumeration: bad arguments", 0); RETURN_FALSE; } if (zoneType != UCAL_ZONE_TYPE_ANY && zoneType != UCAL_ZONE_TYPE_CANONICAL && zoneType != UCAL_ZONE_TYPE_CANONICAL_LOCATION) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_time_zone_id_enumeration: bad zone type", 0 TSRMLS_CC); + "intltz_create_time_zone_id_enumeration: bad zone type", 0); RETURN_FALSE; } - if (ZEND_NUM_ARGS() == 3) { - if (offset_arg < (long)INT32_MIN || offset_arg > (long)INT32_MAX) { + if (!arg3isnull) { + if (offset_arg < (zend_long)INT32_MIN || offset_arg > (zend_long)INT32_MAX) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_create_time_zone_id_enumeration: offset out of bounds", 0 TSRMLS_CC); + "intltz_create_time_zone_id_enumeration: offset out of bounds", 0); RETURN_FALSE; } - - if (!arg3isnull) { - offset = (int32_t)offset_arg; - offsetp = &offset; - } //else leave offsetp NULL - } + offset = (int32_t)offset_arg; + offsetp = &offset; + } //else leave offsetp NULL StringEnumeration *se; UErrorCode uec = UErrorCode(); @@ -286,21 +274,21 @@ U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration) INTL_CHECK_STATUS(uec, "intltz_create_time_zone_id_enumeration: " "Error obtaining time zone id enumeration") - IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC); + IntlIterator_from_StringEnumeration(se, return_value); } #endif U_CFUNC PHP_FUNCTION(intltz_get_canonical_id) { char *str_id; - int str_id_len; + size_t str_id_len; zval *is_systemid = NULL; - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z", &str_id, &str_id_len, &is_systemid) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_canonical_id: bad arguments", 0 TSRMLS_CC); + "intltz_get_canonical_id: bad arguments", 0); RETURN_FALSE; } @@ -308,7 +296,7 @@ U_CFUNC PHP_FUNCTION(intltz_get_canonical_id) UnicodeString id; if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, - "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC); + "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } @@ -316,14 +304,14 @@ U_CFUNC PHP_FUNCTION(intltz_get_canonical_id) UBool isSystemID; TimeZone::getCanonicalID(id, result, isSystemID, status); INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID"); - - intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), - result.getBuffer(), result.length(), &status); + + zend_string *u8str =intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status); INTL_CHECK_STATUS(status, "intltz_get_canonical_id: could not convert time zone id to UTF-16"); - Z_TYPE_P(return_value) = IS_STRING; - + RETVAL_NEW_STR(u8str); + if (is_systemid) { /* by-ref argument passed */ + ZVAL_DEREF(is_systemid); zval_dtor(is_systemid); ZVAL_BOOL(is_systemid, isSystemID); } @@ -333,14 +321,14 @@ U_CFUNC PHP_FUNCTION(intltz_get_canonical_id) U_CFUNC PHP_FUNCTION(intltz_get_region) { char *str_id; - int str_id_len; - char outbuf[3]; - intl_error_reset(NULL TSRMLS_CC); + size_t str_id_len; + char outbuf[3]; + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str_id, &str_id_len) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_region: bad arguments", 0 TSRMLS_CC); + "intltz_get_region: bad arguments", 0); RETURN_FALSE; } @@ -348,24 +336,24 @@ U_CFUNC PHP_FUNCTION(intltz_get_region) UnicodeString id; if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, - "intltz_get_region: could not convert time zone id to UTF-16", 0 TSRMLS_CC); + "intltz_get_region: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } int32_t region_len = TimeZone::getRegion(id, outbuf, sizeof(outbuf), status); INTL_CHECK_STATUS(status, "intltz_get_region: Error obtaining region"); - RETURN_STRINGL(outbuf, region_len, 1); + RETURN_STRINGL(outbuf, region_len); } #endif U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version) { - intl_error_reset(NULL TSRMLS_CC); + intl_error_reset(NULL); if (zend_parse_parameters_none() == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_tz_data_version: bad arguments", 0 TSRMLS_CC); + "intltz_get_tz_data_version: bad arguments", 0); RETURN_FALSE; } @@ -374,21 +362,21 @@ U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version) INTL_CHECK_STATUS(status, "intltz_get_tz_data_version: " "Error obtaining time zone data version"); - RETURN_STRING(res, 1); + RETURN_STRING(res); } U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id) { - char *str_id; - int str_id_len; - long index; - intl_error_reset(NULL TSRMLS_CC); + char *str_id; + size_t str_id_len; + zend_long index; + intl_error_reset(NULL); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", + if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl", &str_id, &str_id_len, &index) == FAILURE || - index < (long)INT32_MIN || index > (long)INT32_MAX) { + index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_equivalent_id: bad arguments", 0 TSRMLS_CC); + "intltz_get_equivalent_id: bad arguments", 0); RETURN_FALSE; } @@ -396,26 +384,27 @@ U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id) UnicodeString id; if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) { intl_error_set(NULL, status, - "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC); + "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0); RETURN_FALSE; } const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index); - intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), - result.getBuffer(), result.length(), &status); + zend_string *u8str; + + u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status); INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: " "could not convert resulting time zone id to UTF-16"); - Z_TYPE_P(return_value) = IS_STRING; + RETVAL_NEW_STR(u8str); } U_CFUNC PHP_FUNCTION(intltz_get_id) { TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_id: bad arguments", 0 TSRMLS_CC); + "intltz_get_id: bad arguments", 0); RETURN_FALSE; } @@ -424,24 +413,23 @@ U_CFUNC PHP_FUNCTION(intltz_get_id) UnicodeString id_us; to->utimezone->getID(id_us); - char *id = NULL; - int id_len = 0; + zend_string *u8str; - intl_convert_utf16_to_utf8(&id, &id_len, + u8str = intl_convert_utf16_to_utf8( id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to)); INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8"); - RETURN_STRINGL(id, id_len, 0); + RETVAL_NEW_STR(u8str); } U_CFUNC PHP_FUNCTION(intltz_use_daylight_time) { TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_use_daylight_time: bad arguments", 0 TSRMLS_CC); + "intltz_use_daylight_time: bad arguments", 0); RETURN_FALSE; } @@ -460,11 +448,11 @@ U_CFUNC PHP_FUNCTION(intltz_get_offset) dstOffset; TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), - "Odbzz", &object, TimeZone_ce_ptr, &date, &local, &rawOffsetArg, + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), + "Odbz/z/", &object, TimeZone_ce_ptr, &date, &local, &rawOffsetArg, &dstOffsetArg) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_offset: bad arguments", 0 TSRMLS_CC); + "intltz_get_offset: bad arguments", 0); RETURN_FALSE; } @@ -475,8 +463,10 @@ U_CFUNC PHP_FUNCTION(intltz_get_offset) INTL_METHOD_CHECK_STATUS(to, "intltz_get_offset: error obtaining offset"); + ZVAL_DEREF(rawOffsetArg); zval_dtor(rawOffsetArg); ZVAL_LONG(rawOffsetArg, rawOffset); + ZVAL_DEREF(dstOffsetArg); zval_dtor(dstOffsetArg); ZVAL_LONG(dstOffsetArg, dstOffset); @@ -487,10 +477,10 @@ U_CFUNC PHP_FUNCTION(intltz_get_raw_offset) { TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_raw_offset: bad arguments", 0 TSRMLS_CC); + "intltz_get_raw_offset: bad arguments", 0); RETURN_FALSE; } @@ -505,18 +495,18 @@ U_CFUNC PHP_FUNCTION(intltz_has_same_rules) TimeZone_object *other_to; TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "OO", &object, TimeZone_ce_ptr, &other_object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_has_same_rules: bad arguments", 0 TSRMLS_CC); + "intltz_has_same_rules: bad arguments", 0); RETURN_FALSE; } TIMEZONE_METHOD_FETCH_OBJECT; - other_to = (TimeZone_object *) zend_object_store_get_object(other_object TSRMLS_CC); + other_to = Z_INTL_TIMEZONE_P(other_object); if (other_to->utimezone == NULL) { intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0 TSRMLS_CC); + "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0); RETURN_FALSE; } @@ -535,16 +525,16 @@ static const TimeZone::EDisplayType display_types[] = { U_CFUNC PHP_FUNCTION(intltz_get_display_name) { zend_bool daylight = 0; - long display_type = TimeZone::LONG; - const char *locale_str = NULL; - int dummy = 0; + zend_long display_type = TimeZone::LONG; + const char *locale_str = NULL; + size_t dummy = 0; TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O|bls!", &object, TimeZone_ce_ptr, &daylight, &display_type, &locale_str, &dummy) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_display_name: bad arguments", 0 TSRMLS_CC); + "intltz_get_display_name: bad arguments", 0); RETURN_FALSE; } @@ -555,12 +545,12 @@ U_CFUNC PHP_FUNCTION(intltz_get_display_name) } if (!found) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_display_name: wrong display type", 0 TSRMLS_CC); + "intltz_get_display_name: wrong display type", 0); RETURN_FALSE; } if (!locale_str) { - locale_str = intl_locale_get_default(TSRMLS_C); + locale_str = intl_locale_get_default(); } TIMEZONE_METHOD_FETCH_OBJECT; @@ -569,48 +559,48 @@ U_CFUNC PHP_FUNCTION(intltz_get_display_name) to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type, Locale::createFromName(locale_str), result); - intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), - result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to)); + zend_string *u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to)); INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: " "could not convert resulting time zone id to UTF-16"); - Z_TYPE_P(return_value) = IS_STRING; + RETVAL_NEW_STR(u8str); } U_CFUNC PHP_FUNCTION(intltz_get_dst_savings) { TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_dst_savings: bad arguments", 0 TSRMLS_CC); + "intltz_get_dst_savings: bad arguments", 0); RETURN_FALSE; } TIMEZONE_METHOD_FETCH_OBJECT; - RETURN_LONG((long)to->utimezone->getDSTSavings()); + RETURN_LONG((zend_long)to->utimezone->getDSTSavings()); } U_CFUNC PHP_FUNCTION(intltz_to_date_time_zone) { + zval tmp; TIMEZONE_METHOD_INIT_VARS; - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_to_date_time_zone: bad arguments", 0 TSRMLS_CC); + "intltz_to_date_time_zone: bad arguments", 0); RETURN_FALSE; } TIMEZONE_METHOD_FETCH_OBJECT; zval *ret = timezone_convert_to_datetimezone(to->utimezone, - &TIMEZONE_ERROR(to), "intltz_to_date_time_zone" TSRMLS_CC); + &TIMEZONE_ERROR(to), "intltz_to_date_time_zone", &tmp); if (ret) { - RETURN_ZVAL(ret, 1, 1); + ZVAL_COPY_VALUE(return_value, ret); } else { RETURN_FALSE; } @@ -620,40 +610,40 @@ U_CFUNC PHP_FUNCTION(intltz_get_error_code) { TIMEZONE_METHOD_INIT_VARS - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_error_code: bad arguments", 0 TSRMLS_CC); + "intltz_get_error_code: bad arguments", 0); RETURN_FALSE; } /* Fetch the object (without resetting its last error code ). */ - to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC); + to = Z_INTL_TIMEZONE_P(object); if (to == NULL) RETURN_FALSE; - RETURN_LONG((long)TIMEZONE_ERROR_CODE(to)); + RETURN_LONG((zend_long)TIMEZONE_ERROR_CODE(to)); } U_CFUNC PHP_FUNCTION(intltz_get_error_message) { - const char* message = NULL; + zend_string* message = NULL; TIMEZONE_METHOD_INIT_VARS - if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", + if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O", &object, TimeZone_ce_ptr) == FAILURE) { intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, - "intltz_get_error_message: bad arguments", 0 TSRMLS_CC ); + "intltz_get_error_message: bad arguments", 0 ); RETURN_FALSE; } /* Fetch the object (without resetting its last error code ). */ - to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC); + to = Z_INTL_TIMEZONE_P(object); if (to == NULL) RETURN_FALSE; /* Return last error message. */ - message = intl_error_get_message(TIMEZONE_ERROR_P(to) TSRMLS_CC); - RETURN_STRING(message, 0); + message = intl_error_get_message(TIMEZONE_ERROR_P(to)); + RETURN_STR(message); } diff --git a/ext/intl/timezone/timezone_methods.h b/ext/intl/timezone/timezone_methods.h index 28c39f4fd7..29d72913fd 100644 --- a/ext/intl/timezone/timezone_methods.h +++ b/ext/intl/timezone/timezone_methods.h @@ -1,6 +1,6 @@ /* +----------------------------------------------------------------------+ - | PHP Version 5 | + | PHP Version 7 | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | |