/* {{{ Cassandra\Date::fromDateTime() */
PHP_METHOD(Date, fromDateTime)
{
cassandra_date *self;
zval *zdatetime;
php5to7_zval retval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zdatetime) == FAILURE) {
return;
}
zend_call_method_with_0_params(PHP5TO7_ZVAL_MAYBE_ADDR_OF(zdatetime),
php_date_get_date_ce(),
NULL,
"gettimestamp",
&retval);
if (!PHP5TO7_ZVAL_IS_UNDEF(retval) &&
Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_P(retval)) == IS_LONG) {
object_init_ex(return_value, cassandra_date_ce);
self = PHP_CASSANDRA_GET_DATE(return_value);
self->date = cass_date_from_epoch(PHP5TO7_Z_LVAL_MAYBE_P(retval));
zval_ptr_dtor(&retval);
return;
}
}
/* {{{ Cassandra\Timestamp::toDateTime() */
PHP_METHOD(Timestamp, toDateTime)
{
cassandra_timestamp *self;
zval *datetime = NULL;
php_date_obj *datetime_obj = NULL;
char *str;
int str_len;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TIMESTAMP(getThis());
PHP5TO7_ZVAL_MAYBE_MAKE(datetime);
php_date_instantiate(php_date_get_date_ce(), datetime TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 7
datetime_obj = php_date_obj_from_obj(Z_OBJ_P(datetime));
#else
datetime_obj = zend_object_store_get_object(datetime TSRMLS_CC);
#endif
str_len = spprintf(&str, 0, "@%ld", (long) (self->timestamp / 1000));
php_date_initialize(datetime_obj, str, str_len, NULL, NULL, 0 TSRMLS_CC);
efree(str);
RETVAL_ZVAL(datetime, 0, 0);
}
/* {{{ MongoDate::toDateTime()
* Returns a DateTime object with the same information as the MongoDate object */
PHP_METHOD(MongoDate, toDateTime)
{
mongo_date *date;
int64_t sec;
int64_t usec;
double dusec;
char *str;
int str_len;
zval datetime_object;
php_date_obj *datetime_obj;
zval *datetime_object_ptr = &datetime_object;
date = (mongo_date*) zend_object_store_get_object(getThis() TSRMLS_CC);
php_date_instantiate(php_date_get_date_ce(), &datetime_object TSRMLS_CC);
mongo_date_to_parts(date, &sec, &usec, &dusec);
#ifdef WIN32
str_len = spprintf(&str, 0, "@%I64d", (int64_t) sec);
#else
str_len = spprintf(&str, 0, "@%lld", (long long int) sec);
#endif
datetime_obj = zend_object_store_get_object(&datetime_object TSRMLS_CC);
php_date_initialize(datetime_obj, str, str_len, NULL, NULL, 0 TSRMLS_CC);
efree(str);
datetime_obj->time->f = dusec;
RETVAL_ZVAL(datetime_object_ptr, 0, 0);
}
/**
* Sets Cache headers to use HTTP cache
*
*<code>
* $this->response->setCache(60);
*</code>
*/
PHP_METHOD(Phalcon_Http_Response, setCache) {
zval *_1, *_3;
zval *minutes_param = NULL, *date, _0, _2, *_4;
int minutes, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &minutes_param);
if (unlikely(Z_TYPE_P(minutes_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'minutes' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
minutes = Z_LVAL_P(minutes_param);
ZEPHIR_INIT_VAR(date);
object_init_ex(date, php_date_get_date_ce());
ZEPHIR_CALL_METHOD(NULL, date, "__construct", NULL, 0);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, minutes);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "+", &_0, " minutes");
ZEPHIR_CALL_METHOD(NULL, date, "modify", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setexpires", NULL, 0, date);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_2);
ZVAL_LONG(&_2, ((minutes * 60)));
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SV(_3, "max-age=", &_2);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "Cache-Control", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setheader", NULL, 0, _4, _3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
RETURN_THIS();
}
/* {{{ Cassandra\Date::toDateTime() */
PHP_METHOD(Date, toDateTime)
{
cassandra_date *self;
zval *ztime = NULL;
cassandra_time* time_obj = NULL;
php5to7_zval datetime;
php_date_obj *datetime_obj = NULL;
char *str;
int str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &ztime) == FAILURE) {
return;
}
if (ztime != NULL) {
time_obj = PHP_CASSANDRA_GET_TIME(ztime);
}
self = PHP_CASSANDRA_GET_DATE(getThis());
PHP5TO7_ZVAL_MAYBE_MAKE(datetime);
php_date_instantiate(php_date_get_date_ce(), PHP5TO7_ZVAL_MAYBE_P(datetime) TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 7
datetime_obj = php_date_obj_from_obj(Z_OBJ(datetime));
#else
datetime_obj = zend_object_store_get_object(datetime TSRMLS_CC);
#endif
str_len = spprintf(&str, 0, "%lld",
cass_date_time_to_epoch(self->date,
time_obj != NULL ? time_obj->time : 0));
php_date_initialize(datetime_obj, str, str_len, "U", NULL, 0 TSRMLS_CC);
efree(str);
RETVAL_ZVAL(PHP5TO7_ZVAL_MAYBE_P(datetime), 0, 1);
}
/* {{{ Cassandra\Timeuuid::value() */
PHP_METHOD(Timeuuid, toDateTime)
{
cassandra_uuid* uuid;
zval* datetime;
php_date_obj* datetime_obj;
char* str;
int str_len;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
uuid = (cassandra_uuid*) zend_object_store_get_object(getThis() TSRMLS_CC);
MAKE_STD_ZVAL(datetime);
php_date_instantiate(php_date_get_date_ce(), datetime TSRMLS_CC);
datetime_obj = zend_object_store_get_object(datetime TSRMLS_CC);
str_len = spprintf(&str, 0, "@%ld", (long) (cass_uuid_timestamp(uuid->uuid) / 1000));
php_date_initialize(datetime_obj, str, str_len, NULL, NULL, 0 TSRMLS_CC);
efree(str);
RETVAL_ZVAL(datetime, 0, 0);
}
U_CFUNC PHP_FUNCTION(intlcal_to_date_time)
{
zval retval;
CALENDAR_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",
&object, Calendar_ce_ptr) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_to_date_time: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
CALENDAR_METHOD_FETCH_OBJECT;
/* There are no exported functions in ext/date to this
* in a more native fashion */
double date = co->ucal->getTime(CALENDAR_ERROR_CODE(co)) / 1000.;
int64_t ts;
char ts_str[sizeof("@-9223372036854775808")];
int ts_str_len;
zval ts_tmp, ts_zval, tmp;
INTL_METHOD_CHECK_STATUS(co, "Call to ICU method has failed");
if (date > (double)U_INT64_MAX || date < (double)U_INT64_MIN) {
intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_to_date_time: The calendar date is out of the "
"range for a 64-bit integer", 0 TSRMLS_CC);
RETURN_FALSE;
}
ZVAL_UNDEF(&retval);
ts = (int64_t)date;
ts_str_len = slprintf(ts_str, sizeof(ts_str), "@%I64d", ts);
ZVAL_STRINGL(&ts_zval, ts_str, ts_str_len);
/* Now get the time zone */
const TimeZone& tz = co->ucal->getTimeZone();
zval *timezone_zval = timezone_convert_to_datetimezone(
&tz, CALENDAR_ERROR_P(co), "intlcal_to_date_time", &tmp TSRMLS_CC);
if (timezone_zval == NULL) {
RETURN_FALSE;
}
/* resources allocated from now on */
/* Finally, instantiate object and call constructor */
object_init_ex(return_value, php_date_get_date_ce());
zend_call_method_with_2_params(return_value, NULL, NULL, "__construct", NULL, &ts_zval, timezone_zval);
if (EG(exception)) {
intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_to_date_time: DateTime constructor has thrown exception",
1 TSRMLS_CC);
zend_object_store_ctor_failed(Z_OBJ_P(return_value) TSRMLS_CC);
zval_ptr_dtor(return_value);
zval_ptr_dtor(&ts_zval);
RETVAL_FALSE;
goto error;
}
zval_ptr_dtor(&ts_zval);
/* due to bug #40743, we have to set the time zone again */
zend_call_method_with_1_params(return_value, NULL, NULL, "settimezone",
&retval, timezone_zval);
if (Z_ISUNDEF(retval) || Z_TYPE(retval) == IS_FALSE) {
intl_errors_set(CALENDAR_ERROR_P(co), U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_to_date_time: call to DateTime::setTimeZone has failed",
1 TSRMLS_CC);
zval_ptr_dtor(return_value);
RETVAL_FALSE;
goto error;
}
error:
zval_ptr_dtor(timezone_zval);
zval_ptr_dtor(&retval);
}
U_CFUNC PHP_FUNCTION(intlcal_from_date_time)
{
zval *zv_arg,
zv_tmp,
*zv_datetime = NULL,
zv_timestamp;
php_date_obj *datetime;
char *locale_str = NULL;
int locale_str_len;
TimeZone *timeZone;
UErrorCode status = U_ZERO_ERROR;
Calendar *cal;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s!",
&zv_arg, &locale_str, &locale_str_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_from_date_time: bad arguments", 0 TSRMLS_CC);
RETURN_NULL();
}
if (!(Z_TYPE_P(zv_arg) == IS_OBJECT && instanceof_function(
Z_OBJCE_P(zv_arg), php_date_get_date_ce() TSRMLS_CC))) {
object_init_ex(&zv_tmp, php_date_get_date_ce());
zend_call_method_with_1_params(&zv_tmp, NULL, NULL, "__construct", NULL, zv_arg);
if (EG(exception)) {
zend_object_store_ctor_failed(Z_OBJ(zv_tmp) TSRMLS_CC);
goto error;
}
zv_datetime = &zv_tmp;
} else {
zv_datetime = zv_arg;
}
datetime = Z_PHPDATE_P(zv_datetime);
if (!datetime->time) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_from_date_time: DateTime object is unconstructed",
0 TSRMLS_CC);
goto error;
}
zend_call_method_with_0_params(zv_datetime, php_date_get_date_ce(), NULL, "gettimestamp", &zv_timestamp);
if (Z_TYPE(zv_timestamp) != IS_LONG) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_from_date_time: bad DateTime; call to "
"DateTime::getTimestamp() failed", 0 TSRMLS_CC);
zval_ptr_dtor(&zv_timestamp);
goto error;
}
if (!datetime->time->is_localtime) {
timeZone = TimeZone::getGMT()->clone();
} else {
timeZone = timezone_convert_datetimezone(datetime->time->zone_type,
datetime, 1, NULL, "intlcal_from_date_time" TSRMLS_CC);
if (timeZone == NULL) {
goto error;
}
}
if (!locale_str) {
locale_str = const_cast<char*>(intl_locale_get_default(TSRMLS_C));
}
cal = Calendar::createInstance(timeZone,
Locale::createFromName(locale_str), status);
if (cal == NULL) {
delete timeZone;
intl_error_set(NULL, status, "intlcal_from_date_time: "
"error creating ICU Calendar object", 0 TSRMLS_CC);
goto error;
}
cal->setTime(((UDate)Z_LVAL(zv_timestamp)) * 1000., status);
if (U_FAILURE(status)) {
/* time zone was adopted by cal; should not be deleted here */
delete cal;
intl_error_set(NULL, status, "intlcal_from_date_time: "
"error creating ICU Calendar::setTime()", 0 TSRMLS_CC);
goto error;
}
calendar_object_create(return_value, cal TSRMLS_CC);
error:
if (zv_datetime && zv_datetime != zv_arg) {
zval_ptr_dtor(zv_datetime);
}
}
U_CFUNC PHP_FUNCTION(datefmt_format_object)
{
zval *object,
*format = NULL;
const char *locale_str = NULL;
size_t locale_len;
bool pattern = false;
UDate date;
TimeZone *timeZone = NULL;
UErrorCode status = U_ZERO_ERROR;
DateFormat *df = NULL;
Calendar *cal = NULL;
DateFormat::EStyle dateStyle = DateFormat::kDefault,
timeStyle = DateFormat::kDefault;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|zs!",
&object, &format, &locale_str, &locale_len) == FAILURE) {
RETURN_FALSE;
}
if (!locale_str) {
locale_str = intl_locale_get_default();
}
if (format == NULL || Z_TYPE_P(format) == IS_NULL) {
//nothing
} else if (Z_TYPE_P(format) == IS_ARRAY) {
HashTable *ht = Z_ARRVAL_P(format);
HashPosition pos = {0};
zval *z;
if (zend_hash_num_elements(ht) != 2) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; if array, it must have "
"two elements", 0);
RETURN_FALSE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the date format (first "
"element of the array) is not valid", 0);
RETURN_FALSE;
}
dateStyle = (DateFormat::EStyle)Z_LVAL_P(z);
zend_hash_move_forward_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the time format ("
"second element of the array) is not valid", 0);
RETURN_FALSE;
}
timeStyle = (DateFormat::EStyle)Z_LVAL_P(z);
} else if (Z_TYPE_P(format) == IS_LONG) {
if (!valid_format(format)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the date/time format type is invalid",
0);
RETURN_FALSE;
}
dateStyle = timeStyle = (DateFormat::EStyle)Z_LVAL_P(format);
} else {
convert_to_string_ex(format);
if (Z_STRLEN_P(format) == 0) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the format is empty", 0);
RETURN_FALSE;
}
pattern = true;
}
//there's no support for relative time in ICU yet
timeStyle = (DateFormat::EStyle)(timeStyle & ~DateFormat::kRelative);
zend_class_entry *instance_ce = Z_OBJCE_P(object);
if (instanceof_function(instance_ce, Calendar_ce_ptr)) {
Calendar *obj_cal = calendar_fetch_native_calendar(object);
if (obj_cal == NULL) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad IntlCalendar instance: "
"not initialized properly", 0);
RETURN_FALSE;
}
timeZone = obj_cal->getTimeZone().clone();
date = obj_cal->getTime(status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: error obtaining instant from "
"IntlCalendar", 0);
RETVAL_FALSE;
goto cleanup;
}
cal = obj_cal->clone();
} else if (instanceof_function(instance_ce, php_date_get_date_ce())) {
if (intl_datetime_decompose(object, &date, &timeZone, NULL,
"datefmt_format_object") == FAILURE) {
RETURN_FALSE;
}
cal = new GregorianCalendar(Locale::createFromName(locale_str), status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create GregorianCalendar",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
intl_error_set(NULL, status, "datefmt_format_object: the passed object "
"must be an instance of either IntlCalendar or DateTime",
0);
RETURN_FALSE;
}
if (pattern) {
df = new SimpleDateFormat(
UnicodeString(Z_STRVAL_P(format), Z_STRLEN_P(format),
UnicodeString::kInvariant),
Locale::createFromName(locale_str),
status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create SimpleDateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
df = DateFormat::createDateTimeInstance(dateStyle, timeStyle,
Locale::createFromName(locale_str));
if (df == NULL) { /* according to ICU sources, this should never happen */
intl_error_set(NULL, status,
"datefmt_format_object: could not create DateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
}
//must be in this order (or have the cal adopt the tz)
df->adoptCalendar(cal);
cal = NULL;
df->adoptTimeZone(timeZone);
timeZone = NULL;
{
char *ret_str;
int ret_str_len;
UnicodeString result = UnicodeString();
df->format(date, result);
if (intl_charFromString(result, &ret_str, &ret_str_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"datefmt_format_object: error converting result to UTF-8",
0);
RETVAL_FALSE;
goto cleanup;
}
RETVAL_STRINGL(ret_str, ret_str_len);
//???
efree(ret_str);
}
cleanup:
delete df;
delete timeZone;
delete cal;
}
U_CFUNC PHP_FUNCTION(intlcal_from_date_time)
{
zval **zv_arg,
*zv_datetime = NULL;
double millis;
php_date_obj *datetime;
char *locale_str = NULL;
int locale_str_len;
TimeZone *timeZone;
UErrorCode status = U_ZERO_ERROR;
Calendar *cal;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|s!",
&zv_arg, &locale_str, &locale_str_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_from_date_time: bad arguments", 0 TSRMLS_CC);
RETURN_NULL();
}
if (!(Z_TYPE_PP(zv_arg) == IS_OBJECT && instanceof_function(
Z_OBJCE_PP(zv_arg), php_date_get_date_ce() TSRMLS_CC))) {
ALLOC_INIT_ZVAL(zv_datetime);
object_init_ex(zv_datetime, php_date_get_date_ce());
zend_call_method_with_1_params(&zv_datetime, NULL, NULL, "__construct",
NULL, *zv_arg);
if (EG(exception)) {
zend_object_store_ctor_failed(zv_datetime TSRMLS_CC);
goto error;
}
} else {
zv_datetime = *zv_arg;
}
datetime = (php_date_obj*)zend_object_store_get_object(zv_datetime TSRMLS_CC);
if (!datetime->time) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_from_date_time: DateTime object is unconstructed",
0 TSRMLS_CC);
goto error;
}
if (intl_datetime_decompose(zv_datetime, &millis, NULL, NULL,
"intlcal_from_date_time" TSRMLS_CC) == FAILURE) {
goto error;
}
if (!datetime->time->is_localtime) {
timeZone = TimeZone::getGMT()->clone();
} else {
timeZone = timezone_convert_datetimezone(datetime->time->zone_type,
datetime, 1, NULL, "intlcal_from_date_time" TSRMLS_CC);
if (timeZone == NULL) {
goto error;
}
}
if (!locale_str) {
locale_str = const_cast<char*>(intl_locale_get_default(TSRMLS_C));
}
cal = Calendar::createInstance(timeZone,
Locale::createFromName(locale_str), status);
if (cal == NULL) {
delete timeZone;
intl_error_set(NULL, status, "intlcal_from_date_time: "
"error creating ICU Calendar object", 0 TSRMLS_CC);
goto error;
}
cal->setTime(millis, status);
if (U_FAILURE(status)) {
/* time zone was adopted by cal; should not be deleted here */
delete cal;
intl_error_set(NULL, status, "intlcal_from_date_time: "
"error creating ICU Calendar::setTime()", 0 TSRMLS_CC);
goto error;
}
calendar_object_create(return_value, cal TSRMLS_CC);
error:
if (zv_datetime != *zv_arg) {
zval_ptr_dtor(&zv_datetime);
}
}