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/calendar.h>
25 #include <unicode/ustring.h>
26 
27 #include "../intl_convertcpp.h"
28 #include "../common/common_date.h"
29 
30 extern "C" {
31 #include "../php_intl.h"
32 #define USE_TIMEZONE_POINTER 1
33 #include "../timezone/timezone_class.h"
34 #define USE_CALENDAR_POINTER 1
35 #include "calendar_class.h"
36 #include "../intl_convert.h"
37 #include <zend_exceptions.h>
38 #include <zend_interfaces.h>
39 #include <ext/date/php_date.h>
40 }
41 #include "../common/common_enum.h"
42 
PHP_METHOD(IntlCalendar,__construct)43 U_CFUNC PHP_METHOD(IntlCalendar, __construct)
44 {
45 	zend_throw_exception( NULL,
46 		"An object of this type cannot be created with the new operator",
47 		0 );
48 }
49 
PHP_FUNCTION(intlcal_create_instance)50 U_CFUNC PHP_FUNCTION(intlcal_create_instance)
51 {
52 	zval		*zv_timezone	= NULL;
53 	const char	*locale_str		= NULL;
54 	size_t			dummy;
55 	TimeZone	*timeZone;
56 	UErrorCode	status			= U_ZERO_ERROR;
57 	intl_error_reset(NULL);
58 
59 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|zs!",
60 			&zv_timezone, &locale_str, &dummy) == FAILURE) {
61 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
62 			"intlcal_create_calendar: bad arguments", 0);
63 		RETURN_NULL();
64 	}
65 
66 	timeZone = timezone_process_timezone_argument(zv_timezone, NULL,
67 		"intlcal_create_instance");
68 	if (timeZone == NULL) {
69 		RETURN_NULL();
70 	}
71 
72 	if (!locale_str) {
73 		locale_str = intl_locale_get_default();
74 	}
75 
76 	Calendar *cal = Calendar::createInstance(timeZone,
77 		Locale::createFromName(locale_str), status);
78 	if (cal == NULL) {
79 		delete timeZone;
80 		intl_error_set(NULL, status, "Error creating ICU Calendar object", 0);
81 		RETURN_NULL();
82 	}
83 
84 	calendar_object_create(return_value, cal);
85 }
86 
87 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 42
88 class BugStringCharEnumeration : public StringEnumeration
89 {
90 public:
BugStringCharEnumeration(UEnumeration * _uenum)91 	BugStringCharEnumeration(UEnumeration* _uenum) : uenum(_uenum) {}
92 
~BugStringCharEnumeration()93 	~BugStringCharEnumeration()
94 	{
95 		uenum_close(uenum);
96 	}
97 
count(UErrorCode & status) const98 	int32_t count(UErrorCode& status) const {
99 		return uenum_count(uenum, &status);
100 	}
101 
snext(UErrorCode & status)102 	virtual const UnicodeString* snext(UErrorCode& status)
103 	{
104 		int32_t length;
105 		const UChar* str = uenum_unext(uenum, &length, &status);
106 		if (str == 0 || U_FAILURE(status)) {
107 			return 0;
108 		}
109 		return &unistr.setTo(str, length);
110 	}
111 
next(int32_t * resultLength,UErrorCode & status)112 	virtual const char* next(int32_t *resultLength, UErrorCode &status)
113 	{
114 		int32_t length = -1;
115 		const char* str = uenum_next(uenum, &length, &status);
116 		if (str == 0 || U_FAILURE(status)) {
117 			return 0;
118 		}
119 		if (resultLength) {
120 			//the bug is that uenum_next doesn't set the length
121 			*resultLength = (length == -1) ? (int32_t)strlen(str) : length;
122 		}
123 
124 		return str;
125 	}
126 
reset(UErrorCode & status)127 	void reset(UErrorCode& status)
128 	{
129 		uenum_reset(uenum, &status);
130 	}
131 
132 	virtual UClassID getDynamicClassID() const;
133 
134 	static UClassID U_EXPORT2 getStaticClassID();
135 
136 private:
137 	UEnumeration *uenum;
138 };
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(BugStringCharEnumeration)139 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(BugStringCharEnumeration)
140 
141 U_CFUNC PHP_FUNCTION(intlcal_get_keyword_values_for_locale)
142 {
143 	UErrorCode	status = U_ZERO_ERROR;
144 	char		*key,
145 				*locale;
146 	size_t			key_len,
147 				locale_len;
148 	zend_bool	commonly_used;
149 	intl_error_reset(NULL);
150 
151 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssb",
152 			&key, &key_len, &locale, &locale_len, &commonly_used) == FAILURE) {
153 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
154 			"intlcal_get_keyword_values_for_locale: bad arguments", 0);
155 		RETURN_FALSE;
156 	}
157 
158 	//does not work; see ICU bug 9194
159 #if 0
160 	StringEnumeration *se = Calendar::getKeywordValuesForLocale(key,
161 		Locale::createFromName(locale), (UBool)commonly_used,
162 		status);
163 	if (se == NULL) {
164 		intl_error_set(NULL, status, "intlcal_get_keyword_values_for_locale: "
165 			"error calling underlying method", 0);
166 		RETURN_FALSE;
167 	}
168 #else
169     UEnumeration *uenum = ucal_getKeywordValuesForLocale(
170 		key, locale, !!commonly_used, &status);
171     if (U_FAILURE(status)) {
172         uenum_close(uenum);
173 		intl_error_set(NULL, status, "intlcal_get_keyword_values_for_locale: "
174 			"error calling underlying method", 0);
175         RETURN_FALSE;
176     }
177 
178     StringEnumeration *se = new BugStringCharEnumeration(uenum);
179 #endif
180 
181 	IntlIterator_from_StringEnumeration(se, return_value);
182 }
183 #endif //ICU 4.2 only
184 
PHP_FUNCTION(intlcal_get_now)185 U_CFUNC PHP_FUNCTION(intlcal_get_now)
186 {
187 	intl_error_reset(NULL);
188 
189 	if (zend_parse_parameters_none() == FAILURE) {
190 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
191 			"intlcal_get_now: bad arguments", 0);
192 		RETURN_FALSE;
193 	}
194 
195 	RETURN_DOUBLE((double)Calendar::getNow());
196 }
197 
PHP_FUNCTION(intlcal_get_available_locales)198 U_CFUNC PHP_FUNCTION(intlcal_get_available_locales)
199 {
200 	intl_error_reset(NULL);
201 
202 	if (zend_parse_parameters_none() == FAILURE) {
203 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
204 			"intlcal_get_available_locales: bad arguments", 0);
205 		RETURN_FALSE;
206 	}
207 
208 	int32_t count;
209 	const Locale *availLocales = Calendar::getAvailableLocales(count);
210 	array_init(return_value);
211 	for (int i = 0; i < count; i++) {
212 		Locale locale = availLocales[i];
213 		add_next_index_string(return_value, locale.getName());
214 	}
215 }
216 
_php_intlcal_field_uec_ret_in32t_method(int32_t (Calendar::* func)(UCalendarDateFields,UErrorCode &)const,const char * method_name,INTERNAL_FUNCTION_PARAMETERS)217 static void _php_intlcal_field_uec_ret_in32t_method(
218 		int32_t (Calendar::*func)(UCalendarDateFields, UErrorCode&) const,
219 		const char *method_name,
220 		INTERNAL_FUNCTION_PARAMETERS)
221 {
222 	zend_long	field;
223 	char	*message;
224 	CALENDAR_METHOD_INIT_VARS;
225 
226 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
227 			"Ol", &object, Calendar_ce_ptr, &field) == FAILURE) {
228 		spprintf(&message, 0, "%s: bad arguments", method_name);
229 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
230 		efree(message);
231 		RETURN_FALSE;
232 	}
233 
234 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
235 		spprintf(&message, 0, "%s: invalid field", method_name);
236 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
237 		efree(message);
238 		RETURN_FALSE;
239 	}
240 
241 	CALENDAR_METHOD_FETCH_OBJECT;
242 
243 	int32_t result = (co->ucal->*func)(
244 		(UCalendarDateFields)field, CALENDAR_ERROR_CODE(co));
245 	INTL_METHOD_CHECK_STATUS(co, "Call to ICU method has failed");
246 
247 	RETURN_LONG((zend_long)result);
248 }
249 
PHP_FUNCTION(intlcal_get)250 U_CFUNC PHP_FUNCTION(intlcal_get)
251 {
252 	_php_intlcal_field_uec_ret_in32t_method(&Calendar::get,
253 		"intlcal_get", INTERNAL_FUNCTION_PARAM_PASSTHRU);
254 }
255 
PHP_FUNCTION(intlcal_get_time)256 U_CFUNC PHP_FUNCTION(intlcal_get_time)
257 {
258 	CALENDAR_METHOD_INIT_VARS;
259 
260 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
261 			&object, Calendar_ce_ptr) == FAILURE) {
262 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
263 			"intlcal_get_time: bad arguments", 0);
264 		RETURN_FALSE;
265 	}
266 
267 	CALENDAR_METHOD_FETCH_OBJECT;
268 
269 	UDate result = co->ucal->getTime(CALENDAR_ERROR_CODE(co));
270 	INTL_METHOD_CHECK_STATUS(co,
271 		"intlcal_get_time: error calling ICU Calendar::getTime");
272 
273 	RETURN_DOUBLE((double)result);
274 }
275 
PHP_FUNCTION(intlcal_set_time)276 U_CFUNC PHP_FUNCTION(intlcal_set_time)
277 {
278 	double	time_arg;
279 	CALENDAR_METHOD_INIT_VARS;
280 
281 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Od",
282 			&object, Calendar_ce_ptr, &time_arg) == FAILURE) {
283 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
284 			"intlcal_set_time: bad arguments", 0);
285 		RETURN_FALSE;
286 	}
287 
288 	CALENDAR_METHOD_FETCH_OBJECT;
289 
290 	co->ucal->setTime((UDate)time_arg, CALENDAR_ERROR_CODE(co));
291 	INTL_METHOD_CHECK_STATUS(co, "Call to underlying method failed");
292 
293 	RETURN_TRUE;
294 }
295 
PHP_FUNCTION(intlcal_add)296 U_CFUNC PHP_FUNCTION(intlcal_add)
297 {
298 	zend_long	field,
299 			amount;
300 	CALENDAR_METHOD_INIT_VARS;
301 
302 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
303 			"Oll", &object, Calendar_ce_ptr, &field, &amount) == FAILURE) {
304 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
305 			"intlcal_add: bad arguments", 0);
306 		RETURN_FALSE;
307 	}
308 
309 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
310 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
311 			"intlcal_add: invalid field", 0);
312 		RETURN_FALSE;
313 	}
314 	if (amount < INT32_MIN || amount > INT32_MAX) {
315 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
316 			"intlcal_add: amount out of bounds", 0);
317 		RETURN_FALSE;
318 	}
319 
320 	CALENDAR_METHOD_FETCH_OBJECT;
321 
322 	co->ucal->add((UCalendarDateFields)field, (int32_t)amount, CALENDAR_ERROR_CODE(co));
323 	INTL_METHOD_CHECK_STATUS(co, "intlcal_add: Call to underlying method failed");
324 
325 	RETURN_TRUE;
326 }
327 
PHP_FUNCTION(intlcal_set_time_zone)328 U_CFUNC PHP_FUNCTION(intlcal_set_time_zone)
329 {
330 	zval			*zv_timezone;
331 	TimeZone		*timeZone;
332 	CALENDAR_METHOD_INIT_VARS;
333 
334 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
335 			"Oz!", &object, Calendar_ce_ptr, &zv_timezone) == FAILURE) {
336 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
337 			"intlcal_set_time_zone: bad arguments", 0);
338 		RETURN_FALSE;
339 	}
340 
341 	CALENDAR_METHOD_FETCH_OBJECT;
342 
343 	if (zv_timezone == NULL) {
344 		RETURN_TRUE; /* the method does nothing if passed null */
345 	}
346 
347 	timeZone = timezone_process_timezone_argument(zv_timezone,
348 			CALENDAR_ERROR_P(co), "intlcal_set_time_zone");
349 	if (timeZone == NULL) {
350 		RETURN_FALSE;
351 	}
352 
353 	co->ucal->adoptTimeZone(timeZone);
354 
355 	RETURN_TRUE;
356 }
357 
358 
_php_intlcal_before_after(UBool (Calendar::* func)(const Calendar &,UErrorCode &)const,INTERNAL_FUNCTION_PARAMETERS)359 static void _php_intlcal_before_after(
360 		UBool (Calendar::*func)(const Calendar&, UErrorCode&) const,
361 		INTERNAL_FUNCTION_PARAMETERS)
362 {
363 	zval			*when_object;
364 	Calendar_object	*when_co;
365 	CALENDAR_METHOD_INIT_VARS;
366 
367 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
368 			"OO", &object, Calendar_ce_ptr, &when_object, Calendar_ce_ptr)
369 			== FAILURE) {
370 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
371 			"intlcal_before/after: bad arguments", 0);
372 		RETURN_FALSE;
373 	}
374 
375 	CALENDAR_METHOD_FETCH_OBJECT;
376 
377 	when_co = Z_INTL_CALENDAR_P(when_object);
378 	if (when_co->ucal == NULL) {
379 		intl_errors_set(&co->err, U_ILLEGAL_ARGUMENT_ERROR,
380 			"intlcal_before/after: Other IntlCalendar was unconstructed", 0);
381 		RETURN_FALSE;
382 	}
383 
384 	UBool res = (co->ucal->*func)(*when_co->ucal, CALENDAR_ERROR_CODE(co));
385 	INTL_METHOD_CHECK_STATUS(co, "intlcal_before/after: Error calling ICU method");
386 
387 	RETURN_BOOL((int)res);
388 }
389 
PHP_FUNCTION(intlcal_after)390 U_CFUNC PHP_FUNCTION(intlcal_after)
391 {
392 	_php_intlcal_before_after(&Calendar::after, INTERNAL_FUNCTION_PARAM_PASSTHRU);
393 }
394 
PHP_FUNCTION(intlcal_before)395 U_CFUNC PHP_FUNCTION(intlcal_before)
396 {
397 	_php_intlcal_before_after(&Calendar::before, INTERNAL_FUNCTION_PARAM_PASSTHRU);
398 }
399 
PHP_FUNCTION(intlcal_set)400 U_CFUNC PHP_FUNCTION(intlcal_set)
401 {
402 	zend_long	arg1, arg2, arg3, arg4, arg5, arg6;
403 	zval	args_a[7] = {0},
404 			*args = args_a;
405 	int		i;
406 	int		variant; /* number of args of the set() overload */
407 	CALENDAR_METHOD_INIT_VARS;
408 
409 	/* must come before zpp because zpp would convert the args in the stack to 0 */
410 	if (ZEND_NUM_ARGS() > (getThis() ? 6 : 7) ||
411 				zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
412 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
413 			"intlcal_set: too many arguments", 0);
414 		RETURN_FALSE;
415 	}
416 	if (!getThis()) {
417 		args++;
418 	}
419 	variant = ZEND_NUM_ARGS() - (getThis() ? 0 : 1);
420 	while (variant > 2 && Z_TYPE(args[variant - 1]) == IS_NULL) {
421 		variant--;
422 	}
423 
424 	if (variant == 4 ||
425 			zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
426 			"Oll|llll",	&object, Calendar_ce_ptr, &arg1, &arg2, &arg3, &arg4,
427 			&arg5, &arg6) == FAILURE) {
428 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
429 			"intlcal_set: bad arguments", 0);
430 		RETURN_FALSE;
431 	}
432 
433 	for (i = 0; i < variant; i++) {
434 		if (Z_LVAL(args[i]) < INT32_MIN || Z_LVAL(args[i]) > INT32_MAX) {
435 			intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
436 				"intlcal_set: at least one of the arguments has an absolute "
437 				"value that is too large", 0);
438 			RETURN_FALSE;
439 		}
440 	}
441 
442 	if (variant == 2 && (arg1 < 0 || arg1 >= UCAL_FIELD_COUNT)) {
443 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
444 			"intlcal_set: invalid field", 0);
445 		RETURN_FALSE;
446 	}
447 
448 	CALENDAR_METHOD_FETCH_OBJECT;
449 
450 	if (variant == 2) {
451 		co->ucal->set((UCalendarDateFields)arg1, (int32_t)arg2);
452 	} else if (variant == 3) {
453 		co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3);
454 	} else if (variant == 5) {
455 		co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3, (int32_t)arg4, (int32_t)arg5);
456 	} else if (variant == 6) {
457 		co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3, (int32_t)arg4, (int32_t)arg5, (int32_t)arg6);
458 	}
459 
460 	RETURN_TRUE;
461 }
462 
PHP_FUNCTION(intlcal_roll)463 U_CFUNC PHP_FUNCTION(intlcal_roll)
464 {
465 	zend_long		field,
466 				value;
467 	zval		args_a[3]		 = {0},
468 				*args			 = args_a;
469 	zend_bool	bool_variant_val = (zend_bool)-1;
470 	CALENDAR_METHOD_INIT_VARS;
471 
472 	if (ZEND_NUM_ARGS() > (getThis() ? 2 :3) ||
473 			zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
474 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
475 			"intlcal_set: too many arguments", 0);
476 		RETURN_FALSE;
477 	}
478 	if (!getThis()) {
479 		args++;
480 	}
481 	if (!Z_ISUNDEF(args[1]) && (Z_TYPE(args[1]) == IS_TRUE || Z_TYPE(args[1]) == IS_FALSE)) {
482 		if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
483 				"Olb", &object, Calendar_ce_ptr, &field, &bool_variant_val)
484 				== FAILURE) {
485 			intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
486 				"intlcal_roll: bad arguments", 0);
487 			RETURN_FALSE;
488 		}
489 		bool_variant_val = Z_TYPE(args[1]) == IS_TRUE? 1 : 0;
490 	} else if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
491 			"Oll", &object, Calendar_ce_ptr, &field, &value) == FAILURE) {
492 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
493 			"intlcal_roll: bad arguments", 0);
494 		RETURN_FALSE;
495 	}
496 
497 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
498 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
499 			"intlcal_roll: invalid field", 0);
500 		RETURN_FALSE;
501 	}
502 	if (bool_variant_val == (zend_bool)-1 &&
503 			(value < INT32_MIN || value > INT32_MAX)) {
504 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
505 			"intlcal_roll: value out of bounds", 0);
506 		RETURN_FALSE;
507 	}
508 
509 	CALENDAR_METHOD_FETCH_OBJECT;
510 
511 	if (bool_variant_val != (zend_bool)-1) {
512 		co->ucal->roll((UCalendarDateFields)field, (UBool)bool_variant_val,
513 			CALENDAR_ERROR_CODE(co));
514 	} else {
515 		co->ucal->roll((UCalendarDateFields)field, (int32_t)value,
516 			CALENDAR_ERROR_CODE(co));
517 	}
518 	INTL_METHOD_CHECK_STATUS(co, "intlcal_roll: Error calling ICU Calendar::roll");
519 
520 	RETURN_TRUE;
521 }
522 
PHP_FUNCTION(intlcal_clear)523 U_CFUNC PHP_FUNCTION(intlcal_clear)
524 {
525 	zend_long field;
526 	zend_bool field_is_null = 1;
527 	CALENDAR_METHOD_INIT_VARS;
528 
529 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(),
530 			getThis(), "O|l!", &object, Calendar_ce_ptr, &field, &field_is_null) == FAILURE) {
531 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
532 			"intlcal_clear: bad arguments", 0);
533 		RETURN_FALSE;
534 	}
535 
536 	CALENDAR_METHOD_FETCH_OBJECT;
537 
538 	if (field_is_null) {
539 		co->ucal->clear();
540 	} else {
541 		if (field < 0 || field >= UCAL_FIELD_COUNT) {
542 			intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
543 				"intlcal_clear: invalid field", 0);
544 			RETURN_FALSE;
545 		}
546 
547 		co->ucal->clear((UCalendarDateFields)field);
548 	}
549 
550 	RETURN_TRUE;
551 }
552 
PHP_FUNCTION(intlcal_field_difference)553 U_CFUNC PHP_FUNCTION(intlcal_field_difference)
554 {
555 	zend_long	field;
556 	double	when;
557 	CALENDAR_METHOD_INIT_VARS;
558 
559 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
560 			"Odl", &object, Calendar_ce_ptr, &when, &field)	== FAILURE) {
561 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
562 			"intlcal_field_difference: bad arguments", 0);
563 		RETURN_FALSE;
564 	}
565 
566 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
567 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
568 			"intlcal_field_difference: invalid field", 0);
569 		RETURN_FALSE;
570 	}
571 
572 	CALENDAR_METHOD_FETCH_OBJECT;
573 
574 	int32_t result = co->ucal->fieldDifference((UDate)when,
575 		(UCalendarDateFields)field, CALENDAR_ERROR_CODE(co));
576 	INTL_METHOD_CHECK_STATUS(co,
577 		"intlcal_field_difference: Call to ICU method has failed");
578 
579 	RETURN_LONG((zend_long)result);
580 }
581 
PHP_FUNCTION(intlcal_get_actual_maximum)582 U_CFUNC PHP_FUNCTION(intlcal_get_actual_maximum)
583 {
584 	_php_intlcal_field_uec_ret_in32t_method(&Calendar::getActualMaximum,
585 		"intlcal_get_actual_maximum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
586 }
587 
PHP_FUNCTION(intlcal_get_actual_minimum)588 U_CFUNC PHP_FUNCTION(intlcal_get_actual_minimum)
589 {
590 	_php_intlcal_field_uec_ret_in32t_method(&Calendar::getActualMinimum,
591 		"intlcal_get_actual_minimum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
592 }
593 
594 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 44
PHP_FUNCTION(intlcal_get_day_of_week_type)595 U_CFUNC PHP_FUNCTION(intlcal_get_day_of_week_type)
596 {
597 	zend_long	dow;
598 	CALENDAR_METHOD_INIT_VARS;
599 
600 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
601 			"Ol", &object, Calendar_ce_ptr, &dow) == FAILURE) {
602 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
603 			"intlcal_get_day_of_week_type: bad arguments", 0);
604 		RETURN_FALSE;
605 	}
606 
607 	if (dow < UCAL_SUNDAY || dow > UCAL_SATURDAY) {
608 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
609 			"intlcal_get_day_of_week_type: invalid day of week", 0);
610 		RETURN_FALSE;
611 	}
612 
613 	CALENDAR_METHOD_FETCH_OBJECT;
614 
615 	int32_t result = co->ucal->getDayOfWeekType(
616 		(UCalendarDaysOfWeek)dow, CALENDAR_ERROR_CODE(co));
617 	INTL_METHOD_CHECK_STATUS(co,
618 		"intlcal_get_day_of_week_type: Call to ICU method has failed");
619 
620 	RETURN_LONG((zend_long)result);
621 }
622 #endif
623 
PHP_FUNCTION(intlcal_get_first_day_of_week)624 U_CFUNC PHP_FUNCTION(intlcal_get_first_day_of_week)
625 {
626 	CALENDAR_METHOD_INIT_VARS;
627 
628 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
629 			"O", &object, Calendar_ce_ptr) == FAILURE) {
630 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
631 			"intlcal_get_first_day_of_week: bad arguments", 0);
632 		RETURN_FALSE;
633 	}
634 
635 	CALENDAR_METHOD_FETCH_OBJECT;
636 
637 	int32_t result = co->ucal->getFirstDayOfWeek(CALENDAR_ERROR_CODE(co));
638 	INTL_METHOD_CHECK_STATUS(co,
639 		"intlcal_get_first_day_of_week: Call to ICU method has failed");
640 
641 	RETURN_LONG((zend_long)result);
642 }
643 
_php_intlcal_field_ret_in32t_method(int32_t (Calendar::* func)(UCalendarDateFields)const,const char * method_name,INTERNAL_FUNCTION_PARAMETERS)644 static void _php_intlcal_field_ret_in32t_method(
645 		int32_t (Calendar::*func)(UCalendarDateFields) const,
646 		const char *method_name,
647 		INTERNAL_FUNCTION_PARAMETERS)
648 {
649 	zend_long	field;
650 	char	*message;
651 	CALENDAR_METHOD_INIT_VARS;
652 
653 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
654 			"Ol", &object, Calendar_ce_ptr, &field) == FAILURE) {
655 		spprintf(&message, 0, "%s: bad arguments", method_name);
656 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
657 		efree(message);
658 		RETURN_FALSE;
659 	}
660 
661 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
662 		spprintf(&message, 0, "%s: invalid field", method_name);
663 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
664 		efree(message);
665 		RETURN_FALSE;
666 	}
667 
668 	CALENDAR_METHOD_FETCH_OBJECT;
669 
670 	int32_t result = (co->ucal->*func)((UCalendarDateFields)field);
671 	INTL_METHOD_CHECK_STATUS(co, "Call to ICU method has failed");
672 
673 	RETURN_LONG((zend_long)result);
674 }
675 
PHP_FUNCTION(intlcal_get_greatest_minimum)676 U_CFUNC PHP_FUNCTION(intlcal_get_greatest_minimum)
677 {
678 	_php_intlcal_field_ret_in32t_method(&Calendar::getGreatestMinimum,
679 		"intlcal_get_greatest_minimum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
680 }
681 
PHP_FUNCTION(intlcal_get_least_maximum)682 U_CFUNC PHP_FUNCTION(intlcal_get_least_maximum)
683 {
684 	_php_intlcal_field_ret_in32t_method(&Calendar::getLeastMaximum,
685 		"intlcal_get_least_maximum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
686 }
687 
PHP_FUNCTION(intlcal_get_locale)688 U_CFUNC PHP_FUNCTION(intlcal_get_locale)
689 {
690 	zend_long	locale_type;
691 	CALENDAR_METHOD_INIT_VARS;
692 
693 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
694 			"Ol", &object, Calendar_ce_ptr, &locale_type) == FAILURE) {
695 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
696 			"intlcal_get_locale: bad arguments", 0);
697 		RETURN_FALSE;
698 	}
699 
700 	if (locale_type != ULOC_ACTUAL_LOCALE && locale_type != ULOC_VALID_LOCALE) {
701 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
702 			"intlcal_get_locale: invalid locale type", 0);
703 		RETURN_FALSE;
704 	}
705 
706 	CALENDAR_METHOD_FETCH_OBJECT;
707 
708 	Locale locale = co->ucal->getLocale((ULocDataLocaleType)locale_type,
709 		CALENDAR_ERROR_CODE(co));
710 	INTL_METHOD_CHECK_STATUS(co,
711 		"intlcal_get_locale: Call to ICU method has failed");
712 
713 	RETURN_STRING(locale.getName());
714 }
715 
PHP_FUNCTION(intlcal_get_maximum)716 U_CFUNC PHP_FUNCTION(intlcal_get_maximum)
717 {
718 	_php_intlcal_field_ret_in32t_method(&Calendar::getMaximum,
719 		"intlcal_get_maximum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
720 }
721 
PHP_FUNCTION(intlcal_get_minimal_days_in_first_week)722 U_CFUNC PHP_FUNCTION(intlcal_get_minimal_days_in_first_week)
723 {
724 	CALENDAR_METHOD_INIT_VARS;
725 
726 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
727 			"O", &object, Calendar_ce_ptr) == FAILURE) {
728 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
729 			"intlcal_get_minimal_days_in_first_week: bad arguments", 0);
730 		RETURN_FALSE;
731 	}
732 
733 	CALENDAR_METHOD_FETCH_OBJECT;
734 
735 	uint8_t result = co->ucal->getMinimalDaysInFirstWeek();
736 	INTL_METHOD_CHECK_STATUS(co,
737 		"intlcal_get_first_day_of_week: Call to ICU method has failed");
738 
739 	RETURN_LONG((zend_long)result);
740 }
741 
PHP_FUNCTION(intlcal_get_minimum)742 U_CFUNC PHP_FUNCTION(intlcal_get_minimum)
743 {
744 	_php_intlcal_field_ret_in32t_method(&Calendar::getMinimum,
745 		"intlcal_get_minimum", INTERNAL_FUNCTION_PARAM_PASSTHRU);
746 }
747 
PHP_FUNCTION(intlcal_get_time_zone)748 U_CFUNC PHP_FUNCTION(intlcal_get_time_zone)
749 {
750 	CALENDAR_METHOD_INIT_VARS;
751 
752 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
753 			"O", &object, Calendar_ce_ptr) == FAILURE) {
754 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
755 			"intlcal_get_time_zone: bad arguments", 0);
756 		RETURN_FALSE;
757 	}
758 
759 	CALENDAR_METHOD_FETCH_OBJECT;
760 
761 	TimeZone *tz = co->ucal->getTimeZone().clone();
762 	if (tz == NULL) {
763 		intl_errors_set(CALENDAR_ERROR_P(co), U_MEMORY_ALLOCATION_ERROR,
764 			"intlcal_get_time_zone: could not clone TimeZone", 0);
765 		RETURN_FALSE;
766 	}
767 
768 	timezone_object_construct(tz, return_value, 1);
769 }
770 
PHP_FUNCTION(intlcal_get_type)771 U_CFUNC PHP_FUNCTION(intlcal_get_type)
772 {
773 	CALENDAR_METHOD_INIT_VARS;
774 
775 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
776 			"O", &object, Calendar_ce_ptr) == FAILURE) {
777 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
778 			"intlcal_get_type: bad arguments", 0);
779 		RETURN_FALSE;
780 	}
781 
782 	CALENDAR_METHOD_FETCH_OBJECT;
783 
784 	RETURN_STRING(co->ucal->getType());
785 }
786 
787 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 44
PHP_FUNCTION(intlcal_get_weekend_transition)788 U_CFUNC PHP_FUNCTION(intlcal_get_weekend_transition)
789 {
790 	zend_long	dow;
791 	CALENDAR_METHOD_INIT_VARS;
792 
793 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
794 			"Ol", &object, Calendar_ce_ptr, &dow) == FAILURE) {
795 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
796 			"intlcal_get_weekend_transition: bad arguments", 0);
797 		RETURN_FALSE;
798 	}
799 
800 	if (dow < UCAL_SUNDAY || dow > UCAL_SATURDAY) {
801 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
802 			"intlcal_get_weekend_transition: invalid day of week", 0);
803 		RETURN_FALSE;
804 	}
805 
806 	CALENDAR_METHOD_FETCH_OBJECT;
807 
808 	int32_t res = co->ucal->getWeekendTransition((UCalendarDaysOfWeek)dow,
809 		CALENDAR_ERROR_CODE(co));
810 	INTL_METHOD_CHECK_STATUS(co, "intlcal_get_weekend_transition: "
811 		"Error calling ICU method");
812 
813 	RETURN_LONG((zend_long)res);
814 }
815 #endif
816 
PHP_FUNCTION(intlcal_in_daylight_time)817 U_CFUNC PHP_FUNCTION(intlcal_in_daylight_time)
818 {
819 	CALENDAR_METHOD_INIT_VARS;
820 
821 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
822 			"O", &object, Calendar_ce_ptr) == FAILURE) {
823 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
824 			"intlcal_in_daylight_time: bad arguments", 0);
825 		RETURN_FALSE;
826 	}
827 
828 	CALENDAR_METHOD_FETCH_OBJECT;
829 
830 	UBool ret = co->ucal->inDaylightTime(CALENDAR_ERROR_CODE(co));
831 	INTL_METHOD_CHECK_STATUS(co, "intlcal_in_daylight_time: "
832 		"Error calling ICU method");
833 
834 	RETURN_BOOL((int)ret);
835 }
836 
PHP_FUNCTION(intlcal_is_equivalent_to)837 U_CFUNC PHP_FUNCTION(intlcal_is_equivalent_to)
838 {
839 	zval			*other_object;
840 	Calendar_object *other_co;
841 	CALENDAR_METHOD_INIT_VARS;
842 
843 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
844 			"OO", &object, Calendar_ce_ptr, &other_object, Calendar_ce_ptr)
845 			== FAILURE) {
846 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
847 			"intlcal_is_equivalent_to: bad arguments", 0);
848 		RETURN_FALSE;
849 	}
850 
851 	other_co = Z_INTL_CALENDAR_P(other_object);
852 	if (other_co->ucal == NULL) {
853 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_is_equivalent_to:"
854 			" Other IntlCalendar is unconstructed", 0);
855 		RETURN_FALSE;
856 	}
857 
858 	CALENDAR_METHOD_FETCH_OBJECT;
859 
860 	RETURN_BOOL((int)co->ucal->isEquivalentTo(*other_co->ucal));
861 }
862 
PHP_FUNCTION(intlcal_is_lenient)863 U_CFUNC PHP_FUNCTION(intlcal_is_lenient)
864 {
865 	CALENDAR_METHOD_INIT_VARS;
866 
867 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
868 			"O", &object, Calendar_ce_ptr) == FAILURE) {
869 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
870 			"intlcal_is_lenient: bad arguments", 0);
871 		RETURN_FALSE;
872 	}
873 
874 	CALENDAR_METHOD_FETCH_OBJECT;
875 
876 	RETURN_BOOL((int)co->ucal->isLenient());
877 }
878 
PHP_FUNCTION(intlcal_is_set)879 U_CFUNC PHP_FUNCTION(intlcal_is_set)
880 {
881 	zend_long field;
882 	CALENDAR_METHOD_INIT_VARS;
883 
884 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
885 			"Ol", &object, Calendar_ce_ptr, &field) == FAILURE) {
886 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
887 			"intlcal_is_set: bad arguments", 0);
888 		RETURN_FALSE;
889 	}
890 
891 	if (field < 0 || field >= UCAL_FIELD_COUNT) {
892 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
893 			"intlcal_is_set: invalid field", 0);
894 		RETURN_FALSE;
895 	}
896 
897 	CALENDAR_METHOD_FETCH_OBJECT;
898 
899 	RETURN_BOOL((int)co->ucal->isSet((UCalendarDateFields)field));
900 }
901 
902 #if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 44
PHP_FUNCTION(intlcal_is_weekend)903 U_CFUNC PHP_FUNCTION(intlcal_is_weekend)
904 {
905 	double date;
906 	zend_bool date_is_null = 1;
907 	CALENDAR_METHOD_INIT_VARS;
908 
909 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
910 				"O|d!", &object, Calendar_ce_ptr, &date, &date_is_null) == FAILURE) {
911 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
912 			"intlcal_is_weekend: bad arguments", 0);
913 		RETURN_FALSE;
914 	}
915 
916 	CALENDAR_METHOD_FETCH_OBJECT;
917 
918 	if (date_is_null) {
919 		RETURN_BOOL((int)co->ucal->isWeekend());
920 	} else {
921 		UBool ret = co->ucal->isWeekend((UDate)date, CALENDAR_ERROR_CODE(co));
922 		INTL_METHOD_CHECK_STATUS(co, "intlcal_is_weekend: "
923 			"Error calling ICU method");
924 		RETURN_BOOL((int)ret);
925 	}
926 }
927 #endif
928 
929 
PHP_FUNCTION(intlcal_set_first_day_of_week)930 U_CFUNC PHP_FUNCTION(intlcal_set_first_day_of_week)
931 {
932 	zend_long	dow;
933 	CALENDAR_METHOD_INIT_VARS;
934 
935 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
936 			"Ol", &object, Calendar_ce_ptr, &dow) == FAILURE) {
937 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
938 			"intlcal_set_first_day_of_week: bad arguments", 0);
939 		RETURN_FALSE;
940 	}
941 
942 	if (dow < UCAL_SUNDAY || dow > UCAL_SATURDAY) {
943 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
944 			"intlcal_set_first_day_of_week: invalid day of week", 0);
945 		RETURN_FALSE;
946 	}
947 
948 	CALENDAR_METHOD_FETCH_OBJECT;
949 
950 	co->ucal->setFirstDayOfWeek((UCalendarDaysOfWeek)dow);
951 
952 	RETURN_TRUE;
953 }
954 
PHP_FUNCTION(intlcal_set_lenient)955 U_CFUNC PHP_FUNCTION(intlcal_set_lenient)
956 {
957 	zend_bool is_lenient;
958 	CALENDAR_METHOD_INIT_VARS;
959 
960 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
961 			"Ob", &object, Calendar_ce_ptr, &is_lenient) == FAILURE) {
962 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
963 			"intlcal_set_lenient: bad arguments", 0);
964 		RETURN_FALSE;
965 	}
966 
967 	CALENDAR_METHOD_FETCH_OBJECT;
968 
969 	co->ucal->setLenient((UBool) is_lenient);
970 
971 	RETURN_TRUE;
972 }
973 
PHP_FUNCTION(intlcal_set_minimal_days_in_first_week)974 U_CFUNC PHP_FUNCTION(intlcal_set_minimal_days_in_first_week)
975 {
976 	zend_long	num_days;
977 	CALENDAR_METHOD_INIT_VARS;
978 
979 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
980 			"Ol", &object, Calendar_ce_ptr, &num_days) == FAILURE) {
981 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
982 			"intlcal_set_minimal_days_in_first_week: bad arguments", 0);
983 		RETURN_FALSE;
984 	}
985 
986 	if (num_days < 1 || num_days > 7) {
987 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
988 			"intlcal_set_minimal_days_in_first_week: invalid number of days; "
989 			"must be between 1 and 7", 0);
990 		RETURN_FALSE;
991 	}
992 
993 	CALENDAR_METHOD_FETCH_OBJECT;
994 
995 	co->ucal->setMinimalDaysInFirstWeek((uint8_t)num_days);
996 
997 	RETURN_TRUE;
998 }
999 
PHP_FUNCTION(intlcal_equals)1000 U_CFUNC PHP_FUNCTION(intlcal_equals)
1001 {
1002 	zval			*other_object;
1003 	Calendar_object	*other_co;
1004 	CALENDAR_METHOD_INIT_VARS;
1005 
1006 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
1007 			"OO", &object, Calendar_ce_ptr, &other_object, Calendar_ce_ptr)
1008 			== FAILURE) {
1009 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1010 			"intlcal_equals: bad arguments", 0);
1011 		RETURN_FALSE;
1012 	}
1013 
1014 	CALENDAR_METHOD_FETCH_OBJECT;
1015 	other_co = Z_INTL_CALENDAR_P(other_object);
1016 	if (other_co->ucal == NULL) {
1017 		intl_errors_set(&co->err, U_ILLEGAL_ARGUMENT_ERROR,
1018 			"intlcal_equals: The second IntlCalendar is unconstructed", 0);
1019 		RETURN_FALSE;
1020 	}
1021 
1022 	UBool result = co->ucal->equals(*other_co->ucal, CALENDAR_ERROR_CODE(co));
1023 	INTL_METHOD_CHECK_STATUS(co, "intlcal_equals: error calling ICU Calendar::equals");
1024 
1025 	RETURN_BOOL((int)result);
1026 }
1027 
1028 #if U_ICU_VERSION_MAJOR_NUM >= 49
1029 
PHP_FUNCTION(intlcal_get_repeated_wall_time_option)1030 U_CFUNC PHP_FUNCTION(intlcal_get_repeated_wall_time_option)
1031 {
1032 	CALENDAR_METHOD_INIT_VARS;
1033 
1034 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
1035 			"O", &object, Calendar_ce_ptr) == FAILURE) {
1036 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1037 			"intlcal_get_repeated_wall_time_option: bad arguments", 0);
1038 		RETURN_FALSE;
1039 	}
1040 
1041 	CALENDAR_METHOD_FETCH_OBJECT;
1042 
1043 	RETURN_LONG(co->ucal->getRepeatedWallTimeOption());
1044 }
1045 
PHP_FUNCTION(intlcal_get_skipped_wall_time_option)1046 U_CFUNC PHP_FUNCTION(intlcal_get_skipped_wall_time_option)
1047 {
1048 	CALENDAR_METHOD_INIT_VARS;
1049 
1050 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
1051 			"O", &object, Calendar_ce_ptr) == FAILURE) {
1052 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1053 			"intlcal_get_skipped_wall_time_option: bad arguments", 0);
1054 		RETURN_FALSE;
1055 	}
1056 
1057 	CALENDAR_METHOD_FETCH_OBJECT;
1058 
1059 	RETURN_LONG(co->ucal->getSkippedWallTimeOption());
1060 }
1061 
PHP_FUNCTION(intlcal_set_repeated_wall_time_option)1062 U_CFUNC PHP_FUNCTION(intlcal_set_repeated_wall_time_option)
1063 {
1064 	zend_long	option;
1065 	CALENDAR_METHOD_INIT_VARS;
1066 
1067 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
1068 			"Ol", &object, Calendar_ce_ptr, &option) == FAILURE) {
1069 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1070 			"intlcal_set_repeated_wall_time_option: bad arguments", 0);
1071 		RETURN_FALSE;
1072 	}
1073 
1074 	if (option != UCAL_WALLTIME_FIRST && option != UCAL_WALLTIME_LAST) {
1075 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1076 			"intlcal_set_repeated_wall_time_option: invalid option", 0);
1077 		RETURN_FALSE;
1078 	}
1079 
1080 	CALENDAR_METHOD_FETCH_OBJECT;
1081 
1082 	co->ucal->setRepeatedWallTimeOption((UCalendarWallTimeOption)option);
1083 
1084 	RETURN_TRUE;
1085 }
1086 
PHP_FUNCTION(intlcal_set_skipped_wall_time_option)1087 U_CFUNC PHP_FUNCTION(intlcal_set_skipped_wall_time_option)
1088 {
1089 	zend_long	option;
1090 	CALENDAR_METHOD_INIT_VARS;
1091 
1092 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
1093 			"Ol", &object, Calendar_ce_ptr, &option) == FAILURE) {
1094 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1095 			"intlcal_set_skipped_wall_time_option: bad arguments", 0);
1096 		RETURN_FALSE;
1097 	}
1098 
1099 	if (option != UCAL_WALLTIME_FIRST && option != UCAL_WALLTIME_LAST
1100 			&& option != UCAL_WALLTIME_NEXT_VALID) {
1101 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1102 			"intlcal_set_skipped_wall_time_option: invalid option", 0);
1103 		RETURN_FALSE;
1104 	}
1105 
1106 	CALENDAR_METHOD_FETCH_OBJECT;
1107 
1108 	co->ucal->setSkippedWallTimeOption((UCalendarWallTimeOption)option);
1109 
1110 	RETURN_TRUE;
1111 }
1112 
1113 #endif
1114 
PHP_FUNCTION(intlcal_from_date_time)1115 U_CFUNC PHP_FUNCTION(intlcal_from_date_time)
1116 {
1117 	zval			*zv_arg,
1118 					zv_tmp,
1119 					*zv_datetime  		= NULL,
1120 					zv_timestamp;
1121 	php_date_obj	*datetime;
1122 	char			*locale_str			= NULL;
1123 	size_t				locale_str_len;
1124 	TimeZone		*timeZone;
1125 	UErrorCode		status				= U_ZERO_ERROR;
1126 	Calendar        *cal;
1127 	intl_error_reset(NULL);
1128 
1129 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|s!",
1130 			&zv_arg, &locale_str, &locale_str_len) == FAILURE) {
1131 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1132 			"intlcal_from_date_time: bad arguments", 0);
1133 		RETURN_NULL();
1134 	}
1135 
1136 	if (!(Z_TYPE_P(zv_arg) == IS_OBJECT && instanceof_function(
1137 			Z_OBJCE_P(zv_arg), php_date_get_date_ce()))) {
1138 		object_init_ex(&zv_tmp, php_date_get_date_ce());
1139 		zend_call_method_with_1_params(&zv_tmp, NULL, NULL, "__construct", NULL, zv_arg);
1140 		zv_datetime = &zv_tmp;
1141 		if (EG(exception)) {
1142 			zend_object_store_ctor_failed(Z_OBJ(zv_tmp));
1143 			goto error;
1144 		}
1145 	} else {
1146 		zv_datetime = zv_arg;
1147 	}
1148 
1149 	datetime = Z_PHPDATE_P(zv_datetime);
1150 	if (!datetime->time) {
1151 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1152 			"intlcal_from_date_time: DateTime object is unconstructed",
1153 			0);
1154 		goto error;
1155 	}
1156 
1157 	zend_call_method_with_0_params(zv_datetime, php_date_get_date_ce(), NULL, "gettimestamp", &zv_timestamp);
1158 	if (Z_TYPE(zv_timestamp) != IS_LONG) {
1159 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1160 			"intlcal_from_date_time: bad DateTime; call to "
1161 			"DateTime::getTimestamp() failed", 0);
1162 		zval_ptr_dtor(&zv_timestamp);
1163 		goto error;
1164 	}
1165 
1166 	if (!datetime->time->is_localtime) {
1167 		timeZone = TimeZone::getGMT()->clone();
1168 	} else {
1169 		timeZone = timezone_convert_datetimezone(datetime->time->zone_type,
1170 			datetime, 1, NULL, "intlcal_from_date_time");
1171 		if (timeZone == NULL) {
1172 			goto error;
1173 		}
1174 	}
1175 
1176 	if (!locale_str) {
1177 		locale_str = const_cast<char*>(intl_locale_get_default());
1178 	}
1179 
1180 	cal = Calendar::createInstance(timeZone,
1181 		Locale::createFromName(locale_str), status);
1182 	if (cal == NULL) {
1183 		delete timeZone;
1184 		intl_error_set(NULL, status, "intlcal_from_date_time: "
1185 				"error creating ICU Calendar object", 0);
1186 		goto error;
1187 	}
1188 	cal->setTime(((UDate)Z_LVAL(zv_timestamp)) * 1000., status);
1189     if (U_FAILURE(status)) {
1190 		/* time zone was adopted by cal; should not be deleted here */
1191 		delete cal;
1192 		intl_error_set(NULL, status, "intlcal_from_date_time: "
1193 				"error creating ICU Calendar::setTime()", 0);
1194         goto error;
1195     }
1196 
1197 	calendar_object_create(return_value, cal);
1198 
1199 error:
1200 	if (zv_datetime && zv_datetime != zv_arg) {
1201 		zval_ptr_dtor(zv_datetime);
1202 	}
1203 }
1204 
PHP_FUNCTION(intlcal_to_date_time)1205 U_CFUNC PHP_FUNCTION(intlcal_to_date_time)
1206 {
1207 	zval retval;
1208 	CALENDAR_METHOD_INIT_VARS;
1209 
1210 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
1211 			&object, Calendar_ce_ptr) == FAILURE) {
1212 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1213 			"intlcal_to_date_time: bad arguments", 0);
1214 		RETURN_FALSE;
1215 	}
1216 
1217 	CALENDAR_METHOD_FETCH_OBJECT;
1218 
1219 	/* There are no exported functions in ext/date to this
1220 	 * in a more native fashion */
1221 	double	date = co->ucal->getTime(CALENDAR_ERROR_CODE(co)) / 1000.;
1222 	int64_t	ts;
1223 	char	ts_str[sizeof("@-9223372036854775808")];
1224 	int		ts_str_len;
1225 	zval	ts_zval, tmp;
1226 
1227 	INTL_METHOD_CHECK_STATUS(co, "Call to ICU method has failed");
1228 
1229 	if (date > (double)U_INT64_MAX || date < (double)U_INT64_MIN) {
1230 		intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
1231 			"intlcal_to_date_time: The calendar date is out of the "
1232 			"range for a 64-bit integer", 0);
1233 		RETURN_FALSE;
1234 	}
1235 
1236 	ZVAL_UNDEF(&retval);
1237 	ts = (int64_t)date;
1238 
1239 	ts_str_len = slprintf(ts_str, sizeof(ts_str), "@%I64d", ts);
1240 	ZVAL_STRINGL(&ts_zval, ts_str, ts_str_len);
1241 
1242 	/* Now get the time zone */
1243 	const TimeZone& tz = co->ucal->getTimeZone();
1244 	zval *timezone_zval = timezone_convert_to_datetimezone(
1245 		&tz, CALENDAR_ERROR_P(co), "intlcal_to_date_time", &tmp);
1246 	if (timezone_zval == NULL) {
1247 		zval_ptr_dtor(&ts_zval);
1248 		RETURN_FALSE;
1249 	}
1250 
1251 	/* resources allocated from now on */
1252 
1253 	/* Finally, instantiate object and call constructor */
1254 	object_init_ex(return_value, php_date_get_date_ce());
1255 	zend_call_method_with_2_params(return_value, NULL, NULL, "__construct", NULL, &ts_zval, timezone_zval);
1256 	if (EG(exception)) {
1257 		intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
1258 			"intlcal_to_date_time: DateTime constructor has thrown exception",
1259 			1);
1260 		zend_object_store_ctor_failed(Z_OBJ_P(return_value));
1261 		zval_ptr_dtor(return_value);
1262 		zval_ptr_dtor(&ts_zval);
1263 
1264 		RETVAL_FALSE;
1265 		goto error;
1266 	}
1267 	zval_ptr_dtor(&ts_zval);
1268 
1269 	/* due to bug #40743, we have to set the time zone again */
1270 	zend_call_method_with_1_params(return_value, NULL, NULL, "settimezone",
1271 			&retval, timezone_zval);
1272 	if (Z_ISUNDEF(retval) || Z_TYPE(retval) == IS_FALSE) {
1273 		intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
1274 			"intlcal_to_date_time: call to DateTime::setTimeZone has failed",
1275 			1);
1276 		zval_ptr_dtor(return_value);
1277 		RETVAL_FALSE;
1278 		goto error;
1279 	}
1280 
1281 error:
1282 	zval_ptr_dtor(timezone_zval);
1283 	zval_ptr_dtor(&retval);
1284 }
1285 
PHP_FUNCTION(intlcal_get_error_code)1286 U_CFUNC PHP_FUNCTION(intlcal_get_error_code)
1287 {
1288 	CALENDAR_METHOD_INIT_VARS;
1289 
1290 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
1291 			&object, Calendar_ce_ptr) == FAILURE) {
1292 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
1293 			"intlcal_get_error_code: bad arguments", 0);
1294 		RETURN_FALSE;
1295 	}
1296 
1297 	/* Fetch the object (without resetting its last error code ). */
1298 	co = Z_INTL_CALENDAR_P(object);
1299 	if (co == NULL)
1300 		RETURN_FALSE;
1301 
1302 	RETURN_LONG((zend_long)CALENDAR_ERROR_CODE(co));
1303 }
1304 
PHP_FUNCTION(intlcal_get_error_message)1305 U_CFUNC PHP_FUNCTION(intlcal_get_error_message)
1306 {
1307 	zend_string* message = NULL;
1308 	CALENDAR_METHOD_INIT_VARS;
1309 
1310 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
1311 			&object, Calendar_ce_ptr) == FAILURE) {
1312 		intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
1313 			"intlcal_get_error_message: bad arguments", 0 );
1314 		RETURN_FALSE;
1315 	}
1316 
1317 
1318 	/* Fetch the object (without resetting its last error code ). */
1319 	co = Z_INTL_CALENDAR_P(object);
1320 	if (co == NULL)
1321 		RETURN_FALSE;
1322 
1323 	/* Return last error message. */
1324 	message = intl_error_get_message(CALENDAR_ERROR_P(co));
1325 	RETURN_STR(message);
1326 }
1327