/* {{{ get_debug_info handler for BreakIterator */
static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
{
- zval zv = zval_used_for_init;
+ zval zv;
BreakIterator_object *bio;
const BreakIterator *biter;
inline BreakIterator *_breakiter_prolog(zend_object_iterator *iter TSRMLS_DC)
{
BreakIterator_object *bio;
- bio = (BreakIterator_object*)zend_object_store_get_object(
- (const zval*)iter->data TSRMLS_CC);
+ bio = Z_INTL_BREAKITERATOR_P(&iter->data);
intl_errors_reset(BREAKITER_ERROR_P(bio) TSRMLS_CC);
if (bio->biter == NULL) {
intl_errors_set(BREAKITER_ERROR_P(bio), U_INVALID_STATE_ERROR,
static void _breakiterator_destroy_it(zend_object_iterator *iter TSRMLS_DC)
{
- zval_ptr_dtor((zval**)&iter->data);
+ zval_ptr_dtor(&iter->data);
}
static void _breakiterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
int32_t pos = biter->next();
if (pos != BreakIterator::DONE) {
- MAKE_STD_ZVAL(zoi_iter->current);
- ZVAL_LONG(zoi_iter->current, (long)pos);
+ ZVAL_LONG(&zoi_iter->current, (long)pos);
} //else we've reached the end of the enum, nothing more is required
}
zoi_with_current *zoi_iter = (zoi_with_current*)iter;
int32_t pos = biter->first();
- MAKE_STD_ZVAL(zoi_iter->current);
- ZVAL_LONG(zoi_iter->current, (long)pos);
+ ZVAL_LONG(&zoi_iter->current, (long)pos);
}
static zend_object_iterator_funcs breakiterator_iterator_funcs = {
return NULL;
}
- bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+ bio = Z_INTL_BREAKITERATOR_P(object);
BreakIterator *biter = bio->biter;
if (biter == NULL) {
return NULL;
}
- zoi_with_current *zoi_iter =
- static_cast<zoi_with_current*>(emalloc(sizeof *zoi_iter));
- zoi_iter->zoi.data = static_cast<void*>(object);
+ zoi_with_current *zoi_iter = static_cast<zoi_with_current*>(emalloc(sizeof *zoi_iter));
+ zend_iterator_init(&zoi_iter->zoi TSRMLS_CC);
+ ZVAL_COPY(&zoi_iter->zoi.data, object);
zoi_iter->zoi.funcs = &breakiterator_iterator_funcs;
zoi_iter->zoi.index = 0;
zoi_iter->destroy_it = _breakiterator_destroy_it;
- zoi_iter->wrapping_obj = NULL; /* not used; object is in zoi.data */
- zoi_iter->current = NULL;
-
- zval_add_ref(&object);
+ ZVAL_UNDEF(&zoi_iter->wrapping_obj); /* not used; object is in zoi.data */
+ ZVAL_UNDEF(&zoi_iter->current);
return reinterpret_cast<zend_object_iterator *>(zoi_iter);
}
static void _breakiterator_parts_destroy_it(zend_object_iterator *iter TSRMLS_DC)
{
- zval_ptr_dtor(reinterpret_cast<zval**>(&iter->data));
+ zval_ptr_dtor(&iter->data);
}
static void _breakiterator_parts_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
/* else zoi_bit->key_type == PARTS_ITERATOR_KEY_SEQUENTIAL
* No need to do anything, the engine increments ->index */
- const char *s = Z_STRVAL_P(bio->text);
- int32_t slen = Z_STRLEN_P(bio->text),
- len;
- char *res;
+ const char *s = Z_STRVAL(bio->text);
+ int32_t slen = Z_STRLEN(bio->text);
+ zend_string *res;
if (next == BreakIterator::DONE) {
next = slen;
}
assert(next <= slen && next >= cur);
- len = next - cur;
- res = static_cast<char*>(emalloc(len + 1));
+ res = STR_ALLOC(next - cur, 0);
- memcpy(res, &s[cur], len);
- res[len] = '\0';
+ memcpy(res->val, &s[cur], res->len);
+ res->val[res->len] = '\0';
- MAKE_STD_ZVAL(zoi_bit->zoi_cur.current);
- ZVAL_STRINGL(zoi_bit->zoi_cur.current, res, len, 0);
+ ZVAL_STR(&zoi_bit->zoi_cur.current, res);
}
static void _breakiterator_parts_rewind(zend_object_iterator *iter TSRMLS_DC)
zoi_break_iter_parts *zoi_bit = (zoi_break_iter_parts*)iter;
BreakIterator_object *bio = zoi_bit->bio;
- if (zoi_bit->zoi_cur.current) {
+ if (!Z_ISUNDEF(zoi_bit->zoi_cur.current)) {
iter->funcs->invalidate_current(iter TSRMLS_CC);
}
{
IntlIterator_object *ii;
- zval_add_ref(&break_iter_zv);
-
object_init_ex(object, IntlPartsIterator_ce_ptr);
- ii = (IntlIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+ ii = Z_INTL_ITERATOR_P(object);
ii->iterator = (zend_object_iterator*)emalloc(sizeof(zoi_break_iter_parts));
- ii->iterator->data = break_iter_zv;
+ zend_iterator_init(ii->iterator TSRMLS_CC);
+ ZVAL_COPY(&ii->iterator->data, break_iter_zv);
ii->iterator->funcs = &breakiterator_parts_it_funcs;
ii->iterator->index = 0;
((zoi_with_current*)ii->iterator)->destroy_it = _breakiterator_parts_destroy_it;
- ((zoi_with_current*)ii->iterator)->wrapping_obj = object;
- ((zoi_with_current*)ii->iterator)->current = NULL;
+ ZVAL_COPY_VALUE(&((zoi_with_current*)ii->iterator)->wrapping_obj, object);
+ ZVAL_UNDEF(&((zoi_with_current*)ii->iterator)->current);
- ((zoi_break_iter_parts*)ii->iterator)->bio = (BreakIterator_object*)
- zend_object_store_get_object(break_iter_zv TSRMLS_CC);
+ ((zoi_break_iter_parts*)ii->iterator)->bio = Z_INTL_BREAKITERATOR_P(break_iter_zv);
assert(((zoi_break_iter_parts*)ii->iterator)->bio->biter != NULL);
((zoi_break_iter_parts*)ii->iterator)->key_type = key_type;
}
-U_CFUNC zend_object_value IntlPartsIterator_object_create(zend_class_entry *ce TSRMLS_DC)
+U_CFUNC zend_object *IntlPartsIterator_object_create(zend_class_entry *ce TSRMLS_DC)
{
- zend_object_value retval;
-
- retval = IntlIterator_ce_ptr->create_object(ce TSRMLS_CC);
- retval.handlers = &IntlPartsIterator_handlers;
+ zend_object* retval = IntlIterator_ce_ptr->create_object(ce TSRMLS_CC);
+ retval->handlers = &IntlPartsIterator_handlers;
return retval;
}
-U_CFUNC zend_function *IntlPartsIterator_get_method(zval **object_ptr,
- char *method, int method_len, const zend_literal *key TSRMLS_DC)
+U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, zend_string *method, const zval *key TSRMLS_DC)
{
- zend_literal local_literal = {0};
zend_function *ret;
- ALLOCA_FLAG(use_heap)
+ zend_string *lc_method_name;
+ ALLOCA_FLAG(use_heap);
if (key == NULL) {
- Z_STRVAL(local_literal.constant) = static_cast<char*>(
- do_alloca(method_len + 1, use_heap));
- zend_str_tolower_copy(Z_STRVAL(local_literal.constant),
- method, method_len);
- local_literal.hash_value = zend_hash_func(
- Z_STRVAL(local_literal.constant), method_len + 1);
- key = &local_literal;
+ STR_ALLOCA_ALLOC(lc_method_name, method->len, use_heap);
+ zend_str_tolower_copy(lc_method_name->val, method->val, method->len);
+ } else {
+ lc_method_name = Z_STR_P(key);
}
- if ((key->hash_value & 0xFFFFFFFF) == 0xA2B486A1 /* hash of getrulestatus\0 */
- && method_len == sizeof("getrulestatus") - 1
- && memcmp("getrulestatus", Z_STRVAL(key->constant), method_len) == 0) {
- IntlIterator_object *obj = (IntlIterator_object*)
- zend_object_store_get_object(*object_ptr TSRMLS_CC);
- if (obj->iterator && obj->iterator->data) {
- zval *break_iter_zv = static_cast<zval*>(obj->iterator->data);
- *object_ptr = break_iter_zv;
- ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr,
- method, method_len, key TSRMLS_CC);
+ if (method->len == sizeof("getrulestatus") - 1
+ && memcmp("getrulestatus", Z_STRVAL_P(key), method->len) == 0) {
+ IntlIterator_object *obj = php_intl_iterator_fetch_object(*object_ptr);
+ if (obj->iterator && !Z_ISUNDEF(obj->iterator->data)) {
+ zval *break_iter_zv = &obj->iterator->data;
+ *object_ptr = Z_OBJ_P(break_iter_zv);
+ ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr, method, key TSRMLS_CC);
goto end;
}
}
- ret = std_object_handlers.get_method(object_ptr,
- method, method_len, key TSRMLS_CC);
+ ret = std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
end:
- if (key == &local_literal) {
- free_alloca(Z_STRVAL(local_literal.constant), use_heap);
+ if (key == NULL) {
+ STR_ALLOCA_FREE(lc_method_name, use_heap);
}
return ret;
INTLITERATOR_METHOD_FETCH_OBJECT;
- zval *biter_zval = static_cast<zval*>(ii->iterator->data);
+ zval *biter_zval = &ii->iterator->data;
RETURN_ZVAL(biter_zval, 1, 0);
}
BREAKITER_METHOD_FETCH_OBJECT;
- if (bio->text == NULL) {
+ if (Z_ISUNDEF(bio->text)) {
RETURN_NULL();
} else {
- RETURN_ZVAL(bio->text, 1, 0);
+ ZVAL_COPY(return_value, &bio->text);
}
}
char *text;
int text_len;
UText *ut = NULL;
- zval **textzv;
+ zval *textzv;
BREAKITER_METHOD_INIT_VARS;
object = getThis();
/* assert it's safe to use text and text_len because zpp changes the
* arguments in the stack */
- assert(text == Z_STRVAL_PP(textzv));
+ assert(text == Z_STRVAL_P(textzv));
ut = utext_openUTF8(ut, text, text_len, BREAKITER_ERROR_CODE_P(bio));
INTL_CTOR_CHECK_STATUS(bio, "breakiter_set_text: error opening UText");
/* When ICU clones the UText, it does not copy the buffer, so we have to
* keep the string buffer around by holding a reference to its zval. This
* also allows a faste implementation of getText() */
- if (bio->text != NULL) {
- zval_ptr_dtor(&bio->text);
- }
- bio->text = *textzv;
- zval_add_ref(&bio->text);
+ zval_ptr_dtor(&bio->text);
+ ZVAL_COPY(&bio->text, textzv);
RETURN_TRUE;
}
if (ZEND_NUM_ARGS() == 0) {
no_arg_version = true;
} else if (ZEND_NUM_ARGS() == 1) {
- zval **arg;
+ zval *arg;
int res = zend_get_parameters_ex(1, &arg);
assert(res == SUCCESS);
- if (Z_TYPE_PP(arg) == IS_NULL) {
+ if (Z_TYPE_P(arg) == IS_NULL) {
no_arg_version = true;
- ht = 0; /* pretend we don't have any argument */
+ ZEND_NUM_ARGS() = 0; /* pretend we don't have any argument */
} else {
no_arg_version = false;
}
INTL_METHOD_CHECK_STATUS(bio,
"breakiter_get_locale: Call to ICU method has failed");
- RETURN_STRING(locale.getName(), 1);
+ RETURN_STRING(locale.getName());
}
U_CFUNC PHP_FUNCTION(breakiter_get_parts_iterator)
}
/* Fetch the object (without resetting its last error code ). */
- bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+ bio = Z_INTL_BREAKITERATOR_P(object);
if (bio == NULL)
RETURN_FALSE;
U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
{
- const char* message = NULL;
+ zend_string* message = NULL;
BREAKITER_METHOD_INIT_VARS;
object = getThis();
/* Fetch the object (without resetting its last error code ). */
- bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+ bio = Z_INTL_BREAKITERATOR_P(object);
if (bio == NULL)
RETURN_FALSE;
/* Return last error message. */
message = intl_error_get_message(BREAKITER_ERROR_P(bio) TSRMLS_CC);
- RETURN_STRING(message, 0);
+ RETURN_STR(message);
}
smart_str parse_error_str;
parse_error_str = intl_parse_error_to_string(&parseError);
spprintf(&msg, 0, "rbbi_create_instance: unable to create "
- "RuleBasedBreakIterator from rules (%s)", parse_error_str.c);
+ "RuleBasedBreakIterator from rules (%s)", parse_error_str.s? parse_error_str.s->val : "");
smart_str_free(&parse_error_str);
intl_error_set_custom_msg(NULL, msg, 1 TSRMLS_CC);
efree(msg);
_php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU);
if (Z_TYPE_P(return_value) == IS_NULL) {
- zend_object_store_ctor_failed(&orig_this TSRMLS_CC);
+ zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC);
zval_dtor(&orig_this);
}
}
BREAKITER_METHOD_FETCH_OBJECT;
+ char *str;
+ int str_len;
const UnicodeString rules = fetch_rbbi(bio)->getRules();
- Z_TYPE_P(return_value) = IS_STRING;
- if (intl_charFromString(rules, &Z_STRVAL_P(return_value),
- &Z_STRLEN_P(return_value), BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
+ if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
{
intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
"rbbi_hash_code: Error converting result to UTF-8 string",
0 TSRMLS_CC);
RETURN_FALSE;
}
+ RETVAL_STRINGL(str, str_len);
+ //???
+ efree(str);
}
U_CFUNC PHP_FUNCTION(rbbi_get_rule_status)
/* {{{ get_debug_info handler for Calendar */
static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
{
- zval zv = zval_used_for_init,
+ zval zv,
zfields;
Calendar_object *co;
const Calendar *cal;
const_cast<char*>(cal->getType()));
{
- zval ztz = zval_used_for_init,
+ zval ztz,
ztz_debug;
int is_tmp;
HashTable *debug_info;
int64_t ts;
char ts_str[sizeof("@-9223372036854775808")];
int ts_str_len;
- zval ts_tmp, ts_zval = zval_used_for_init;
+ zval ts_tmp, ts_zval;
INTL_METHOD_CHECK_STATUS(co, "Call to ICU method has failed");
/* {{{ Collator_objects_free */
void Collator_objects_free(zend_object *object TSRMLS_DC )
{
- Collator_object* co = php_collator_fetch_object(object);
+ Collator_object* co = php_intl_collator_fetch_object(object);
zend_object_std_dtor(&co->zo TSRMLS_CC );
Collator_object* co = NULL; \
intl_error_reset( NULL TSRMLS_CC ); \
-#define COLLATOR_METHOD_FETCH_OBJECT INTL_METHOD_FETCH_OBJECT(INIL_COLLATOR, co)
+#define COLLATOR_METHOD_FETCH_OBJECT INTL_METHOD_FETCH_OBJECT(INTL_COLLATOR, co)
// Macro to check return value of a ucol_* function call.
#define COLLATOR_CHECK_STATUS( co, msg ) \
*/
PHP_FUNCTION( collator_get_error_message )
{
- const char* message = NULL;
+ zend_string* message = NULL;
COLLATOR_METHOD_INIT_VARS
/* Return last error message. */
message = intl_error_get_message( COLLATOR_ERROR_P( co ) TSRMLS_CC );
- RETVAL_STRING( (char*)message);
- //???
- efree((char *)message);
+ RETURN_STR(message);
}
/* }}} */
zend_object *NumberFormatter_object_clone(zval *object TSRMLS_DC)
{
NumberFormatter_object *nfo, *new_nfo;
+ zend_object *new_obj;
FORMATTER_METHOD_FETCH_OBJECT_NO_CHECK;
- new_nfo = NumberFormatter_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC);
+ new_obj = NumberFormatter_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC);
+ new_nfo = php_intl_number_format_fetch_object(new_obj);
/* clone standard parts */
zend_objects_clone_members(&new_nfo->zo, &nfo->zo TSRMLS_CC);
/* clone formatter object. It may fail, the destruction code must handle this case */
} else {
zend_throw_exception(NULL, "Cannot clone unconstructed NumberFormatter", 0 TSRMLS_CC);
}
- return new_nfo;
+ return new_obj;
}
/* }}} */
RETURN_FALSE;
}
- nfo = Z_INTL_NUMERFORMATTER_P(object);
+ nfo = Z_INTL_NUMBERFORMATTER_P(object);
/* Return formatter's last error code. */
RETURN_LONG( INTL_DATA_ERROR_CODE(nfo) );
RETURN_FALSE;
}
- nfo = Z_INTL_NUMERFORMATTER_P(object);
+ nfo = Z_INTL_NUMBERFORMATTER_P(object);
/* Return last error message. */
message = intl_error_get_message( INTL_DATA_ERROR_P(nfo) TSRMLS_CC );
}
if ( NULL != next ) {
- if ( !PZVAL_IS_REF(next) ) {
+ if ( !Z_ISREF_P(next) ) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"grapheme_extract: 'next' was not passed by reference", 0 TSRMLS_CC );
RETURN_FALSE;
}
else {
+ ZVAL_DEREF(next);
/* initialize next */
zval_dtor(next);
ZVAL_LONG(next, lstart);
}
/* return the allocated string, not a duplicate */
- RETURN_STRINGL(((char *)converted_utf8), converted_utf8_len, 0);
+ RETVAL_STRINGL(((char *)converted_utf8), converted_utf8_len);
+ //????
+ efree(converted_utf8);
}
static void php_intl_idn_handoff(INTERNAL_FUNCTION_PARAMETERS, int mode)
}
if (used_tz == NULL) {
- zval nullzv = zval_used_for_init,
- *zvptr = &nullzv;
- used_tz = timezone_process_timezone_argument(zvptr, &err,
- "msgfmt_format" TSRMLS_CC);
+ zval nullzv, *zvptr = &nullzv;
+ ZVAL_UNDEF(zvptr);
+ used_tz = timezone_process_timezone_argument(zvptr, &err, "msgfmt_format" TSRMLS_CC);
if (used_tz == NULL) {
continue;
}
/* {{{ */
static void msgfmt_do_parse(MessageFormatter_object *mfo, char *source, int src_len, zval *return_value TSRMLS_DC)
{
- zval **fargs;
+ zval *fargs;
int count = 0;
int i;
UChar *usource = NULL;
array_init(return_value);
for(i=0;i<count;i++) {
- add_next_index_zval(return_value, fargs[i]);
+ add_next_index_zval(return_value, &fargs[i]);
}
efree(fargs);
}
*/
PHP_RSHUTDOWN_FUNCTION( intl )
{
- if(INTL_G(current_collator)) {
- INTL_G(current_collator) = NULL;
+ if(!Z_ISUNDEF(INTL_G(current_collator))) {
+ ZVAL_UNDEF(&INTL_G(current_collator));
}
if (INTL_G(grapheme_iterator)) {
grapheme_close_global_iterator( TSRMLS_C );
case URES_ARRAY:
case URES_TABLE:
object_init_ex( return_value, ResourceBundle_ce_ptr );
- newrb = (ResourceBundle_object *) zend_object_store_get_object( return_value TSRMLS_CC );
+ newrb = Z_INTL_RESOURCEBUNDLE_P(return_value);
newrb->me = source->child;
source->child = NULL;
intl_errors_reset(INTL_DATA_ERROR_P(source) TSRMLS_CC);
/* }}} */
/* {{{ resourcebundle_array_get */
-zval *resourcebundle_array_get(zval *object, zval *offset, int type TSRMLS_DC)
+zval *resourcebundle_array_get(zval *object, zval *offset, int type, zval *rv TSRMLS_DC)
{
- zval *retval;
-
if(offset == NULL) {
php_error( E_ERROR, "Cannot apply [] to ResourceBundle object" );
}
- MAKE_STD_ZVAL(retval);
-
- resourcebundle_array_fetch(object, offset, retval, 1 TSRMLS_CC);
- Z_DELREF_P(retval);
- return retval;
+ ZVAL_NULL(rv);
+ resourcebundle_array_fetch(object, offset, rv, 1 TSRMLS_CC);
+ return rv;
}
/* }}} */
*/
/* {{{ Spoofchecker_objects_dtor */
-static void Spoofchecker_objects_dtor(
- void *object,
- zend_object_handle handle TSRMLS_DC)
+static void Spoofchecker_objects_dtor(zend_object *object TSRMLS_DC)
{
- zend_objects_destroy_object(object, handle TSRMLS_CC);
+ zend_objects_destroy_object(object TSRMLS_CC);
}
/* }}} */
/* {{{ Spoofchecker_objects_free */
void Spoofchecker_objects_free(zend_object *object TSRMLS_DC)
{
- Spoofchecker_object* co = (Spoofchecker_object*)object;
+ Spoofchecker_object* co = php_intl_spoofchecker_fetch_object(object);
zend_object_std_dtor(&co->zo TSRMLS_CC);
spoofchecker_object_destroy(co TSRMLS_CC);
-
- efree(co);
}
/* }}} */
/* {{{ Spoofchecker_object_create */
-zend_object_value Spoofchecker_object_create(
+zend_object *Spoofchecker_object_create(
zend_class_entry *ce TSRMLS_DC)
{
- zend_object_value retval;
Spoofchecker_object* intern;
- intern = ecalloc(1, sizeof(Spoofchecker_object));
+ intern = ecalloc(1, sizeof(Spoofchecker_object) + sizeof(zval) * (ce->default_properties_count - 1));
intl_error_init(SPOOFCHECKER_ERROR_P(intern) TSRMLS_CC);
zend_object_std_init(&intern->zo, ce TSRMLS_CC);
object_properties_init(&intern->zo, ce);
- retval.handle = zend_objects_store_put(
- intern,
- Spoofchecker_objects_dtor,
- (zend_objects_free_object_storage_t)Spoofchecker_objects_free,
- NULL TSRMLS_CC);
-
- retval.handlers = &Spoofchecker_handlers;
+ intern->zo.handlers = &Spoofchecker_handlers;
- return retval;
+ return &intern->zo;
}
/* }}} */
};
/* }}} */
-static zend_object_value spoofchecker_clone_obj(zval *object TSRMLS_DC) /* {{{ */
+static zend_object *spoofchecker_clone_obj(zval *object TSRMLS_DC) /* {{{ */
{
- zend_object_value new_obj_val;
- zend_object_handle handle = Z_OBJ_HANDLE_P(object);
+ zend_object *new_obj_val;
Spoofchecker_object *sfo, *new_sfo;
- sfo = (Spoofchecker_object *) zend_object_store_get_object(object TSRMLS_CC);
+ sfo = Z_INTL_SPOOFCHECKER_P(object);
intl_error_reset(SPOOFCHECKER_ERROR_P(sfo) TSRMLS_CC);
new_obj_val = Spoofchecker_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC);
- new_sfo = (Spoofchecker_object *)zend_object_store_get_object_by_handle(new_obj_val.handle TSRMLS_CC);
+ new_sfo = php_intl_spoofchecker_fetch_object(new_obj_val);
/* clone standard parts */
- zend_objects_clone_members(&new_sfo->zo, new_obj_val, &sfo->zo, handle TSRMLS_CC);
+ zend_objects_clone_members(&new_sfo->zo, &sfo->zo TSRMLS_CC);
/* clone internal object */
new_sfo->uspoof = uspoof_clone(sfo->uspoof, SPOOFCHECKER_ERROR_CODE_P(new_sfo));
if(U_FAILURE(SPOOFCHECKER_ERROR_CODE(new_sfo))) {
/* set up error in case error handler is interested */
intl_error_set( NULL, SPOOFCHECKER_ERROR_CODE(new_sfo), "Failed to clone SpoofChecker object", 0 TSRMLS_CC );
- Spoofchecker_objects_dtor(new_sfo, new_obj_val.handle TSRMLS_CC); /* free new object */
+ Spoofchecker_objects_dtor(&new_sfo->zo TSRMLS_CC); /* free new object */
zend_error(E_ERROR, "Failed to clone SpoofChecker object");
}
return new_obj_val;
memcpy(&Spoofchecker_handlers, zend_get_std_object_handlers(),
sizeof Spoofchecker_handlers);
+ Spoofchecker_handlers.offset = XtOffsetOf(Spoofchecker_object, zo);
Spoofchecker_handlers.clone_obj = spoofchecker_clone_obj;
+ Spoofchecker_handlers.dtor_obj = Spoofchecker_objects_dtor;
+ Spoofchecker_handlers.free_obj = Spoofchecker_objects_free;
if (!Spoofchecker_ce_ptr) {
zend_error(E_ERROR,
#include <unicode/uspoof.h>
typedef struct {
- zend_object zo;
-
// error handling
intl_error err;
// ICU Spoofchecker
USpoofChecker* uspoof;
+
+ zend_object zo;
} Spoofchecker_object;
+static inline Spoofchecker_object *php_intl_spoofchecker_fetch_object(zend_object *obj) {
+ return (Spoofchecker_object *)((char*)(obj) - XtOffsetOf(Spoofchecker_object, zo));
+}
+#define Z_INTL_SPOOFCHECKER_P(zv) php_intl_spoofchecker_fetch_object((Z_OBJ_P(zv)))
+
#define SPOOFCHECKER_ERROR(co) (co)->err
#define SPOOFCHECKER_ERROR_P(co) &(SPOOFCHECKER_ERROR(co))
Spoofchecker_object* co = NULL; \
intl_error_reset(NULL TSRMLS_CC); \
-#define SPOOFCHECKER_METHOD_FETCH_OBJECT_NO_CHECK INTL_METHOD_FETCH_OBJECT(Spoofchecker, co)
+#define SPOOFCHECKER_METHOD_FETCH_OBJECT_NO_CHECK INTL_METHOD_FETCH_OBJECT(INTL_SPOOFCHECKER, co)
#define SPOOFCHECKER_METHOD_FETCH_OBJECT \
SPOOFCHECKER_METHOD_FETCH_OBJECT_NO_CHECK; \
if (co->uspoof == NULL) { \
UnicodeString id;
char *message = NULL;
php_timezone_obj *tzobj;
- zval arg = zval_used_for_init;
+ zval arg;
timeZone->getID(id);
if (id.isBogus()) {
intl_error *outside_error,
const char *func TSRMLS_DC)
{
- zval local_zv_tz = zval_used_for_init;
+ zval local_zv_tz;
char *message = NULL;
TimeZone *timeZone;
/* {{{ get_debug_info handler for TimeZone */
static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
{
- zval zv = zval_used_for_init;
+ zval zv;
TimeZone_object *to;
const TimeZone *tz;
UnicodeString ustr;
projects / php / commitdiff