Merge branch 'phpng' of git.php.net:php-src into phpng

# By Dmitry Stogov
# Via Dmitry Stogov
* 'phpng' of git.php.net:php-src:
  ext/soap support for phpng (incomplete - just compilable)

1 files changed, 567 insertions, 666 deletions

diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c
index c4ce4476bc..071c0fd3e1 100644
--- a/ext/soap/php_encoding.c
+++ b/ext/soap/php_encoding.c
@@ -29,16 +29,16 @@
 #include "zend_interfaces.h"
 
 /* zval type decode */
-static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
 
 static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
@@ -71,17 +71,17 @@ static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNode
 static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 
-static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
 
 static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 
-static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
 static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 
 /* Try and guess for non-wsdl clients and servers */
-static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
+static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
 static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
 
 static int is_map(zval *array);
@@ -118,16 +118,12 @@ static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type);
 	{ \
 		xmlAttrPtr null; \
 		if (!xml) { \
-			zval *ret; \
-			ALLOC_INIT_ZVAL(ret); \
 			ZVAL_NULL(ret); \
 			return ret; \
 		} \
 		if (xml->properties) { \
 			null = get_attribute(xml->properties, "nil"); \
 			if (null) { \
-				zval *ret; \
-				ALLOC_INIT_ZVAL(ret); \
 				ZVAL_NULL(ret); \
 				return ret; \
 			} \
@@ -151,7 +147,8 @@ encode defaultEncoding[] = {
 	{{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
 	{{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long},
 	{{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double},
-	{{IS_BOOL, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
+	{{IS_FALSE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
+	{{IS_TRUE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool},
 	{{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string},
 	{{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map},
 	{{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object},
@@ -275,37 +272,34 @@ void whiteSpace_collapse(xmlChar* str)
 static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
 {
 	if (sdl && sdl->encoders) {
-		HashPosition pos;
-		encodePtr *enc;
+		encodePtr enc;
 
-		for (zend_hash_internal_pointer_reset_ex(sdl->encoders, &pos);
-		     zend_hash_get_current_data_ex(sdl->encoders, (void **) &enc, &pos) == SUCCESS;
-		     zend_hash_move_forward_ex(sdl->encoders, &pos)) {
-		    if (strcmp((*enc)->details.type_str, type) == 0) {
-				return *enc;
+		ZEND_HASH_FOREACH_PTR(sdl->encoders, enc)  {
+		    if (strcmp(enc->details.type_str, type) == 0) {
+				return enc;
 			}
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 	return NULL;
 }
 
 static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
-	xmlNodePtr *node_ptr;
+	xmlNodePtr node_ptr;
 
 	if (SOAP_GLOBAL(ref_map)) {
 		if (Z_TYPE_P(data) == IS_OBJECT) {
-			data = (zval*)zend_objects_get_address(data TSRMLS_CC);
+			data = (zval*)Z_OBJ_P(data);
 		}
-		if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node_ptr) == SUCCESS) {
-			xmlAttrPtr attr = (*node_ptr)->properties;
+		if ((node_ptr = zend_hash_index_find_ptr(SOAP_GLOBAL(ref_map), (ulong)data)) != NULL) {
+			xmlAttrPtr attr = node_ptr->properties;
 			char *id;
 			smart_str prefix = {0};
 
-			if (*node_ptr == node) {
+			if (node_ptr == node) {
 				return 0;
 			}
-			xmlNodeSetName(node, (*node_ptr)->name);
-			xmlSetNs(node, (*node_ptr)->ns);
+			xmlNodeSetName(node, node_ptr->name);
+			xmlSetNs(node, node_ptr->ns);
 			if (SOAP_GLOBAL(soap_version) == SOAP_1_1) {
 				while (1) {
 					attr = get_attribute(attr, "id");
@@ -319,14 +313,14 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
 					smart_str_appendc(&prefix, '#');
 					smart_str_appends(&prefix, id);
 					smart_str_0(&prefix);
-					id = prefix.c;
+					id = prefix.s->val;
 				} else {
 					SOAP_GLOBAL(cur_uniq_ref)++;
 					smart_str_appendl(&prefix, "#ref", 4);
 					smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
 					smart_str_0(&prefix);
-					id = prefix.c;
-					xmlSetProp((*node_ptr), BAD_CAST("id"), BAD_CAST(id+1));
+					id = prefix.s->val;
+					xmlSetProp(node_ptr, BAD_CAST("id"), BAD_CAST(id+1));
 				}
 				xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id));
 			} else {
@@ -336,21 +330,21 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
 					smart_str_appendc(&prefix, '#');
 					smart_str_appends(&prefix, id);
 					smart_str_0(&prefix);
-					id = prefix.c;
+					id = prefix.s->val;
 				} else {
 					SOAP_GLOBAL(cur_uniq_ref)++;
 					smart_str_appendl(&prefix, "#ref", 4);
 					smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref));
 					smart_str_0(&prefix);
-					id = prefix.c;
-					set_ns_prop((*node_ptr), SOAP_1_2_ENC_NAMESPACE, "id", id+1);
+					id = prefix.s->val;
+					set_ns_prop(node_ptr, SOAP_1_2_ENC_NAMESPACE, "id", id+1);
 				}
 				set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id);
 			}
 			smart_str_free(&prefix);
 			return 1;
 		} else {
-			zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node, sizeof(xmlNodePtr), NULL);
+			zend_hash_index_update_ptr(SOAP_GLOBAL(ref_map), (ulong)data, node);
 		}
 	}
 	return 0;
@@ -358,32 +352,34 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
 
 static zval* soap_find_xml_ref(xmlNodePtr node TSRMLS_DC)
 {
-	zval **data_ptr;
+	zval *data_ptr;
 
 	if (SOAP_GLOBAL(ref_map) && 
-	    zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {
-		Z_SET_ISREF_PP(data_ptr);
-		Z_ADDREF_PP(data_ptr);
-		return *data_ptr;
+	    (data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) {
+//???		Z_SET_ISREF_PP(data_ptr);
+	    SEPARATE_ZVAL_TO_MAKE_IS_REF(data_ptr);
+		Z_ADDREF_P(data_ptr);
+		return data_ptr;
 	}
 	return NULL;
 }
 
-static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC)
+static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC)
 {
-	zval **data_ptr;
+	zval *data_ptr;
 
 	if (SOAP_GLOBAL(ref_map)) {
-		if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) {
-			if (*data != *data_ptr) {
+		if ((data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) {
+			if (data != data_ptr) {
 				zval_ptr_dtor(data);
-				*data = *data_ptr;
-				Z_SET_ISREF_PP(data);
-				Z_ADDREF_PP(data);
+				ZVAL_COPY_VALUE(data, data_ptr);
+//???				Z_SET_ISREF_PP(data);
+			    SEPARATE_ZVAL_TO_MAKE_IS_REF(data);
+				Z_ADDREF_P(data);
 				return 1;
 			}
 		} else {
-			zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, (void**)data, sizeof(zval*), NULL);
+			zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, data);
 		}
 	}
 	return 0;
@@ -398,92 +394,81 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 	if (data &&
 	    Z_TYPE_P(data) == IS_OBJECT &&
 	    Z_OBJCE_P(data) == soap_var_class_entry) {
-		zval **ztype, **zdata, **zns, **zstype, **zname, **znamens;
+		zval *ztype, *zdata, *zns, *zstype, *zname, *znamens;
 		encodePtr enc = NULL;
 		HashTable *ht = Z_OBJPROP_P(data);
 
-		if (zend_hash_find(ht, "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {
+		if ((ztype = zend_hash_str_find(ht, "enc_type", sizeof("enc_type")-1)) == NULL) {
 			soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property");
 		}
 
-		if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
-			if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
-				enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
+		if ((zstype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+			if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+				enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
 			} else {
 				zns = NULL;
-				enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
+				enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
 			}
 			if (enc == NULL && SOAP_GLOBAL(typemap)) {
-				encodePtr *new_enc;
 				smart_str nscat = {0};
 
 				if (zns != NULL) {
-					smart_str_appendl(&nscat, Z_STRVAL_PP(zns), Z_STRLEN_PP(zns));
+					smart_str_appendl(&nscat, Z_STRVAL_P(zns), Z_STRLEN_P(zns));
 					smart_str_appendc(&nscat, ':');
 				}
-				smart_str_appendl(&nscat, Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype));
+				smart_str_appendl(&nscat, Z_STRVAL_P(zstype), Z_STRLEN_P(zstype));
 				smart_str_0(&nscat);
-				if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
-					enc = *new_enc;
-				}
+				enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s);
 				smart_str_free(&nscat);			
 			}
 		}
 		if (enc == NULL) {
-			enc = get_conversion(Z_LVAL_P(*ztype));
+			enc = get_conversion(Z_LVAL_P(ztype));
 		}
 		if (enc == NULL) {
 			enc = encode;
 		}
 
-		if (zend_hash_find(ht, "enc_value", sizeof("enc_value"), (void **)&zdata) == FAILURE) {
-			node = master_to_xml(enc, NULL, style, parent TSRMLS_CC);
-		} else {
-			node = master_to_xml(enc, *zdata, style, parent TSRMLS_CC);
-		}
+		zdata = zend_hash_str_find(ht, "enc_value", sizeof("enc_value")-1);
+		node = master_to_xml(enc, zdata, style, parent TSRMLS_CC);
 
 		if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
-			if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) {
-				if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) {
-					set_ns_and_type_ex(node, Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype));
+			if ((ztype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+				if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+					set_ns_and_type_ex(node, Z_STRVAL_P(zns), Z_STRVAL_P(zstype));
 				} else {
-					set_ns_and_type_ex(node, NULL, Z_STRVAL_PP(zstype));
+					set_ns_and_type_ex(node, NULL, Z_STRVAL_P(zstype));
 				}
 			}
 		}
 
-		if (zend_hash_find(ht, "enc_name", sizeof("enc_name"), (void **)&zname) == SUCCESS) {
-			xmlNodeSetName(node, BAD_CAST(Z_STRVAL_PP(zname)));
+		if ((zname = zend_hash_str_find(ht, "enc_name", sizeof("enc_name")-1)) != NULL) {
+			xmlNodeSetName(node, BAD_CAST(Z_STRVAL_P(zname)));
 		}
-		if (zend_hash_find(ht, "enc_namens", sizeof("enc_namens"), (void **)&znamens) == SUCCESS) {
-			xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_PP(znamens));
+		if ((znamens = zend_hash_str_find(ht, "enc_namens", sizeof("enc_namens")-1)) != NULL) {
+			xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_P(znamens));
 			xmlSetNs(node, nsp);
 		}
 	} else {
 		if (check_class_map && SOAP_GLOBAL(class_map) && data &&
 		    Z_TYPE_P(data) == IS_OBJECT &&
-		    !Z_OBJPROP_P(data)->nApplyCount) {
+		    !ZEND_HASH_GET_APPLY_COUNT(Z_OBJPROP_P(data))) {
 			zend_class_entry *ce = Z_OBJCE_P(data);
-			HashPosition pos;
-			zval **tmp;
-			char *type_name = NULL;
-			uint type_len;
-			ulong idx;
-
-			for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(class_map), &pos);
-			     zend_hash_get_current_data_ex(SOAP_GLOBAL(class_map), (void **) &tmp, &pos) == SUCCESS;
-			     zend_hash_move_forward_ex(SOAP_GLOBAL(class_map), &pos)) {
-				if (Z_TYPE_PP(tmp) == IS_STRING &&
-				    ce->name_length == Z_STRLEN_PP(tmp) &&
-				    zend_binary_strncasecmp(ce->name, ce->name_length, Z_STRVAL_PP(tmp), ce->name_length, ce->name_length) == 0 &&
-				    zend_hash_get_current_key_ex(SOAP_GLOBAL(class_map), &type_name, &type_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {
+			zval *tmp;
+			zend_string *type_name;
+
+			ZEND_HASH_FOREACH_STR_KEY_VAL(SOAP_GLOBAL(class_map), type_name, tmp) {
+				if (Z_TYPE_P(tmp) == IS_STRING &&
+				    ce->name->len == Z_STRLEN_P(tmp) &&
+				    zend_binary_strncasecmp(ce->name->val, ce->name->len, Z_STRVAL_P(tmp), ce->name->len, ce->name->len) == 0 &&
+				    type_name) {
 
 					/* TODO: namespace isn't stored */
 					encodePtr enc = NULL;
 					if (SOAP_GLOBAL(sdl)) {
-						enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name);
+						enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name->val);
 						if (!enc) {
-							enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name);
+							enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name->val);
 						}
 					}
 					if (enc) {
@@ -494,7 +479,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 					}
 					break;
 				}
-			}
+			} ZEND_HASH_FOREACH_END();
 		}
 
 		if (encode == NULL) {
@@ -502,7 +487,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 		}
 		if (SOAP_GLOBAL(typemap) && encode->details.type_str) {
 			smart_str nscat = {0};
-			encodePtr *new_enc;
+			encodePtr new_enc;
 
 			if (encode->details.ns) {
 				smart_str_appends(&nscat, encode->details.ns);
@@ -510,8 +495,8 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 			}
 			smart_str_appends(&nscat, encode->details.type_str);
 			smart_str_0(&nscat);
-			if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
-				encode = *new_enc;
+			if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+				encode = new_enc;
 			}
 			smart_str_free(&nscat);			
 		}
@@ -530,14 +515,12 @@ xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr par
 	return master_to_xml_int(encode, data, style, parent, 1 TSRMLS_CC);
 }
 
-static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC)
+static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret = NULL;
-
 	if (SOAP_GLOBAL(typemap)) {
 		if (encode->details.type_str) {
 			smart_str nscat = {0};
-			encodePtr *new_enc;
+			encodePtr new_enc;
 
 			if (encode->details.ns) {
 				smart_str_appends(&nscat, encode->details.ns);
@@ -545,15 +528,15 @@ static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC)
 			}
 			smart_str_appends(&nscat, encode->details.type_str);
 			smart_str_0(&nscat);
-			if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
-				encode = *new_enc;
+			if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+				encode = new_enc;
 			}
 			smart_str_free(&nscat);			
 		} else {
 			xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE);
 
 			if (type_attr != NULL) {
-				encodePtr *new_enc;
+				encodePtr new_enc;
 				xmlNsPtr nsptr;
 				char *ns, *cptype;
 				smart_str nscat = {0};
@@ -568,20 +551,20 @@ static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC)
 				smart_str_0(&nscat);
 				efree(cptype);
 				if (ns) {efree(ns);}
-				if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) {
-					encode = *new_enc;
+				if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) {
+					encode = new_enc;
 				}
 				smart_str_free(&nscat);			
 			}
 		}
 	}
 	if (encode->to_zval) {
-		ret = encode->to_zval(&encode->details, data TSRMLS_CC);
+		ret = encode->to_zval(ret, &encode->details, data TSRMLS_CC);
 	}
 	return ret;
 }
 
-zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC)
+zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
 {
 	data = check_and_resolve_href(data);
 
@@ -612,22 +595,22 @@ zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC)
 			}
 		}
 	}
-	return master_to_zval_int(encode, data TSRMLS_CC);
+	return master_to_zval_int(ret, encode, data TSRMLS_CC);
 }
 
 xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
 {
 	xmlNodePtr ret = NULL;
-	zval *return_value;
+	zval return_value;
 
-	if (type && type->map && type->map->to_xml) {
-		MAKE_STD_ZVAL(return_value);
+	if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) {
+		ZVAL_NULL(&return_value);
 
-		if (call_user_function(EG(function_table), NULL, type->map->to_xml, return_value, 1, &data TSRMLS_CC) == FAILURE) {
+		if (call_user_function(EG(function_table), NULL, &type->map->to_xml, &return_value, 1, data TSRMLS_CC) == FAILURE) {
 			soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
 		}
-		if (Z_TYPE_P(return_value) == IS_STRING) {		
-			xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value));
+		if (Z_TYPE(return_value) == IS_STRING) {		
+			xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL(return_value), Z_STRLEN(return_value));
 			if (doc && doc->children) {				
 				ret = xmlDocCopyNode(doc->children, parent->doc, 1);
 			}
@@ -646,41 +629,37 @@ xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr par
 	return ret;
 }
 
-zval *to_zval_user(encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
+zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
 {
-	zval *return_value;
-
-	if (type && type->map && type->map->to_zval) {
+	if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
 		xmlBufferPtr buf;
-		zval *data;
+		zval data;
 		xmlNodePtr copy;
 
 		copy = xmlCopyNode(node, 1);
 		buf = xmlBufferCreate();
 		xmlNodeDump(buf, NULL, copy, 0, 0);
-		MAKE_STD_ZVAL(data);
-		ZVAL_STRING(data, (char*)xmlBufferContent(buf), 1);
+		ZVAL_STRING(&data, (char*)xmlBufferContent(buf));
 		xmlBufferFree(buf);
 		xmlFreeNode(copy);
 
-		ALLOC_INIT_ZVAL(return_value);
+		ZVAL_NULL(ret);
 		
-		if (call_user_function(EG(function_table), NULL, type->map->to_zval, return_value, 1, &data TSRMLS_CC) == FAILURE) {
+		if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data TSRMLS_CC) == FAILURE) {
 			soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
 		}
 		zval_ptr_dtor(&data);
 	} else {
-		ALLOC_INIT_ZVAL(return_value);
+		ZVAL_NULL(ret);
 	}
-	return return_value;
+	return ret;
 }
 
 /* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */
 /* String encode/decode */
-static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	if (data && data->children) {
 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
@@ -690,17 +669,17 @@ static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 				int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
 
 				if (n >= 0) {
-					ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+					ZVAL_STRING(ret, (char*)xmlBufferContent(out));
 				} else {
-					ZVAL_STRING(ret, (char*)data->children->content, 1);
+					ZVAL_STRING(ret, (char*)data->children->content);
 				}
 				xmlBufferFree(out);
 				xmlBufferFree(in);
 			} else {
-				ZVAL_STRING(ret, (char*)data->children->content, 1);
+				ZVAL_STRING(ret, (char*)data->children->content);
 			}
 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
-			ZVAL_STRING(ret, (char*)data->children->content, 1);
+			ZVAL_STRING(ret, (char*)data->children->content);
 		} else {
 			soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 		}
@@ -710,10 +689,9 @@ static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	return ret;
 }
 
-static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	if (data && data->children) {
 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
@@ -724,17 +702,17 @@ static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 				int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
 
 				if (n >= 0) {
-					ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+					ZVAL_STRING(ret, (char*)xmlBufferContent(out));
 				} else {
-					ZVAL_STRING(ret, (char*)data->children->content, 1);
+					ZVAL_STRING(ret, (char*)data->children->content);
 				}
 				xmlBufferFree(out);
 				xmlBufferFree(in);
 			} else {
-				ZVAL_STRING(ret, (char*)data->children->content, 1);
+				ZVAL_STRING(ret, (char*)data->children->content);
 			}
 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
-			ZVAL_STRING(ret, (char*)data->children->content, 1);
+			ZVAL_STRING(ret, (char*)data->children->content);
 		} else {
 			soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 		}
@@ -744,10 +722,9 @@ static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	return ret;
 }
 
-static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	if (data && data->children) {
 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
@@ -758,17 +735,17 @@ static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 				int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in);
 
 				if (n >= 0) {
-					ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1);
+					ZVAL_STRING(ret, (char*)xmlBufferContent(out));
 				} else {
-					ZVAL_STRING(ret, (char*)data->children->content, 1);
+					ZVAL_STRING(ret, (char*)data->children->content);
 				}
 				xmlBufferFree(out);
 				xmlBufferFree(in);
 			} else {
-				ZVAL_STRING(ret, (char*)data->children->content, 1);
+				ZVAL_STRING(ret, (char*)data->children->content);
 			}
 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
-			ZVAL_STRING(ret, (char*)data->children->content, 1);
+			ZVAL_STRING(ret, (char*)data->children->content);
 		} else {
 			soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 		}
@@ -778,28 +755,26 @@ static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	return ret;
 }
 
-static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	char *str;
-	int str_len;
+	zend_string *str;
 
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	if (data && data->children) {
 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
 			whiteSpace_collapse(data->children->content);
-			str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
+			str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
 			if (!str) {
 				soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 			}
-			ZVAL_STRINGL(ret, str, str_len, 0);
+			ZVAL_STR(ret, str);
 		} else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) {
-			str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len);
+			str = php_base64_decode(data->children->content, strlen((char*)data->children->content));
 			if (!str) {
 				soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 			}
-			ZVAL_STRINGL(ret, str, str_len, 0);
+			ZVAL_STR(ret, str);
 		} else {
 			soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 		}
@@ -809,14 +784,13 @@ static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	return ret;
 }
 
-static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	unsigned char *str;
-	int str_len, i, j;
+	zend_string *str;
+	int i, j;
 	unsigned char c;
 
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	if (data && data->children) {
 		if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) {
@@ -825,32 +799,31 @@ static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 			return ret;
 		}
-		str_len = strlen((char*)data->children->content) / 2;
-		str = emalloc(str_len+1);
-		for (i = j = 0; i < str_len; i++) {
+		str = STR_ALLOC(strlen((char*)data->children->content) / 2, 0);
+		for (i = j = 0; i < str->len; i++) {
 			c = data->children->content[j++];
 			if (c >= '0' && c <= '9') {
-				str[i] = (c - '0') << 4;
+				str->val[i] = (c - '0') << 4;
 			} else if (c >= 'a' && c <= 'f') {
-				str[i] = (c - 'a' + 10) << 4;
+				str->val[i] = (c - 'a' + 10) << 4;
 			} else if (c >= 'A' && c <= 'F') {
-				str[i] = (c - 'A' + 10) << 4;
+				str->val[i] = (c - 'A' + 10) << 4;
 			} else {
 				soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 			}
 			c = data->children->content[j++];
 			if (c >= '0' && c <= '9') {
-				str[i] |= c - '0';
+				str->val[i] |= c - '0';
 			} else if (c >= 'a' && c <= 'f') {
-				str[i] |= c - 'a' + 10;
+				str->val[i] |= c - 'a' + 10;
 			} else if (c >= 'A' && c <= 'F') {
-				str[i] |= c - 'A' + 10;
+				str->val[i] |= c - 'A' + 10;
 			} else {
 				soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
 			}
 		}
-		str[str_len] = '\0';
-		ZVAL_STRINGL(ret, (char*)str, str_len, 0);
+		str->val[str->len] = '\0';
+		ZVAL_STR(ret, str);
 	} else {
 		ZVAL_EMPTY_STRING(ret);
 	}
@@ -948,27 +921,26 @@ static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNo
 static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
 {
 	xmlNodePtr ret, text;
-	unsigned char *str;
-	int str_len;
+	zend_string *str;
 
 	ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 	xmlAddChild(parent, ret);
 	FIND_ZVAL_NULL(data, ret, style);
 
 	if (Z_TYPE_P(data) == IS_STRING) {
-		str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data), &str_len);
-		text = xmlNewTextLen(str, str_len);
+		str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data));
+		text = xmlNewTextLen(BAD_CAST(str->val), str->len);
 		xmlAddChild(ret, text);
