- Added MAKE_COPY_ZVAL(ppzv, pzv) macro

diff --git a/Zend/zend.h b/Zend/zend.h
index f6fd95de83a1e14d1ddce11d8531586950dba7dc..33ca08d0b821bd4c60bcf315ed4496002d79dfa8 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -765,6 +765,11 @@ END_EXTERN_C()
                FREE_ZVAL(pzv);                                         \
        }                                                                               \
        INIT_PZVAL(&(zv));
+       
+#define MAKE_COPY_ZVAL(ppzv, pzv) \
+       *(pzv) = **(ppzv);            \
+       zval_copy_ctor((pzv));        \
+       INIT_PZVAL((pzv));
 
 #define REPLACE_ZVAL_VALUE(ppzv_dest, pzv_src, copy) { \
        int is_ref, refcount;                                           \

diff --git a/ext/filter/filter.c b/ext/filter/filter.c
index 7e57b81535c73aae74f76996a8c4fcdb6d996234..18b2a5d77c52a50a21a1814a32afc3208ec11d73 100644 (file)
--- a/ext/filter/filter.c
+++ b/ext/filter/filter.c
@@ -406,9 +406,7 @@ static void php_zval_filter(zval **value, long filter, long flags, zval *options
        ) {
                zval **tmp; 
                if (zend_hash_find(HASH_OF(options), "default", sizeof("default"), (void **)&tmp) == SUCCESS) {
-                       **value = **tmp;
-                       zval_copy_ctor(*value);
-                       INIT_PZVAL(*value);
+                       MAKE_COPY_ZVAL(tmp, *value);
                }
        }
 }
@@ -692,9 +690,7 @@ static void php_filter_call(zval **filtered, long filter, zval **filter_args, co
                zval *tmp;
 
                ALLOC_ZVAL(tmp);
-               *tmp = **filtered;
-               zval_copy_ctor(tmp);
-               INIT_PZVAL(tmp);
+               MAKE_COPY_ZVAL(filtered, tmp);
 
                zval_dtor(*filtered);
 
@@ -714,15 +710,11 @@ static void php_filter_array_handler(zval *input, zval **op, zval *return_value
 
        if (!op) {
                zval_dtor(return_value);
-               *return_value = *input;
-               zval_copy_ctor(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(&input, return_value);
                php_filter_call(&return_value, FILTER_DEFAULT, NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
        } else if (Z_TYPE_PP(op) == IS_LONG) {
                zval_dtor(return_value);
-               *return_value = *input;
-               zval_copy_ctor(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(&input, return_value);
                php_filter_call(&return_value, Z_LVAL_PP(op), NULL, 0, FILTER_REQUIRE_ARRAY TSRMLS_CC);
        } else if (Z_TYPE_PP(op) == IS_ARRAY) {
                array_init(return_value);
@@ -748,9 +740,7 @@ static void php_filter_array_handler(zval *input, zval **op, zval *return_value
                                zval *nval;
 
                                ALLOC_ZVAL(nval);
-                               *nval = **tmp;
-                               zval_copy_ctor(nval);
-                               INIT_PZVAL(nval);
+                               MAKE_COPY_ZVAL(tmp, nval);
 
                                php_filter_call(&nval, -1, arg_elm, 0, FILTER_REQUIRE_SCALAR TSRMLS_CC);
                                add_assoc_zval_ex(return_value, arg_key.s, arg_key_len, nval);
@@ -796,9 +786,7 @@ PHP_FUNCTION(filter_input)
                                Z_TYPE_PP(opt) == IS_ARRAY &&
                                zend_hash_find(HASH_OF(*opt), "default", sizeof("default"), (void **)&def) == SUCCESS
                        ) {
-                               *return_value = **def;
-                               zval_copy_ctor(return_value);
-                               INIT_PZVAL(return_value);
+                               MAKE_COPY_ZVAL(def, return_value);
                                return;
                        }
                }
@@ -809,9 +797,7 @@ PHP_FUNCTION(filter_input)
                }
        }
 
-       *return_value = **tmp;
-       zval_copy_ctor(return_value);  /* Watch out for empty strings */
-       INIT_PZVAL(return_value);
+       MAKE_COPY_ZVAL(tmp, return_value);
 
        php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
 }
@@ -833,9 +819,7 @@ PHP_FUNCTION(filter_var)
                RETURN_FALSE;
        }
 
-       *return_value = *data;
-       zval_copy_ctor(data);
-       INIT_PZVAL(return_value);
+       MAKE_COPY_ZVAL(&data, return_value);
 
        php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
 }

diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index 415b2f30e150a3e548acba98c8b3075b3b74d9b5..42d741e14a64c374102456bb762daecbe1dcdd92 100644 (file)
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -1442,9 +1442,7 @@ static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_repl
                if (!zend_is_callable(replace, 0, &callback_name TSRMLS_CC)) {
                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires argument 2, '%R', to be a valid callback", Z_TYPE(callback_name), Z_UNIVAL(callback_name));
                        zval_dtor(&callback_name);
-                       *return_value = *subject;
-                       zval_copy_ctor(return_value);
-                       INIT_PZVAL(return_value);
+                       MAKE_COPY_ZVAL(&subject, return_value);
                        return;
                }
                zval_dtor(&callback_name);

diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index 8093deb55339a24a6ed43e66713de425a9268ea2..55f3ba428046b9ad595cb4632c44f526cfc07a98 100755 (executable)
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -470,9 +470,7 @@ static PHP_METHOD(PDOStatement, execute)
 
                        param.param_type = PDO_PARAM_STR;
                        MAKE_STD_ZVAL(param.parameter);
-                       *param.parameter = **tmp;
-                       zval_copy_ctor(param.parameter);
-                       INIT_PZVAL(param.parameter);
+                       MAKE_COPY_ZVAL(tmp, param.parameter);
 
                        if (!really_register_bound_param(&param, stmt, 1 TSRMLS_CC)) {
                                zval_ptr_dtor(&param.parameter);
@@ -1283,9 +1281,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
                                                zval_ptr_dtor(&return_value); /* we don't need that */
                                                return_value = retval;
                                        } else if (retval) {
-                                               *return_value = *retval;
-                                               zval_copy_ctor(return_value);
-                                               INIT_PZVAL(return_value);
+                                               MAKE_COPY_ZVAL(&retval, return_value);
                                                zval_ptr_dtor(&retval);
                                        }
                                }

diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index 3cacc65aaed6f985dbf2cf8581016080b7ecf6e3..3d61e275d8eed8c5cd863f6d7158a82d97dec0e1 100644 (file)
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -517,9 +517,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
                func->funcname = estrdup(func_name);
                
                MAKE_STD_ZVAL(func->func);
-               *(func->func) = *callback;
-               zval_copy_ctor(func->func);
-               INIT_PZVAL(func->func);
+               MAKE_COPY_ZVAL(&callback, func->func);
                
                func->argc = argc;
 
@@ -591,14 +589,10 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
                func->funcname = estrdup(func_name);
                
                MAKE_STD_ZVAL(func->step);
-               *(func->step) = *step_callback;
-               zval_copy_ctor(func->step);
-               INIT_PZVAL(func->step);
+               MAKE_COPY_ZVAL(&step_callback, func->step);
 
                MAKE_STD_ZVAL(func->fini);
-               *(func->fini) = *fini_callback;
-               zval_copy_ctor(func->fini);
-               INIT_PZVAL(func->fini);
+               MAKE_COPY_ZVAL(&fini_callback, func->fini);
                
                func->argc = argc;
 

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 61b146b3e0d2f093112cb096c91e734b21d6fcdc..06fd97fa6c92c481dedc06e8b6d5ecbe19c2af97 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -208,9 +208,7 @@ static void _default_get_entry(zval *object, char *name, int name_len, zval *ret
                RETURN_FALSE;
        }
 
