static String HHVM_METHOD(IntlDateFormatter, format, CVarRef value) {
DATFMT_GET(data, this_, null_string);
double ts = data->getTimestamp(value);
if (ts == NAN) {
return null_string;
}
UErrorCode error = U_ZERO_ERROR;
int32_t len = udat_format(data->datefmt(), ts, nullptr, 0, nullptr, &error);
if (error != U_BUFFER_OVERFLOW_ERROR) {
data->setError(error);
return null_string;
}
error = U_ZERO_ERROR;
String ret((len + 1) * sizeof(UChar), ReserveString);
udat_format(data->datefmt(), ts, (UChar*)ret->mutableData(),
ret->capacity() / sizeof(UChar), nullptr, &error);
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
ret->setSize(len * sizeof(UChar));
String out(u8(ret, error));
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
return out;
}
static Variant HHVM_METHOD(IntlDateFormatter, parse,
const String& value, VRefParam position) {
DATFMT_GET(data, this_, 0);
int32_t pos = position.toInt64();
if (pos > value.size()) {
return false;
}
UErrorCode error = U_ZERO_ERROR;
String str(u16(value, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting timezone to UTF-16");
return false;
}
error = U_ZERO_ERROR;
UDate timestamp = udat_parse(data->datefmt(),
(UChar*)str.c_str(), str.size() / sizeof(UChar),
&pos, &error);
position = (int64_t)pos;
if (U_FAILURE(error)) {
data->setError(error, "Date parsing failed");
return false;
}
double result = (double)timestamp / U_MILLIS_PER_SECOND;
if ((result > LONG_MAX) || (result < -LONG_MAX)) {
return (double)((result > 0) ? ceil(result) : floor(result));
} else {
return (int64_t)result;
}
}
static String HHVM_METHOD(IntlDateFormatter, format, CVarRef value) {
DATFMT_GET(data, this_, null_string);
double ts = data->getTimestamp(value);
if (ts == NAN) {
return null_string;
}
UErrorCode error = U_ZERO_ERROR;
int32_t len = udat_format(data->datefmt(), ts, nullptr, 0, nullptr, &error);
if (error != U_BUFFER_OVERFLOW_ERROR) {
data->setError(error);
return null_string;
}
error = U_ZERO_ERROR;
icu::UnicodeString ret;
auto *buffer = ret.getBuffer(len + 1);
udat_format(data->datefmt(), ts, buffer, len + 1, nullptr, &error);
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
ret.releaseBuffer(len);
String out(u8(ret, error));
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
return out;
}
static bool HHVM_METHOD(IntlDateFormatter, setTimeZone, CVarRef zone) {
DATFMT_GET(data, this_, false);
icu::TimeZone *tz = IntlTimeZone::ParseArg(zone, "datefmt_set_timezone",
data->m_error);
if (tz == nullptr) {
return false;
}
data->datefmtObject()->adoptTimeZone(tz);
return true;
}
static Object HHVM_METHOD(IntlDateFormatter, getTimeZone) {
DATFMT_GET(data, this_, null_object);
const icu::TimeZone& tz = data->datefmtObject()->getTimeZone();
auto ntz = tz.clone();
if (!ntz) {
data->setError(U_MEMORY_ALLOCATION_ERROR,
"datefmt_get_timezone: Out of memory "
"when cloning time zone");
return null_object;
}
return (NEWOBJ(IntlTimeZone)(ntz, true))->wrap();
}
static String HHVM_METHOD(IntlDateFormatter, getTimeZoneId) {
DATFMT_GET(data, this_, 0);
UnicodeString id;
data->datefmtObject()->getTimeZone().getID(id);
UErrorCode error = U_ZERO_ERROR;
String ret(u8(id, error));
if (U_FAILURE(error)) {
data->setError(error, "Could not convert time zone id to UTF-8");
return null_string;
}
return ret;
}
static Variant HHVM_METHOD(IntlDateFormatter, localtime,
const String& value, VRefParam position) {
DATFMT_GET(data, this_, uninit_null());
int32_t parse_pos = -1;
if (!position.isNull()) {
parse_pos = position.toInt64();
if (parse_pos > value.size()) {
return false;
}
}
UErrorCode error = U_ZERO_ERROR;
String uValue(u16(value, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting timezone to UTF-16");
return false;
}
error = U_ZERO_ERROR;
UCalendar *cal = const_cast<UCalendar*>(udat_getCalendar(data->datefmt()));
udat_parseCalendar(data->datefmt(), cal,
(UChar*)uValue.c_str(), uValue.size() / sizeof(UChar),
&parse_pos, &error);
Array ret = Array::Create();
error = U_ZERO_ERROR;
add_to_localtime_arr(ret, cal, UCAL_SECOND, s_tm_sec, error);
add_to_localtime_arr(ret, cal, UCAL_MINUTE, s_tm_min, error);
add_to_localtime_arr(ret, cal, UCAL_HOUR_OF_DAY, s_tm_hour, error);
add_to_localtime_arr(ret, cal, UCAL_YEAR, s_tm_year, error, -1900);
add_to_localtime_arr(ret, cal, UCAL_DAY_OF_MONTH, s_tm_mday, error);
add_to_localtime_arr(ret, cal, UCAL_DAY_OF_WEEK, s_tm_wday, error, -1);
add_to_localtime_arr(ret, cal, UCAL_DAY_OF_YEAR, s_tm_yday, error);
add_to_localtime_arr(ret, cal, UCAL_MONTH, s_tm_mon, error);
if (U_FAILURE(error)) {
data->setError(error, "Date parsing - localtime failed : "
"could not get a field from calendar");
return false;
}
error = U_ZERO_ERROR;
auto isDST = ucal_inDaylightTime(cal, &error);
if (U_FAILURE(error)) {
data->setError(error, "Date parsing - localtime failed : "
"while checking if currently in DST.");
return false;
}
ret.set(s_tm_isdst, isDST ? 1 : 0);
position = (int64_t)parse_pos;
return ret;
}
static bool HHVM_METHOD(IntlDateFormatter, setPattern,
const String& pattern) {
DATFMT_GET(data, this_, false);
UErrorCode error = U_ZERO_ERROR;
String pat(u16(pattern, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting pattern to UTF-16");
return false;
}
udat_applyPattern(data->datefmt(), (UBool)false,
(UChar*)pat.c_str(), pat.size() / sizeof(UChar));
return true;
}
static bool HHVM_METHOD(IntlDateFormatter, setPattern,
const String& pattern) {
DATFMT_GET(data, this_, false);
UErrorCode error = U_ZERO_ERROR;
icu::UnicodeString pat(u16(pattern, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting pattern to UTF-16");
return false;
}
udat_applyPattern(data->datefmt(), (UBool)false,
pat.getBuffer(), pat.length());
return true;
}
static String HHVM_METHOD(IntlDateFormatter, getLocale, CVarRef which) {
ULocDataLocaleType whichloc = ULOC_ACTUAL_LOCALE;
if (!which.isNull()) whichloc = (ULocDataLocaleType)which.toInt64();
DATFMT_GET(data, this_, null_string);
UErrorCode error = U_ZERO_ERROR;
const char *loc = udat_getLocaleByType(data->datefmt(), whichloc, &error);
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
return String(loc, CopyString);
}
static String HHVM_METHOD(IntlDateFormatter, getPattern) {
DATFMT_GET(data, this_, null_string);
UErrorCode error = U_ZERO_ERROR;
int32_t len = udat_toPattern(data->datefmt(), false, nullptr, 0, &error);
icu::UnicodeString tmp;
auto buf = tmp.getBuffer(len + 1);
error = U_ZERO_ERROR;
udat_toPattern(data->datefmt(), false, buf, len + 1, &error);
if (U_FAILURE(error)) {
data->setError(error, "Error getting formatter pattern");
return null_string;
}
tmp.releaseBuffer(len);
String ret(u8(tmp, error));
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
return ret;
}
static String HHVM_METHOD(IntlDateFormatter, getPattern) {
DATFMT_GET(data, this_, null_string);
UErrorCode error = U_ZERO_ERROR;
int32_t len = udat_toPattern(data->datefmt(), false, nullptr, 0, &error);
String buf((len+1) * sizeof(UChar), ReserveString);
error = U_ZERO_ERROR;
udat_toPattern(data->datefmt(), false, (UChar*)buf->mutableData(),
buf->capacity() / sizeof(UChar), &error);
if (U_FAILURE(error)) {
data->setError(error, "Error getting formatter pattern");
return null_string;
}
buf->setSize(len * sizeof(UChar));
String ret(u8(buf, error));
if (U_FAILURE(error)) {
data->setError(error);
return null_string;
}
return ret;
}
static int64_t HHVM_METHOD(IntlDateFormatter, getTimeType) {
DATFMT_GET(data, this_, 0);
return data->timeType();
}
static bool HHVM_METHOD(IntlDateFormatter, setLenient, bool lenient) {
DATFMT_GET(data, this_, false);
udat_setLenient(data->datefmt(), (UBool)lenient);
return true;
}
static bool HHVM_METHOD(IntlDateFormatter, isLenient) {
DATFMT_GET(data, this_, false);
return udat_isLenient(data->datefmt());
}
static String HHVM_METHOD(IntlDateFormatter, getErrorMessage) {
DATFMT_GET(data, this_, null_string);
return data->getErrorMessage();
}
static int64_t HHVM_METHOD(IntlDateFormatter, getErrorCode) {
DATFMT_GET(data, this_, 0);
return data->getErrorCode();
}
static int64_t HHVM_METHOD(IntlDateFormatter, getCalendar) {
DATFMT_GET(data, this_, 0);
return data->calendar();
}
