resourcebundle_class.c [plain text]
#include <stdlib.h>
#include <unicode/ures.h>
#include <unicode/uenum.h>
#include <zend.h>
#include <Zend/zend_exceptions.h>
#include <Zend/zend_interfaces.h>
#include <php.h>
#include "php_intl.h"
#include "intl_data.h"
#include "intl_common.h"
#include "resourcebundle/resourcebundle.h"
#include "resourcebundle/resourcebundle_iterator.h"
#include "resourcebundle/resourcebundle_class.h"
zend_class_entry *ResourceBundle_ce_ptr = NULL;
static zend_object_handlers ResourceBundle_object_handlers;
static void ResourceBundle_object_free( zend_object *object )
{
ResourceBundle_object *rb = php_intl_resourcebundle_fetch_object(object);
intl_error_reset( INTL_DATA_ERROR_P(rb) );
if (rb->me) {
ures_close( rb->me );
}
if (rb->child) {
ures_close( rb->child );
}
zend_object_std_dtor( &rb->zend );
}
static zend_object *ResourceBundle_object_create( zend_class_entry *ce )
{
ResourceBundle_object *rb;
rb = zend_object_alloc(sizeof(ResourceBundle_object), ce);
zend_object_std_init( &rb->zend, ce );
object_properties_init( &rb->zend, ce);
intl_error_init( INTL_DATA_ERROR_P(rb) );
rb->me = NULL;
rb->child = NULL;
rb->zend.handlers = &ResourceBundle_object_handlers;
return &rb->zend;
}
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;
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle___construct, 0, 0, 2 )
ZEND_ARG_INFO( 0, locale )
ZEND_ARG_INFO( 0, bundlename )
ZEND_ARG_INFO( 0, fallback )
ZEND_END_ARG_INFO()
PHP_METHOD( ResourceBundle, __construct )
{
zend_error_handling error_handling;
zend_replace_error_handling(EH_THROW, IntlException_ce_ptr, &error_handling);
return_value = getThis();
if (resourcebundle_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1) == FAILURE) {
if (!EG(exception)) {
zend_throw_exception(IntlException_ce_ptr, "Constructor failed", 0);
}
}
zend_restore_error_handling(&error_handling);
}
PHP_FUNCTION( resourcebundle_create )
{
object_init_ex( return_value, ResourceBundle_ce_ptr );
if (resourcebundle_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0) == FAILURE) {
zval_ptr_dtor(return_value);
RETURN_NULL();
}
}
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 );
}
zval *resourcebundle_array_get(zval *object, zval *offset, int type, zval *rv)
{
if(offset == NULL) {
php_error( E_ERROR, "Cannot apply [] to ResourceBundle object" );
}
ZVAL_NULL(rv);
resourcebundle_array_fetch(object, offset, rv, 1);
return rv;
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get, 0, 0, 1 )
ZEND_ARG_INFO( 0, index )
ZEND_ARG_INFO( 0, fallback )
ZEND_END_ARG_INFO()
PHP_FUNCTION( resourcebundle_get )
{
zend_bool fallback = 1;
zval * offset;
zval * object;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Oz|b", &object, ResourceBundle_ce_ptr, &offset, &fallback ) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_get: unable to parse input params", 0);
RETURN_FALSE;
}
resourcebundle_array_fetch(object, offset, return_value, fallback);
}
int resourcebundle_array_count(zval *object, zend_long *count)
{
ResourceBundle_object *rb;
RESOURCEBUNDLE_METHOD_FETCH_OBJECT_NO_CHECK;
if (rb->me == NULL) {
intl_errors_set(&rb->error, U_ILLEGAL_ARGUMENT_ERROR,
"Found unconstructed ResourceBundle", 0);
return 0;
}
*count = ures_getSize( rb->me );
return SUCCESS;
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_count, 0, 0, 0 )
ZEND_END_ARG_INFO()
PHP_FUNCTION( resourcebundle_count )
{
int32_t len;
RESOURCEBUNDLE_METHOD_INIT_VARS;
if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O", &object, ResourceBundle_ce_ptr ) == FAILURE ) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_count: unable to parse input params", 0);
RETURN_FALSE;
}
RESOURCEBUNDLE_METHOD_FETCH_OBJECT;
len = ures_getSize( rb->me );
RETURN_LONG( len );
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_getlocales, 0, 0, 1 )
ZEND_ARG_INFO( 0, bundlename )
ZEND_END_ARG_INFO()
PHP_FUNCTION( resourcebundle_locales )
{
char * bundlename;
size_t bundlename_len = 0;
const char * entry;
int entry_len;
UEnumeration *icuenum;
UErrorCode icuerror = U_ZERO_ERROR;
intl_errors_reset( NULL );
if( zend_parse_parameters(ZEND_NUM_ARGS(), "s", &bundlename, &bundlename_len ) == FAILURE )
{
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_locales: unable to parse input params", 0);
RETURN_FALSE;
}
if (bundlename_len >= MAXPATHLEN) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "resourcebundle_locales: bundle name too long", 0 );
RETURN_FALSE;
}
if(bundlename_len == 0) {
bundlename = NULL;
}
icuenum = ures_openAvailableLocales( bundlename, &icuerror );
INTL_CHECK_STATUS(icuerror, "Cannot fetch locales list");
uenum_reset( icuenum, &icuerror );
INTL_CHECK_STATUS(icuerror, "Cannot iterate locales list");
array_init( return_value );
while ((entry = uenum_next( icuenum, &entry_len, &icuerror ))) {
add_next_index_stringl( return_value, (char *) entry, entry_len);
}
uenum_close( icuenum );
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get_error_code, 0, 0, 0 )
ZEND_END_ARG_INFO()
PHP_FUNCTION( resourcebundle_get_error_code )
{
RESOURCEBUNDLE_METHOD_INIT_VARS;
if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O",
&object, ResourceBundle_ce_ptr ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_get_error_code: unable to parse input params", 0 );
RETURN_FALSE;
}
rb = Z_INTL_RESOURCEBUNDLE_P( object );
RETURN_LONG(INTL_DATA_ERROR_CODE(rb));
}
ZEND_BEGIN_ARG_INFO_EX( arginfo_resourcebundle_get_error_message, 0, 0, 0 )
ZEND_END_ARG_INFO()
PHP_FUNCTION( resourcebundle_get_error_message )
{
zend_string* message = NULL;
RESOURCEBUNDLE_METHOD_INIT_VARS;
if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "O",
&object, ResourceBundle_ce_ptr ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_get_error_message: unable to parse input params", 0 );
RETURN_FALSE;
}
rb = Z_INTL_RESOURCEBUNDLE_P( object );
message = intl_error_get_message(INTL_DATA_ERROR_P(rb));
RETURN_STR(message);
}
static const zend_function_entry ResourceBundle_class_functions[] = {
PHP_ME( ResourceBundle, __construct, arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_NAMED_ME( create, ZEND_FN( resourcebundle_create ), arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
ZEND_NAMED_ME( get, ZEND_FN(resourcebundle_get), arginfo_resourcebundle_get, ZEND_ACC_PUBLIC )
ZEND_NAMED_ME( count, ZEND_FN(resourcebundle_count), arginfo_resourcebundle_count, ZEND_ACC_PUBLIC )
ZEND_NAMED_ME( getLocales, ZEND_FN(resourcebundle_locales), arginfo_resourcebundle_getlocales, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC )
ZEND_NAMED_ME( getErrorCode, ZEND_FN(resourcebundle_get_error_code), arginfo_resourcebundle_get_error_code, ZEND_ACC_PUBLIC )
ZEND_NAMED_ME( getErrorMessage, ZEND_FN(resourcebundle_get_error_message), arginfo_resourcebundle_get_error_message, ZEND_ACC_PUBLIC )
PHP_FE_END
};
void resourcebundle_register_class( void )
{
zend_class_entry ce;
INIT_CLASS_ENTRY( ce, "ResourceBundle", ResourceBundle_class_functions );
ce.create_object = ResourceBundle_object_create;
ce.get_iterator = resourcebundle_get_iterator;
ResourceBundle_ce_ptr = zend_register_internal_class( &ce );
ResourceBundle_object_handlers = std_object_handlers;
ResourceBundle_object_handlers.offset = XtOffsetOf(ResourceBundle_object, zend);
ResourceBundle_object_handlers.clone_obj = NULL;
ResourceBundle_object_handlers.free_obj = ResourceBundle_object_free;
ResourceBundle_object_handlers.read_dimension = resourcebundle_array_get;
ResourceBundle_object_handlers.count_elements = resourcebundle_array_count;
zend_class_implements(ResourceBundle_ce_ptr, 1, zend_ce_traversable);
}