-		efree(str);
+		STR_RELEASE(str);
 	} else {
-		zval tmp = *data;
-
-		zval_copy_ctor(&tmp);
+		zval tmp;
+		
+		ZVAL_DUP(&tmp, data);
 		convert_to_string(&tmp);
-		str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp), &str_len);
-		text = xmlNewTextLen(str, str_len);
+		str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp));
+		text = xmlNewTextLen(BAD_CAST(str->val), str->len);
 		xmlAddChild(ret, text);
-		efree(str);
+		STR_RELEASE(str);
 		zval_dtor(&tmp);
 	}
 
@@ -1017,10 +989,9 @@ static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 
 	if (data && data->children) {
@@ -1031,12 +1002,10 @@ static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			whiteSpace_collapse(data->children->content);
 			switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
 				case IS_LONG:
-					Z_TYPE_P(ret) = IS_DOUBLE;
-					Z_DVAL_P(ret) = lval;
+					ZVAL_DOUBLE(ret, lval);
 					break;
 				case IS_DOUBLE:
-					Z_TYPE_P(ret) = IS_DOUBLE;
-					Z_DVAL_P(ret) = dval;
+					ZVAL_DOUBLE(ret, dval);
 					break;
 				default:
 					if (strncasecmp((char*)data->children->content, "NaN", sizeof("NaN")-1) == 0) {
@@ -1058,10 +1027,9 @@ static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	return ret;
 }
 
-static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 
 	if (data && data->children) {
@@ -1072,12 +1040,12 @@ static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			whiteSpace_collapse(data->children->content);
 			errno = 0;
 
-			switch ((Z_TYPE_P(ret) = is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0))) {
+			switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) {
 				case IS_LONG:
-					Z_LVAL_P(ret) = lval;
+					ZVAL_LONG(ret, lval);
 					break;
 				case IS_DOUBLE:
-					Z_DVAL_P(ret) = dval;
+					ZVAL_DOUBLE(ret, dval);
 					break;
 				default:
 					soap_error0(E_ERROR, "Encoding: Violation of encoding rules");
@@ -1149,10 +1117,9 @@ static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 
 	if (data && data->children) {
@@ -1161,13 +1128,13 @@ static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			if (stricmp((char*)data->children->content, "true") == 0 ||
 				stricmp((char*)data->children->content, "t") == 0 ||
 				strcmp((char*)data->children->content, "1") == 0) {
-				ZVAL_BOOL(ret, 1);
+				ZVAL_TRUE(ret);
 			} else if (stricmp((char*)data->children->content, "false") == 0 ||
 				stricmp((char*)data->children->content, "f") == 0 ||
 				strcmp((char*)data->children->content, "0") == 0) {
-				ZVAL_BOOL(ret, 0);
+				ZVAL_FALSE(ret);
 			} else {
-				ZVAL_STRING(ret, (char*)data->children->content, 1);
+				ZVAL_STRING(ret, (char*)data->children->content);
 				convert_to_boolean(ret);
 			}
 		} else {
@@ -1200,10 +1167,8 @@ static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNode
 }
 
 /* Null encode/decode */
-static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
 	ZVAL_NULL(ret);
 	return ret;
 }
@@ -1231,25 +1196,26 @@ static void set_zval_property(zval* object, char* name, zval* val TSRMLS_DC)
 	EG(scope) = old_scope;
 }
 
-static zval* get_zval_property(zval* object, char* name TSRMLS_DC)
+static zval* get_zval_property(zval* object, char* name, zval *rv TSRMLS_DC)
 {
 	if (Z_TYPE_P(object) == IS_OBJECT) {
-		zval member;
+		zval member, rv;
 		zval *data;
 		zend_class_entry *old_scope;
 
-		INIT_PZVAL(&member);
-		ZVAL_STRING(&member, name, 0);
+//???		INIT_PZVAL(&member);
+//???		ZVAL_STRING(&member, name, 0);
+		ZVAL_STRING(&member, name);
 		old_scope = EG(scope);
 		EG(scope) = Z_OBJCE_P(object);
-		data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0 TSRMLS_CC);
-		if (data == EG(uninitialized_zval_ptr)) {
+		data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0, &rv TSRMLS_CC);
+		if (data == &EG(uninitialized_zval)) {
 			/* Hack for bug #32455 */
 			zend_property_info *property_info;
 
 			property_info = zend_get_property_info(Z_OBJCE_P(object), &member, 1 TSRMLS_CC);
 			EG(scope) = old_scope;
-			if (property_info && zend_hash_quick_exists(Z_OBJPROP_P(object), property_info->name, property_info->name_length+1, property_info->h)) {
+			if (property_info && zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) {
 				return data;
 			}
 			return NULL;
@@ -1257,13 +1223,13 @@ static zval* get_zval_property(zval* object, char* name TSRMLS_DC)
 		EG(scope) = old_scope;
 		return data;
 	} else if (Z_TYPE_P(object) == IS_ARRAY) {
-		zval **data_ptr;
+		zval *data_ptr;
 
-		if (zend_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) {
-		  return *data_ptr;
+		if ((data_ptr = zend_hash_str_find(Z_ARRVAL_P(object), name, strlen(name))) != NULL) {
+		  return data_ptr;
 		}
 	}
-  return NULL;
+	return NULL;
 }
 
 static void unset_zval_property(zval* object, char* name TSRMLS_DC)
@@ -1272,48 +1238,49 @@ static void unset_zval_property(zval* object, char* name TSRMLS_DC)
 		zval member;
 		zend_class_entry *old_scope;
 
-		INIT_PZVAL(&member);
-		ZVAL_STRING(&member, name, 0);
+//???		INIT_PZVAL(&member);
+//???		ZVAL_STRING(&member, name, 0);
+		ZVAL_STRING(&member, name);
 		old_scope = EG(scope);
 		EG(scope) = Z_OBJCE_P(object);
 		Z_OBJ_HT_P(object)->unset_property(object, &member, 0 TSRMLS_CC);
 		EG(scope) = old_scope;
 	} else if (Z_TYPE_P(object) == IS_ARRAY) {
-		zend_hash_del(Z_ARRVAL_P(object), name, strlen(name)+1);
+		zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name));
 	}
 }
 
 static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
 {
+	zval rv, arr;
 	zval* any = NULL;
 	char* name = NULL;
 
 	while (node != NULL) {
-		if (get_zval_property(ret, (char*)node->name TSRMLS_CC) == NULL) {
-			zval* val = master_to_zval(get_conversion(XSD_ANYXML), node TSRMLS_CC);
+		if (get_zval_property(ret, (char*)node->name, &rv TSRMLS_CC) == NULL) {
+			zval* val = master_to_zval(ret, get_conversion(XSD_ANYXML), node TSRMLS_CC);
 			
 			if (any && Z_TYPE_P(any) != IS_ARRAY) {
 				/* Convert into array */
-				zval *arr;
-
-				MAKE_STD_ZVAL(arr);
-				array_init(arr);
+				array_init(&arr);
 				if (name) {
-					add_assoc_zval(arr, name, any);
+					add_assoc_zval(&arr, name, any);
 				} else {
-					add_next_index_zval(arr, any);
+					add_next_index_zval(&arr, any);
 				}
-				any = arr;
+				any = &arr;
 			}
 
 			if (Z_TYPE_P(val) == IS_STRING && *Z_STRVAL_P(val) == '<') {
 				name = NULL;
 				while (node->next != NULL) {
-					zval* val2 = master_to_zval(get_conversion(XSD_ANYXML), node->next TSRMLS_CC);
-					if (Z_TYPE_P(val2) != IS_STRING ||  *Z_STRVAL_P(val) != '<') {
+					zval val2;
+
+					master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next TSRMLS_CC);
+					if (Z_TYPE(val2) != IS_STRING ||  *Z_STRVAL_P(val) != '<') {
 						break;
 					}
-					add_string_to_string(val, val, val2);
+					add_string_to_string(val, val, &val2);
 					zval_ptr_dtor(&val2);
 					node = node->next;
 				}
@@ -1324,12 +1291,9 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
 			if (any == NULL) {
 				if (name) {
 					/* Convert into array */
-					zval *arr;
-
-					MAKE_STD_ZVAL(arr);
-					array_init(arr);
-					add_assoc_zval(arr, name, val);
-					any = arr;
+					array_init(&arr);
+					add_assoc_zval(&arr, name, val);
+					any = &arr;
 					name = NULL;
 				} else {
 					any = val;
@@ -1337,18 +1301,15 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
 			} else {
 				/* Add array element */
 				if (name) {
-					zval **el;
-					if (zend_hash_find(Z_ARRVAL_P(any), name, strlen(name)+1, (void**)&el) == SUCCESS) {
-						if (Z_TYPE_PP(el) != IS_ARRAY) {
+					zval *el;
+					if ((el = zend_hash_str_find(Z_ARRVAL_P(any), name, strlen(name))) != NULL) {
+						if (Z_TYPE_P(el) != IS_ARRAY) {
 							/* Convert into array */
-							zval *arr;
-	
-							MAKE_STD_ZVAL(arr);
-							array_init(arr);
-							add_next_index_zval(arr, *el);
-							*el = arr;
+							array_init(&arr);
+							add_next_index_zval(&arr, el);
+							el = &arr;
 						}
-						add_next_index_zval(*el, val);
+						add_next_index_zval(el, val);
 					} else {
 						add_assoc_zval(any, name, val);
 					}
@@ -1373,7 +1334,7 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 				xmlNodePtr node = get_node(data->children, model->u.element->name);
 
 				if (node) {
-					zval *val;
+					zval val;
 					xmlNodePtr r_node;
 
 					r_node = check_and_resolve_href(node);
@@ -1381,78 +1342,73 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 						if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) {
 							soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, r_node->children->content);
 						}
-						val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
 					} else if (model->u.element->fixed) {
 						xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 						xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
-						val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
 						xmlFreeNode(dummy);
 					} else if (model->u.element->def && !model->u.element->nillable) {
 						xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 						xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
-						val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
 						xmlFreeNode(dummy);
 					} else {
-						val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
 					}
 					if ((node = get_node(node->next, model->u.element->name)) != NULL) {
-						zval *array;
+						zval array;
 
-						MAKE_STD_ZVAL(array);
-						array_init(array);
-						add_next_index_zval(array, val);
+						array_init(&array);
+						add_next_index_zval(&array, &val);
 						do {
 							if (node && node->children && node->children->content) {
 								if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) {
 									soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, node->children->content);
 								}
-								val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
 							} else if (model->u.element->fixed) {
 								xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 								xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
-								val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
 								xmlFreeNode(dummy);
 							} else if (model->u.element->def && !model->u.element->nillable) {
 								xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 								xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def));
-								val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
 								xmlFreeNode(dummy);
 							} else {
-								val = master_to_zval(model->u.element->encode, node TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
 							}
-							add_next_index_zval(array, val);
+							add_next_index_zval(&array, &val);
 						} while ((node = get_node(node->next, model->u.element->name)) != NULL);
-						val = array;
-					} else if ((Z_TYPE_P(val) != IS_NULL || !model->u.element->nillable) &&
+						ZVAL_COPY_VALUE(&val, &array);
+					} else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) &&
 					           (SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) &&
 					           (model->max_occurs == -1 || model->max_occurs > 1)) {
-						zval *array;
+						zval array;
 
-						MAKE_STD_ZVAL(array);
-						array_init(array);
-						add_next_index_zval(array, val);
-						val = array;
+						array_init(&array);
+						add_next_index_zval(&array, &val);
+						ZVAL_COPY_VALUE(&val, &array);
 					}
-					set_zval_property(ret, model->u.element->name, val TSRMLS_CC);
+					set_zval_property(ret, model->u.element->name, &val TSRMLS_CC);
 				}
 			}
 			break;
 		case XSD_CONTENT_ALL:
 		case XSD_CONTENT_SEQUENCE:
 		case XSD_CONTENT_CHOICE: {
-			sdlContentModelPtr *tmp;
-			HashPosition pos;
+			sdlContentModelPtr tmp;
 			sdlContentModelPtr any = NULL;
 
-			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
-			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
-				if ((*tmp)->kind == XSD_CONTENT_ANY) {
-					any = *tmp;
+			ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+				if (tmp->kind == XSD_CONTENT_ANY) {
+					any = tmp;
 				} else {
-					model_to_zval_object(ret, *tmp, data, sdl TSRMLS_CC);
+					model_to_zval_object(ret, tmp, data, sdl TSRMLS_CC);
 				}
-				zend_hash_move_forward_ex(model->u.content, &pos);
-			}
+			} ZEND_HASH_FOREACH_END();
 			if (any) {
 				model_to_zval_any(ret, data->children TSRMLS_CC);
 			}
@@ -1467,24 +1423,23 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 }
 
 /* Struct encode/decode */
