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: 220 246 89.4 %
Date: 2014-08-04 Functions: 19 20 95.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       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             :         int             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 = (php_timezone_obj *)zend_objects_get_address(zv_timezone TSRMLS_CC);
      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           7 :         if (arg == NULL || Z_TYPE_PP(arg) == IS_NULL) {
     161           2 :                 se = TimeZone::createEnumeration();
     162           3 :         } else if (Z_TYPE_PP(arg) == IS_LONG) {
     163             : int_offset:
     164           1 :                 if (Z_LVAL_PP(arg) < (long)INT32_MIN ||
     165             :                                 Z_LVAL_PP(arg) > (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_PP(arg));
     171             :                 }
     172           2 :         } else if (Z_TYPE_PP(arg) == IS_DOUBLE) {
     173             : double_offset:
     174           0 :                 convert_to_long_ex(arg);
     175           0 :                 goto int_offset;
     176           3 :         } else if (Z_TYPE_PP(arg) == IS_OBJECT || Z_TYPE_PP(arg) == IS_STRING) {
     177             :                 long lval;
     178             :                 double dval;
     179           1 :                 convert_to_string_ex(arg);
     180           1 :                 switch (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &lval, &dval, 0)) {
     181             :                 case IS_DOUBLE:
     182           0 :                         SEPARATE_ZVAL(arg);
     183           0 :                         zval_dtor(*arg);
     184           0 :                         Z_TYPE_PP(arg) = IS_DOUBLE;
     185           0 :                         Z_DVAL_PP(arg) = dval;
     186           0 :                         goto double_offset;
     187             :                 case IS_LONG:
     188           0 :                         SEPARATE_ZVAL(arg);
     189           0 :                         zval_dtor(*arg);
     190           0 :                         Z_TYPE_PP(arg) = IS_LONG;
     191           0 :                         Z_LVAL_PP(arg) = lval;
     192           0 :                         goto int_offset;
     193             :                 }
     194             :                 /* else call string version */
     195           1 :                 se = TimeZone::createEnumeration(Z_STRVAL_PP(arg));
     196             :         } else {
     197             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     198           1 :                         "intltz_create_enumeration: invalid argument type", 0 TSRMLS_CC);
     199           1 :                 RETURN_FALSE;
     200             :         }
     201             : 
     202           4 :         if (se) {
     203           4 :                 IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC);
     204             :         } else {
     205             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     206           0 :                         "intltz_create_enumeration: error obtaining enumeration", 0 TSRMLS_CC);
     207           0 :                 RETVAL_FALSE;
     208             :         }
     209             : }
     210             : 
     211           7 : U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids)
     212             : {
     213             :         char    *str_id;
     214             :         int             str_id_len;
     215           7 :         intl_error_reset(NULL TSRMLS_CC);
     216             : 
     217           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
     218             :                         &str_id, &str_id_len) == FAILURE) {
     219             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     220           4 :                         "intltz_count_equivalent_ids: bad arguments", 0 TSRMLS_CC);
     221           4 :                 RETURN_FALSE;
     222             :         }
     223             : 
     224           3 :         UErrorCode status = UErrorCode();
     225           3 :         UnicodeString id = UnicodeString();
     226           3 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     227             :                 intl_error_set(NULL, status,
     228           1 :                         "intltz_count_equivalent_ids: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
     229           1 :                 RETURN_FALSE;
     230             :         }
     231             : 
     232           2 :         int32_t result = TimeZone::countEquivalentIDs(id);
     233           2 :         RETURN_LONG((long)result);
     234             : }
     235             : 
     236             : #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
     237             : U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration)
     238             : {
     239             :         long    zoneType,
     240             :                         offset_arg;
     241             :         char    *region         = NULL;
     242             :         int             region_len      = 0;
     243             :         int32_t offset,
     244             :                         *offsetp        = NULL;
     245             :         int             arg3isnull      = 0;
     246             :         intl_error_reset(NULL TSRMLS_CC);
     247             : 
     248             :         /* must come before zpp because zpp would convert the arg in the stack to 0 */
     249             :         if (ZEND_NUM_ARGS() == 3) {
     250             :                 zval **dummy, **zvoffset;
     251             :                 arg3isnull = zend_get_parameters_ex(3, &dummy, &dummy, &zvoffset)
     252             :                                 != FAILURE && Z_TYPE_PP(zvoffset) == IS_NULL;
     253             :         }
     254             : 
     255             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s!l",
     256             :                         &zoneType, &region, &region_len, &offset_arg) == FAILURE) {
     257             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     258             :                         "intltz_create_time_zone_id_enumeration: bad arguments", 0 TSRMLS_CC);
     259             :                 RETURN_FALSE;
     260             :         }
     261             : 
     262             :         if (zoneType != UCAL_ZONE_TYPE_ANY && zoneType != UCAL_ZONE_TYPE_CANONICAL
     263             :                         && zoneType != UCAL_ZONE_TYPE_CANONICAL_LOCATION) {
     264             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     265             :                         "intltz_create_time_zone_id_enumeration: bad zone type", 0 TSRMLS_CC);
     266             :                 RETURN_FALSE;
     267             :         }
     268             : 
     269             :         if (ZEND_NUM_ARGS() == 3) {
     270             :                 if (offset_arg < (long)INT32_MIN || offset_arg > (long)INT32_MAX) {
     271             :                         intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     272             :                                 "intltz_create_time_zone_id_enumeration: offset out of bounds", 0 TSRMLS_CC);
     273             :                         RETURN_FALSE;
     274             :                 }
     275             :                 
     276             :                 if (!arg3isnull) {
     277             :                         offset = (int32_t)offset_arg;
     278             :                         offsetp = &offset;
     279             :                 } //else leave offsetp NULL
     280             :         }
     281             : 
     282             :         StringEnumeration *se;
     283             :         UErrorCode uec = UErrorCode();
     284             :         se = TimeZone::createTimeZoneIDEnumeration((USystemTimeZoneType)zoneType,
     285             :                 region, offsetp, uec);
     286             :         INTL_CHECK_STATUS(uec, "intltz_create_time_zone_id_enumeration: "
     287             :                 "Error obtaining time zone id enumeration")
     288             : 
     289             :         IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC);
     290             : }
     291             : #endif
     292             : 
     293           8 : U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
     294             : {
     295             :         char    *str_id;
     296             :         int             str_id_len;
     297           8 :         zval    *is_systemid = NULL;
     298           8 :         intl_error_reset(NULL TSRMLS_CC);
     299             : 
     300           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z",
     301             :                         &str_id, &str_id_len, &is_systemid) == FAILURE) {
     302             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     303           3 :                         "intltz_get_canonical_id: bad arguments", 0 TSRMLS_CC);
     304           3 :                 RETURN_FALSE;
     305             :         }
     306             : 
     307           5 :         UErrorCode status = UErrorCode();
     308           5 :         UnicodeString id;
     309           5 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     310             :                 intl_error_set(NULL, status,
     311           1 :                         "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
     312           1 :                 RETURN_FALSE;
     313             :         }
     314             : 
     315           4 :         UnicodeString result;
     316             :         UBool isSystemID;
     317           4 :         TimeZone::getCanonicalID(id, result, isSystemID, status);
     318           4 :         INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID");
     319             :         
     320             :         intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value),
     321           4 :                 result.getBuffer(), result.length(), &status);
     322           4 :         INTL_CHECK_STATUS(status,
     323             :                 "intltz_get_canonical_id: could not convert time zone id to UTF-16");
     324           4 :         Z_TYPE_P(return_value) = IS_STRING;
     325             :         
     326           4 :         if (is_systemid) { /* by-ref argument passed */
     327           2 :                 zval_dtor(is_systemid);
     328           2 :                 ZVAL_BOOL(is_systemid, isSystemID);
     329           0 :         }
     330             : }
     331             : 
     332             : #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
     333             : U_CFUNC PHP_FUNCTION(intltz_get_region)
     334             : {
     335             :         char    *str_id;
     336             :         int             str_id_len;
     337             :         char    outbuf[3];
     338             :         intl_error_reset(NULL TSRMLS_CC);
     339             : 
     340             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
     341             :                         &str_id, &str_id_len) == FAILURE) {
     342             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     343             :                         "intltz_get_region: bad arguments", 0 TSRMLS_CC);
     344             :                 RETURN_FALSE;
     345             :         }
     346             : 
     347             :         UErrorCode status = UErrorCode();
     348             :         UnicodeString id;
     349             :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     350             :                 intl_error_set(NULL, status,
     351             :                         "intltz_get_region: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
     352             :                 RETURN_FALSE;
     353             :         }
     354             : 
     355             :         int32_t region_len = TimeZone::getRegion(id, outbuf, sizeof(outbuf), status);
     356             :         INTL_CHECK_STATUS(status, "intltz_get_region: Error obtaining region");
     357             : 
     358             :         RETURN_STRINGL(outbuf, region_len, 1);
     359             : }
     360             : #endif
     361             : 
     362           3 : U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version)
     363             : {
     364           3 :         intl_error_reset(NULL TSRMLS_CC);
     365             : 
     366           3 :         if (zend_parse_parameters_none() == FAILURE) {
     367             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     368           1 :                         "intltz_get_tz_data_version: bad arguments", 0 TSRMLS_CC);
     369           1 :                 RETURN_FALSE;
     370             :         }
     371             : 
     372           2 :         UErrorCode status = UErrorCode();
     373           2 :         const char *res = TimeZone::getTZDataVersion(status);
     374           2 :         INTL_CHECK_STATUS(status, "intltz_get_tz_data_version: "
     375             :                 "Error obtaining time zone data version");
     376             : 
     377           2 :         RETURN_STRING(res, 1);
     378             : }
     379             : 
     380           7 : U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
     381             : {
     382             :         char    *str_id;
     383             :         int             str_id_len;
     384             :         long    index;
     385           7 :         intl_error_reset(NULL TSRMLS_CC);
     386             : 
     387           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl",
     388             :                         &str_id, &str_id_len, &index) == FAILURE ||
     389             :                         index < (long)INT32_MIN || index > (long)INT32_MAX) {
     390             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     391           4 :                         "intltz_get_equivalent_id: bad arguments", 0 TSRMLS_CC);
     392           4 :                 RETURN_FALSE;
     393             :         }
     394             : 
     395           3 :         UErrorCode status = UErrorCode();
     396           3 :         UnicodeString id;
     397           3 :         if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
     398             :                 intl_error_set(NULL, status,
     399           1 :                         "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
     400           1 :                 RETURN_FALSE;
     401             :         }
     402             : 
     403           2 :         const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
     404             :         intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value),
     405           2 :                 result.getBuffer(), result.length(), &status);
     406           2 :         INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
     407             :                 "could not convert resulting time zone id to UTF-16");
     408           2 :         Z_TYPE_P(return_value) = IS_STRING;
     409             : }
     410             : 
     411          28 : U_CFUNC PHP_FUNCTION(intltz_get_id)
     412             : {
     413          28 :         TIMEZONE_METHOD_INIT_VARS;
     414             : 
     415          28 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
     416             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     417             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     418           2 :                         "intltz_get_id: bad arguments", 0 TSRMLS_CC);
     419           2 :                 RETURN_FALSE;
     420             :         }
     421             : 
     422          26 :         TIMEZONE_METHOD_FETCH_OBJECT;
     423             : 
     424          26 :         UnicodeString id_us;
     425          26 :         to->utimezone->getID(id_us);
     426             : 
     427          26 :         char *id = NULL;
     428          26 :         int  id_len   = 0;
     429             : 
     430             :         intl_convert_utf16_to_utf8(&id, &id_len,
     431          26 :                 id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
     432          26 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
     433             : 
     434          26 :         RETURN_STRINGL(id, id_len, 0);
     435             : }
     436             : 
     437           6 : U_CFUNC PHP_FUNCTION(intltz_use_daylight_time)
     438             : {
     439           6 :         TIMEZONE_METHOD_INIT_VARS;
     440             : 
     441           6 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
     442             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     443             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     444           2 :                         "intltz_use_daylight_time: bad arguments", 0 TSRMLS_CC);
     445           2 :                 RETURN_FALSE;
     446             :         }
     447             : 
     448           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     449             : 
     450           4 :         RETURN_BOOL(to->utimezone->useDaylightTime());
     451             : }
     452             : 
     453           7 : U_CFUNC PHP_FUNCTION(intltz_get_offset)
     454             : {
     455             :         UDate           date;
     456             :         zend_bool       local;
     457             :         zval            *rawOffsetArg,
     458             :                                 *dstOffsetArg;
     459             :         int32_t         rawOffset,
     460             :                                 dstOffset;
     461           7 :         TIMEZONE_METHOD_INIT_VARS;
     462             : 
     463           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
     464             :                         "Odbzz", &object, TimeZone_ce_ptr, &date, &local, &rawOffsetArg,
     465             :                         &dstOffsetArg) == FAILURE) {
     466             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     467           3 :                         "intltz_get_offset: bad arguments", 0 TSRMLS_CC);
     468           3 :                 RETURN_FALSE;
     469             :         }
     470             : 
     471           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     472             : 
     473             :         to->utimezone->getOffset(date, (UBool) local, rawOffset, dstOffset,
     474           4 :                 TIMEZONE_ERROR_CODE(to));
     475             : 
     476           4 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_offset: error obtaining offset");
     477             : 
     478           2 :         zval_dtor(rawOffsetArg);
     479           2 :         ZVAL_LONG(rawOffsetArg, rawOffset);
     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() TSRMLS_CC, 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 TSRMLS_CC);
     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() TSRMLS_CC, 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 TSRMLS_CC);
     513           3 :                 RETURN_FALSE;
     514             :         }
     515           3 :         TIMEZONE_METHOD_FETCH_OBJECT;
     516           3 :         other_to = (TimeZone_object *) zend_object_store_get_object(other_object TSRMLS_CC);
     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 TSRMLS_CC);
     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 :         long            display_type    = TimeZone::LONG;
     539          14 :         const char      *locale_str             = NULL;
     540          14 :         int                     dummy                   = 0;
     541          14 :         TIMEZONE_METHOD_INIT_VARS;
     542             : 
     543          14 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, 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 TSRMLS_CC);
     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 TSRMLS_CC);
     559           1 :                 RETURN_FALSE;
     560             :         }
     561             : 
     562           8 :         if (!locale_str) {
     563           7 :                 locale_str = intl_locale_get_default(TSRMLS_C);
     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             :         intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value),
     573           8 :                 result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
     574           8 :         INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
     575             :                 "could not convert resulting time zone id to UTF-16");
     576             : 
     577           8 :         Z_TYPE_P(return_value) = IS_STRING;
     578             : }
     579             : 
     580           4 : U_CFUNC PHP_FUNCTION(intltz_get_dst_savings)
     581             : {
     582           4 :         TIMEZONE_METHOD_INIT_VARS;
     583             : 
     584           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
     585             :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     586             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     587           2 :                         "intltz_get_dst_savings: bad arguments", 0 TSRMLS_CC);
     588           2 :                 RETURN_FALSE;
     589             :         }
     590             : 
     591           2 :         TIMEZONE_METHOD_FETCH_OBJECT;
     592             : 
     593           2 :         RETURN_LONG((long)to->utimezone->getDSTSavings());
     594             : }
     595             : 
     596           7 : U_CFUNC PHP_FUNCTION(intltz_to_date_time_zone)
     597             : {
     598           7 :         TIMEZONE_METHOD_INIT_VARS;
     599             : 
     600           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
     601             :                         "O", &object, TimeZone_ce_ptr) == FAILURE) {
     602             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     603           3 :                         "intltz_to_date_time_zone: bad arguments", 0 TSRMLS_CC);
     604           3 :                 RETURN_FALSE;
     605             :         }
     606             : 
     607           4 :         TIMEZONE_METHOD_FETCH_OBJECT;
     608             : 
     609             :         zval *ret = timezone_convert_to_datetimezone(to->utimezone,
     610           4 :                 &TIMEZONE_ERROR(to), "intltz_to_date_time_zone" TSRMLS_CC);
     611             : 
     612           4 :         if (ret) {
     613           6 :                 RETURN_ZVAL(ret, 1, 1);
     614             :         } else {
     615           1 :                 RETURN_FALSE;
     616             :         }
     617             : }
     618             : 
     619           4 : U_CFUNC PHP_FUNCTION(intltz_get_error_code)
     620             : {
     621           4 :         TIMEZONE_METHOD_INIT_VARS
     622             : 
     623           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
     624             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     625             :                 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
     626           2 :                         "intltz_get_error_code: bad arguments", 0 TSRMLS_CC);
     627           2 :                 RETURN_FALSE;
     628             :         }
     629             : 
     630             :         /* Fetch the object (without resetting its last error code ). */
     631           2 :         to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
     632           2 :         if (to == NULL)
     633           0 :                 RETURN_FALSE;
     634             : 
     635           2 :         RETURN_LONG((long)TIMEZONE_ERROR_CODE(to));
     636             : }
     637             : 
     638           4 : U_CFUNC PHP_FUNCTION(intltz_get_error_message)
     639             : {
     640           4 :         const char* message = NULL;
     641           4 :         TIMEZONE_METHOD_INIT_VARS
     642             : 
     643           4 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
     644             :                         &object, TimeZone_ce_ptr) == FAILURE) {
     645             :                 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
     646           2 :                         "intltz_get_error_message: bad arguments", 0 TSRMLS_CC );
     647           2 :                 RETURN_FALSE;
     648             :         }
     649             : 
     650             : 
     651             :         /* Fetch the object (without resetting its last error code ). */
     652           2 :         to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
     653           2 :         if (to == NULL)
     654           0 :                 RETURN_FALSE;
     655             : 
     656             :         /* Return last error message. */
     657           2 :         message = intl_error_get_message(TIMEZONE_ERROR_P(to) TSRMLS_CC);
     658           2 :         RETURN_STRING(message, 0);
     659             : }

Generated by: LCOV version 1.10

Generated at Mon, 04 Aug 2014 15:49:06 +0000 (42 days ago)

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