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
PHP_METHOD(IntlTimeZone,__construct)40 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 TSRMLS_CC );
45 }
46
PHP_FUNCTION(intltz_create_time_zone)47 U_CFUNC PHP_FUNCTION(intltz_create_time_zone)
48 {
49 char *str_id;
50 int str_id_len;
51 intl_error_reset(NULL TSRMLS_CC);
52
53 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 "intltz_create_time_zone: bad arguments", 0 TSRMLS_CC);
57 RETURN_NULL();
58 }
59
60 UErrorCode status = UErrorCode();
61 UnicodeString id = UnicodeString();
62 if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
63 intl_error_set(NULL, status,
64 "intltz_create_time_zone: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
65 RETURN_NULL();
66 }
67
68 //guaranteed non-null; GMT if timezone cannot be understood
69 TimeZone *tz = TimeZone::createTimeZone(id);
70 timezone_object_construct(tz, return_value, 1 TSRMLS_CC);
71 }
72
PHP_FUNCTION(intltz_from_date_time_zone)73 U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone)
74 {
75 zval *zv_timezone;
76 TimeZone *tz;
77 php_timezone_obj *tzobj;
78 intl_error_reset(NULL TSRMLS_CC);
79
80 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 "intltz_from_date_time_zone: bad arguments", 0 TSRMLS_CC);
84 RETURN_NULL();
85 }
86
87 tzobj = (php_timezone_obj *)zend_objects_get_address(zv_timezone TSRMLS_CC);
88 if (!tzobj->initialized) {
89 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
90 "intltz_from_date_time_zone: DateTimeZone object is unconstructed",
91 0 TSRMLS_CC);
92 RETURN_NULL();
93 }
94
95 tz = timezone_convert_datetimezone(tzobj->type, tzobj, FALSE, NULL,
96 "intltz_from_date_time_zone" TSRMLS_CC);
97 if (tz == NULL) {
98 RETURN_NULL();
99 }
100
101 timezone_object_construct(tz, return_value, 1 TSRMLS_CC);
102 }
103
PHP_FUNCTION(intltz_create_default)104 U_CFUNC PHP_FUNCTION(intltz_create_default)
105 {
106 intl_error_reset(NULL TSRMLS_CC);
107
108 if (zend_parse_parameters_none() == FAILURE) {
109 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
110 "intltz_create_default: bad arguments", 0 TSRMLS_CC);
111 RETURN_NULL();
112 }
113
114 TimeZone *tz = TimeZone::createDefault();
115 timezone_object_construct(tz, return_value, 1 TSRMLS_CC);
116 }
117
PHP_FUNCTION(intltz_get_gmt)118 U_CFUNC PHP_FUNCTION(intltz_get_gmt)
119 {
120 intl_error_reset(NULL TSRMLS_CC);
121
122 if (zend_parse_parameters_none() == FAILURE) {
123 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
124 "intltz_get_gmt: bad arguments", 0 TSRMLS_CC);
125 RETURN_NULL();
126 }
127
128 timezone_object_construct(TimeZone::getGMT(), return_value, 0 TSRMLS_CC);
129 }
130
131 #if U_ICU_VERSION_MAJOR_NUM >= 49
PHP_FUNCTION(intltz_get_unknown)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
PHP_FUNCTION(intltz_create_enumeration)146 U_CFUNC PHP_FUNCTION(intltz_create_enumeration)
147 {
148 zval **arg = NULL;
149 StringEnumeration *se = NULL;
150 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 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Z", &arg) == FAILURE) {
155 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
156 "intltz_create_enumeration: bad arguments", 0 TSRMLS_CC);
157 RETURN_FALSE;
158 }
159
160 if (arg == NULL || Z_TYPE_PP(arg) == IS_NULL) {
161 se = TimeZone::createEnumeration();
162 } else if (Z_TYPE_PP(arg) == IS_LONG) {
163 int_offset:
164 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 "intltz_create_enumeration: value is out of range", 0 TSRMLS_CC);
168 RETURN_FALSE;
169 } else {
170 se = TimeZone::createEnumeration((int32_t) Z_LVAL_PP(arg));
171 }
172 } else if (Z_TYPE_PP(arg) == IS_DOUBLE) {
173 double_offset:
174 convert_to_long_ex(arg);
175 goto int_offset;
176 } else if (Z_TYPE_PP(arg) == IS_OBJECT || Z_TYPE_PP(arg) == IS_STRING) {
177 long lval;
178 double dval;
179 convert_to_string_ex(arg);
180 switch (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &lval, &dval, 0)) {
181 case IS_DOUBLE:
182 SEPARATE_ZVAL(arg);
183 zval_dtor(*arg);
184 Z_TYPE_PP(arg) = IS_DOUBLE;
185 Z_DVAL_PP(arg) = dval;
186 goto double_offset;
187 case IS_LONG:
188 SEPARATE_ZVAL(arg);
189 zval_dtor(*arg);
190 Z_TYPE_PP(arg) = IS_LONG;
191 Z_LVAL_PP(arg) = lval;
192 goto int_offset;
193 }
194 /* else call string version */
195 se = TimeZone::createEnumeration(Z_STRVAL_PP(arg));
196 } else {
197 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
198 "intltz_create_enumeration: invalid argument type", 0 TSRMLS_CC);
199 RETURN_FALSE;
200 }
201
202 if (se) {
203 IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC);
204 } else {
205 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
206 "intltz_create_enumeration: error obtaining enumeration", 0 TSRMLS_CC);
207 RETVAL_FALSE;
208 }
209 }
210
PHP_FUNCTION(intltz_count_equivalent_ids)211 U_CFUNC PHP_FUNCTION(intltz_count_equivalent_ids)
212 {
213 char *str_id;
214 int str_id_len;
215 intl_error_reset(NULL TSRMLS_CC);
216
217 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 "intltz_count_equivalent_ids: bad arguments", 0 TSRMLS_CC);
221 RETURN_FALSE;
222 }
223
224 UErrorCode status = UErrorCode();
225 UnicodeString id = UnicodeString();
226 if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
227 intl_error_set(NULL, status,
228 "intltz_count_equivalent_ids: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
229 RETURN_FALSE;
230 }
231
232 int32_t result = TimeZone::countEquivalentIDs(id);
233 RETURN_LONG((long)result);
234 }
235
236 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
PHP_FUNCTION(intltz_create_time_zone_id_enumeration)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, ®ion, ®ion_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
PHP_FUNCTION(intltz_get_canonical_id)293 U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
294 {
295 char *str_id;
296 int str_id_len;
297 zval *is_systemid = NULL;
298 intl_error_reset(NULL TSRMLS_CC);
299
300 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 "intltz_get_canonical_id: bad arguments", 0 TSRMLS_CC);
304 RETURN_FALSE;
305 }
306
307 UErrorCode status = UErrorCode();
308 UnicodeString id;
309 if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
310 intl_error_set(NULL, status,
311 "intltz_get_canonical_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
312 RETURN_FALSE;
313 }
314
315 UnicodeString result;
316 UBool isSystemID;
317 TimeZone::getCanonicalID(id, result, isSystemID, status);
318 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 result.getBuffer(), result.length(), &status);
322 INTL_CHECK_STATUS(status,
323 "intltz_get_canonical_id: could not convert time zone id to UTF-16");
324 Z_TYPE_P(return_value) = IS_STRING;
325
326 if (is_systemid) { /* by-ref argument passed */
327 zval_dtor(is_systemid);
328 ZVAL_BOOL(is_systemid, isSystemID);
329 }
330 }
331
332 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
PHP_FUNCTION(intltz_get_region)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
PHP_FUNCTION(intltz_get_tz_data_version)362 U_CFUNC PHP_FUNCTION(intltz_get_tz_data_version)
363 {
364 intl_error_reset(NULL TSRMLS_CC);
365
366 if (zend_parse_parameters_none() == FAILURE) {
367 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
368 "intltz_get_tz_data_version: bad arguments", 0 TSRMLS_CC);
369 RETURN_FALSE;
370 }
371
372 UErrorCode status = UErrorCode();
373 const char *res = TimeZone::getTZDataVersion(status);
374 INTL_CHECK_STATUS(status, "intltz_get_tz_data_version: "
375 "Error obtaining time zone data version");
376
377 RETURN_STRING(res, 1);
378 }
379
PHP_FUNCTION(intltz_get_equivalent_id)380 U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
381 {
382 char *str_id;
383 int str_id_len;
384 long index;
385 intl_error_reset(NULL TSRMLS_CC);
386
387 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 "intltz_get_equivalent_id: bad arguments", 0 TSRMLS_CC);
392 RETURN_FALSE;
393 }
394
395 UErrorCode status = UErrorCode();
396 UnicodeString id;
397 if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
398 intl_error_set(NULL, status,
399 "intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
400 RETURN_FALSE;
401 }
402
403 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 result.getBuffer(), result.length(), &status);
406 INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
407 "could not convert resulting time zone id to UTF-16");
408 Z_TYPE_P(return_value) = IS_STRING;
409 }
410
PHP_FUNCTION(intltz_get_id)411 U_CFUNC PHP_FUNCTION(intltz_get_id)
412 {
413 TIMEZONE_METHOD_INIT_VARS;
414
415 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 "intltz_get_id: bad arguments", 0 TSRMLS_CC);
419 RETURN_FALSE;
420 }
421
422 TIMEZONE_METHOD_FETCH_OBJECT;
423
424 UnicodeString id_us;
425 to->utimezone->getID(id_us);
426
427 char *id = NULL;
428 int id_len = 0;
429
430 intl_convert_utf16_to_utf8(&id, &id_len,
431 id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
432 INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
433
434 RETURN_STRINGL(id, id_len, 0);
435 }
436
PHP_FUNCTION(intltz_use_daylight_time)437 U_CFUNC PHP_FUNCTION(intltz_use_daylight_time)
438 {
439 TIMEZONE_METHOD_INIT_VARS;
440
441 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 "intltz_use_daylight_time: bad arguments", 0 TSRMLS_CC);
445 RETURN_FALSE;
446 }
447
448 TIMEZONE_METHOD_FETCH_OBJECT;
449
450 RETURN_BOOL(to->utimezone->useDaylightTime());
451 }
452
PHP_FUNCTION(intltz_get_offset)453 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 TIMEZONE_METHOD_INIT_VARS;
462
463 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 "intltz_get_offset: bad arguments", 0 TSRMLS_CC);
468 RETURN_FALSE;
469 }
470
471 TIMEZONE_METHOD_FETCH_OBJECT;
472
473 to->utimezone->getOffset(date, (UBool) local, rawOffset, dstOffset,
474 TIMEZONE_ERROR_CODE(to));
475
476 INTL_METHOD_CHECK_STATUS(to, "intltz_get_offset: error obtaining offset");
477
478 zval_dtor(rawOffsetArg);
479 ZVAL_LONG(rawOffsetArg, rawOffset);
480 zval_dtor(dstOffsetArg);
481 ZVAL_LONG(dstOffsetArg, dstOffset);
482
483 RETURN_TRUE;
484 }
485
PHP_FUNCTION(intltz_get_raw_offset)486 U_CFUNC PHP_FUNCTION(intltz_get_raw_offset)
487 {
488 TIMEZONE_METHOD_INIT_VARS;
489
490 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 "intltz_get_raw_offset: bad arguments", 0 TSRMLS_CC);
494 RETURN_FALSE;
495 }
496
497 TIMEZONE_METHOD_FETCH_OBJECT;
498
499 RETURN_LONG(to->utimezone->getRawOffset());
500 }
501
PHP_FUNCTION(intltz_has_same_rules)502 U_CFUNC PHP_FUNCTION(intltz_has_same_rules)
503 {
504 zval *other_object;
505 TimeZone_object *other_to;
506 TIMEZONE_METHOD_INIT_VARS;
507
508 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 "intltz_has_same_rules: bad arguments", 0 TSRMLS_CC);
513 RETURN_FALSE;
514 }
515 TIMEZONE_METHOD_FETCH_OBJECT;
516 other_to = (TimeZone_object *) zend_object_store_get_object(other_object TSRMLS_CC);
517 if (other_to->utimezone == NULL) {
518 intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR,
519 "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0 TSRMLS_CC);
520 RETURN_FALSE;
521 }
522
523 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
PHP_FUNCTION(intltz_get_display_name)535 U_CFUNC PHP_FUNCTION(intltz_get_display_name)
536 {
537 zend_bool daylight = 0;
538 long display_type = TimeZone::LONG;
539 const char *locale_str = NULL;
540 int dummy = 0;
541 TIMEZONE_METHOD_INIT_VARS;
542
543 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 "intltz_get_display_name: bad arguments", 0 TSRMLS_CC);
548 RETURN_FALSE;
549 }
550
551 bool found = false;
552 for (int i = 0; !found && i < sizeof(display_types)/sizeof(*display_types); i++) {
553 if (display_types[i] == display_type)
554 found = true;
555 }
556 if (!found) {
557 intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
558 "intltz_get_display_name: wrong display type", 0 TSRMLS_CC);
559 RETURN_FALSE;
560 }
561
562 if (!locale_str) {
563 locale_str = intl_locale_get_default(TSRMLS_C);
564 }
565
566 TIMEZONE_METHOD_FETCH_OBJECT;
567
568 UnicodeString result;
569 to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type,
570 Locale::createFromName(locale_str), result);
571
572 intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value),
573 result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
574 INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
575 "could not convert resulting time zone id to UTF-16");
576
577 Z_TYPE_P(return_value) = IS_STRING;
578 }
579
PHP_FUNCTION(intltz_get_dst_savings)580 U_CFUNC PHP_FUNCTION(intltz_get_dst_savings)
581 {
582 TIMEZONE_METHOD_INIT_VARS;
583
584 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 "intltz_get_dst_savings: bad arguments", 0 TSRMLS_CC);
588 RETURN_FALSE;
589 }
590
591 TIMEZONE_METHOD_FETCH_OBJECT;
592
593 RETURN_LONG((long)to->utimezone->getDSTSavings());
594 }
595
PHP_FUNCTION(intltz_to_date_time_zone)596 U_CFUNC PHP_FUNCTION(intltz_to_date_time_zone)
597 {
598 TIMEZONE_METHOD_INIT_VARS;
599
600 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 "intltz_to_date_time_zone: bad arguments", 0 TSRMLS_CC);
604 RETURN_FALSE;
605 }
606
607 TIMEZONE_METHOD_FETCH_OBJECT;
608
609 zval *ret = timezone_convert_to_datetimezone(to->utimezone,
610 &TIMEZONE_ERROR(to), "intltz_to_date_time_zone" TSRMLS_CC);
611
612 if (ret) {
613 RETURN_ZVAL(ret, 1, 1);
614 } else {
615 RETURN_FALSE;
616 }
617 }
618
PHP_FUNCTION(intltz_get_error_code)619 U_CFUNC PHP_FUNCTION(intltz_get_error_code)
620 {
621 TIMEZONE_METHOD_INIT_VARS
622
623 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 "intltz_get_error_code: bad arguments", 0 TSRMLS_CC);
627 RETURN_FALSE;
628 }
629
630 /* Fetch the object (without resetting its last error code ). */
631 to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
632 if (to == NULL)
633 RETURN_FALSE;
634
635 RETURN_LONG((long)TIMEZONE_ERROR_CODE(to));
636 }
637
PHP_FUNCTION(intltz_get_error_message)638 U_CFUNC PHP_FUNCTION(intltz_get_error_message)
639 {
640 const char* message = NULL;
641 TIMEZONE_METHOD_INIT_VARS
642
643 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 "intltz_get_error_message: bad arguments", 0 TSRMLS_CC );
647 RETURN_FALSE;
648 }
649
650
651 /* Fetch the object (without resetting its last error code ). */
652 to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
653 if (to == NULL)
654 RETURN_FALSE;
655
656 /* Return last error message. */
657 message = intl_error_get_message(TIMEZONE_ERROR_P(to) TSRMLS_CC);
658 RETURN_STRING(message, 0);
659 }
660
