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: 227 251 90.4 %
Date: 2015-04-14 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          10 : U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone)
      73             : {
      74             :         zval                            *zv_timezone;
      75             :         TimeZone                        *tz;
      76             :         php_timezone_obj        *tzobj;
      77          10 :         intl_error_reset(NULL);
      78             : 
      79          10 :         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           6 :                         "intltz_from_date_time_zone: bad arguments", 0);
      83           6 :                 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             :         char *str;
     309             :         size_t str_len;
     310           4 :         intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
     311           4 :         INTL_CHECK_STATUS(status,
     312             :                 "intltz_get_canonical_id: could not convert time zone id to UTF-16");
     313           8 :         RETVAL_STRINGL(str, str_len);
     314             :         //????
     315           4 :         efree(str);
     316             : 
     317           4 :         if (is_systemid) { /* by-ref argument passed */
     318           4 :                 ZVAL_DEREF(is_systemid);
     319           2 :                 zval_dtor(is_systemid);
     320           2 :                 ZVAL_BOOL(is_systemid, isSystemID);
     321           0 :         }
     322             : }
     323             : 
     324             : #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
     325             : U_CFUNC PHP_FUNCTION(intltz_get_region)
     326             : {
     327             :         char    *str_id;
     328             :         size_t   str_id_len;
     329             :         char     outbuf[3];
     330             :         intl_error_reset(NULL);
     331             : 
     332             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
     333             :                         &str_id, &str_id_len) == FAILURE) {
     334             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     335             :                         "intltz_get_region: bad arguments", 0);
     336             :                 RETURN_FALSE;
     337             :         }
     338             : 
     339             :         UErrorCode status = UErrorCode();
     340             :         UnicodeString id;
     341             :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     342             :                 intl_error_set(NULL, status,
     343             :                         "intltz_get_region: could not convert time zone id to UTF-16", 0);
     344             :                 RETURN_FALSE;
     345             :         }
     346             : 
     347             :         int32_t region_len = TimeZone::getRegion(id, outbuf, sizeof(outbuf), status);
     348             :         INTL_CHECK_STATUS(status, "intltz_get_region: Error obtaining region");
     349             : 
     350             :         RETURN_STRINGL(outbuf, region_len);
     351             : }
     352             : #endif
     353             : 
     354           3 : U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version)
     355             : {
     356           3 :         intl_error_reset(NULL);
     357             : 
     358           3 :         if (zend_parse_parameters_none() == FAILURE) {
     359             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     360           1 :                         "intltz_get_tz_data_version: bad arguments", 0);
     361           1 :                 RETURN_FALSE;
     362             :         }
     363             : 
     364           2 :         UErrorCode status = UErrorCode();
     365           2 :         const char *res = TimeZone::getTZDataVersion(status);
     366           2 :         INTL_CHECK_STATUS(status, "intltz_get_tz_data_version: "
     367             :                 "Error obtaining time zone data version");
     368             : 
     369           4 :         RETURN_STRING(res);
     370             : }
     371             : 
     372           7 : U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
     373             : {
     374             :         char       *str_id;
     375             :         size_t          str_id_len;
     376             :         zend_long       index;
     377           7 :         intl_error_reset(NULL);
     378             : 
     379           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
     380             :                         &str_id, &str_id_len, &index) == FAILURE ||
     381             :                         index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) {
     382             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     383           4 :                         "intltz_get_equivalent_id: bad arguments", 0);
     384           4 :                 RETURN_FALSE;
     385             :         }
     386             : 
     387           3 :         UErrorCode status = UErrorCode();
     388           3 :         UnicodeString id;
     389           3 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     390             :                 intl_error_set(NULL, status,
     391           1 :                         "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0);
     392           1 :                 RETURN_FALSE;
     393             :         }
     394             : 
     395           2 :         const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
     396             :         char *str;
     397             :         size_t str_len;
     398             : 
     399           2 :         intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
     400           2 :         INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
     401             :                 "could not convert resulting time zone id to UTF-16");
     402           4 :         RETVAL_STRINGL(str, str_len);
     403             :         //????
     404           2 :         efree(str);
     405             : }
     406             : 
     407          28 : U_CFUNC PHP_FUNCTION(intltz_get_id)
     408             : {
     409          28 :         TIMEZONE_METHOD_INIT_VARS;
     410             : 
     411          28 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     412             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     413             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     414           2 :                         "intltz_get_id: bad arguments", 0);
     415           2 :                 RETURN_FALSE;
     416             :         }
     417             : 
     418          26 :         TIMEZONE_METHOD_FETCH_OBJECT;
     419             : 
     420          26 :         UnicodeString id_us;
     421          26 :         to->utimezone->getID(id_us);
     422             : 
     423          26 :         char   *id = NULL;
     424          26 :         size_t  id_len   = 0;
     425             : 
     426             :         intl_convert_utf16_to_utf8(&id, &id_len,
     427          26 :                 id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
     428          26 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
     429             : 
     430          52 :         RETVAL_STRINGL(id, id_len);
     431             :         //???
     432          26 :         efree(id);
     433             : }
     434             : 
     435           6 : U_CFUNC PHP_FUNCTION(intltz_use_daylight_time)
     436             : {
     437           6 :         TIMEZONE_METHOD_INIT_VARS;
     438             : 
     439           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     440             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     441             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     442           2 :                         "intltz_use_daylight_time: bad arguments", 0);
     443           2 :                 RETURN_FALSE;
     444             :         }
     445             : 
     446           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     447             : 
     448           4 :         RETURN_BOOL(to->utimezone->useDaylightTime());
     449             : }
     450             : 
     451           7 : U_CFUNC PHP_FUNCTION(intltz_get_offset)
     452             : {
     453             :         UDate           date;
     454             :         zend_bool       local;
     455             :         zval            *rawOffsetArg,
     456             :                                 *dstOffsetArg;
     457             :         int32_t         rawOffset,
     458             :                                 dstOffset;
     459           7 :         TIMEZONE_METHOD_INIT_VARS;
     460             : 
     461           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     462             :                         "Odbz/z/", &object, TimeZone_ce_ptr, &date, &local, &rawOffsetArg,
     463             :                         &dstOffsetArg) == FAILURE) {
     464             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     465           3 :                         "intltz_get_offset: bad arguments", 0);
     466           3 :                 RETURN_FALSE;
     467             :         }
     468             : 
     469           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     470             : 
     471             :         to->utimezone->getOffset(date, (UBool) local, rawOffset, dstOffset,
     472           4 :                 TIMEZONE_ERROR_CODE(to));
     473             : 
     474           4 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_offset: error obtaining offset");
     475             : 
     476           4 :         ZVAL_DEREF(rawOffsetArg);
     477           2 :         zval_dtor(rawOffsetArg);
     478           2 :         ZVAL_LONG(rawOffsetArg, rawOffset);
     479           4 :         ZVAL_DEREF(dstOffsetArg);
     480           2 :         zval_dtor(dstOffsetArg);
     481           2 :         ZVAL_LONG(dstOffsetArg, dstOffset);
     482             : 
     483           2 :         RETURN_TRUE;
     484             : }
     485             : 
     486          10 : U_CFUNC PHP_FUNCTION(intltz_get_raw_offset)
     487             : {
     488          10 :         TIMEZONE_METHOD_INIT_VARS;
     489             : 
     490          10 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     491             :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     492             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     493           2 :                         "intltz_get_raw_offset: bad arguments", 0);
     494           2 :                 RETURN_FALSE;
     495             :         }
     496             : 
     497           8 :         TIMEZONE_METHOD_FETCH_OBJECT;
     498             : 
     499           8 :         RETURN_LONG(to->utimezone->getRawOffset());
     500             : }
     501             : 
     502           6 : U_CFUNC PHP_FUNCTION(intltz_has_same_rules)
     503             : {
     504             :         zval                    *other_object;
     505             :         TimeZone_object *other_to;
     506           6 :         TIMEZONE_METHOD_INIT_VARS;
     507             : 
     508           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     509             :                         "OO", &object, TimeZone_ce_ptr, &other_object, TimeZone_ce_ptr)
     510             :                         == FAILURE) {
     511             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     512           3 :                         "intltz_has_same_rules: bad arguments", 0);
     513           3 :                 RETURN_FALSE;
     514             :         }
     515           3 :         TIMEZONE_METHOD_FETCH_OBJECT;
     516           3 :         other_to = Z_INTL_TIMEZONE_P(other_object);
     517           3 :         if (other_to->utimezone == NULL) {
     518             :                 intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR,
     519           0 :                         "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0);
     520           0 :                 RETURN_FALSE;
     521             :         }
     522             : 
     523           3 :         RETURN_BOOL(to->utimezone->hasSameRules(*other_to->utimezone));
     524             : }
     525             : 
     526             : static const TimeZone::EDisplayType display_types[] = {
     527             :         TimeZone::SHORT,                                TimeZone::LONG,
     528             : #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 44
     529             :         TimeZone::SHORT_GENERIC,                TimeZone::LONG_GENERIC,
     530             :         TimeZone::SHORT_GMT,                    TimeZone::LONG_GMT,
     531             :         TimeZone::SHORT_COMMONLY_USED,  TimeZone::GENERIC_LOCATION
     532             : #endif
     533             : };
     534             : 
     535          14 : U_CFUNC PHP_FUNCTION(intltz_get_display_name)
     536             : {
     537          14 :         zend_bool       daylight                = 0;
     538          14 :         zend_long       display_type    = TimeZone::LONG;
     539          14 :         const char *locale_str          = NULL;
     540          14 :         size_t          dummy                   = 0;
     541          14 :         TIMEZONE_METHOD_INIT_VARS;
     542             : 
     543          14 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     544             :                         "O|bls!", &object, TimeZone_ce_ptr, &daylight, &display_type,
     545             :                         &locale_str, &dummy) == FAILURE) {
     546             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     547           5 :                         "intltz_get_display_name: bad arguments", 0);
     548           5 :                 RETURN_FALSE;
     549             :         }
     550             : 
     551           9 :         bool found = false;
     552          27 :         for (int i = 0; !found && i < sizeof(display_types)/sizeof(*display_types); i++) {
     553          18 :                 if (display_types[i] == display_type)
     554           8 :                         found = true;
     555             :         }
     556           9 :         if (!found) {
     557             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     558           1 :                         "intltz_get_display_name: wrong display type", 0);
     559           1 :                 RETURN_FALSE;
     560             :         }
     561             : 
     562           8 :         if (!locale_str) {
     563           7 :                 locale_str = intl_locale_get_default();
     564             :         }
     565             : 
     566           8 :         TIMEZONE_METHOD_FETCH_OBJECT;
     567             : 
     568           8 :         UnicodeString result;
     569             :         to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type,
     570           8 :                 Locale::createFromName(locale_str), result);
     571             : 
     572             :         char *str;
     573             :         size_t str_len;
     574           8 :         intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
     575           8 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
     576             :                 "could not convert resulting time zone id to UTF-16");
     577             : 
     578          16 :         RETVAL_STRINGL(str, str_len);
     579             :         //????
     580           8 :         efree(str);
     581             : }
     582             : 
     583           4 : U_CFUNC PHP_FUNCTION(intltz_get_dst_savings)
     584             : {
     585           4 :         TIMEZONE_METHOD_INIT_VARS;
     586             : 
     587           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     588             :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     589             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     590           2 :                         "intltz_get_dst_savings: bad arguments", 0);
     591           2 :                 RETURN_FALSE;
     592             :         }
     593             : 
     594           2 :         TIMEZONE_METHOD_FETCH_OBJECT;
     595             : 
     596           2 :         RETURN_LONG((zend_long)to->utimezone->getDSTSavings());
     597             : }
     598             : 
     599           7 : U_CFUNC PHP_FUNCTION(intltz_to_date_time_zone)
     600             : {
     601             :         zval tmp;
     602           7 :         TIMEZONE_METHOD_INIT_VARS;
     603             : 
     604           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
     605             :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     606             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     607           3 :                         "intltz_to_date_time_zone: bad arguments", 0);
     608           3 :                 RETURN_FALSE;
     609             :         }
     610             : 
     611           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     612             : 
     613             :         zval *ret = timezone_convert_to_datetimezone(to->utimezone,
     614           4 :                 &TIMEZONE_ERROR(to), "intltz_to_date_time_zone", &tmp);
     615             : 
     616           4 :         if (ret) {
     617           9 :                 RETURN_ZVAL(ret, 1, 1);
     618             :         } else {
     619           1 :                 RETURN_FALSE;
     620             :         }
     621             : }
     622             : 
     623           4 : U_CFUNC PHP_FUNCTION(intltz_get_error_code)
     624             : {
     625           4 :         TIMEZONE_METHOD_INIT_VARS
     626             : 
     627           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     628             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     629             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     630           2 :                         "intltz_get_error_code: bad arguments", 0);
     631           2 :                 RETURN_FALSE;
     632             :         }
     633             : 
     634             :         /* Fetch the object (without resetting its last error code ). */
     635           2 :         to = Z_INTL_TIMEZONE_P(object);
     636           2 :         if (to == NULL)
     637           0 :                 RETURN_FALSE;
     638             : 
     639           2 :         RETURN_LONG((zend_long)TIMEZONE_ERROR_CODE(to));
     640             : }
     641             : 
     642           4 : U_CFUNC PHP_FUNCTION(intltz_get_error_message)
     643             : {
     644           4 :         zend_string* message = NULL;
     645           4 :         TIMEZONE_METHOD_INIT_VARS
     646             : 
     647           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
     648             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     649             :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
     650           2 :                         "intltz_get_error_message: bad arguments", 0 );
     651           2 :                 RETURN_FALSE;
     652             :         }
     653             : 
     654             : 
     655             :         /* Fetch the object (without resetting its last error code ). */
     656           2 :         to = Z_INTL_TIMEZONE_P(object);
     657           2 :         if (to == NULL)
     658           0 :                 RETURN_FALSE;
     659             : 
     660             :         /* Return last error message. */
     661           2 :         message = intl_error_get_message(TIMEZONE_ERROR_P(to));
     662           2 :         RETURN_STR(message);
     663             : }

Generated by: LCOV version 1.10

Generated at Tue, 14 Apr 2015 11:48:44 +0000 (3 days ago)

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