-static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC)
+static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC)
 {
-	zval *ret;
 	xmlNodePtr trav;
 	sdlPtr sdl;
 	sdlTypePtr sdlType = type->sdl_type;
 	zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR;
-	zval *redo_any = NULL;
+	zval *redo_any = NULL, rv, arr;
 
 	if (pce) {
 		ce = pce;
 	} else if (SOAP_GLOBAL(class_map) && type->type_str) {
-		zval             **classname;
+		zval              *classname;
 		zend_class_entry  *tmp;
 
-		if (zend_hash_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str)+1, (void**)&classname) == SUCCESS &&
-		    Z_TYPE_PP(classname) == IS_STRING &&
-		    (tmp = zend_fetch_class(Z_STRVAL_PP(classname), Z_STRLEN_PP(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) {
+		if ((classname = zend_hash_str_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL &&
+		    Z_TYPE_P(classname) == IS_STRING &&
+		    (tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) {
 			ce = tmp;
 		}
 	}
@@ -1502,20 +1457,20 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 				enc = enc->details.sdl_type->encode;
 			}
 			if (enc) {
-				zval *base;
+				zval base;
 
-				ALLOC_INIT_ZVAL(ret);
-				if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+				ZVAL_NULL(ret);
+				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 					return ret;
 				}
 
 				object_init_ex(ret, ce);
-				base = master_to_zval_int(enc, data TSRMLS_CC);
-				set_zval_property(ret, "_", base TSRMLS_CC);
+				master_to_zval_int(&base, enc, data TSRMLS_CC);
+				set_zval_property(ret, "_", &base TSRMLS_CC);
 			} else {
-				ALLOC_INIT_ZVAL(ret);
+				ZVAL_NULL(ret);
 				FIND_XML_NULL(data, ret);
-				if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 					return ret;
 				}
 				object_init_ex(ret, ce);
@@ -1542,34 +1497,34 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 			        (sdlType->encode->details.sdl_type->encode == NULL ||
 			         (sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY &&
 			          sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) {
-					ret = to_zval_object_ex(&sdlType->encode->details, data, ce TSRMLS_CC);
+					to_zval_object_ex(ret, &sdlType->encode->details, data, ce TSRMLS_CC);
 			    } else {
-					ret = master_to_zval_int(sdlType->encode, data TSRMLS_CC);
+					master_to_zval_int(ret, sdlType->encode, data TSRMLS_CC);
 				}
-				if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 					return ret;
 				}
-				redo_any = get_zval_property(ret, "any" TSRMLS_CC);
+				redo_any = get_zval_property(ret, "any", &rv TSRMLS_CC);
 				if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) {
-					zend_object *zobj = zend_objects_get_address(ret TSRMLS_CC);
+					zend_object *zobj = Z_OBJ_P(ret);
 					zobj->ce = ce;
 				}
 			} else {
-				zval *base;
+				zval base;
 
-				ALLOC_INIT_ZVAL(ret);
-				if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+				ZVAL_NULL(ret);
+				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 					return ret;
 				}
 
 				object_init_ex(ret, ce);
-				base = master_to_zval_int(sdlType->encode, data TSRMLS_CC);
-				set_zval_property(ret, "_", base TSRMLS_CC);
+				master_to_zval_int(&base, sdlType->encode, data TSRMLS_CC);
+				set_zval_property(ret, "_", &base TSRMLS_CC);
 			}
 		} else {
-			ALLOC_INIT_ZVAL(ret);
+			ZVAL_NULL(ret);
 			FIND_XML_NULL(data, ret);
-			if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+			if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 				return ret;
 			}
 			object_init_ex(ret, ce);
@@ -1581,7 +1536,7 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 			}
 			model_to_zval_object(ret, sdlType->model, data, sdl TSRMLS_CC);
 			if (redo_any) {
-				zval *tmp = get_zval_property(ret, "any" TSRMLS_CC);
+				zval *tmp = get_zval_property(ret, "any", &rv TSRMLS_CC);
 
 				if (tmp == NULL) {
 					model_to_zval_any(ret, data->children TSRMLS_CC);
@@ -1589,49 +1544,45 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 					zval_dtor(tmp);
 					efree(tmp);
 				}
-				zval_ptr_dtor(&redo_any);
+				zval_ptr_dtor(redo_any);
 			}
 		}
 		if (sdlType->attributes) {
-			sdlAttributePtr *attr;
-			HashPosition pos;
+			sdlAttributePtr attr;
 
-			zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos);
-			while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) {
-				if ((*attr)->name) {
-					xmlAttrPtr val = get_attribute(data->properties, (*attr)->name);
+			ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
+				if (attr->name) {
+					xmlAttrPtr val = get_attribute(data->properties, attr->name);
 					char *str_val = NULL;
 
 					if (val && val->children && val->children->content) {
 						str_val = (char*)val->children->content;
-						if ((*attr)->fixed && strcmp((*attr)->fixed, str_val) != 0) {
-							soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, str_val);
+						if (attr->fixed && strcmp(attr->fixed, str_val) != 0) {
+							soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, str_val);
 						}
-					} else if ((*attr)->fixed) {
-						str_val = (*attr)->fixed;
-					} else if ((*attr)->def) {
-						str_val = (*attr)->def;
+					} else if (attr->fixed) {
+						str_val = attr->fixed;
+					} else if (attr->def) {
+						str_val = attr->def;
 					}
 					if (str_val) {
 						xmlNodePtr dummy, text;
-						zval *data;
+						zval data;
 
 						dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 						text = xmlNewText(BAD_CAST(str_val));
 						xmlAddChild(dummy, text);
-						data = master_to_zval((*attr)->encode, dummy TSRMLS_CC);
+						master_to_zval(&data, attr->encode, dummy TSRMLS_CC);
 						xmlFreeNode(dummy);
-						set_zval_property(ret, (*attr)->name, data TSRMLS_CC);
+						set_zval_property(ret, attr->name, &data TSRMLS_CC);
 					}
 				}
-				zend_hash_move_forward_ex(sdlType->attributes, &pos);
-			}
+			} ZEND_HASH_FOREACH_END();
 		}
 	} else {
-
-		ALLOC_INIT_ZVAL(ret);
+		ZVAL_NULL(ret);
 		FIND_XML_NULL(data, ret);
-		if (soap_check_xml_ref(&ret, data TSRMLS_CC)) {
+		if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
 			return ret;
 		}
 
@@ -1640,38 +1591,34 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 
 		while (trav != NULL) {
 			if (trav->type == XML_ELEMENT_NODE) {
-				zval  *tmpVal;
+				zval  tmpVal, rv;
 				zval *prop;
 
-				tmpVal = master_to_zval(NULL, trav TSRMLS_CC);
+				master_to_zval(&tmpVal, NULL, trav TSRMLS_CC);
 
-				prop = get_zval_property(ret, (char*)trav->name TSRMLS_CC);
+				prop = get_zval_property(ret, (char*)trav->name, &rv TSRMLS_CC);
 				if (!prop) {
 					if (!trav->next || !get_node(trav->next, (char*)trav->name)) {
-						set_zval_property(ret, (char*)trav->name, tmpVal TSRMLS_CC);
+						set_zval_property(ret, (char*)trav->name, &tmpVal TSRMLS_CC);
 					} else {
-						zval *arr;
+						zval arr;
 
-						MAKE_STD_ZVAL(arr);
-						array_init(arr);
-						add_next_index_zval(arr, tmpVal);
-						set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
+						array_init(&arr);
+						add_next_index_zval(&arr, &tmpVal);
+						set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
 					}
 				} else {
 					/* Property already exist - make array */
 					if (Z_TYPE_P(prop) != IS_ARRAY) {
 						/* Convert into array */
-						zval *arr;
-
-						MAKE_STD_ZVAL(arr);
-						array_init(arr);
+						array_init(&arr);
 						Z_ADDREF_P(prop);
-						add_next_index_zval(arr, prop);
-						set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
-						prop = arr;
+						add_next_index_zval(&arr, prop);
+						set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
+						prop = &arr;
 					}
 					/* Add array element */
-					add_next_index_zval(prop, tmpVal);
+					add_next_index_zval(prop, &tmpVal);
 				}
 			}
 			trav = trav->next;
@@ -1680,9 +1627,9 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e
 	return ret;
 }
 
-static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	return to_zval_object_ex(type, data, NULL TSRMLS_CC);
+	return to_zval_object_ex(ret, type, data, NULL TSRMLS_CC);
 }
 
 
@@ -1693,8 +1640,9 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			zval *data;
 			xmlNodePtr property;
 			encodePtr enc;
+			zval rv;
 
