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

Generated by: LCOV version 1.10

Generated at Sat, 29 Aug 2015 10:22:16 +0000 (23 hours ago)

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