-       *return_value = **value;
-       zval_copy_ctor(return_value);
-       INIT_PZVAL(return_value);
+       MAKE_COPY_ZVAL(value, return_value);
 }
 /* }}} */
 
@@ -3243,9 +3241,7 @@ ZEND_METHOD(reflection_class, getStaticProperties)
                        if (!(class_name.s && class_name.s[0] != '*' && u_strcmp(class_name.u, ce->name.u))) {                          
                                /* copy: enforce read only access */
                                ALLOC_ZVAL(prop_copy);
-                               *prop_copy = **value;
-                               zval_copy_ctor(prop_copy);
-                               INIT_PZVAL(prop_copy);
+                               MAKE_COPY_ZVAL(value, prop_copy);
 
                                add_u_assoc_zval(return_value, IS_UNICODE, prop_name, prop_copy);
                        }
@@ -3371,9 +3367,7 @@ ZEND_METHOD(reflection_class, getDefaultProperties)
 
                                /* copy: enforce read only access */
                                ALLOC_ZVAL(prop_copy);
-                               *prop_copy = **prop;
-                               zval_copy_ctor(prop_copy);
-                               INIT_PZVAL(prop_copy);
+                               MAKE_COPY_ZVAL(prop, prop_copy);
 
                                add_u_assoc_zval(return_value, IS_UNICODE, prop_name, prop_copy);
                        }
@@ -3934,9 +3928,7 @@ ZEND_METHOD(reflection_class, getConstant)
        if (zend_u_hash_find(&ce->constants_table, name_type, name, name_len + 1, (void **) &value) == FAILURE) {
                RETURN_FALSE;
        }
-       *return_value = **value;
-       zval_copy_ctor(return_value);
-       INIT_PZVAL(return_value);
+       MAKE_COPY_ZVAL(value, return_value);
 }
 /* }}} */
 
@@ -4719,9 +4711,7 @@ ZEND_METHOD(reflection_property, getDefaultValue)
 
        if (zend_u_hash_quick_find(prop_defaults, utype, ref->prop.name, ref->prop.name_length+1, ref->prop.h, (void**)&zdef) == SUCCESS) {
                ALLOC_ZVAL(zv);
-               *zv = **zdef;
-               zval_copy_ctor(zv);
-               INIT_PZVAL(zv);
+               MAKE_COPY_ZVAL(zdef, zv);
                zval_update_constant_ex(&zv, (void*)1, ref->ce TSRMLS_CC);
                RETURN_ZVAL(zv, 1, 1);
        }
@@ -4771,9 +4761,7 @@ ZEND_METHOD(reflection_property, getValue)
                        zend_error(E_ERROR, "Internal error: Could not find the property %v::%v", intern->ce->name, ref->prop.name);
                        /* Bails out */
                }