-			data = get_zval_property(object, model->u.element->name TSRMLS_CC);
+			data = get_zval_property(object, model->u.element->name, &rv TSRMLS_CC);
 			if (data &&
 			    Z_TYPE_P(data) == IS_NULL &&
 			    !model->u.element->nillable &&
@@ -1708,16 +1656,15 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 				    Z_TYPE_P(data) == IS_ARRAY &&
 				    !is_map(data)) {
 					HashTable *ht = Z_ARRVAL_P(data);
-					zval **val;
+					zval *val;
 
-					zend_hash_internal_pointer_reset(ht);
-					while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) {
-						if (Z_TYPE_PP(val) == IS_NULL && model->u.element->nillable) {
+					ZEND_HASH_FOREACH_VAL(ht, val) {
+						if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) {
 							property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 							xmlAddChild(node, property);
 							set_xsi_nil(property);
 						} else {
-							property = master_to_xml(enc, *val, style, node TSRMLS_CC);
+							property = master_to_xml(enc, val, style, node TSRMLS_CC);
 							if (property->children && property->children->content &&
 							    model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) {
 								soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content);
@@ -1730,8 +1677,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 							xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens);
 							xmlSetNs(property, nsp);
 						}
-						zend_hash_move_forward(ht);
-					}
+					} ZEND_HASH_FOREACH_END();
 				} else {
 					if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) {
 						property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
@@ -1780,21 +1726,20 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			zval *data;
 			xmlNodePtr property;
 			encodePtr enc;
+			zval rv;
 
-			data = get_zval_property(object, "any" TSRMLS_CC);
+			data = get_zval_property(object, "any", &rv TSRMLS_CC);
 			if (data) {
 				enc = get_conversion(XSD_ANYXML);
 				if ((model->max_occurs == -1 || model->max_occurs > 1) &&
 				    Z_TYPE_P(data) == IS_ARRAY &&
 				    !is_map(data)) {
 					HashTable *ht = Z_ARRVAL_P(data);
-					zval **val;
+					zval *val;
 
-					zend_hash_internal_pointer_reset(ht);
-					while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) {
-						property = master_to_xml(enc, *val, style, node TSRMLS_CC);
-						zend_hash_move_forward(ht);
-					}
+					ZEND_HASH_FOREACH_VAL(ht, val) {
+						property = master_to_xml(enc, val, style, node TSRMLS_CC);
+					} ZEND_HASH_FOREACH_END();
 				} else {
 					property = master_to_xml(enc, data, style, node TSRMLS_CC);
 				}
@@ -1811,36 +1756,30 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 		}
 		case XSD_CONTENT_SEQUENCE:
 		case XSD_CONTENT_ALL: {
-			sdlContentModelPtr *tmp;
-			HashPosition pos;
+			sdlContentModelPtr tmp;
 
-			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
-			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
-				if (!model_to_xml_object(node, *tmp, object, style, strict && ((*tmp)->min_occurs > 0) TSRMLS_CC)) {
-					if (!strict || (*tmp)->min_occurs > 0) {
+			ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+				if (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0) TSRMLS_CC)) {
+					if (!strict || tmp->min_occurs > 0) {
 						return 0;
 					}
 				}
 				strict = 1;
-				zend_hash_move_forward_ex(model->u.content, &pos);
-			}
+			} ZEND_HASH_FOREACH_END();
 			return 1;
 		}
 		case XSD_CONTENT_CHOICE: {
-			sdlContentModelPtr *tmp;
-			HashPosition pos;
+			sdlContentModelPtr tmp;
 			int ret = 0;
 
-			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
-			while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) {
-				int tmp_ret = model_to_xml_object(node, *tmp, object, style, 0 TSRMLS_CC);
+			ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+				int tmp_ret = model_to_xml_object(node, tmp, object, style, 0 TSRMLS_CC);
 				if (tmp_ret == 1) {
 					return 1;
 				} else if (tmp_ret != 0) {
 					ret = 1;
 				}
-				zend_hash_move_forward_ex(model->u.content, &pos);
-			}
+			} ZEND_HASH_FOREACH_END();
 			return ret;
 		}
 		case XSD_CONTENT_GROUP: {
@@ -1865,15 +1804,14 @@ static sdlTypePtr model_array_element(sdlContentModelPtr model)
 		case XSD_CONTENT_SEQUENCE:
 		case XSD_CONTENT_ALL:
 		case XSD_CONTENT_CHOICE: {
-			sdlContentModelPtr *tmp;
-			HashPosition pos;
+			sdlContentModelPtr tmp;
 
 			if (zend_hash_num_elements(model->u.content) != 1) {
 			  return NULL;
 			}
-			zend_hash_internal_pointer_reset_ex(model->u.content, &pos);
-			zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos);
-			return model_array_element(*tmp);
+			ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
+				return model_array_element(tmp);
+			} ZEND_HASH_FOREACH_END();
 		}
 		case XSD_CONTENT_GROUP: {
 			return model_array_element(model->u.group->model);
@@ -1920,7 +1858,8 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 				enc = enc->details.sdl_type->encode;
 			}
 			if (enc) {
-				zval *tmp = get_zval_property(data, "_" TSRMLS_CC);
+				zval rv;
+				zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
 				if (tmp) {
 					xmlParam = master_to_xml(enc, tmp, style, parent TSRMLS_CC);
 				} else if (prop == NULL) {
@@ -1940,11 +1879,12 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 			    sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST &&
 			    sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
 
-				if (prop) prop->nApplyCount++;
+				if (prop) ZEND_HASH_INC_APPLY_COUNT(prop);
 				xmlParam = master_to_xml(sdlType->encode, data, style, parent TSRMLS_CC);
-				if (prop) prop->nApplyCount--;
+				if (prop) ZEND_HASH_DEC_APPLY_COUNT(prop);
 			} else {
-				zval *tmp = get_zval_property(data, "_" TSRMLS_CC);
+				zval rv;
+				zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
 
 				if (tmp) {
 					xmlParam = master_to_xml(sdlType->encode, tmp, style, parent TSRMLS_CC);
@@ -1971,17 +1911,16 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 		      sdlType->attributes == NULL &&
 		      sdlType->model != NULL &&
 		      (array_el = model_array_element(sdlType->model)) != NULL) {
-				zval **val;
+				zval *val;
 
-				zend_hash_internal_pointer_reset(prop);
-				while (zend_hash_get_current_data(prop,(void**)&val) == SUCCESS) {
+				ZEND_HASH_FOREACH_VAL(prop, val) {
 					xmlNodePtr property;
-					if (Z_TYPE_PP(val) == IS_NULL && array_el->nillable) {
+					if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) {
 						property = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 						xmlAddChild(xmlParam, property);
 						set_xsi_nil(property);
 					} else {
-						property = master_to_xml(array_el->encode, *val, style, xmlParam TSRMLS_CC);
+						property = master_to_xml(array_el->encode, val, style, xmlParam TSRMLS_CC);
 					}
 					xmlNodeSetName(property, BAD_CAST(array_el->name));
 					if (style == SOAP_LITERAL &&
@@ -1990,47 +1929,43 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 						xmlNsPtr nsp = encode_add_ns(property, array_el->namens);
 						xmlSetNs(property, nsp);
 					}
-					zend_hash_move_forward(prop);
-				}
+				} ZEND_HASH_FOREACH_END();
 			} else if (sdlType->model) {
 				model_to_xml_object(xmlParam, sdlType->model, data, style, 1 TSRMLS_CC);
 			}
 			if (sdlType->attributes) {
-				sdlAttributePtr *attr;
-				zval *zattr;
-				HashPosition pos;
-
-				zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos);
-				while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) {
-					if ((*attr)->name) {
-						zattr = get_zval_property(data, (*attr)->name TSRMLS_CC);
+				sdlAttributePtr attr;
+				zval *zattr, rv;
+
+				ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
+					if (attr->name) {
+						zattr = get_zval_property(data, attr->name, &rv TSRMLS_CC);
 						if (zattr) {
 							xmlNodePtr dummy;
 
-							dummy = master_to_xml((*attr)->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC);
+							dummy = master_to_xml(attr->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC);
 							if (dummy->children && dummy->children->content) {
-								if ((*attr)->fixed && strcmp((*attr)->fixed, (char*)dummy->children->content) != 0) {
-									soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, dummy->children->content);
+								if (attr->fixed && strcmp(attr->fixed, (char*)dummy->children->content) != 0) {
+									soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, dummy->children->content);
 								}
 								/* we need to handle xml: namespace specially, since it is
 								   an implicit schema. Otherwise, use form.
 								*/
-								if ((*attr)->namens &&
-								    (!strncmp((*attr)->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
-								     (*attr)->form == XSD_FORM_QUALIFIED)) {
-									xmlNsPtr nsp = encode_add_ns(xmlParam, (*attr)->namens);
+								if (attr->namens &&
+								    (!strncmp(attr->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) ||
+								     attr->form == XSD_FORM_QUALIFIED)) {
+									xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens);
 
-									xmlSetNsProp(xmlParam, nsp, BAD_CAST((*attr)->name), dummy->children->content);
+									xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name), dummy->children->content);
 								} else {
-									xmlSetProp(xmlParam, BAD_CAST((*attr)->name), dummy->children->content);
+									xmlSetProp(xmlParam, BAD_CAST(attr->name), dummy->children->content);
 								}
 							}
 							xmlUnlinkNode(dummy);
 							xmlFreeNode(dummy);
 						}
 					}
-					zend_hash_move_forward_ex(sdlType->attributes, &pos);
-				}
+				} ZEND_HASH_FOREACH_END();
 			}
 		}
 		if (style == SOAP_ENCODED) {
@@ -2049,16 +1984,15 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 
 			for (;i > 0;i--) {
 				xmlNodePtr property;
-				zval **zprop;
-				char *str_key;
+				zval *zprop;
+				zend_string *str_key;
 				ulong index;
 				int key_type;
-				unsigned int str_key_len;
 
-				key_type = zend_hash_get_current_key_ex(prop, &str_key, &str_key_len, &index, FALSE, NULL);
-				zend_hash_get_current_data(prop, (void **)&zprop);
+				key_type = zend_hash_get_current_key_ex(prop, &str_key, &index, FALSE, &prop->nInternalPointer);
+				zprop = zend_hash_get_current_data(prop);
 
-				property = master_to_xml(get_conversion((*zprop)->type), (*zprop), style, xmlParam TSRMLS_CC);
+				property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam TSRMLS_CC);
 
 				if (key_type == HASH_KEY_IS_STRING) {
 					const char *prop_name;
@@ -2066,9 +2000,9 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 					if (Z_TYPE_P(data) == IS_OBJECT) {
 						const char *class_name;
 
-						zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name);
+						zend_unmangle_property_name(str_key->val, str_key->len, &class_name, &prop_name);
 					} else {
-						prop_name = str_key;
+						prop_name = str_key->val;
 					}
 					if (prop_name) {
 						xmlNodeSetName(property, BAD_CAST(prop_name));
@@ -2209,11 +2143,11 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
 	int j;
 
 	if (data && Z_TYPE_P(data) == IS_ARRAY) {
-	 	zend_hash_internal_pointer_reset(data->value.ht);
+	 	zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
 		for (j=0; j<dims[0]; j++) {
- 			zval **zdata;
+ 			zval *zdata;
 
- 			if (zend_hash_get_current_data(data->value.ht, (void **)&zdata) != SUCCESS) {
+ 			if ((zdata = zend_hash_get_current_data(Z_ARRVAL_P(data))) == NULL) {
  				zdata = NULL;
  			}
  			if (dimension == 1) {
@@ -2221,9 +2155,9 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
 
 	 			if (zdata) {
 	 				if (enc == NULL) {
- 						xparam = master_to_xml(get_conversion((*zdata)->type), (*zdata), style, xmlParam TSRMLS_CC);
+ 						xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam TSRMLS_CC);
  					} else {
- 						xparam = master_to_xml(enc, (*zdata), style, xmlParam TSRMLS_CC);
+ 						xparam = master_to_xml(enc, zdata, style, xmlParam TSRMLS_CC);
 		 			}
 		 		} else {
 					xparam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
@@ -2240,12 +2174,12 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
  				}
  			} else {
  				if (zdata) {
-	 			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, *zdata, style TSRMLS_CC);
+	 			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style TSRMLS_CC);
 	 			} else {
 	 			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style TSRMLS_CC);
 	 			}
  			}
- 			zend_hash_move_forward(data->value.ht);
+ 			zend_hash_move_forward(Z_ARRVAL_P(data));
  		}
  	} else {
 		for (j=0; j<dims[0]; j++) {
@@ -2272,8 +2206,8 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
 static inline int array_num_elements(HashTable* ht)
 {
 	if (ht->nNumUsed &&
-	    ht->arData[ht->nNumUsed-1].xData &&
-	    ht->arData[ht->nNumUsed-1].nKeyLength == 0) {
+	    Z_TYPE(ht->arData[ht->nNumUsed-1].val) != IS_UNUSED &&
+	    ht->arData[ht->nNumUsed-1].key == NULL) {
 
 	    return ht->arData[ht->nNumUsed-1].h - 1;
 	}
@@ -2291,8 +2225,9 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 	int dimension = 1;
 	int* dims;
 	int soap_version;
-	zval *array_copy = NULL;
+	zval array_copy;
 
+	ZVAL_UNDEF(&array_copy);
 	soap_version = SOAP_GLOBAL(soap_version);
 
 	xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
@@ -2313,11 +2248,9 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 	if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable TSRMLS_CC)) {
 		zend_object_iterator   *iter;
 		zend_class_entry       *ce = Z_OBJCE_P(data);
-		zval                  **val;
+		zval                   *val;
 
-		ALLOC_ZVAL(array_copy);
-		INIT_PZVAL(array_copy);
-		array_init(array_copy);
+		array_init(&array_copy);
 
 		iter = ce->get_iterator(ce, data, 0 TSRMLS_CC);
 
@@ -2337,7 +2270,7 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 				goto iterator_done;
 			}
 
-			iter->funcs->get_current_data(iter, &val TSRMLS_CC);
+			val = iter->funcs->get_current_data(iter TSRMLS_CC);
 			if (EG(exception)) {
 				goto iterator_done;
 			}
@@ -2347,13 +2280,13 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 				if (EG(exception)) {
 					goto iterator_done;
 				}
-				array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val);
+				array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
 				zval_ptr_dtor(val);
 				zval_dtor(&key);
 			} else {
-				add_next_index_zval(array_copy, *val);
+				add_next_index_zval(&array_copy, val);
 			}
