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

Generated by: LCOV version 1.10

Generated at Sat, 13 Dec 2014 06:16:14 +0000 (6 days ago)

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