PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/intl/timezone - timezone_methods.cpp (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 278 322 86.3 %
Date: 2019-05-06 Functions: 24 25 96.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | This source file is subject to version 3.01 of the PHP license,      |
       6             :    | that is bundled with this package in the file LICENSE, and is        |
       7             :    | available through the world-wide-web at the following url:           |
       8             :    | http://www.php.net/license/3_01.txt                                  |
       9             :    | If you did not receive a copy of the PHP license and are unable to   |
      10             :    | obtain it through the world-wide-web, please send a note to          |
      11             :    | license@php.net so we can mail you a copy immediately.               |
      12             :    +----------------------------------------------------------------------+
      13             :    | Authors: Gustavo Lopes <cataphract@php.net>                          |
      14             :    +----------------------------------------------------------------------+
      15             : */
      16             : 
      17             : #ifdef HAVE_CONFIG_H
      18             : #include "config.h"
      19             : #endif
      20             : 
      21             : #include "../intl_cppshims.h"
      22             : 
      23             : #include <unicode/locid.h>
      24             : #include <unicode/timezone.h>
      25             : #include <unicode/ustring.h>
      26             : #include <unicode/calendar.h>
      27             : #include "intl_convertcpp.h"
      28             : 
      29             : #include "../common/common_date.h"
      30             : 
      31             : extern "C" {
      32             : #include "../php_intl.h"
      33             : #define USE_TIMEZONE_POINTER 1
      34             : #include "timezone_class.h"
      35             : #include "intl_convert.h"
      36             : #include <zend_exceptions.h>
      37             : #include <ext/date/php_date.h>
      38             : }
      39             : #include "common/common_enum.h"
      40             : 
      41             : using icu::Locale;
      42             : using icu::Calendar;
      43             : 
      44           0 : U_CFUNC PHP_METHOD(IntlTimeZone, __construct)
      45             : {
      46           0 :         zend_throw_exception( NULL,
      47             :                 "An object of this type cannot be created with the new operator",
      48             :                 0 );
      49           0 : }
      50             : 
      51          32 : U_CFUNC PHP_FUNCTION(intltz_create_time_zone)
      52             : {
      53             :         char    *str_id;
      54             :         size_t   str_id_len;
      55          32 :         intl_error_reset(NULL);
      56             : 
      57          32 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str_id, &str_id_len) == FAILURE) {
      58           3 :                 RETURN_NULL();
      59             :         }
      60             : 
      61          31 :         UErrorCode status = UErrorCode();
      62          61 :         UnicodeString id = UnicodeString();
      63          31 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
      64           1 :                 intl_error_set(NULL, status,
      65             :                         "intltz_create_time_zone: could not convert time zone id to UTF-16", 0);
      66           1 :                 RETURN_NULL();
      67             :         }
      68             : 
      69             :         //guaranteed non-null; GMT if timezone cannot be understood
      70          30 :         TimeZone *tz = TimeZone::createTimeZone(id);
      71          30 :         timezone_object_construct(tz, return_value, 1);
      72             : }
      73             : 
      74           4 : U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone)
      75             : {
      76             :         zval                            *zv_timezone;
      77             :         TimeZone                        *tz;
      78             :         php_timezone_obj        *tzobj;
      79           4 :         intl_error_reset(NULL);
      80             : 
      81           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "O",
      82           4 :                         &zv_timezone, php_date_get_timezone_ce()) == FAILURE) {
      83           1 :                 RETURN_NULL();
      84             :         }
      85             : 
      86           4 :         tzobj = Z_PHPTIMEZONE_P(zv_timezone);
      87           4 :         if (!tzobj->initialized) {
      88           0 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
      89             :                         "intltz_from_date_time_zone: DateTimeZone object is unconstructed",
      90             :                         0);
      91           0 :                 RETURN_NULL();
      92             :         }
      93             : 
      94           4 :         tz = timezone_convert_datetimezone(tzobj->type, tzobj, FALSE, NULL,
      95             :                 "intltz_from_date_time_zone");
      96           4 :         if (tz == NULL) {
      97           1 :                 RETURN_NULL();
      98             :         }
      99             : 
     100           3 :         timezone_object_construct(tz, return_value, 1);
     101             : }
     102             : 
     103           2 : U_CFUNC PHP_FUNCTION(intltz_create_default)
     104             : {
     105           2 :         intl_error_reset(NULL);
     106             : 
     107           2 :         if (zend_parse_parameters_none() == FAILURE) {
     108           0 :                 RETURN_NULL();
     109             :         }
     110             : 
     111           2 :         TimeZone *tz = TimeZone::createDefault();
     112           2 :         timezone_object_construct(tz, return_value, 1);
     113             : }
     114             : 
     115           8 : U_CFUNC PHP_FUNCTION(intltz_get_gmt)
     116             : {
     117           8 :         intl_error_reset(NULL);
     118             : 
     119           8 :         if (zend_parse_parameters_none() == FAILURE) {
     120           0 :                 RETURN_NULL();
     121             :         }
     122             : 
     123           8 :         timezone_object_construct(TimeZone::getGMT(), return_value, 0);
     124             : }
     125             : 
     126           2 : U_CFUNC PHP_FUNCTION(intltz_get_unknown)
     127             : {
     128           2 :         intl_error_reset(NULL);
     129             : 
     130           2 :         if (zend_parse_parameters_none() == FAILURE) {
     131           0 :                 RETURN_NULL();
     132             :         }
     133             : 
     134           2 :         timezone_object_construct(&TimeZone::getUnknown(), return_value, 0);
     135             : }
     136             : 
     137           5 : U_CFUNC PHP_FUNCTION(intltz_create_enumeration)
     138             : {
     139           5 :         zval                            *arg = NULL;
     140           5 :         StringEnumeration       *se       = NULL;
     141           5 :         intl_error_reset(NULL);
     142             : 
     143             :         /* double indirection to have the zend engine destroy the new zval that
     144             :          * results from separation */
     145           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &arg) == FAILURE) {
     146           1 :                 RETURN_FALSE;
     147             :         }
     148             : 
     149           8 :         if (arg == NULL || Z_TYPE_P(arg) == IS_NULL) {
     150           2 :                 se = TimeZone::createEnumeration();
     151           6 :         } else if (Z_TYPE_P(arg) == IS_LONG) {
     152           1 : int_offset:
     153           2 :                 if (Z_LVAL_P(arg) < (zend_long)INT32_MIN ||
     154           1 :                                 Z_LVAL_P(arg) > (zend_long)INT32_MAX) {
     155           0 :                         intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     156             :                                 "intltz_create_enumeration: value is out of range", 0);
     157           0 :                         RETURN_FALSE;
     158             :                 } else {
     159           1 :                         se = TimeZone::createEnumeration((int32_t) Z_LVAL_P(arg));
     160             :                 }
     161           4 :         } else if (Z_TYPE_P(arg) == IS_DOUBLE) {
     162           0 : double_offset:
     163           0 :                 convert_to_long_ex(arg);
     164           0 :                 goto int_offset;
     165           6 :         } else if (Z_TYPE_P(arg) == IS_OBJECT || Z_TYPE_P(arg) == IS_STRING) {
     166             :                 zend_long lval;
     167             :                 double dval;
     168           2 :                 convert_to_string_ex(arg);
     169           2 :                 switch (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &lval, &dval, 0)) {
     170           0 :                 case IS_DOUBLE:
     171           0 :                         zval_ptr_dtor(arg);
     172           0 :                         ZVAL_DOUBLE(arg, dval);
     173           0 :                         goto double_offset;
     174           0 :                 case IS_LONG:
     175           0 :                         zval_ptr_dtor(arg);
     176           0 :                         ZVAL_LONG(arg, lval);
     177           0 :                         goto int_offset;
     178             :                 }
     179             :                 /* else call string version */
     180           1 :                 se = TimeZone::createEnumeration(Z_STRVAL_P(arg));
     181             :         } else {
     182           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     183             :                         "intltz_create_enumeration: invalid argument type", 0);
     184           1 :                 RETURN_FALSE;
     185             :         }
     186             : 
     187           4 :         if (se) {
     188           4 :                 IntlIterator_from_StringEnumeration(se, return_value);
     189             :         } else {
     190           0 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     191             :                         "intltz_create_enumeration: error obtaining enumeration", 0);
     192           0 :                 RETVAL_FALSE;
     193             :         }
     194             : }
     195             : 
     196           4 : U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids)
     197             : {
     198             :         char    *str_id;
     199             :         size_t   str_id_len;
     200           4 :         intl_error_reset(NULL);
     201             : 
     202           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
     203           4 :                         &str_id, &str_id_len) == FAILURE) {
     204           1 :                 RETURN_FALSE;
     205             :         }
     206             : 
     207           3 :         UErrorCode status = UErrorCode();
     208           6 :         UnicodeString id = UnicodeString();
     209           3 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     210           1 :                 intl_error_set(NULL, status,
     211             :                         "intltz_count_equivalent_ids: could not convert time zone id to UTF-16", 0);
     212           1 :                 RETURN_FALSE;
     213             :         }
     214             : 
     215           2 :         int32_t result = TimeZone::countEquivalentIDs(id);
     216           2 :         RETURN_LONG((zend_long)result);
     217             : }
     218             : 
     219          11 : U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration)
     220             : {
     221             :         zend_long zoneType,
     222             :                           offset_arg;
     223          11 :         char     *region                = NULL;
     224          11 :         size_t    region_len    = 0;
     225             :         int32_t   offset,
     226          11 :                          *offsetp       = NULL;
     227          11 :         zend_bool arg3isnull = 1;
     228             : 
     229          11 :         intl_error_reset(NULL);
     230             : 
     231          22 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|s!l!",
     232          11 :                         &zoneType, &region, &region_len, &offset_arg, &arg3isnull) == FAILURE) {
     233           3 :                 RETURN_FALSE;
     234             :         }
     235             : 
     236          10 :         if (zoneType != UCAL_ZONE_TYPE_ANY && zoneType != UCAL_ZONE_TYPE_CANONICAL
     237           2 :                         && zoneType != UCAL_ZONE_TYPE_CANONICAL_LOCATION) {
     238           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     239             :                         "intltz_create_time_zone_id_enumeration: bad zone type", 0);
     240           1 :                 RETURN_FALSE;
     241             :         }
     242             : 
     243           9 :         if (!arg3isnull) {
     244           3 :                 if (offset_arg < (zend_long)INT32_MIN || offset_arg > (zend_long)INT32_MAX) {
     245           0 :                         intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     246             :                                 "intltz_create_time_zone_id_enumeration: offset out of bounds", 0);
     247           0 :                         RETURN_FALSE;
     248             :                 }
     249           3 :                 offset = (int32_t)offset_arg;
     250           3 :                 offsetp = &offset;
     251             :         } //else leave offsetp NULL
     252             : 
     253             :         StringEnumeration *se;
     254           9 :         UErrorCode uec = UErrorCode();
     255           9 :         se = TimeZone::createTimeZoneIDEnumeration((USystemTimeZoneType)zoneType,
     256             :                 region, offsetp, uec);
     257           9 :         INTL_CHECK_STATUS(uec, "intltz_create_time_zone_id_enumeration: "
     258             :                 "Error obtaining time zone id enumeration")
     259             : 
     260           9 :         IntlIterator_from_StringEnumeration(se, return_value);
     261             : }
     262             : 
     263           6 : U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
     264             : {
     265             :         char    *str_id;
     266             :         size_t   str_id_len;
     267           6 :         zval    *is_systemid = NULL;
     268           6 :         intl_error_reset(NULL);
     269             : 
     270          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z",
     271           6 :                         &str_id, &str_id_len, &is_systemid) == FAILURE) {
     272           4 :                 RETURN_FALSE;
     273             :         }
     274             : 
     275           5 :         UErrorCode status = UErrorCode();
     276           8 :         UnicodeString id;
     277           5 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     278           1 :                 intl_error_set(NULL, status,
     279             :                         "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0);
     280           1 :                 RETURN_FALSE;
     281             :         }
     282             : 
     283           7 :         UnicodeString result;
     284             :         UBool isSystemID;
     285           4 :         TimeZone::getCanonicalID(id, result, isSystemID, status);
     286           4 :         INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID");
     287             : 
     288           3 :         zend_string *u8str =intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status);
     289           3 :         INTL_CHECK_STATUS(status,
     290             :                 "intltz_get_canonical_id: could not convert time zone id to UTF-16");
     291           3 :         RETVAL_NEW_STR(u8str);
     292             : 
     293           3 :         if (is_systemid) { /* by-ref argument passed */
     294           2 :                 ZVAL_DEREF(is_systemid);
     295           1 :                 zval_ptr_dtor(is_systemid);
     296           1 :                 ZVAL_BOOL(is_systemid, isSystemID);
     297             :         }
     298             : }
     299             : 
     300           5 : U_CFUNC PHP_FUNCTION(intltz_get_region)
     301             : {
     302             :         char    *str_id;
     303             :         size_t   str_id_len;
     304             :         char     outbuf[3];
     305           5 :         intl_error_reset(NULL);
     306             : 
     307          10 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
     308           5 :                         &str_id, &str_id_len) == FAILURE) {
     309           1 :                 RETURN_FALSE;
     310             :         }
     311             : 
     312           4 :         UErrorCode status = UErrorCode();
     313           8 :         UnicodeString id;
     314           4 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     315           1 :                 intl_error_set(NULL, status,
     316             :                         "intltz_get_region: could not convert time zone id to UTF-16", 0);
     317           1 :                 RETURN_FALSE;
     318             :         }
     319             : 
     320           3 :         int32_t region_len = TimeZone::getRegion(id, outbuf, sizeof(outbuf), status);
     321           3 :         INTL_CHECK_STATUS(status, "intltz_get_region: Error obtaining region");
     322             : 
     323           4 :         RETURN_STRINGL(outbuf, region_len);
     324             : }
     325             : 
     326           2 : U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version)
     327             : {
     328           2 :         intl_error_reset(NULL);
     329             : 
     330           2 :         if (zend_parse_parameters_none() == FAILURE) {
     331           0 :                 RETURN_FALSE;
     332             :         }
     333             : 
     334           2 :         UErrorCode status = UErrorCode();
     335           2 :         const char *res = TimeZone::getTZDataVersion(status);
     336           2 :         INTL_CHECK_STATUS(status, "intltz_get_tz_data_version: "
     337             :                 "Error obtaining time zone data version");
     338             : 
     339           4 :         RETURN_STRING(res);
     340             : }
     341             : 
     342           4 : U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
     343             : {
     344             :         char       *str_id;
     345             :         size_t          str_id_len;
     346             :         zend_long       index;
     347           4 :         intl_error_reset(NULL);
     348             : 
     349           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
     350           3 :                         &str_id, &str_id_len, &index) == FAILURE ||
     351           7 :                         index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) {
     352           3 :                 RETURN_FALSE;
     353             :         }
     354             : 
     355           3 :         UErrorCode status = UErrorCode();
     356           5 :         UnicodeString id;
     357           3 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     358           1 :                 intl_error_set(NULL, status,
     359             :                         "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0);
     360           1 :                 RETURN_FALSE;
     361             :         }
     362             : 
     363           4 :         const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
     364             :         zend_string *u8str;
     365             : 
     366           2 :         u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status);
     367           2 :         INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
     368             :                 "could not convert resulting time zone id to UTF-16");
     369           2 :         RETVAL_NEW_STR(u8str);
     370             : }
     371             : 
     372          34 : U_CFUNC PHP_FUNCTION(intltz_get_id)
     373             : {
     374          34 :         TIMEZONE_METHOD_INIT_VARS;
     375             : 
     376         102 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     377          34 :                         &object, TimeZone_ce_ptr) == FAILURE) {
     378           0 :                 RETURN_FALSE;
     379             :         }
     380             : 
     381          34 :         TIMEZONE_METHOD_FETCH_OBJECT;
     382             : 
     383          68 :         UnicodeString id_us;
     384          34 :         to->utimezone->getID(id_us);
     385             : 
     386             :         zend_string *u8str;
     387             : 
     388          34 :         u8str = intl_convert_utf16_to_utf8(
     389             :                 id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
     390          34 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
     391             : 
     392          34 :         RETVAL_NEW_STR(u8str);
     393             : }
     394             : 
     395           4 : U_CFUNC PHP_FUNCTION(intltz_use_daylight_time)
     396             : {
     397           4 :         TIMEZONE_METHOD_INIT_VARS;
     398             : 
     399          12 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     400           4 :                         &object, TimeZone_ce_ptr) == FAILURE) {
     401           0 :                 RETURN_FALSE;
     402             :         }
     403             : 
     404           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     405             : 
     406           4 :         RETURN_BOOL(to->utimezone->useDaylightTime());
     407             : }
     408             : 
     409           4 : U_CFUNC PHP_FUNCTION(intltz_get_offset)
     410             : {
     411             :         double          date;
     412             :         zend_bool       local;
     413             :         zval            *rawOffsetArg,
     414             :                                 *dstOffsetArg;
     415             :         int32_t         rawOffset,
     416             :                                 dstOffset;
     417           4 :         TIMEZONE_METHOD_INIT_VARS;
     418             : 
     419          12 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     420             :                         "Odbz/z/", &object, TimeZone_ce_ptr, &date, &local, &rawOffsetArg,
     421           4 :                         &dstOffsetArg) == FAILURE) {
     422           0 :                 RETURN_FALSE;
     423             :         }
     424             : 
     425           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     426             : 
     427           8 :         to->utimezone->getOffset((UDate) date, (UBool) local, rawOffset, dstOffset,
     428           4 :                 TIMEZONE_ERROR_CODE(to));
     429             : 
     430           4 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_offset: error obtaining offset");
     431             : 
     432           2 :         zval_ptr_dtor(rawOffsetArg);
     433           2 :         ZVAL_LONG(rawOffsetArg, rawOffset);
     434           2 :         zval_ptr_dtor(dstOffsetArg);
     435           2 :         ZVAL_LONG(dstOffsetArg, dstOffset);
     436             : 
     437           2 :         RETURN_TRUE;
     438             : }
     439             : 
     440           8 : U_CFUNC PHP_FUNCTION(intltz_get_raw_offset)
     441             : {
     442           8 :         TIMEZONE_METHOD_INIT_VARS;
     443             : 
     444          24 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     445           8 :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     446           0 :                 RETURN_FALSE;
     447             :         }
     448             : 
     449           8 :         TIMEZONE_METHOD_FETCH_OBJECT;
     450             : 
     451           8 :         RETURN_LONG(to->utimezone->getRawOffset());
     452             : }
     453             : 
     454           3 : U_CFUNC PHP_FUNCTION(intltz_has_same_rules)
     455             : {
     456             :         zval                    *other_object;
     457             :         TimeZone_object *other_to;
     458           3 :         TIMEZONE_METHOD_INIT_VARS;
     459             : 
     460           9 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     461             :                         "OO", &object, TimeZone_ce_ptr, &other_object, TimeZone_ce_ptr)
     462           3 :                         == FAILURE) {
     463           0 :                 RETURN_FALSE;
     464             :         }
     465           3 :         TIMEZONE_METHOD_FETCH_OBJECT;
     466           3 :         other_to = Z_INTL_TIMEZONE_P(other_object);
     467           3 :         if (other_to->utimezone == NULL) {
     468           0 :                 intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR,
     469             :                         "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0);
     470           0 :                 RETURN_FALSE;
     471             :         }
     472             : 
     473           3 :         RETURN_BOOL(to->utimezone->hasSameRules(*other_to->utimezone));
     474             : }
     475             : 
     476             : static const TimeZone::EDisplayType display_types[] = {
     477             :         TimeZone::SHORT,                                TimeZone::LONG,
     478             :         TimeZone::SHORT_GENERIC,                TimeZone::LONG_GENERIC,
     479             :         TimeZone::SHORT_GMT,                    TimeZone::LONG_GMT,
     480             :         TimeZone::SHORT_COMMONLY_USED,  TimeZone::GENERIC_LOCATION
     481             : };
     482             : 
     483          14 : U_CFUNC PHP_FUNCTION(intltz_get_display_name)
     484             : {
     485          14 :         zend_bool       daylight                = 0;
     486          14 :         zend_long       display_type    = TimeZone::LONG;
     487          14 :         const char *locale_str          = NULL;
     488          14 :         size_t          dummy                   = 0;
     489          14 :         TIMEZONE_METHOD_INIT_VARS;
     490             : 
     491          42 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     492             :                         "O|bls!", &object, TimeZone_ce_ptr, &daylight, &display_type,
     493          14 :                         &locale_str, &dummy) == FAILURE) {
     494           1 :                 RETURN_FALSE;
     495             :         }
     496             : 
     497          14 :         bool found = false;
     498          68 :         for (int i = 0; !found && i < sizeof(display_types)/sizeof(*display_types); i++) {
     499          54 :                 if (display_types[i] == display_type)
     500          13 :                         found = true;
     501             :         }
     502          14 :         if (!found) {
     503           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     504             :                         "intltz_get_display_name: wrong display type", 0);
     505           1 :                 RETURN_FALSE;
     506             :         }
     507             : 
     508          13 :         if (!locale_str) {
     509          13 :                 locale_str = intl_locale_get_default();
     510             :         }
     511             : 
     512          13 :         TIMEZONE_METHOD_FETCH_OBJECT;
     513             : 
     514          26 :         UnicodeString result;
     515          39 :         to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type,
     516          39 :                 Locale::createFromName(locale_str), result);
     517             : 
     518          13 :         zend_string *u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
     519          13 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
     520             :                 "could not convert resulting time zone id to UTF-16");
     521             : 
     522          13 :         RETVAL_NEW_STR(u8str);
     523             : }
     524             : 
     525           2 : U_CFUNC PHP_FUNCTION(intltz_get_dst_savings)
     526             : {
     527           2 :         TIMEZONE_METHOD_INIT_VARS;
     528             : 
     529           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     530           2 :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     531           0 :                 RETURN_FALSE;
     532             :         }
     533             : 
     534           2 :         TIMEZONE_METHOD_FETCH_OBJECT;
     535             : 
     536           2 :         RETURN_LONG((zend_long)to->utimezone->getDSTSavings());
     537             : }
     538             : 
     539           4 : U_CFUNC PHP_FUNCTION(intltz_to_date_time_zone)
     540             : {
     541             :         zval tmp;
     542           4 :         TIMEZONE_METHOD_INIT_VARS;
     543             : 
     544          12 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     545           4 :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     546           1 :                 RETURN_FALSE;
     547             :         }
     548             : 
     549           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     550             : 
     551           4 :         zval *ret = timezone_convert_to_datetimezone(to->utimezone,
     552           4 :                 &TIMEZONE_ERROR(to), "intltz_to_date_time_zone", &tmp);
     553             : 
     554           4 :         if (ret) {
     555           3 :                 ZVAL_COPY_VALUE(return_value, ret);
     556             :         } else {
     557           1 :                 RETURN_FALSE;
     558             :         }
     559             : }
     560             : 
     561           2 : U_CFUNC PHP_FUNCTION(intltz_get_error_code)
     562             : {
     563           2 :         TIMEZONE_METHOD_INIT_VARS
     564             : 
     565           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     566           2 :                         &object, TimeZone_ce_ptr) == FAILURE) {
     567           0 :                 RETURN_FALSE;
     568             :         }
     569             : 
     570             :         /* Fetch the object (without resetting its last error code ). */
     571           2 :         to = Z_INTL_TIMEZONE_P(object);
     572           2 :         if (to == NULL)
     573           0 :                 RETURN_FALSE;
     574             : 
     575           2 :         RETURN_LONG((zend_long)TIMEZONE_ERROR_CODE(to));
     576             : }
     577             : 
     578           2 : U_CFUNC PHP_FUNCTION(intltz_get_error_message)
     579             : {
     580           2 :         zend_string* message = NULL;
     581           2 :         TIMEZONE_METHOD_INIT_VARS
     582             : 
     583           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     584           2 :                         &object, TimeZone_ce_ptr) == FAILURE) {
     585           0 :                 RETURN_FALSE;
     586             :         }
     587             : 
     588             : 
     589             :         /* Fetch the object (without resetting its last error code ). */
     590           2 :         to = Z_INTL_TIMEZONE_P(object);
     591           2 :         if (to == NULL)
     592           0 :                 RETURN_FALSE;
     593             : 
     594             :         /* Return last error message. */
     595           2 :         message = intl_error_get_message(TIMEZONE_ERROR_P(to));
     596           4 :         RETURN_STR(message);
     597             : }
     598             : 
     599             : #if U_ICU_VERSION_MAJOR_NUM >= 52
     600             : /* {{{ proto string IntlTimeZone::getWindowsID(string $timezone)
     601             :        proto string intltz_get_windows_id(string $timezone)
     602             : Translate a system timezone (e.g. "America/Los_Angeles" into a
     603             : Windows Timezone (e.g. "Pacific Standard Time")
     604             :  */
     605          10 : U_CFUNC PHP_FUNCTION(intltz_get_windows_id)
     606             : {
     607             :         zend_string *id, *winID;
     608          20 :         UnicodeString uID, uWinID;
     609             :         UErrorCode error;
     610             : 
     611          10 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &id) == FAILURE) {
     612           0 :                 return;
     613             :         }
     614             : 
     615          10 :         error = U_ZERO_ERROR;
     616          10 :         if (intl_stringFromChar(uID, id->val, id->len, &error) == FAILURE) {
     617           0 :                 intl_error_set(NULL, error,
     618             :                                "intltz_get_windows_id: could not convert time zone id to UTF-16", 0);
     619           0 :                 RETURN_FALSE;
     620             :         }
     621             : 
     622          10 :         error = U_ZERO_ERROR;
     623          10 :         TimeZone::getWindowsID(uID, uWinID, error);
     624          10 :         INTL_CHECK_STATUS(error, "intltz_get_windows_id: Unable to get timezone from windows ID");
     625          10 :         if (uWinID.length() == 0) {
     626           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     627             :                                "intltz_get_windows_id: Unknown system timezone", 0);
     628           1 :                 RETURN_FALSE;
     629             :         }
     630             : 
     631           9 :         error = U_ZERO_ERROR;
     632           9 :         winID = intl_convert_utf16_to_utf8(uWinID.getBuffer(), uWinID.length(), &error);
     633           9 :         INTL_CHECK_STATUS(error, "intltz_get_windows_id: could not convert time zone id to UTF-8");
     634          18 :         RETURN_STR(winID);
     635             : }
     636             : /* }}} */
     637             : 
     638             : /* {{{ proto string IntlTimeZone::getIDForWindowsID(string $timezone[, string $region = NULL])
     639             :        proto string intltz_get_id_for_windows_id(string $timezone[, string $region = NULL])
     640             : Translate a windows timezone (e.g. "Pacific Time Zone" into a
     641             : System Timezone (e.g. "America/Los_Angeles")
     642             :  */
     643          12 : U_CFUNC PHP_FUNCTION(intltz_get_id_for_windows_id)
     644             : {
     645          12 :         zend_string *winID, *region = NULL, *id;
     646          24 :         UnicodeString uWinID, uID;
     647             :         UErrorCode error;
     648             : 
     649          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|S", &winID, &region) == FAILURE) {
     650           0 :                 return;
     651             :         }
     652             : 
     653          12 :         error = U_ZERO_ERROR;
     654          12 :         if (intl_stringFromChar(uWinID, winID->val, winID->len, &error) == FAILURE) {
     655           0 :                 intl_error_set(NULL, error,
     656             :                                "intltz_get_id_for_windows_id: could not convert time zone id to UTF-16", 0);
     657           0 :                 RETURN_FALSE;
     658             :         }
     659             : 
     660          12 :         error = U_ZERO_ERROR;
     661          12 :         TimeZone::getIDForWindowsID(uWinID, region ? region->val : NULL, uID, error);
     662          12 :         INTL_CHECK_STATUS(error, "intltz_get_id_for_windows_id: Unable to get windows ID for timezone");
     663          12 :         if (uID.length() == 0) {
     664           1 :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     665             :                                "intltz_get_windows_id: Unknown windows timezone", 0);
     666           1 :                 RETURN_FALSE;
     667             :         }
     668             : 
     669          11 :         error = U_ZERO_ERROR;
     670          11 :         id = intl_convert_utf16_to_utf8(uID.getBuffer(), uID.length(), &error);
     671          11 :         INTL_CHECK_STATUS(error, "intltz_get_id_for_windows_id: could not convert time zone id to UTF-8");
     672          22 :         RETURN_STR(id);
     673             : }
     674             : /* }}} */
     675             : #endif

Generated by: LCOV version 1.10

Generated at Mon, 06 May 2019 17:58:16 +0000 (992 days ago)

Copyright © 2005-2022 The PHP Group
All rights reserved.