-			Z_ADDREF_PP(val);
+			Z_ADDREF_P(val);
 
 			iter->funcs->move_forward(iter TSRMLS_CC);
 			if (EG(exception)) {
@@ -2364,54 +2297,54 @@ iterator_done:
 		iter->funcs->dtor(iter TSRMLS_CC);
 		if (EG(exception)) {
 			zval_ptr_dtor(&array_copy);
-			array_copy = NULL;
+			ZVAL_UNDEF(&array_copy);
 		} else {
-			data = array_copy;
+			data = &array_copy;
 		}
 	}
 
 	if (Z_TYPE_P(data) == IS_ARRAY) {
-		sdlAttributePtr *arrayType;
-		sdlExtraAttributePtr *ext;
+		sdlAttributePtr arrayType;
+		sdlExtraAttributePtr ext;
 		sdlTypePtr elementType;
 
 		i = zend_hash_num_elements(Z_ARRVAL_P(data));
 
 		if (sdl_type &&
 		    sdl_type->attributes &&
-		    zend_hash_find(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
-		      sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"),
-		      (void **)&arrayType) == SUCCESS &&
-		    (*arrayType)->extraAttributes &&
-		    zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
+		    (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
+		      sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
+		    arrayType->extraAttributes &&
+		    (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
 
 			char *value, *end;
-			zval** el;
+			zval *el;
 
-			value = estrdup((*ext)->val);
+			value = estrdup(ext->val);
 			end = strrchr(value,'[');
 			if (end) {
 				*end = '\0';
 				end++;
 				dimension = calc_dimension(end);
 			}
-			if ((*ext)->ns != NULL) {
-				enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, value);
-				get_type_str(xmlParam, (*ext)->ns, value, &array_type);
+			if (ext->ns != NULL) {
+				enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, value);
+				get_type_str(xmlParam, ext->ns, value, &array_type);
 			} else {
 				smart_str_appends(&array_type, value);
 			}
 
 			dims = safe_emalloc(sizeof(int), dimension, 0);
 			dims[0] = i;
-			el = &data;
+			//??? el = &data;
+			el = data;
 			for (i = 1; i < dimension; i++) {
-				if (el != NULL && Z_TYPE_PP(el) == IS_ARRAY &&
-				    zend_hash_num_elements(Z_ARRVAL_PP(el)) > 0) {
-				  zend_hash_internal_pointer_reset(Z_ARRVAL_PP(el));
-					zend_hash_get_current_data(Z_ARRVAL_PP(el), (void**)&el);
-					if (Z_TYPE_PP(el) == IS_ARRAY) {
-						dims[i] = zend_hash_num_elements(Z_ARRVAL_PP(el));
+				if (el != NULL && Z_TYPE_P(el) == IS_ARRAY &&
+				    zend_hash_num_elements(Z_ARRVAL_P(el)) > 0) {
+					zend_hash_internal_pointer_reset(Z_ARRVAL_P(el));
+					el = zend_hash_get_current_data(Z_ARRVAL_P(el));
+					if (Z_TYPE_P(el) == IS_ARRAY) {
+						dims[i] = zend_hash_num_elements(Z_ARRVAL_P(el));
 					} else {
 						dims[i] = 0;
 					}
@@ -2428,24 +2361,22 @@ iterator_done:
 
 		} else if (sdl_type &&
 		           sdl_type->attributes &&
-		           zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
-		             sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"),
-		             (void **)&arrayType) == SUCCESS &&
-		           (*arrayType)->extraAttributes &&
-		           zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) {
-			if ((*ext)->ns != NULL) {
-				enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val);
-				get_type_str(xmlParam, (*ext)->ns, (*ext)->val, &array_type);
+		           (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
+		             sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
+		           arrayType->extraAttributes &&
+		           (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
+			if (ext->ns != NULL) {
+				enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
+				get_type_str(xmlParam, ext->ns, ext->val, &array_type);
 			} else {
-				smart_str_appends(&array_type, (*ext)->val);
-			}
-			if (zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
-			                   sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
-			                   (void **)&arrayType) == SUCCESS &&
-			    (*arrayType)->extraAttributes &&
-			    zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
-				dimension = calc_dimension_12((*ext)->val);
-				dims = get_position_12(dimension, (*ext)->val);
+				smart_str_appends(&array_type, ext->val);
+			}
+			if ((arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+			                   sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+			    arrayType->extraAttributes &&
+			    (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+				dimension = calc_dimension_12(ext->val);
+				dims = get_position_12(dimension, ext->val);
 				if (dims[0] == 0) {dims[0] = i;}
 
 				smart_str_append_long(&array_size, dims[0]);
@@ -2460,13 +2391,12 @@ iterator_done:
 			}
 		} else if (sdl_type &&
 		           sdl_type->attributes &&
-		           zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
-		             sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
-		             (void **)&arrayType) == SUCCESS &&
-		           (*arrayType)->extraAttributes &&
-		           zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize"), (void **)&ext) == SUCCESS) {
-			dimension = calc_dimension_12((*ext)->val);
-			dims = get_position_12(dimension, (*ext)->val);
+		           (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+		             sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+		           arrayType->extraAttributes &&
+		           (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) {
+			dimension = calc_dimension_12(ext->val);
+			dims = get_position_12(dimension, ext->val);
 			if (dims[0] == 0) {dims[0] = i;}
 
 			smart_str_append_long(&array_size, dims[0]);
@@ -2478,8 +2408,7 @@ iterator_done:
 			if (sdl_type && sdl_type->elements &&
 			    zend_hash_num_elements(sdl_type->elements) == 1 &&
 			    (zend_hash_internal_pointer_reset(sdl_type->elements),
-			     zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) &&
-					(elementType = *(sdlTypePtr*)elementType) != NULL &&
+			     (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
 			     elementType->encode && elementType->encode->details.type_str) {
 				element_type = elementType;
 				enc = elementType->encode;
@@ -2490,8 +2419,7 @@ iterator_done:
 		} else if (sdl_type && sdl_type->elements &&
 		           zend_hash_num_elements(sdl_type->elements) == 1 &&
 		           (zend_hash_internal_pointer_reset(sdl_type->elements),
-		            zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) &&
-		           (elementType = *(sdlTypePtr*)elementType) != NULL &&
+		            (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) &&
 		           elementType->encode && elementType->encode->details.type_str) {
 
 			element_type = elementType;
@@ -2513,7 +2441,7 @@ iterator_done:
 		if (style == SOAP_ENCODED) {
 			if (soap_version == SOAP_1_1) {
 				smart_str_0(&array_type);
-				if (strcmp(array_type.c,"xsd:anyType") == 0) {
+				if (strcmp(array_type.s->val,"xsd:anyType") == 0) {
 					smart_str_free(&array_type);
 					smart_str_appendl(&array_type,"xsd:ur-type",sizeof("xsd:ur-type")-1);
 				}
@@ -2521,17 +2449,17 @@ iterator_done:
 				smart_str_append(&array_type, &array_size);
 				smart_str_appendc(&array_type, ']');
 				smart_str_0(&array_type);
-				set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.c);
+				set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.s->val);
 			} else {
 				int i = 0;
-				while (i < array_size.len) {
-					if (array_size.c[i] == ',') {array_size.c[i] = ' ';}
+				while (i < array_size.s->len) {
+					if (array_size.s->val[i] == ',') {array_size.s->val[i] = ' ';}
 					++i;
 				}
 				smart_str_0(&array_type);
 				smart_str_0(&array_size);
-				set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.c);
-				set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.c);
+				set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.s->val);
+				set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.s->val);
 			}
 		}
 		smart_str_free(&array_type);
@@ -2548,16 +2476,13 @@ iterator_done:
 		}
 	}
 
-	if (array_copy) {
-		zval_ptr_dtor(&array_copy);
-	}
+	zval_ptr_dtor(&array_copy);
 
 	return xmlParam;
 }
 
-static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret;
 	xmlNodePtr trav;
 	encodePtr enc = NULL;
 	int dimension = 1;
@@ -2565,11 +2490,11 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	int* pos = NULL;
 	xmlAttrPtr attr;
 	sdlPtr sdl;
-	sdlAttributePtr *arrayType;
-	sdlExtraAttributePtr *ext;
+	sdlAttributePtr arrayType;
+	sdlExtraAttributePtr ext;
 	sdlTypePtr elementType;
 
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 	sdl = SOAP_GLOBAL(sdl);
 
@@ -2625,20 +2550,19 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 
 	} else if (type->sdl_type != NULL &&
 	           type->sdl_type->attributes != NULL &&
-	           zend_hash_find(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
-	                          sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"),
-	                          (void **)&arrayType) == SUCCESS &&
-	           (*arrayType)->extraAttributes &&
-	           zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) {
+	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType",
+	                          sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL &&
+	           arrayType->extraAttributes &&
+	           (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) {
 		char *type, *end;
 
-		type = estrdup((*ext)->val);
+		type = estrdup(ext->val);
 		end = strrchr(type,'[');
 		if (end) {
 			*end = '\0';
 		}
-		if ((*ext)->ns != NULL) {
-			enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, type);
+		if (ext->ns != NULL) {
+			enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type);
 		}
 		efree(type);
 
@@ -2647,50 +2571,45 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 
 	} else if (type->sdl_type != NULL &&
 	           type->sdl_type->attributes != NULL &&
-	           zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
-	                          sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"),
-	                          (void **)&arrayType) == SUCCESS &&
-	           (*arrayType)->extraAttributes &&
-	           zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) {
-
-		if ((*ext)->ns != NULL) {
-			enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val);
-		}
-
-		if (zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
-		                   sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
-		                   (void **)&arrayType) == SUCCESS &&
-		    (*arrayType)->extraAttributes &&
-		    zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
-			dimension = calc_dimension_12((*ext)->val);
-			dims = get_position_12(dimension, (*ext)->val);
+	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType",
+	                          sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL &&
+	           arrayType->extraAttributes &&
+	           (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) {
+
+		if (ext->ns != NULL) {
+			enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val);
+		}
+
+		if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+		                   sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+		    arrayType->extraAttributes &&
+		    (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+			dimension = calc_dimension_12(ext->val);
+			dims = get_position_12(dimension, ext->val);
 		} else {
 			dims = emalloc(sizeof(int));
 			*dims = 0;
 		}
 	} else if (type->sdl_type != NULL &&
 	           type->sdl_type->attributes != NULL &&
-	           zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
-	                          sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"),
-	                          (void **)&arrayType) == SUCCESS &&
-	           (*arrayType)->extraAttributes &&
-	           zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) {
-
-		dimension = calc_dimension_12((*ext)->val);
-		dims = get_position_12(dimension, (*ext)->val);
+	           (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize",
+	                          sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL &&
+	           arrayType->extraAttributes &&
+	           (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) {
+
+		dimension = calc_dimension_12(ext->val);
+		dims = get_position_12(dimension, ext->val);
 		if (type->sdl_type && type->sdl_type->elements &&
 		    zend_hash_num_elements(type->sdl_type->elements) == 1 &&
 		    (zend_hash_internal_pointer_reset(type->sdl_type->elements),
-		     zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) &&
-		    (elementType = *(sdlTypePtr*)elementType) != NULL &&
+		     (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
 		    elementType->encode) {
 			enc = elementType->encode;
 		}
 	} else if (type->sdl_type && type->sdl_type->elements &&
 	           zend_hash_num_elements(type->sdl_type->elements) == 1 &&
 	           (zend_hash_internal_pointer_reset(type->sdl_type->elements),
-	            zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) &&
-	           (elementType = *(sdlTypePtr*)elementType) != NULL &&
+	            (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) &&
 	           elementType->encode) {
 		enc = elementType->encode;
 	}
@@ -2717,10 +2636,10 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 	while (trav) {
 		if (trav->type == XML_ELEMENT_NODE) {
 			int i;
-			zval *tmpVal, *ar;
+			zval tmpVal, *ar;
 			xmlAttrPtr position = get_attribute(trav->properties,"position");
 
-			tmpVal = master_to_zval(enc, trav TSRMLS_CC);
+			master_to_zval(&tmpVal, enc, trav TSRMLS_CC);
 			if (position != NULL && position->children && position->children->content) {
 				char* tmp = strrchr((char*)position->children->content, '[');
 				if (tmp == NULL) {
@@ -2733,19 +2652,17 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			i = 0;
 			ar = ret;
 			while (i < dimension-1) {
-				zval** ar2;
-				if (zend_hash_index_find(Z_ARRVAL_P(ar), pos[i], (void**)&ar2) == SUCCESS) {
-					ar = *ar2;
+				zval* ar2;
+				if ((ar2 = zend_hash_index_find(Z_ARRVAL_P(ar), pos[i])) != NULL) {
+					ar = ar2;
 				} else {
-					zval *tmpAr;
-					MAKE_STD_ZVAL(tmpAr);
-					array_init(tmpAr);
-					zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr, sizeof(zval*), (void**)&ar2);
-					ar = *ar2;
+					zval tmpAr;
+					array_init(&tmpAr);
+					ar = zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr);
 				}
 				i++;
 			}
-			zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal, sizeof(zval *), NULL);
+			zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal);
 
 			/* Increment position */
 			i = dimension;
@@ -2782,24 +2699,24 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP
 
 	if (Z_TYPE_P(data) == IS_ARRAY) {
 		i = zend_hash_num_elements(Z_ARRVAL_P(data));
-		zend_hash_internal_pointer_reset(data->value.ht);
+		zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
 		for (;i > 0;i--) {
 			xmlNodePtr xparam, item;
 			xmlNodePtr key;
-			zval **temp_data;
-			char *key_val;
+			zval *temp_data;
+			zend_string *key_val;
 			ulong int_val;
 
-			zend_hash_get_current_data(data->value.ht, (void **)&temp_data);
+			temp_data = zend_hash_get_current_data(Z_ARRVAL_P(data));
 			item = xmlNewNode(NULL, BAD_CAST("item"));
 			xmlAddChild(xmlParam, item);
 			key = xmlNewNode(NULL, BAD_CAST("key"));
 			xmlAddChild(item,key);
-			if (zend_hash_get_current_key(data->value.ht, &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) {
+			if (zend_hash_get_current_key(Z_ARRVAL_P(data), &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) {
 				if (style == SOAP_ENCODED) {
 					set_xsi_type(key, "xsd:string");
 				}
-				xmlNodeSetContent(key, BAD_CAST(key_val));
+				xmlNodeSetContent(key, BAD_CAST(key_val->val));
 			} else {
 				smart_str tmp = {0};
 				smart_str_append_long(&tmp, int_val);
@@ -2808,15 +2725,15 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP
 				if (style == SOAP_ENCODED) {
 					set_xsi_type(key, "xsd:int");
 				}
-				xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len);
+				xmlNodeSetContentLen(key, BAD_CAST(tmp.s->val), tmp.s->len);
 
 				smart_str_free(&tmp);
 			}
 
-			xparam = master_to_xml(get_conversion((*temp_data)->type), (*temp_data), style, item TSRMLS_CC);
+			xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item TSRMLS_CC);
 			xmlNodeSetName(xparam, BAD_CAST("value"));
 
-			zend_hash_move_forward(data->value.ht);
+			zend_hash_move_forward(Z_ARRVAL_P(data));
 		}
 	}
 	if (style == SOAP_ENCODED) {
@@ -2826,12 +2743,12 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP
 	return xmlParam;
 }
 
-static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
-	zval *ret, *key, *value;
+	zval key, value;
 	xmlNodePtr trav, item, xmlKey, xmlValue;
 
-	MAKE_STD_ZVAL(ret);
+	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
 
 	if (data && data->children) {
@@ -2850,13 +2767,13 @@ static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 				soap_error0(E_ERROR,  "Encoding: Can't decode apache map, missing value");
 			}
 
-			key = master_to_zval(NULL, xmlKey TSRMLS_CC);
-			value = master_to_zval(NULL, xmlValue TSRMLS_CC);
+			master_to_zval(&key, NULL, xmlKey TSRMLS_CC);
+			master_to_zval(&value, NULL, xmlValue TSRMLS_CC);
 
-			if (Z_TYPE_P(key) == IS_STRING) {
-				zend_symtable_update(Z_ARRVAL_P(ret), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
-			} else if (Z_TYPE_P(key) == IS_LONG) {
-				zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL);
+			if (Z_TYPE(key) == IS_STRING) {
+				zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
+			} else if (Z_TYPE(key) == IS_LONG) {
+				zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value);
 			} else {
 				soap_error0(E_ERROR,  "Encoding: Can't decode apache map, only Strings or Longs are allowd as keys");
 			}
@@ -2876,7 +2793,7 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x
 	xmlNodePtr ret;
 
 	if (data) {
-		enc = get_conversion(data->type);
+		enc = get_conversion(Z_TYPE_P(data));
 	} else {
 		enc = get_conversion(IS_NULL);
 	}
@@ -2889,12 +2806,11 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x
 	return ret;
 }
 
-static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
 	encodePtr enc = NULL;
 	xmlAttrPtr tmpattr;
 	xmlChar *type_name = NULL;
-	zval *ret;
 
 	data = check_and_resolve_href(data);
 
@@ -2947,26 +2863,25 @@ static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 			}
 		}
 	}
-	ret = master_to_zval_int(enc, data TSRMLS_CC);
+	master_to_zval_int(ret, enc, data TSRMLS_CC);
 	if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
-		zval* soapvar;
+		zval soapvar;
 		char *ns, *cptype;
 		xmlNsPtr nsptr;
 
-		MAKE_STD_ZVAL(soapvar);
-		object_init_ex(soapvar, soap_var_class_entry);
-		add_property_long(soapvar, "enc_type", enc->details.type);
+		object_init_ex(&soapvar, soap_var_class_entry);
+		add_property_long(&soapvar, "enc_type", enc->details.type);
 		Z_DELREF_P(ret);
-		add_property_zval(soapvar, "enc_value", ret);
+		add_property_zval(&soapvar, "enc_value", ret);
 		parse_namespace(type_name, &cptype, &ns);
 		nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
-		add_property_string(soapvar, "enc_stype", cptype);
+		add_property_string(&soapvar, "enc_stype", cptype);
 		if (nsptr) {
-			add_property_string(soapvar, "enc_ns", (char*)nsptr->href);
+			add_property_string(&soapvar, "enc_ns", (char*)nsptr->href);
 		}
 		efree(cptype);
 		if (ns) {efree(ns);}
-		ret = soapvar;
+		ZVAL_COPY_VALUE(ret, &soapvar);
 	}
 	return ret;
 }
