/* {{{ */
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
char* locale;
int locale_len = 0;
zval* object;
Collator_object* co;
intl_error_reset( NULL TSRMLS_CC );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 TSRMLS_CC );
zval_dtor(return_value);
RETURN_NULL();
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
co = (Collator_object *) zend_object_store_get_object( object TSRMLS_CC );
intl_error_reset( COLLATOR_ERROR_P( co ) TSRMLS_CC );
if(locale_len == 0) {
locale = UG(default_locale);
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
}
/* {{{ void intl_errors_reset( intl_error* err )
*/
void intl_errors_reset( intl_error* err )
{
if(err) {
intl_error_reset( err );
}
intl_error_reset( NULL );
}
/* {{{ clone handler for Transliterator */
static zend_object *Transliterator_clone_obj( zval *object )
{
Transliterator_object *to_orig,
*to_new;
zend_object *ret_val;
intl_error_reset( NULL );
to_orig = Z_INTL_TRANSLITERATOR_P( object );
intl_error_reset( INTL_DATA_ERROR_P( to_orig ) );
ret_val = Transliterator_ce_ptr->create_object( Z_OBJCE_P( object ) );
to_new = php_intl_transliterator_fetch_object( ret_val );
zend_objects_clone_members( &to_new->zo, &to_orig->zo );
if( to_orig->utrans != NULL )
{
zval tempz; /* dummy zval to pass to transliterator_object_construct */
/* guaranteed to return NULL if it fails */
UTransliterator *utrans = utrans_clone( to_orig->utrans, TRANSLITERATOR_ERROR_CODE_P( to_orig ) );
if( U_FAILURE( TRANSLITERATOR_ERROR_CODE( to_orig ) ) )
goto err;
ZVAL_OBJ(&tempz, ret_val);
transliterator_object_construct( &tempz, utrans,
TRANSLITERATOR_ERROR_CODE_P( to_orig ) );
if( U_FAILURE( TRANSLITERATOR_ERROR_CODE( to_orig ) ) )
{
zend_string *err_msg;
err:
if( utrans != NULL )
transliterator_object_destroy( to_new );
/* set the error anyway, in case in the future we decide not to
* throw an error. It also helps build the error message */
intl_error_set_code( NULL, INTL_DATA_ERROR_CODE( to_orig ) );
intl_errors_set_custom_msg( TRANSLITERATOR_ERROR_P( to_orig ),
"Could not clone transliterator", 0 );
err_msg = intl_error_get_message( TRANSLITERATOR_ERROR_P( to_orig ) );
zend_throw_error( NULL, "%s", ZSTR_VAL(err_msg) );
zend_string_free( err_msg ); /* if it's changed into a warning */
/* do not destroy tempz; we need to return something */
}
}
else
{
/* We shouldn't have unconstructed objects in the first place */
php_error_docref( NULL, E_WARNING,
"Cloning unconstructed transliterator." );
}
return ret_val;
}
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
{
char *str_id;
int str_id_len;
long index;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl",
&str_id, &str_id_len, &index) == FAILURE ||
index < (long)INT32_MIN || index > (long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_equivalent_id: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
UErrorCode status = UErrorCode();
UnicodeString id;
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
RETURN_FALSE;
}
const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
intl_convert_utf16_to_utf8(&Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value),
result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
"could not convert resulting time zone id to UTF-16");
Z_TYPE_P(return_value) = IS_STRING;
}
/* {{{ */
static void msgfmt_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
char* locale;
char* pattern;
int locale_len = 0, pattern_len = 0;
UChar* spattern = NULL;
int spattern_len = 0;
zval* object;
MessageFormatter_object* mfo;
intl_error_reset( NULL TSRMLS_CC );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "ss",
&locale, &locale_len, &pattern, &pattern_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"msgfmt_create: unable to parse input parameters", 0 TSRMLS_CC );
zval_dtor(return_value);
RETURN_NULL();
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
MSG_FORMAT_METHOD_FETCH_OBJECT;
/* Convert pattern (if specified) to UTF-16. */
if(pattern && pattern_len) {
intl_convert_utf8_to_utf16(&spattern, &spattern_len, pattern, pattern_len, &INTL_DATA_ERROR_CODE(mfo));
INTL_CTOR_CHECK_STATUS(mfo, "msgfmt_create: error converting pattern to UTF-16");
} else {
spattern_len = 0;
spattern = NULL;
}
if(locale_len == 0) {
locale = INTL_G(default_locale);
}
#ifdef MSG_FORMAT_QUOTE_APOS
if(msgformat_fix_quotes(&spattern, &spattern_len, &INTL_DATA_ERROR_CODE(mfo)) != SUCCESS) {
INTL_CTOR_CHECK_STATUS(mfo, "msgfmt_create: error converting pattern to quote-friendly format");
}
#endif
if ((mfo)->mf_data.orig_format) {
msgformat_data_free(&mfo->mf_data TSRMLS_CC);
}
(mfo)->mf_data.orig_format = estrndup(pattern, pattern_len);
(mfo)->mf_data.orig_format_len = pattern_len;
/* Create an ICU message formatter. */
MSG_FORMAT_OBJECT(mfo) = umsg_open(spattern, spattern_len, locale, NULL, &INTL_DATA_ERROR_CODE(mfo));
if(spattern) {
efree(spattern);
}
INTL_CTOR_CHECK_STATUS(mfo, "msgfmt_create: message formatter creation failed");
}
U_CFUNC PHP_FUNCTION(intlgregcal_create_instance)
{
intl_error_reset(NULL);
object_init_ex(return_value, GregorianCalendar_ce_ptr);
_php_intlgregcal_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
U_CFUNC PHP_FUNCTION(intltz_create_enumeration)
{
zval *arg = NULL;
StringEnumeration *se = NULL;
intl_error_reset(NULL);
/* double indirection to have the zend engine destroy the new zval that
* results from separation */
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &arg) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: bad arguments", 0);
RETURN_FALSE;
}
if (arg == NULL || Z_TYPE_P(arg) == IS_NULL) {
se = TimeZone::createEnumeration();
} else if (Z_TYPE_P(arg) == IS_LONG) {
int_offset:
if (Z_LVAL_P(arg) < (zend_long)INT32_MIN ||
Z_LVAL_P(arg) > (zend_long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: value is out of range", 0);
RETURN_FALSE;
} else {
se = TimeZone::createEnumeration((int32_t) Z_LVAL_P(arg));
}
} else if (Z_TYPE_P(arg) == IS_DOUBLE) {
double_offset:
convert_to_long_ex(arg);
goto int_offset;
} else if (Z_TYPE_P(arg) == IS_OBJECT || Z_TYPE_P(arg) == IS_STRING) {
zend_long lval;
double dval;
convert_to_string_ex(arg);
switch (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &lval, &dval, 0)) {
case IS_DOUBLE:
zval_ptr_dtor(arg);
ZVAL_DOUBLE(arg, dval);
goto double_offset;
case IS_LONG:
zval_ptr_dtor(arg);
ZVAL_LONG(arg, lval);
goto int_offset;
}
/* else call string version */
se = TimeZone::createEnumeration(Z_STRVAL_P(arg));
} else {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: invalid argument type", 0);
RETURN_FALSE;
}
if (se) {
IntlIterator_from_StringEnumeration(se, return_value);
} else {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_enumeration: error obtaining enumeration", 0);
RETVAL_FALSE;
}
}
/* {{{ */
static int collator_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor)
{
const char* locale;
size_t locale_len = 0;
zval* object;
Collator_object* co;
int zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;
intl_error_reset( NULL );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 );
return FAILURE;
}
INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);
COLLATOR_METHOD_FETCH_OBJECT;
if(locale_len == 0) {
locale = intl_locale_get_default();
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
return SUCCESS;
}
U_CFUNC PHP_FUNCTION(intltz_get_region)
{
char *str_id;
size_t str_id_len;
char outbuf[3];
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&str_id, &str_id_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_region: bad arguments", 0);
RETURN_FALSE;
}
UErrorCode status = UErrorCode();
UnicodeString id;
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_get_region: could not convert time zone id to UTF-16", 0);
RETURN_FALSE;
}
int32_t region_len = TimeZone::getRegion(id, outbuf, sizeof(outbuf), status);
INTL_CHECK_STATUS(status, "intltz_get_region: Error obtaining region");
RETURN_STRINGL(outbuf, region_len);
}
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
{
char *str_id;
size_t str_id_len;
zend_long index;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
&str_id, &str_id_len, &index) == FAILURE ||
index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_equivalent_id: bad arguments", 0);
RETURN_FALSE;
}
UErrorCode status = UErrorCode();
UnicodeString id;
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0);
RETURN_FALSE;
}
const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
zend_string *u8str;
u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
"could not convert resulting time zone id to UTF-16");
RETVAL_NEW_STR(u8str);
}
U_CFUNC PHP_FUNCTION(intltz_from_date_time_zone)
{
zval *zv_timezone;
TimeZone *tz;
php_timezone_obj *tzobj;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O",
&zv_timezone, php_date_get_timezone_ce()) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_from_date_time_zone: bad arguments", 0);
RETURN_NULL();
}
tzobj = Z_PHPTIMEZONE_P(zv_timezone);
if (!tzobj->initialized) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_from_date_time_zone: DateTimeZone object is unconstructed",
0);
RETURN_NULL();
}
tz = timezone_convert_datetimezone(tzobj->type, tzobj, FALSE, NULL,
"intltz_from_date_time_zone");
if (tz == NULL) {
RETURN_NULL();
}
timezone_object_construct(tz, return_value, 1);
}
/* {{{ */
static void collator_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
const char* locale;
size_t locale_len = 0;
zval* object;
Collator_object* co;
intl_error_reset( NULL );
object = return_value;
/* Parse parameters. */
if( zend_parse_parameters( ZEND_NUM_ARGS(), "s",
&locale, &locale_len ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"collator_create: unable to parse input params", 0 );
zval_dtor(return_value);
RETURN_NULL();
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
COLLATOR_METHOD_FETCH_OBJECT;
if(locale_len == 0) {
locale = intl_locale_get_default();
}
/* Open ICU collator. */
co->ucoll = ucol_open( locale, COLLATOR_ERROR_CODE_P( co ) );
INTL_CTOR_CHECK_STATUS(co, "collator_create: unable to open ICU collator");
}
U_CFUNC PHP_FUNCTION(intltz_create_time_zone)
{
char *str_id;
int str_id_len;
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
&str_id, &str_id_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_time_zone: bad arguments", 0 TSRMLS_CC);
RETURN_NULL();
}
UErrorCode status = UErrorCode();
UnicodeString id = UnicodeString();
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_create_time_zone: could not convert time zone id to UTF-16", 0 TSRMLS_CC);
RETURN_NULL();
}
//guaranteed non-null; GMT if timezone cannot be understood
TimeZone *tz = TimeZone::createTimeZone(id);
timezone_object_construct(tz, return_value, 1 TSRMLS_CC);
}
/* {{{ ResourceBundle_ctor */
static int resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor)
{
const char *bundlename;
size_t bundlename_len = 0;
const char *locale;
size_t locale_len = 0;
zend_bool fallback = 1;
int zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;
zval *object = return_value;
ResourceBundle_object *rb = Z_INTL_RESOURCEBUNDLE_P( object );
intl_error_reset( NULL );
if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s!s!|b",
&locale, &locale_len, &bundlename, &bundlename_len, &fallback ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_ctor: unable to parse input parameters", 0 );
return FAILURE;
}
INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);
if (locale == NULL) {
locale = intl_locale_get_default();
}
if (bundlename_len >= MAXPATHLEN) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "Bundle name too long", 0 );
zval_ptr_dtor(return_value);
ZVAL_NULL(return_value);
return FAILURE;
}
if (fallback) {
rb->me = ures_open(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
} else {
rb->me = ures_openDirect(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
}
INTL_CTOR_CHECK_STATUS(rb, "resourcebundle_ctor: Cannot load libICU resource bundle");
if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING ||
INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
char *pbuf;
intl_errors_set_code(NULL, INTL_DATA_ERROR_CODE(rb));
spprintf(&pbuf, 0, "resourcebundle_ctor: Cannot load libICU resource "
"'%s' without fallback from %s to %s",
bundlename ? bundlename : "(default data)", locale,
ures_getLocaleByType(
rb->me, ULOC_ACTUAL_LOCALE, &INTL_DATA_ERROR_CODE(rb)));
intl_errors_set_custom_msg(INTL_DATA_ERROR_P(rb), pbuf, 1);
efree(pbuf);
return FAILURE;
}
return SUCCESS;
}
/* {{{
* Gets the value from ICU , called when PHP userspace function is called
* common code shared by get_primary_language,get_script or get_region or get_variant
*/
static void get_icu_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS)
{
const char* loc_name = NULL;
size_t loc_name_len = 0;
char* tag_value = NULL;
char* empty_result = "";
int result = 0;
char* msg = NULL;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset( NULL );
if(zend_parse_parameters( ZEND_NUM_ARGS(), "s",
&loc_name ,&loc_name_len ) == FAILURE) {
spprintf(&msg , 0, "locale_get_%s : unable to parse input params", tag_name );
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, msg , 1 );
efree(msg);
RETURN_FALSE;
}
if(loc_name_len == 0) {
loc_name = intl_locale_get_default();
}
/* Call ICU get */
tag_value = get_icu_value_internal( loc_name , tag_name , &result ,0);
/* No value found */
if( result == -1 ) {
if( tag_value){
efree( tag_value);
}
RETURN_STRING( empty_result);
}
/* value found */
if( tag_value){
RETVAL_STRING( tag_value );
//???
efree(tag_value);
return;
}
/* Error encountered while fetching the value */
if( result ==0) {
spprintf(&msg , 0, "locale_get_%s : unable to get locale %s", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 );
efree(msg);
RETURN_NULL();
}
}
U_CFUNC PHP_FUNCTION(intltz_create_time_zone_id_enumeration)
{
long zoneType,
offset_arg;
char *region = NULL;
int region_len = 0;
int32_t offset,
*offsetp = NULL;
int arg3isnull = 0;
intl_error_reset(NULL TSRMLS_CC);
/* must come before zpp because zpp would convert the arg in the stack to 0 */
if (ZEND_NUM_ARGS() == 3) {
zval **dummy, **zvoffset;
arg3isnull = zend_get_parameters_ex(3, &dummy, &dummy, &zvoffset)
!= FAILURE && Z_TYPE_PP(zvoffset) == IS_NULL;
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s!l",
&zoneType, ®ion, ®ion_len, &offset_arg) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_time_zone_id_enumeration: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (zoneType != UCAL_ZONE_TYPE_ANY && zoneType != UCAL_ZONE_TYPE_CANONICAL
&& zoneType != UCAL_ZONE_TYPE_CANONICAL_LOCATION) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_time_zone_id_enumeration: bad zone type", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (ZEND_NUM_ARGS() == 3) {
if (offset_arg < (long)INT32_MIN || offset_arg > (long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_time_zone_id_enumeration: offset out of bounds", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (!arg3isnull) {
offset = (int32_t)offset_arg;
offsetp = &offset;
} //else leave offsetp NULL
}
StringEnumeration *se;
UErrorCode uec = UErrorCode();
se = TimeZone::createTimeZoneIDEnumeration((USystemTimeZoneType)zoneType,
region, offsetp, uec);
INTL_CHECK_STATUS(uec, "intltz_create_time_zone_id_enumeration: "
"Error obtaining time zone id enumeration")
IntlIterator_from_StringEnumeration(se, return_value TSRMLS_CC);
}
/* {{{ void msgformat_data_init( msgformat_data* mf_data )
* Initialize internals of msgformat_data.
*/
void msgformat_data_init( msgformat_data* mf_data )
{
if( !mf_data )
return;
mf_data->umsgf = NULL;
mf_data->orig_format = NULL;
mf_data->arg_types = NULL;
mf_data->tz_set = 0;
intl_error_reset( &mf_data->error );
}
/* {{{ Calendar_objects_free */
static void Calendar_objects_free(zend_object *object)
{
Calendar_object* co = php_intl_calendar_fetch_object(object);
if (co->ucal) {
delete co->ucal;
co->ucal = NULL;
}
intl_error_reset(CALENDAR_ERROR_P(co));
zend_object_std_dtor(&co->zo);
}
U_CFUNC PHP_FUNCTION(intlcal_get_now)
{
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_get_now: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
RETURN_DOUBLE((double)Calendar::getNow());
}
/* {{{ TimeZone_objects_free */
static void TimeZone_objects_free(zend_object *object)
{
TimeZone_object* to = php_intl_timezone_fetch_object(object);
if (to->utimezone && to->should_delete) {
delete to->utimezone;
to->utimezone = NULL;
}
intl_error_reset(TIMEZONE_ERROR_P(to));
zend_object_std_dtor(&to->zo);
}
U_CFUNC PHP_FUNCTION(intltz_get_unknown)
{
intl_error_reset(NULL);
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_unknown: bad arguments", 0);
RETURN_NULL();
}
timezone_object_construct(&TimeZone::getUnknown(), return_value, 0);
}
U_CFUNC PHP_FUNCTION(intltz_get_gmt)
{
intl_error_reset(NULL TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_gmt: bad arguments", 0 TSRMLS_CC);
RETURN_NULL();
}
timezone_object_construct(TimeZone::getGMT(), return_value, 0 TSRMLS_CC);
}
/* {{{ void transliterator_object_destroy( Transliterator_object* to )
* Clean up mem allocted by internals of Transliterator_object
*/
static void transliterator_object_destroy( Transliterator_object* to )
{
if( !to )
return;
if( to->utrans )
{
utrans_close( to->utrans );
to->utrans = NULL;
}
intl_error_reset( TRANSLITERATOR_ERROR_P( to ) );
}
U_CFUNC PHP_FUNCTION(intltz_create_default)
{
intl_error_reset(NULL);
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_create_default: bad arguments", 0);
RETURN_NULL();
}
TimeZone *tz = TimeZone::createDefault();
timezone_object_construct(tz, return_value, 1);
}
/* {{{ void spoofchecker_object_destroy( Spoofchecker_object* co )
* Clean up mem allocted by internals of Spoofchecker_object
*/
void spoofchecker_object_destroy(Spoofchecker_object* co)
{
if (!co) {
return;
}
if (co->uspoof) {
uspoof_close(co->uspoof);
co->uspoof = NULL;
}
intl_error_reset(SPOOFCHECKER_ERROR_P(co));
}
/* {{{ resourcebundle_array_fetch */
static void resourcebundle_array_fetch(zval *object, zval *offset, zval *return_value, int fallback)
{
int32_t meindex = 0;
char * mekey = NULL;
zend_bool is_numeric = 0;
char *pbuf;
ResourceBundle_object *rb;
intl_error_reset( NULL );
RESOURCEBUNDLE_METHOD_FETCH_OBJECT;
if(Z_TYPE_P(offset) == IS_LONG) {
is_numeric = 1;
meindex = (int32_t)Z_LVAL_P(offset);
rb->child = ures_getByIndex( rb->me, meindex, rb->child, &INTL_DATA_ERROR_CODE(rb) );
} else if(Z_TYPE_P(offset) == IS_STRING) {
mekey = Z_STRVAL_P(offset);
rb->child = ures_getByKey(rb->me, mekey, rb->child, &INTL_DATA_ERROR_CODE(rb) );
} else {
intl_errors_set(INTL_DATA_ERROR_P(rb), U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_get: index should be integer or string", 0);
RETURN_NULL();
}
intl_error_set_code( NULL, INTL_DATA_ERROR_CODE(rb) );
if (U_FAILURE(INTL_DATA_ERROR_CODE(rb))) {
if (is_numeric) {
spprintf( &pbuf, 0, "Cannot load resource element %d", meindex );
} else {
spprintf( &pbuf, 0, "Cannot load resource element '%s'", mekey );
}
intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
efree(pbuf);
RETURN_NULL();
}
if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING || INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
UErrorCode icuerror;
const char * locale = ures_getLocaleByType( rb->me, ULOC_ACTUAL_LOCALE, &icuerror );
if (is_numeric) {
spprintf( &pbuf, 0, "Cannot load element %d without fallback from to %s", meindex, locale );
} else {
spprintf( &pbuf, 0, "Cannot load element '%s' without fallback from to %s", mekey, locale );
}
intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
efree(pbuf);
RETURN_NULL();
}
resourcebundle_extract_value( return_value, rb );
}
/* {{{ clone handler for TimeZone */
static zend_object *TimeZone_clone_obj(zval *object)
{
TimeZone_object *to_orig,
*to_new;
zend_object *ret_val;
intl_error_reset(NULL);
to_orig = Z_INTL_TIMEZONE_P(object);
intl_error_reset(TIMEZONE_ERROR_P(to_orig));
ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object));
to_new = php_intl_timezone_fetch_object(ret_val);
zend_objects_clone_members(&to_new->zo, &to_orig->zo);
if (to_orig->utimezone != NULL) {
TimeZone *newTimeZone;
newTimeZone = to_orig->utimezone->clone();
to_new->should_delete = 1;
if (!newTimeZone) {
zend_string *err_msg;
intl_errors_set_code(TIMEZONE_ERROR_P(to_orig),
U_MEMORY_ALLOCATION_ERROR);
intl_errors_set_custom_msg(TIMEZONE_ERROR_P(to_orig),
"Could not clone IntlTimeZone", 0);
err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig));
zend_throw_exception(NULL, err_msg->val, 0);
zend_string_free(err_msg);
} else {
to_new->utimezone = newTimeZone;
}
} else {
zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0);
}
return ret_val;
}
/* {{{ ResourceBundle_object_dtor */
static void ResourceBundle_object_destroy( zend_object *object )
{
ResourceBundle_object *rb = php_intl_resourcebundle_fetch_object(object);
// only free local errors
intl_error_reset( INTL_DATA_ERROR_P(rb) );
if (rb->me) {
ures_close( rb->me );
}
if (rb->child) {
ures_close( rb->child );
}
}
/* {{{ clone handler for Calendar */
static zend_object *Calendar_clone_obj(zval *object)
{
Calendar_object *co_orig,
*co_new;
zend_object *ret_val;
intl_error_reset(NULL);
co_orig = Z_INTL_CALENDAR_P(object);
intl_error_reset(INTL_DATA_ERROR_P(co_orig));
ret_val = Calendar_ce_ptr->create_object(Z_OBJCE_P(object));
co_new = php_intl_calendar_fetch_object(ret_val);
zend_objects_clone_members(&co_new->zo, &co_orig->zo);
if (co_orig->ucal != NULL) {
Calendar *newCalendar;
newCalendar = co_orig->ucal->clone();
if (!newCalendar) {
zend_string *err_msg;
intl_errors_set_code(CALENDAR_ERROR_P(co_orig),
U_MEMORY_ALLOCATION_ERROR);
intl_errors_set_custom_msg(CALENDAR_ERROR_P(co_orig),
"Could not clone IntlCalendar", 0);
err_msg = intl_error_get_message(CALENDAR_ERROR_P(co_orig));
zend_throw_exception(NULL, err_msg->val, 0);
zend_string_free(err_msg);
} else {
co_new->ucal = newCalendar;
}
} else {
zend_throw_exception(NULL, "Cannot clone unconstructed IntlCalendar", 0);
}
return ret_val;
}
U_CFUNC PHP_METHOD(IntlGregorianCalendar, __construct)
{
zval orig_this = *getThis();
intl_error_reset(NULL TSRMLS_CC);
return_value = getThis();
//changes this to IS_NULL (without first destroying) if there's an error
_php_intlgregcal_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU);
if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) {
zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC);
zval_dtor(&orig_this);
ZEND_CTOR_MAKE_NULL();
}
}