-               *return_value= **member;
-               zval_copy_ctor(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(member, return_value);
        } else {
                zstr class_name, prop_name;
                int prop_name_len;
@@ -4784,9 +4772,7 @@ ZEND_METHOD(reflection_property, getValue)
                zend_u_unmangle_property_name(IS_UNICODE, ref->prop.name, ref->prop.name_length, &class_name, &prop_name);
                prop_name_len = u_strlen(prop_name.u);
                member_p = zend_u_read_property(ref->ce, object, IS_UNICODE, prop_name, prop_name_len, 1 TSRMLS_CC);
-               *return_value= *member_p;
-               zval_copy_ctor(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(&member_p, return_value);
                if (member_p != EG(uninitialized_zval_ptr)) {
                        zval_add_ref(&member_p);
                        zval_ptr_dtor(&member_p);

diff --git a/ext/soap/soap.c b/ext/soap/soap.c
index b6e2b3fb8f8ddc43e3ccb4e6201fe37391a56852..a5e18dd915c435ffc8dd3fac8e4b238412ed97c2 100644 (file)
--- a/ext/soap/soap.c
+++ b/ext/soap/soap.c
@@ -1727,9 +1727,7 @@ PHP_METHOD(SoapServer, setObject)
        service->type = SOAP_OBJECT;
 
        MAKE_STD_ZVAL(service->soap_object);
-       *service->soap_object = *obj;
-       zval_copy_ctor(service->soap_object);
-       INIT_PZVAL(service->soap_object);
+       MAKE_COPY_ZVAL(&obj, service->soap_object);
 
        SOAP_SERVER_END_CODE();
 }
@@ -2637,9 +2635,7 @@ static void soap_error_handler(int error_num, const char *error_filename, const
                        fault = add_soap_fault(SOAP_GLOBAL(error_object), code, buffer, NULL, NULL TSRMLS_CC);
                        efree(buffer);
                        MAKE_STD_ZVAL(exception);
-                       *exception = *fault;
-                       zval_copy_ctor(exception);
-                       INIT_PZVAL(exception);
+                       MAKE_COPY_ZVAL(&fault, exception);
                        zend_throw_exception_object(exception TSRMLS_CC);
 
                        old_objects = EG(objects_store).object_buckets;
@@ -3269,9 +3265,7 @@ static void do_soap_call(zval* this_ptr,
 
        if (!ret) {
                if (client->fault) {
-                       *return_value = *client->fault;
-                       zval_copy_ctor(return_value);
-                       INIT_PZVAL(return_value);
+                       MAKE_COPY_ZVAL(&client->fault, return_value);
                } else {
                        *return_value = *add_soap_fault(this_ptr, "Client", "Unknown Error", NULL, NULL TSRMLS_CC);
                        zval_copy_ctor(return_value);
@@ -3279,9 +3273,7 @@ static void do_soap_call(zval* this_ptr,
                }
        } else {
                if (client->fault) {
-                       *return_value = *client->fault;
-                       zval_copy_ctor(return_value);
-                       INIT_PZVAL(return_value);
+                       MAKE_COPY_ZVAL(&client->fault, return_value);
                }
        }
        if (!EG(exception) &&
@@ -3291,9 +3283,7 @@ static void do_soap_call(zval* this_ptr,
                zval *exception;
 
                MAKE_STD_ZVAL(exception);
-               *exception = *return_value;
-               zval_copy_ctor(exception);
-               INIT_PZVAL(exception);
+               MAKE_COPY_ZVAL(&return_value, exception);
                zend_throw_exception_object(exception TSRMLS_CC);
        }
        SOAP_GLOBAL(features) = old_features;
@@ -3687,9 +3677,7 @@ PHP_METHOD(SoapClient, __getCookies)
        if (!client->cookies) {
                array_init(return_value);
        } else {
-               *return_value = *client->cookies;
-               zval_copy_ctor(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(&client->cookies, return_value);
        }
 }
 /* }}} */
@@ -3716,9 +3704,7 @@ PHP_METHOD(SoapClient, __setSoapHeaders)
        } else if (Z_TYPE_P(headers) == IS_ARRAY) {
                verify_soap_headers_array(Z_ARRVAL_P(headers) TSRMLS_CC);
                ALLOC_ZVAL(client->default_headers);
-               *client->default_headers = *headers;
-               INIT_PZVAL(client->default_headers);
-               zval_copy_ctor(client->default_headers);
+               MAKE_COPY_ZVAL(&headers, client->default_headers);
        } else if (Z_TYPE_P(headers) == IS_OBJECT &&
                   instanceof_function(Z_OBJCE_P(headers), soap_header_class_entry TSRMLS_CC)) {
                ALLOC_INIT_ZVAL(client->default_headers);

diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index bc006ced93d540a241b112f55713aca51a0c86a6..b70a5b95ad081be84c257b7aee0a2a1e5adc2d23 100755 (executable)
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -2451,10 +2451,7 @@ SPL_METHOD(CachingIterator, __toString)
                        return;
                }
        } else if (intern->u.caching.flags & CIT_TOSTRING_USE_CURRENT) {
-               *return_value = *intern->current.data;
-               zval_copy_ctor(return_value);
-               convert_to_unicode(return_value);
-               INIT_PZVAL(return_value);
+               MAKE_COPY_ZVAL(&intern->current.data, return_value);
                return;
        }
        if (intern->u.caching.zstr) {

diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c
index f1d54412d39825a7c5a1d2eb2314700697e3163a..a89b9e3f5680cf8dcef04b234206c205a89ff40d 100644 (file)
--- a/ext/sqlite3/sqlite3.c
+++ b/ext/sqlite3/sqlite3.c
@@ -885,9 +885,7 @@ PHP_METHOD(sqlite3, createFunction)
                func->func_name = eustrdup(sql_func);
 
                MAKE_STD_ZVAL(func->func);
-               *(func->func) = *callback_func;
-               zval_copy_ctor(func->func);
-               INIT_PZVAL(func->func);
+               MAKE_COPY_ZVAL(&callback_func, func->func);
 
                func->argc = sql_func_num_args;
                func->next = db_obj->funcs;
@@ -944,14 +942,10 @@ PHP_METHOD(sqlite3, createAggregate)
                func->func_name = eustrdup(sql_func);
 
                MAKE_STD_ZVAL(func->step);
-               *(func->step) = *step_callback;
-               zval_copy_ctor(func->step);
-               INIT_PZVAL(func->step);
+               MAKE_COPY_ZVAL(&step_callback, func->step);
 
                MAKE_STD_ZVAL(func->fini);
-               *(func->fini) = *fini_callback;
-               zval_copy_ctor(func->fini);
-               INIT_PZVAL(func->fini);
+               MAKE_COPY_ZVAL(&fini_callback, func->fini);
 
                func->argc = sql_func_num_args;
                func->next = db_obj->funcs;

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 669af82429f91cfffeda02b77e483bd14a43c4fc..c9e684db0d6da7987affe31c00afb806d4975ccd 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -1549,9 +1549,7 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu
                if (zend_u_hash_find(eg_active_symbol_table, Z_TYPE_P(entry), key, key_len + 1, (void **)&value_ptr) != FAILURE) {
                        value = *value_ptr;
                        ALLOC_ZVAL(data);
-                       *data = *value;
-                       zval_copy_ctor(data);
-                       INIT_PZVAL(data);
+                       MAKE_COPY_ZVAL(&value, data);
 
                        zend_u_hash_update(Z_ARRVAL_P(return_value), Z_TYPE_P(entry), key, key_len + 1, &data, sizeof(zval *), NULL);
                }
@@ -4282,9 +4280,7 @@ PHP_FUNCTION(array_reduce)
 
        if (ZEND_NUM_ARGS() > 2) {
                ALLOC_ZVAL(result);
-               *result = *initial;
-               zval_copy_ctor(result);
-               INIT_PZVAL(result);
+               MAKE_COPY_ZVAL(&initial, result);
        } else {
                MAKE_STD_ZVAL(result);
                ZVAL_NULL(result);

diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index 20d2b61f9f7d172124208447e89769924a5054e1..e802b9196359a4e89ecbceb07e3bcc51840c34a7 100644 (file)
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -5926,13 +5926,8 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal
                                break;
                        }
                        ALLOC_ZVAL(element);
-                       *element = *arg2;
-                       zval_copy_ctor(element);
-                       INIT_PZVAL(element);
-
-                       name = *arg1;
-                       zval_copy_ctor(&name);
-                       INIT_PZVAL(&name);
+                       MAKE_COPY_ZVAL(&arg2, element);
+                       MAKE_COPY_ZVAL(&arg1, &name);
 
                        convert_to_unicode_with_converter(element, UG(utf8_conv));
                        convert_to_unicode_with_converter(&name, UG(utf8_conv));
@@ -5989,9 +5984,7 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal
                        }
 
                        ALLOC_ZVAL(element);
-                       *element = *arg2;
-                       zval_copy_ctor(element);
-                       INIT_PZVAL(element);
+                       MAKE_COPY_ZVAL(&arg2, element);
 
                        convert_to_unicode_with_converter(element, UG(utf8_conv));
 
@@ -6018,9 +6011,7 @@ static void php_ini_parser_cb_with_sections(zval *arg1, zval *arg2, zval *arg3,
        if (callback_type == ZEND_INI_PARSER_SECTION) {
                MAKE_STD_ZVAL(BG(active_ini_file_section));
                array_init(BG(active_ini_file_section));
-               name = *arg1;
-               zval_copy_ctor(&name);
-               INIT_PZVAL(&name);
+               MAKE_COPY_ZVAL(&arg1, &name);
 
                convert_to_unicode_with_converter(&name, UG(utf8_conv));
 

diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c
index 7cd387920035aa8f7928f956179bb6bef6e1496f..c12fb4afb78f147fa62a66f699a2b31a2c2f665b 100644 (file)
--- a/ext/standard/streamsfuncs.c
+++ b/ext/standard/streamsfuncs.c
@@ -499,9 +499,7 @@ PHP_FUNCTION(stream_get_meta_data)
        
        if (stream->wrapperdata) {
                MAKE_STD_ZVAL(newval);
-               *newval = *(stream->wrapperdata);
-               zval_copy_ctor(newval);
-               INIT_PZVAL(newval);
+               MAKE_COPY_ZVAL(&stream->wrapperdata, newval);
 
                add_ascii_assoc_zval(return_value, "wrapper_data", newval);
        }

diff --git a/ext/standard/string.c b/ext/standard/string.c
index c889792d045fe2a8a0f1e8c3743bb2440b466dad..92256881bc41cb318be3055e265f491949545801 100644 (file)
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -5418,9 +5418,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
        /* If search is an array */
        if (Z_TYPE_P(search) == IS_ARRAY) {
                /* Duplicate subject string for repeated replacement */
-               *result = **subject;
-               zval_copy_ctor(result);
-               INIT_PZVAL(result);
+               MAKE_COPY_ZVAL(subject, result);
 
                zend_hash_internal_pointer_reset(Z_ARRVAL_P(search));
 
@@ -5527,9 +5525,7 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
                                                                                                                           &Z_USTRLEN_P(result), replace_count TSRMLS_CC);
                        }
                } else {
-                       *result = **subject;
-                       zval_copy_ctor(result);
-                       INIT_PZVAL(result);
+                       MAKE_COPY_ZVAL(subject, result);
                }
        }
 }

diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index 184a030fc5976c753ecb5b1a5d0500d93063f400..13a42da6ec63feec42b2607338f0ac17b8d93210 100644 (file)
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -1314,9 +1314,7 @@ PHP_FUNCTION(xml_set_object)
 #endif */
 
        ALLOC_ZVAL(parser->object);
-       *parser->object = *mythis;
-       zval_copy_ctor(parser->object);
-       INIT_PZVAL(parser->object);
+       MAKE_COPY_ZVAL(&mythis, parser->object);
 
        RETVAL_TRUE;
 }

diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 589f1e6c1e20539519f50ab40169ef0ff263bc48..71530c280e1633186ac2634a35b2df3ff32cdfe9 100644 (file)
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -574,9 +574,7 @@ static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int dep
                                                }
 
                                                MAKE_STD_ZVAL(val_arr);
-                                               *val_arr = *val;
-                                               zval_copy_ctor(val_arr);
-                                               INIT_PZVAL(val_arr);
+                                               MAKE_COPY_ZVAL(&val, val_arr);
                                                convert_to_array(val_arr);
                                                
                                                vtype = determine_vector_type(Z_ARRVAL_P(val_arr));