@@ -3083,9 +2998,9 @@ static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNo
 	return to_xml_datetime_ex(type, data, "--%m--", style, parent TSRMLS_CC);
 }
 
-static zval* to_zval_list(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
 	/*FIXME*/
-	return to_zval_stringc(enc, data TSRMLS_CC);
+	return to_zval_stringc(ret, enc, data TSRMLS_CC);
 }
 
 static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
@@ -3093,27 +3008,26 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 	encodePtr list_enc = NULL;
 
 	if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST && enc->sdl_type->elements) {
-		sdlTypePtr *type;
+		sdlTypePtr type;
 
-		zend_hash_internal_pointer_reset(enc->sdl_type->elements);
-		if (zend_hash_get_current_data(enc->sdl_type->elements, (void**)&type) == SUCCESS) {
-			list_enc = (*type)->encode;
-		}
+		ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) {
+			list_enc = type->encode;
+			break;
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	ret = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 	xmlAddChild(parent, ret);
 	FIND_ZVAL_NULL(data, ret, style);
 	if (Z_TYPE_P(data) == IS_ARRAY) {
-		zval **tmp;
+		zval *tmp;
 		smart_str list = {0};
 		HashTable *ht = Z_ARRVAL_P(data);
 
-		zend_hash_internal_pointer_reset(ht);
-		while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) {
-			xmlNodePtr dummy = master_to_xml(list_enc, *tmp, SOAP_LITERAL, ret TSRMLS_CC);
+		ZEND_HASH_FOREACH_VAL(ht, tmp) {
+			xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret TSRMLS_CC);
 			if (dummy && dummy->children && dummy->children->content) {
-				if (list.len != 0) {
+				if (list.s && list.s->len != 0) {
 					smart_str_appendc(&list, ' ');
 				}
 				smart_str_appends(&list, (char*)dummy->children->content);
@@ -3122,10 +3036,9 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 			}
 			xmlUnlinkNode(dummy);
 			xmlFreeNode(dummy);
-			zend_hash_move_forward(ht);
-		}
+		} ZEND_HASH_FOREACH_END();
 		smart_str_0(&list);
-		xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len);
+		xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len);
 		smart_str_free(&list);
 	} else {
 		zval tmp = *data;
@@ -3149,10 +3062,11 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 			  *next = '\0';
 			  next++;
 			}
-			ZVAL_STRING(&dummy_zval, start, 0);
+//???			ZVAL_STRING(&dummy_zval, start, 0);
+			ZVAL_STRING(&dummy_zval, start);
 			dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret TSRMLS_CC);
 			if (dummy && dummy->children && dummy->children->content) {
-				if (list.len != 0) {
+				if (list.s && list.s->len != 0) {
 					smart_str_appendc(&list, ' ');
 				}
 				smart_str_appends(&list, (char*)dummy->children->content);
@@ -3165,7 +3079,7 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 			start = next;
 		}
 		smart_str_0(&list);
-		xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len);
+		xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len);
 		smart_str_free(&list);
 		efree(str);
 		if (data == &tmp) {zval_dtor(&tmp);}
@@ -3178,9 +3092,9 @@ static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNode
 	return to_xml_list(enc,data,style, parent TSRMLS_CC);
 }
 
-static zval* to_zval_union(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
 	/*FIXME*/
-	return to_zval_list(enc, data TSRMLS_CC);
+	return to_zval_list(ret, enc, data TSRMLS_CC);
 }
 
 static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
@@ -3188,14 +3102,13 @@ static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNode
 	return to_xml_list(enc,data,style, parent TSRMLS_CC);
 }
 
-static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 {
 	xmlBufferPtr buf;
-	zval *ret;
 
 	if (SOAP_GLOBAL(sdl) && SOAP_GLOBAL(sdl)->elements && data->name) {
 		smart_str nscat = {0};		
-		sdlTypePtr *sdl_type;
+		sdlTypePtr sdl_type;
 
 		if (data->ns && data->ns->href) {
 			smart_str_appends(&nscat, (char*)data->ns->href);
@@ -3204,18 +3117,17 @@ static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 		smart_str_appends(&nscat, (char*)data->name);
 		smart_str_0(&nscat);
 
-		if (zend_hash_find(SOAP_GLOBAL(sdl)->elements, nscat.c, nscat.len+1, (void **)&sdl_type) == SUCCESS &&
-		    (*sdl_type)->encode) {
+		if ((sdl_type = zend_hash_find_ptr(SOAP_GLOBAL(sdl)->elements, nscat.s)) != NULL &&
+		    sdl_type->encode) {
 			smart_str_free(&nscat);
-			return master_to_zval_int((*sdl_type)->encode, data TSRMLS_CC);
+			return master_to_zval_int(ret, sdl_type->encode, data TSRMLS_CC);
 		}		
 		smart_str_free(&nscat);
 	}
 
 	buf = xmlBufferCreate();
 	xmlNodeDump(buf, NULL, data, 0, 0);
-	MAKE_STD_ZVAL(ret);
-	ZVAL_STRING(ret, (char*)xmlBufferContent(buf), 1);
+	ZVAL_STRING(ret, (char*)xmlBufferContent(buf));
 	xmlBufferFree(buf);
 	return ret;
 }
@@ -3225,23 +3137,17 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP
 	xmlNodePtr ret = NULL;
 
 	if (Z_TYPE_P(data) == IS_ARRAY) {
-		HashPosition pos;
-		zval **el;
+		zval *el;
 		encodePtr enc = get_conversion(XSD_ANYXML);
-		char *name;
-		uint name_len;
-		ulong idx;
-
-		for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(data), &pos);
-		     zend_hash_get_current_data_ex(Z_ARRVAL_P(data), (void **) &el, &pos) == SUCCESS;
-		     zend_hash_move_forward_ex(Z_ARRVAL_P(data), &pos)) {
-			ret = master_to_xml(enc, *el, style, parent TSRMLS_CC);
+		zend_string *name;
+
+		ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), name, el) {
+			ret = master_to_xml(enc, el, style, parent TSRMLS_CC);
 		    if (ret &&
-		        ret->name != xmlStringTextNoenc &&
-		        zend_hash_get_current_key_ex(Z_ARRVAL_P(data), &name, &name_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) {
-				xmlNodeSetName(ret, BAD_CAST(name));
+		        ret->name != xmlStringTextNoenc) {
+				xmlNodeSetName(ret, BAD_CAST(name->val));
 		    }
-		}
+		} ZEND_HASH_FOREACH_END();
 		return ret;
 	}
 	if (Z_TYPE_P(data) == IS_STRING) {
@@ -3270,13 +3176,13 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP
 	return ret;
 }
 
-zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
+zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
 {
 	sdlTypePtr type;
 
 	type = enc->sdl_type;
 	if (type == NULL) {
-		return guess_zval_convert(enc, data TSRMLS_CC);
+		return guess_zval_convert(ret, enc, data TSRMLS_CC);
 	}
 /*FIXME: restriction support
 	if (type && type->restrictions &&
@@ -3310,27 +3216,27 @@ zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
 	switch (type->kind) {
 		case XSD_TYPEKIND_SIMPLE:
 			if (type->encode && enc != &type->encode->details) {
-				return master_to_zval_int(type->encode, data TSRMLS_CC);
+				return master_to_zval_int(ret, type->encode, data TSRMLS_CC);
 			} else {
-				return guess_zval_convert(enc, data TSRMLS_CC);
+				return guess_zval_convert(ret, enc, data TSRMLS_CC);
 			}
 			break;
 		case XSD_TYPEKIND_LIST:
-			return to_zval_list(enc, data TSRMLS_CC);
+			return to_zval_list(ret, enc, data TSRMLS_CC);
 		case XSD_TYPEKIND_UNION:
-			return to_zval_union(enc, data TSRMLS_CC);
+			return to_zval_union(ret, enc, data TSRMLS_CC);
 		case XSD_TYPEKIND_COMPLEX:
 		case XSD_TYPEKIND_RESTRICTION:
 		case XSD_TYPEKIND_EXTENSION:
 			if (type->encode &&
 			    (type->encode->details.type == IS_ARRAY ||
 			     type->encode->details.type == SOAP_ENC_ARRAY)) {
-				return to_zval_array(enc, data TSRMLS_CC);
+				return to_zval_array(ret, enc, data TSRMLS_CC);
 			}
-			return to_zval_object(enc, data TSRMLS_CC);
+			return to_zval_object(ret, enc, data TSRMLS_CC);
 		default:
 	  	soap_error0(E_ERROR, "Encoding: Internal Error");
-			return guess_zval_convert(enc, data TSRMLS_CC);
+			return guess_zval_convert(ret, enc, data TSRMLS_CC);
 	}
 }
 
@@ -3462,7 +3368,7 @@ static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type)
 {
 	smart_str nstype = {0};
 	get_type_str(node, ns, type, &nstype);
-	set_xsi_type(node, nstype.c);
+	set_xsi_type(node, nstype.s->val);
 	smart_str_free(&nstype);
 }
 
@@ -3519,7 +3425,7 @@ xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns)
 		xmlChar* prefix;
         TSRMLS_FETCH();
 
-		if (zend_hash_find(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns) + 1, (void **)&prefix) == SUCCESS) {
+		if ((prefix = zend_hash_str_find_ptr(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns))) != NULL) {
 			xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), prefix);
 		} else {
 			smart_str prefix = {0};
@@ -3529,16 +3435,15 @@ xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns)
 				smart_str_appendl(&prefix, "ns", 2);
 				smart_str_append_long(&prefix, num);
 				smart_str_0(&prefix);
-				if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.c)) == NULL) {
+				if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.s->val)) == NULL) {
 					break;
 				}
 				smart_str_free(&prefix);
-				prefix.c = NULL;
-				prefix.len = 0;
+				prefix.s = NULL;
 				num = ++SOAP_GLOBAL(cur_uniq_ns);
 			}
 
-			xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.c));
+			xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.s ? prefix.s->val : ""));
 			smart_str_free(&prefix);
 		}
 	}
@@ -3587,14 +3492,14 @@ void encode_finish()
 
 encodePtr get_conversion(int encode)
 {
-	encodePtr *enc = NULL;
+	encodePtr enc;
 	TSRMLS_FETCH();
 
-	if (zend_hash_index_find(&SOAP_GLOBAL(defEncIndex), encode, (void **)&enc) == FAILURE) {
+	if ((enc = zend_hash_index_find_ptr(&SOAP_GLOBAL(defEncIndex), encode)) == NULL) {
 		soap_error0(E_ERROR,  "Encoding: Cannot find encoding");
 		return NULL;
 	} else {
-		return *enc;
+		return enc;
 	}
 }
 
@@ -3604,10 +3509,10 @@ static int is_map(zval *array)
 
 	zend_hash_internal_pointer_reset(Z_ARRVAL_P(array));
 	for (i = 0; i < count; i++) {
-		char *str_index;
+		zend_string *_str_index;
 		ulong num_index;
 
-		if (zend_hash_get_current_key(Z_ARRVAL_P(array), &str_index, &num_index, 0) == HASH_KEY_IS_STRING ||
+		if (zend_hash_get_current_key(Z_ARRVAL_P(array), &_str_index, &num_index, 0) == HASH_KEY_IS_STRING ||
 		    num_index != i) {
 			return TRUE;
 		}
@@ -3620,7 +3525,7 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS
 {
 	HashTable *ht;
 	int i, count, cur_type, prev_type, different;
-	zval **tmp;
+	zval *tmp;
 	char *prev_stype = NULL, *cur_stype = NULL, *prev_ns = NULL, *cur_ns = NULL;
 
 	if (!array || Z_TYPE_P(array) != IS_ARRAY) {
@@ -3635,35 +3540,35 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS
 
 	zend_hash_internal_pointer_reset(ht);
 	for (i = 0;i < count;i++) {
-		zend_hash_get_current_data(ht, (void **)&tmp);
+		tmp = zend_hash_get_current_data(ht);
 
-		if (Z_TYPE_PP(tmp) == IS_OBJECT &&
-		    Z_OBJCE_PP(tmp) == soap_var_class_entry) {
-			zval **ztype;
+		if (Z_TYPE_P(tmp) == IS_OBJECT &&
+		    Z_OBJCE_P(tmp) == soap_var_class_entry) {
+			zval *ztype;
 
-			if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) {
+			if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_type", sizeof("enc_type")-1)) == NULL) {
 				soap_error0(E_ERROR,  "Encoding: SoapVar has no 'enc_type' property");
 			}
-			cur_type = Z_LVAL_PP(ztype);
+			cur_type = Z_LVAL_P(ztype);
 
-			if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_stype", sizeof("enc_stype"), (void **)&ztype) == SUCCESS) {
-				cur_stype = Z_STRVAL_PP(ztype);
+			if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_stype", sizeof("enc_stype")-1)) != NULL) {
+				cur_stype = Z_STRVAL_P(ztype);
 			} else {
 				cur_stype = NULL;
 			}
 
-			if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_ns", sizeof("enc_ns"), (void **)&ztype) == SUCCESS) {
-				cur_ns = Z_STRVAL_PP(ztype);
+			if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_ns", sizeof("enc_ns")-1)) != NULL) {
+				cur_ns = Z_STRVAL_P(ztype);
 			} else {
 				cur_ns = NULL;
 			}
 
-		} else if (Z_TYPE_PP(tmp) == IS_ARRAY && is_map(*tmp)) {
+		} else if (Z_TYPE_P(tmp) == IS_ARRAY && is_map(tmp)) {
 			cur_type = APACHE_MAP;
 			cur_stype = NULL;
 			cur_ns = NULL;
 		} else {
-			cur_type = Z_TYPE_PP(tmp);
+			cur_type = Z_TYPE_P(tmp);
 			cur_stype = NULL;
 			cur_ns = NULL;
 		}
@@ -3707,7 +3612,7 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS
 			smart_str_appends(&array_type, cur_stype);
 			smart_str_0(&array_type);
 
-			enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.c, array_type.len);
+			enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.s->val, array_type.s->len);
 			smart_str_free(&array_type);
 			return enc;
 		} else {
@@ -3743,18 +3648,14 @@ static void delete_mapping(void *data)
 {
 	soapMappingPtr map = (soapMappingPtr)data;
 
-	if (map->to_xml) {
-		zval_ptr_dtor(&map->to_xml);
-	}
-	if (map->to_zval) {
-		zval_ptr_dtor(&map->to_zval);
-	}
+	zval_ptr_dtor(&map->to_xml);
+	zval_ptr_dtor(&map->to_zval);
 	efree(map);
 }
 
-void delete_encoder(void *encode)
+void delete_encoder(zval *zv)
 {
-	encodePtr t = *((encodePtr*)encode);
+	encodePtr t = Z_PTR_P(zv);
 	if (t->details.ns) {
 		efree(t->details.ns);
 	}
@@ -3767,9 +3668,9 @@ void delete_encoder(void *encode)
 	efree(t);
 }
 
-void delete_encoder_persistent(void *encode)
+void delete_encoder_persistent(zval *zv)
 {
-	encodePtr t = *((encodePtr*)encode);
+	encodePtr t = Z_PTR_P(zv);
 	if (t->details.ns) {
 		free(t->details.ns);
 	}