Merge branch 'master' into jsond

Conflicts:
	ext/json/JSON_parser.c
	ext/json/JSON_parser.h
	ext/json/config.m4
	ext/json/config.w32
	ext/json/json.c
	ext/json/php_json.h

1 files changed, 244 insertions, 249 deletions

diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c
index 9e554a9f5a..d147d5ac2f 100644
--- a/ext/soap/php_encoding.c
+++ b/ext/soap/php_encoding.c
@@ -29,63 +29,63 @@
 #include "zend_interfaces.h"
 
 /* zval type decode */
-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);
-static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data);
+
+static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
 /* String encode */
-static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
 /* Null encode */
-static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
 /* Array encode */
-static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
-static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent);
 
 /* Datetime encode/decode */
-static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
-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(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(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC);
-static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC);
+static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data);
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data);
+
+static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
+
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data);
+static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
 /* Try and guess for non-wsdl clients and servers */
-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 zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data);
+static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent);
 
 static int is_map(zval *array);
-static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *out_type TSRMLS_DC);
+static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *out_type);
 
 static xmlNodePtr check_and_resolve_href(xmlNodePtr data);
 
@@ -283,7 +283,7 @@ static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type)
 	return NULL;
 }
 
-static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
+static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node) {
 	xmlNodePtr node_ptr;
 
 	if (SOAP_GLOBAL(ref_map)) {
@@ -350,7 +350,7 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) {
 	return 0;
 }
 
-static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC)
+static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node)
 {
 	zval *data_ptr;
 
@@ -368,14 +368,14 @@ static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC)
 	return 0;
 }
 
-static void soap_add_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC)
+static void soap_add_xml_ref(zval *data, xmlNodePtr node)
 {
 	if (SOAP_GLOBAL(ref_map)) {
 		zend_hash_index_update(SOAP_GLOBAL(ref_map), (zend_ulong)node, data);
 	}
 }
 
-static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xmlNodePtr parent, int check_class_map TSRMLS_DC)
+static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xmlNodePtr parent, int check_class_map)
 {
 	xmlNodePtr node = NULL;
 	int add_type = 0;
@@ -420,7 +420,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 		}
 
 		zdata = zend_hash_str_find(ht, "enc_value", sizeof("enc_value")-1);
-		node = master_to_xml(enc, zdata, style, parent TSRMLS_CC);
+		node = master_to_xml(enc, zdata, style, parent);
 
 		if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) {
 			if ((ztype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) {
@@ -491,7 +491,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 			smart_str_free(&nscat);			
 		}
 		if (encode->to_xml) {
-			node = encode->to_xml(&encode->details, data, style, parent TSRMLS_CC);
+			node = encode->to_xml(&encode->details, data, style, parent);
 			if (add_type) {
 				set_ns_and_type(node, &encode->details);
 			}
@@ -500,12 +500,12 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml
 	return node;
 }
 
-xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr parent)
 {
-	return master_to_xml_int(encode, data, style, parent, 1 TSRMLS_CC);
+	return master_to_xml_int(encode, data, style, parent, 1);
 }
 
-static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
+static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data)
 {
 	if (SOAP_GLOBAL(typemap)) {
 		if (encode->details.type_str) {
@@ -549,12 +549,12 @@ static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data TSR
 		}
 	}
 	if (encode->to_zval) {
-		ret = encode->to_zval(ret, &encode->details, data TSRMLS_CC);
+		ret = encode->to_zval(ret, &encode->details, data);
 	}
 	return ret;
 }
 
-zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
+zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data)
 {
 	data = check_and_resolve_href(data);
 
@@ -585,10 +585,10 @@ zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC)
 			}
 		}
 	}
-	return master_to_zval_int(ret, encode, data TSRMLS_CC);
+	return master_to_zval_int(ret, encode, data);
 }
 
-xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret = NULL;
 	zval return_value;
@@ -596,7 +596,7 @@ xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr par
 	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) == FAILURE) {
 			soap_error0(E_ERROR, "Encoding: Error calling to_xml callback");
 		}
 		if (Z_TYPE(return_value) == IS_STRING) {		
@@ -619,7 +619,7 @@ xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr par
 	return ret;
 }
 
-zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
+zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node)
 {
 	if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) {
 		xmlBufferPtr buf;
@@ -633,7 +633,7 @@ zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
 		xmlBufferFree(buf);
 		xmlFreeNode(copy);
 		
-		if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data TSRMLS_CC) == FAILURE) {
+		if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data) == FAILURE) {
 			soap_error0(E_ERROR, "Encoding: Error calling from_xml callback");
 		} else if (EG(exception)) {
 			ZVAL_NULL(ret);
@@ -647,7 +647,7 @@ zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC)
 
 /* 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(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -679,7 +679,7 @@ static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data TSRML
 	return ret;
 }
 
-static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -712,7 +712,7 @@ static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data TSRM
 	return ret;
 }
 
-static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -745,7 +745,7 @@ static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data TSRM
 	return ret;
 }
 
-static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	zend_string *str;
 
@@ -774,7 +774,7 @@ static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data TSRML
 	return ret;
 }
 
-static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	zend_string *str;
 	int i, j;
@@ -820,7 +820,7 @@ static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data TSRML
 	return ret;
 }
 
-static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret, text;
 	char *str;
@@ -905,7 +905,7 @@ static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret, text;
 	zend_string *str;
@@ -937,7 +937,7 @@ static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	static char hexconvtab[] = "0123456789ABCDEF";
 	xmlNodePtr ret, text;
@@ -974,7 +974,7 @@ static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -1012,7 +1012,7 @@ static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data TSRML
 	return ret;
 }
 
-static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -1044,7 +1044,7 @@ static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_
 	return ret;
 }
 
-static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret;
 
@@ -1075,7 +1075,7 @@ static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNode
 	return ret;
 }
 
-static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret;
 	zval tmp;
@@ -1098,7 +1098,7 @@ static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNo
 	return ret;
 }
 
-static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	FIND_XML_NULL(data, ret);
@@ -1127,7 +1127,7 @@ static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_
 	return ret;
 }
 
-static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret;
 
@@ -1135,7 +1135,7 @@ static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNode
 	xmlAddChild(parent, ret);
 	FIND_ZVAL_NULL(data, ret, style);
 
-	if (zend_is_true(data TSRMLS_CC)) {
+	if (zend_is_true(data)) {
 		xmlNodeSetContent(ret, BAD_CAST("true"));
 	} else {
 		xmlNodeSetContent(ret, BAD_CAST("false"));
@@ -1148,13 +1148,13 @@ static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNode
 }
 
 /* Null encode/decode */
-static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	ZVAL_NULL(ret);
 	return ret;
 }
 
-static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret;
 
@@ -1166,7 +1166,7 @@ static xmlNodePtr to_xml_null(encodeTypePtr type, zval *data, int style, xmlNode
 	return ret;
 }
 
-static void set_zval_property(zval* object, char* name, zval* val TSRMLS_DC)
+static void set_zval_property(zval* object, char* name, zval* val)
 {
 	zend_class_entry *old_scope;
 
@@ -1177,7 +1177,7 @@ 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, zval *rv TSRMLS_DC)
+static zval* get_zval_property(zval* object, char* name, zval *rv)
 {
 	if (Z_TYPE_P(object) == IS_OBJECT) {
 		zval member;
@@ -1187,12 +1187,12 @@ static zval* get_zval_property(zval* object, char* name, zval *rv TSRMLS_DC)
 		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, NULL, rv TSRMLS_CC);
+		data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, NULL, rv);
 		if (data == &EG(uninitialized_zval)) {
 			/* Hack for bug #32455 */
 			zend_property_info *property_info;
 
-			property_info = zend_get_property_info(Z_OBJCE_P(object), Z_STR(member), 1 TSRMLS_CC);
+			property_info = zend_get_property_info(Z_OBJCE_P(object), Z_STR(member), 1);
 			EG(scope) = old_scope;
 			if (property_info != ZEND_WRONG_PROPERTY_INFO && property_info &&
 			    zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) {
@@ -1215,7 +1215,7 @@ static zval* get_zval_property(zval* object, char* name, zval *rv TSRMLS_DC)
 	return NULL;
 }
 
-static void unset_zval_property(zval* object, char* name TSRMLS_DC)
+static void unset_zval_property(zval* object, char* name)
 {
 	if (Z_TYPE_P(object) == IS_OBJECT) {
 		zval member;
@@ -1224,7 +1224,7 @@ static void unset_zval_property(zval* object, char* name TSRMLS_DC)
 		ZVAL_STRING(&member, name);
 		old_scope = EG(scope);
 		EG(scope) = Z_OBJCE_P(object);
-		Z_OBJ_HT_P(object)->unset_property(object, &member, NULL TSRMLS_CC);
+		Z_OBJ_HT_P(object)->unset_property(object, &member, NULL);
 		EG(scope) = old_scope;
 		zval_ptr_dtor(&member);
 	} else if (Z_TYPE_P(object) == IS_ARRAY) {
@@ -1232,17 +1232,17 @@ static void unset_zval_property(zval* object, char* name TSRMLS_DC)
 	}
 }
 
-static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
+static void model_to_zval_any(zval *ret, xmlNodePtr node)
 {
 	zval rv, arr, val;
 	zval* any = NULL;
 	char* name = NULL;
 
 	while (node != NULL) {
-		if (get_zval_property(ret, (char*)node->name, &rv TSRMLS_CC) == NULL) {
+		if (get_zval_property(ret, (char*)node->name, &rv) == NULL) {
 			
 			ZVAL_NULL(&val);
-			master_to_zval(&val, get_conversion(XSD_ANYXML), node TSRMLS_CC);
+			master_to_zval(&val, get_conversion(XSD_ANYXML), node);
 			
 			if (any && Z_TYPE_P(any) != IS_ARRAY) {
 				/* Convert into array */
@@ -1261,7 +1261,7 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
 					zval val2;
 
 					ZVAL_NULL(&val2);
-					master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next TSRMLS_CC);
+					master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next);
 					if (Z_TYPE(val2) != IS_STRING ||  *Z_STRVAL(val) != '<') {
 						break;
 					}
@@ -1307,11 +1307,11 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC)
 		node = node->next;
 	}
 	if (any) {
-		set_zval_property(ret, name ? name : "any", any TSRMLS_CC);
+		set_zval_property(ret, name ? name : "any", any);
 	}
 }
 
-static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr data, sdlPtr sdl TSRMLS_DC)
+static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr data, sdlPtr sdl)
 {
 	switch (model->kind) {
 		case XSD_CONTENT_ELEMENT:
@@ -1328,19 +1328,19 @@ 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);
 						}
-						master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, r_node);
 					} else if (model->u.element->fixed) {
 						xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 						xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
-						master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, dummy);
 						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));
-						master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, dummy);
 						xmlFreeNode(dummy);
 					} else {
-						master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC);
+						master_to_zval(&val, model->u.element->encode, r_node);
 					}
 					if ((node = get_node(node->next, model->u.element->name)) != NULL) {
 						zval array;
@@ -1352,19 +1352,19 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 								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);
 								}
-								master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, node);
 							} else if (model->u.element->fixed) {
 								xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 								xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed));
-								master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, dummy);
 								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));
-								master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, dummy);
 								xmlFreeNode(dummy);
 							} else {
-								master_to_zval(&val, model->u.element->encode, node TSRMLS_CC);
+								master_to_zval(&val, model->u.element->encode, node);
 							}
 							add_next_index_zval(&array, &val);
 						} while ((node = get_node(node->next, model->u.element->name)) != NULL);
@@ -1378,7 +1378,7 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 						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);
 				}
 			}
 			break;
@@ -1392,16 +1392,16 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 				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);
 				}
 			} ZEND_HASH_FOREACH_END();
 			if (any) {
-				model_to_zval_any(ret, data->children TSRMLS_CC);
+				model_to_zval_any(ret, data->children);
 			}
 			break;
 		}
 		case XSD_CONTENT_GROUP:
-			model_to_zval_object(ret, model->u.group->model, data, sdl TSRMLS_CC);
+			model_to_zval_object(ret, model->u.group->model, data, sdl);
 			break;
 		default:
 		  break;
@@ -1409,7 +1409,7 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr
 }
 
 /* Struct encode/decode */
-static zval *to_zval_object_ex(zval *ret, 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)
 {
 	xmlNodePtr trav;
 	sdlPtr sdl;
@@ -1425,7 +1425,7 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 
 		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) {
+		    (tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO)) != NULL) {
 			ce = tmp;
 		}
 	}
@@ -1446,21 +1446,21 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 				zval base;
 
 				ZVAL_NULL(ret);
-				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data)) {
 					return ret;
 				}
 
 				object_init_ex(ret, ce);
-				master_to_zval_int(&base, enc, data TSRMLS_CC);
-				set_zval_property(ret, "_", &base TSRMLS_CC);
+				master_to_zval_int(&base, enc, data);
+				set_zval_property(ret, "_", &base);
 			} else {
 				ZVAL_NULL(ret);
 				FIND_XML_NULL(data, ret);
-				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data)) {
 					return ret;
 				}
 				object_init_ex(ret, ce);
-				soap_add_xml_ref(ret, data TSRMLS_CC);
+				soap_add_xml_ref(ret, data);
 			}
 		} else if (sdlType->kind == XSD_TYPEKIND_EXTENSION &&
 		           sdlType->encode &&
@@ -1471,7 +1471,7 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 			    sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
 
 				CHECK_XML_NULL(data);
-				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data)) {
 					return ret;
 				}
 
@@ -1484,14 +1484,14 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 			        (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))) {
-					to_zval_object_ex(ret, &sdlType->encode->details, data, ce TSRMLS_CC);
+					to_zval_object_ex(ret, &sdlType->encode->details, data, ce);
 			    } else {
-					master_to_zval_int(ret, sdlType->encode, data TSRMLS_CC);
+					master_to_zval_int(ret, sdlType->encode, data);
 				}
 				
-				soap_add_xml_ref(ret, data TSRMLS_CC);
+				soap_add_xml_ref(ret, data);
 
-				redo_any = get_zval_property(ret, "any", &rv TSRMLS_CC);
+				redo_any = get_zval_property(ret, "any", &rv);
 				if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) {
 					zend_object *zobj = Z_OBJ_P(ret);
 					zobj->ce = ce;
@@ -1500,32 +1500,32 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 				zval base;
 
 				ZVAL_NULL(ret);
-				if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+				if (soap_check_xml_ref(ret, data)) {
 					return ret;
 				}
 
 				object_init_ex(ret, ce);
-				soap_add_xml_ref(ret, data TSRMLS_CC);
-				master_to_zval_int(&base, sdlType->encode, data TSRMLS_CC);
-				set_zval_property(ret, "_", &base TSRMLS_CC);
+				soap_add_xml_ref(ret, data);
+				master_to_zval_int(&base, sdlType->encode, data);
+				set_zval_property(ret, "_", &base);
 			}
 		} else {
 			ZVAL_NULL(ret);
 			FIND_XML_NULL(data, ret);
-			if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+			if (soap_check_xml_ref(ret, data)) {
 				return ret;
 			}
 			object_init_ex(ret, ce);
-			soap_add_xml_ref(ret, data TSRMLS_CC);
+			soap_add_xml_ref(ret, data);
 		}
 		if (sdlType->model) {
-			model_to_zval_object(ret, sdlType->model, data, sdl TSRMLS_CC);
+			model_to_zval_object(ret, sdlType->model, data, sdl);
 			if (redo_any) {
-				if (!get_zval_property(ret, "any", &rv TSRMLS_CC)) {
-					model_to_zval_any(ret, data->children TSRMLS_CC);
-					soap_add_xml_ref(ret, data TSRMLS_CC);
+				if (!get_zval_property(ret, "any", &rv)) {
+					model_to_zval_any(ret, data->children);
+					soap_add_xml_ref(ret, data);
 				} else {
-					unset_zval_property(ret, "any" TSRMLS_CC);
+					unset_zval_property(ret, "any");
 				}
 			}
 		}
@@ -1555,9 +1555,9 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 						text = xmlNewText(BAD_CAST(str_val));
 						xmlAddChild(dummy, text);
 						ZVAL_NULL(&data);
-						master_to_zval(&data, attr->encode, dummy TSRMLS_CC);
+						master_to_zval(&data, attr->encode, dummy);
 						xmlFreeNode(dummy);
-						set_zval_property(ret, attr->name, &data TSRMLS_CC);
+						set_zval_property(ret, attr->name, &data);
 					}
 				}
 			} ZEND_HASH_FOREACH_END();
@@ -1565,12 +1565,12 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 	} else {
 		ZVAL_NULL(ret);
 		FIND_XML_NULL(data, ret);
-		if (soap_check_xml_ref(ret, data TSRMLS_CC)) {
+		if (soap_check_xml_ref(ret, data)) {
 			return ret;
 		}
 
 		object_init_ex(ret, ce);
-		soap_add_xml_ref(ret, data TSRMLS_CC);
+		soap_add_xml_ref(ret, data);
 		trav = data->children;
 
 		while (trav != NULL) {
@@ -1579,18 +1579,18 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 				zval *prop;
 
 				ZVAL_NULL(&tmpVal);
-				master_to_zval(&tmpVal, NULL, trav TSRMLS_CC);
+				master_to_zval(&tmpVal, NULL, trav);
 
-				prop = get_zval_property(ret, (char*)trav->name, &rv TSRMLS_CC);
+				prop = get_zval_property(ret, (char*)trav->name, &rv);
 				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);
 					} else {
 						zval arr;
 
 						array_init(&arr);
 						add_next_index_zval(&arr, &tmpVal);
-						set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
+						set_zval_property(ret, (char*)trav->name, &arr);
 					}
 				} else {
 					/* Property already exist - make array */
@@ -1599,7 +1599,7 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 						array_init(&arr);
 						Z_ADDREF_P(prop);
 						add_next_index_zval(&arr, prop);
-						set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC);
+						set_zval_property(ret, (char*)trav->name, &arr);
 						prop = &arr;
 					}
 					/* Add array element */
@@ -1612,13 +1612,13 @@ static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, z
 	return ret;
 }
 
-static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
-	return to_zval_object_ex(ret, type, data, NULL TSRMLS_CC);
+	return to_zval_object_ex(ret, type, data, NULL);
 }
 
 
-static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *object, int style, int strict TSRMLS_DC)
+static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *object, int style, int strict)
 {
 	switch (model->kind) {
 		case XSD_CONTENT_ELEMENT: {
@@ -1627,7 +1627,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			encodePtr enc;
 			zval rv;
 
-			data = get_zval_property(object, model->u.element->name, &rv TSRMLS_CC);
+			data = get_zval_property(object, model->u.element->name, &rv);
 			if (data &&
 			    Z_TYPE_P(data) == IS_NULL &&
 			    !model->u.element->nillable &&
@@ -1649,7 +1649,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 							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);
 							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);
@@ -1671,7 +1671,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 					} else if (Z_TYPE_P(data) == IS_NULL && model->min_occurs == 0) {
 						return 1;
 					} else {
-						property = master_to_xml(enc, data, style, node TSRMLS_CC);
+						property = master_to_xml(enc, data, style, node);
 						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);
@@ -1712,7 +1712,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			encodePtr enc;
 			zval rv;
 
-			data = get_zval_property(object, "any", &rv TSRMLS_CC);
+			data = get_zval_property(object, "any", &rv);
 			if (data) {
 				enc = get_conversion(XSD_ANYXML);
 				if ((model->max_occurs == -1 || model->max_occurs > 1) &&
@@ -1722,10 +1722,10 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 					zval *val;
 
 					ZEND_HASH_FOREACH_VAL(ht, val) {
-						master_to_xml(enc, val, style, node TSRMLS_CC);
+						master_to_xml(enc, val, style, node);
 					} ZEND_HASH_FOREACH_END();
 				} else {
-					master_to_xml(enc, data, style, node TSRMLS_CC);
+					master_to_xml(enc, data, style, node);
 				}
 				return 1;
 			} else if (model->min_occurs == 0) {
@@ -1743,7 +1743,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			sdlContentModelPtr tmp;
 
 			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 (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0))) {
 					if (!strict || tmp->min_occurs > 0) {
 						return 0;
 					}
@@ -1757,7 +1757,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			int ret = 0;
 
 			ZEND_HASH_FOREACH_PTR(model->u.content, tmp) {
-				int tmp_ret = model_to_xml_object(node, tmp, object, style, 0 TSRMLS_CC);
+				int tmp_ret = model_to_xml_object(node, tmp, object, style, 0);
 				if (tmp_ret == 1) {
 					return 1;
 				} else if (tmp_ret != 0) {
@@ -1767,7 +1767,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval *
 			return ret;
 		}
 		case XSD_CONTENT_GROUP: {
-			return model_to_xml_object(node, model->u.group->model, object, style, strict && model->min_occurs > 0 TSRMLS_CC);
+			return model_to_xml_object(node, model->u.group->model, object, style, strict && model->min_occurs > 0);
 		}
 		default:
 		  break;
@@ -1806,7 +1806,7 @@ static sdlTypePtr model_array_element(sdlContentModelPtr model)
 	return NULL;
 }
 
-static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr xmlParam;
 	HashTable *prop = NULL;
@@ -1842,11 +1842,11 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 			}
 			if (enc) {
 				zval rv;
-				zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
+				zval *tmp = get_zval_property(data, "_", &rv);
 				if (tmp) {
-					xmlParam = master_to_xml(enc, tmp, style, parent TSRMLS_CC);
+					xmlParam = master_to_xml(enc, tmp, style, parent);
 				} else if (prop == NULL) {
-					xmlParam = master_to_xml(enc, data, style, parent TSRMLS_CC);
+					xmlParam = master_to_xml(enc, data, style, parent);
 				} else {
 					xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 					xmlAddChild(parent, xmlParam);
@@ -1863,16 +1863,16 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 			    sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) {
 
 				if (prop) ZEND_HASH_INC_APPLY_COUNT(prop);
-				xmlParam = master_to_xml(sdlType->encode, data, style, parent TSRMLS_CC);
+				xmlParam = master_to_xml(sdlType->encode, data, style, parent);
 				if (prop) ZEND_HASH_DEC_APPLY_COUNT(prop);
 			} else {
 				zval rv;
-				zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC);
+				zval *tmp = get_zval_property(data, "_", &rv);
 
 				if (tmp) {
-					xmlParam = master_to_xml(sdlType->encode, tmp, style, parent TSRMLS_CC);
+					xmlParam = master_to_xml(sdlType->encode, tmp, style, parent);
 				} else if (prop == NULL) {
-					xmlParam = master_to_xml(sdlType->encode, data, style, parent TSRMLS_CC);
+					xmlParam = master_to_xml(sdlType->encode, data, style, parent);
 				} else {
 					xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 					xmlAddChild(parent, xmlParam);
@@ -1883,7 +1883,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 			xmlAddChild(parent, xmlParam);
 		}
 
-		if (soap_check_zval_ref(data, xmlParam TSRMLS_CC)) {
+		if (soap_check_zval_ref(data, xmlParam)) {
 			return xmlParam;
 		}
 		if (prop != NULL) {
@@ -1903,7 +1903,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 						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);
 					}
 					xmlNodeSetName(property, BAD_CAST(array_el->name));
 					if (style == SOAP_LITERAL &&
@@ -1914,7 +1914,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 					}
 				} ZEND_HASH_FOREACH_END();
 			} else if (sdlType->model) {
-				model_to_xml_object(xmlParam, sdlType->model, data, style, 1 TSRMLS_CC);
+				model_to_xml_object(xmlParam, sdlType->model, data, style, 1);
 			}
 			if (sdlType->attributes) {
 				sdlAttributePtr attr;
@@ -1922,11 +1922,11 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 
 				ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) {
 					if (attr->name) {
-						zattr = get_zval_property(data, attr->name, &rv TSRMLS_CC);
+						zattr = get_zval_property(data, attr->name, &rv);
 						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);
 							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);
@@ -1958,7 +1958,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 		xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS"));
 		xmlAddChild(parent, xmlParam);
 
-		if (soap_check_zval_ref(data, xmlParam TSRMLS_CC)) {
+		if (soap_check_zval_ref(data, xmlParam)) {
 			return xmlParam;
 		}
 		if (prop != NULL) {
@@ -1968,7 +1968,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 
 			ZEND_HASH_FOREACH_STR_KEY_VAL_IND(prop, str_key, zprop) {
 
-				property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam TSRMLS_CC);
+				property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam);
 				
 				if (str_key) {
 					const char *prop_name;
@@ -1994,7 +1994,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
 }
 
 /* Array encode/decode */
-static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	encodePtr enc = NULL;
 
@@ -2009,7 +2009,7 @@ static xmlNodePtr guess_array_map(encodeTypePtr type, zval *data, int style, xml
 		enc = get_conversion(IS_NULL);
 	}
 
-	return master_to_xml(enc, data, style, parent TSRMLS_CC);
+	return master_to_xml(enc, data, style, parent);
 }
 
 static int calc_dimension_12(const char* str)
@@ -2113,7 +2113,7 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
                                    int* dims,
                                    zval* data,
                                    int style
-                                   TSRMLS_DC)
+                                  )
 {
 	int j = 0;
 	zval *zdata;
@@ -2126,9 +2126,9 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
 	 		}
  			if (dimension == 1) {
  				if (enc == NULL) {
-					xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam TSRMLS_CC);
+					xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam);
 				} else {
-					xparam = master_to_xml(enc, zdata, style, xmlParam TSRMLS_CC);
+					xparam = master_to_xml(enc, zdata, style, xmlParam);
 	 			}
 
 	 			if (type) {
@@ -2140,7 +2140,7 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
  					xmlNodeSetName(xparam, BAD_CAST("item"));
  				}
  			} else {
- 				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);
  			}
  			j++;
  		} ZEND_HASH_FOREACH_END();
@@ -2163,7 +2163,7 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
  			}
 		} else {
 	 		while (j < dims[0]) {
-				add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style TSRMLS_CC);
+				add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
  				j++;
  			}
 		}
@@ -2183,7 +2183,7 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
  					xmlNodeSetName(xparam, BAD_CAST("item"));
  				}
  			} else {
- 			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style TSRMLS_CC);
+ 			  add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style);
  			}
 		}
  	}
@@ -2200,7 +2200,7 @@ static inline int array_num_elements(HashTable* ht)
 	return 0;
 }
 
-static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	sdlTypePtr sdl_type = type->sdl_type;
 	sdlTypePtr element_type = NULL;
@@ -2231,42 +2231,42 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 		return xmlParam;
 	}
 
-	if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable TSRMLS_CC)) {
+	if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable)) {
 		zend_object_iterator   *iter;
 		zend_class_entry       *ce = Z_OBJCE_P(data);
 		zval                   *val;
 
 		array_init(&array_copy);
 
-		iter = ce->get_iterator(ce, data, 0 TSRMLS_CC);
+		iter = ce->get_iterator(ce, data, 0);
 
 		if (EG(exception)) {
 			goto iterator_done;
 		}
 
 		if (iter->funcs->rewind) {
-			iter->funcs->rewind(iter TSRMLS_CC);
+			iter->funcs->rewind(iter);
 			if (EG(exception)) {
 				goto iterator_done;
 			}
 		}
 
-		while (iter->funcs->valid(iter TSRMLS_CC) == SUCCESS) {
+		while (iter->funcs->valid(iter) == SUCCESS) {
 			if (EG(exception)) {
 				goto iterator_done;
 			}
 
-			val = iter->funcs->get_current_data(iter TSRMLS_CC);
+			val = iter->funcs->get_current_data(iter);
 			if (EG(exception)) {
 				goto iterator_done;
 			}
 			if (iter->funcs->get_current_key) {
 				zval key;
-				iter->funcs->get_current_key(iter, &key TSRMLS_CC);
+				iter->funcs->get_current_key(iter, &key);
 				if (EG(exception)) {
 					goto iterator_done;
 				}
-				array_set_zval_key(Z_ARRVAL(array_copy), &key, val TSRMLS_CC);
+				array_set_zval_key(Z_ARRVAL(array_copy), &key, val);
 				zval_ptr_dtor(val);
 				zval_dtor(&key);
 			} else {
@@ -2274,7 +2274,7 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod
 			}
 			Z_ADDREF_P(val);
 
-			iter->funcs->move_forward(iter TSRMLS_CC);
+			iter->funcs->move_forward(iter);
 			if (EG(exception)) {
 				goto iterator_done;
 			}
@@ -2401,7 +2401,7 @@ iterator_done:
 				enc = elementType->encode;
 				get_type_str(xmlParam, elementType->encode->details.ns, elementType->encode->details.type_str, &array_type);
 			} else {
-				enc = get_array_type(xmlParam, data, &array_type TSRMLS_CC);
+				enc = get_array_type(xmlParam, data, &array_type);
 			}
 		} else if (sdl_type && sdl_type->elements &&
 		           zend_hash_num_elements(sdl_type->elements) == 1 &&
@@ -2419,7 +2419,7 @@ iterator_done:
 			dims[0] = i;
 		} else {
 
-			enc = get_array_type(xmlParam, data, &array_type TSRMLS_CC);
+			enc = get_array_type(xmlParam, data, &array_type);
 			smart_str_append_long(&array_size, i);
 			dims = safe_emalloc(sizeof(int), dimension, 0);
 			dims[0] = i;
@@ -2452,7 +2452,7 @@ iterator_done:
 		smart_str_free(&array_type);
 		smart_str_free(&array_size);
 
-		add_xml_array_elements(xmlParam, element_type, enc, enc?encode_add_ns(xmlParam,enc->details.ns):NULL, dimension, dims, data, style TSRMLS_CC);
+		add_xml_array_elements(xmlParam, element_type, enc, enc?encode_add_ns(xmlParam,enc->details.ns):NULL, dimension, dims, data, style);
 		efree(dims);
 	}
 	if (style == SOAP_ENCODED) {
@@ -2468,7 +2468,7 @@ iterator_done:
 	return xmlParam;
 }
 
-static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	xmlNodePtr trav;
 	encodePtr enc = NULL;
@@ -2625,7 +2625,7 @@ static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS
 			xmlAttrPtr position = get_attribute(trav->properties,"position");
 
 			ZVAL_NULL(&tmpVal);
-			master_to_zval(&tmpVal, enc, trav TSRMLS_CC);
+			master_to_zval(&tmpVal, enc, trav);
 			if (position != NULL && position->children && position->children->content) {
 				char* tmp = strrchr((char*)position->children->content, '[');
 				if (tmp == NULL) {
@@ -2674,7 +2674,7 @@ static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS
 }
 
 /* Map encode/decode */
-static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	zval *temp_data;
 	zend_string *key_val;
@@ -2712,7 +2712,7 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP
 				smart_str_free(&tmp);
 			}
 
-			xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item TSRMLS_CC);
+			xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item);
 			xmlNodeSetName(xparam, BAD_CAST("value"));
 		} ZEND_HASH_FOREACH_END();
 	}
@@ -2723,7 +2723,7 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP
 	return xmlParam;
 }
 
-static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	zval key, value;
 	xmlNodePtr trav, item, xmlKey, xmlValue;
@@ -2748,9 +2748,9 @@ static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_D
 			}
 
 			ZVAL_NULL(&key);
-			master_to_zval(&key, NULL, xmlKey TSRMLS_CC);
+			master_to_zval(&key, NULL, xmlKey);
 			ZVAL_NULL(&value);
-			master_to_zval(&value, NULL, xmlValue TSRMLS_CC);
+			master_to_zval(&value, NULL, xmlValue);
 
 			if (Z_TYPE(key) == IS_STRING) {
 				zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value);
@@ -2769,7 +2769,7 @@ static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_D
 }
 
 /* Unknown encode/decode */
-static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	encodePtr  enc;
 	xmlNodePtr ret;
@@ -2779,7 +2779,7 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x
 	} else {
 		enc = get_conversion(IS_NULL);
 	}
-	ret = master_to_xml_int(enc, data, style, parent, 0 TSRMLS_CC);
+	ret = master_to_xml_int(enc, data, style, parent, 0);
 /*
 	if (style == SOAP_LITERAL && SOAP_GLOBAL(sdl)) {
 		set_ns_and_type(ret, &enc->details);
@@ -2788,7 +2788,7 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x
 	return ret;
 }
 
-static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	encodePtr enc = NULL;
 	xmlAttrPtr tmpattr;
@@ -2845,7 +2845,7 @@ static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data T
 			}
 		}
 	}
-	master_to_zval_int(ret, enc, data TSRMLS_CC);
+	master_to_zval_int(ret, enc, data);
 	if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) {
 		zval soapvar;
 		char *ns, *cptype;
@@ -2869,7 +2869,7 @@ static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data T
 }
 
 /* Time encode/decode */
-static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *format, int style, xmlNodePtr parent)
 {
 	/* logic hacked from ext/standard/datetime.c */
 	struct tm *ta, tmbuf;
@@ -2933,59 +2933,59 @@ static xmlNodePtr to_xml_datetime_ex(encodeTypePtr type, zval *data, char *forma
 	return xmlParam;
 }
 
-static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	/* TODO: '-'?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T([0-9]+H)?([0-9]+M)?([0-9]+S)? */
-	return to_xml_string(type, data, style, parent TSRMLS_CC);
+	return to_xml_string(type, data, style, parent);
 }
 
-static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_datetime(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "%Y-%m-%dT%H:%M:%S", style, parent);
 }
 
-static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_time(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	/* TODO: microsecconds */
-	return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "%H:%M:%S", style, parent);
 }
 
-static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_date(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "%Y-%m-%d", style, parent);
 }
 
-static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_gyearmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "%Y-%m", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "%Y-%m", style, parent);
 }
 
-static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_gyear(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "%Y", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "%Y", style, parent);
 }
 
-static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_gmonthday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "--%m-%d", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "--%m-%d", style, parent);
 }
 
-static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "---%d", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "---%d", style, parent);
 }
 
-static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
-	return to_xml_datetime_ex(type, data, "--%m--", style, parent TSRMLS_CC);
+	return to_xml_datetime_ex(type, data, "--%m--", style, parent);
 }
 
-static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
 	/*FIXME*/
-	return to_zval_stringc(ret, enc, data TSRMLS_CC);
+	return to_zval_stringc(ret, enc, data);
 }
 
-static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
+static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
 	xmlNodePtr ret;
 	encodePtr list_enc = NULL;
 
@@ -3007,7 +3007,7 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 		HashTable *ht = Z_ARRVAL_P(data);
 
 		ZEND_HASH_FOREACH_VAL(ht, tmp) {
-			xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret TSRMLS_CC);
+			xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret);
 			if (dummy && dummy->children && dummy->children->content) {
 				if (list.s && list.s->len != 0) {
 					smart_str_appendc(&list, ' ');
@@ -3044,7 +3044,7 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 			  next++;
 			}
 			ZVAL_STRING(&dummy_zval, start);
-			dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret TSRMLS_CC);
+			dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret);
 			zval_ptr_dtor(&dummy_zval);
 			if (dummy && dummy->children && dummy->children->content) {
 				if (list.s && list.s->len != 0) {
@@ -3068,22 +3068,22 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP
 	return ret;
 }
 
-static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
+static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
 	/*FIXME: minLength=1 */
-	return to_xml_list(enc,data,style, parent TSRMLS_CC);
+	return to_xml_list(enc,data,style, parent);
 }
 
-static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) {
+static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data) {
 	/*FIXME*/
-	return to_zval_list(ret, enc, data TSRMLS_CC);
+	return to_zval_list(ret, enc, data);
 }
 
-static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) {
+static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent) {
 	/*FIXME*/
-	return to_xml_list(enc,data,style, parent TSRMLS_CC);
+	return to_xml_list(enc,data,style, parent);
 }
 
-static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
+static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data)
 {
 	xmlBufferPtr buf;
 
@@ -3101,7 +3101,7 @@ static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_D
 		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(ret, sdl_type->encode, data TSRMLS_CC);
+			return master_to_zval_int(ret, sdl_type->encode, data);
 		}		
 		smart_str_free(&nscat);
 	}
@@ -3113,7 +3113,7 @@ static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_D
 	return ret;
 }
 
-static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent)
 {
 	xmlNodePtr ret = NULL;
 
@@ -3123,7 +3123,7 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP
 		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);
+			ret = master_to_xml(enc, el, style, parent);
 		    if (ret &&
 		        ret->name != xmlStringTextNoenc) {
 				xmlNodeSetName(ret, BAD_CAST(name->val));
@@ -3154,13 +3154,13 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP
 	return ret;
 }
 
-zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC)
+zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data)
 {
 	sdlTypePtr type;
 
 	type = enc->sdl_type;
 	if (type == NULL) {
-		return guess_zval_convert(ret, enc, data TSRMLS_CC);
+		return guess_zval_convert(ret, enc, data);
 	}
 /*FIXME: restriction support
 	if (type && type->restrictions &&
@@ -3194,31 +3194,31 @@ zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRML
 	switch (type->kind) {
 		case XSD_TYPEKIND_SIMPLE:
 			if (type->encode && enc != &type->encode->details) {
-				return master_to_zval_int(ret, type->encode, data TSRMLS_CC);
+				return master_to_zval_int(ret, type->encode, data);
 			} else {
-				return guess_zval_convert(ret, enc, data TSRMLS_CC);
+				return guess_zval_convert(ret, enc, data);
 			}
 			break;
 		case XSD_TYPEKIND_LIST:
-			return to_zval_list(ret, enc, data TSRMLS_CC);
+			return to_zval_list(ret, enc, data);
 		case XSD_TYPEKIND_UNION:
-			return to_zval_union(ret, enc, data TSRMLS_CC);
+			return to_zval_union(ret, enc, data);
 		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(ret, enc, data TSRMLS_CC);
+				return to_zval_array(ret, enc, data);
 			}
-			return to_zval_object(ret, enc, data TSRMLS_CC);
+			return to_zval_object(ret, enc, data);
 		default:
 	  	soap_error0(E_ERROR, "Encoding: Internal Error");
-			return guess_zval_convert(ret, enc, data TSRMLS_CC);
+			return guess_zval_convert(ret, enc, data);
 	}
 }
 
-xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC)
+xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent)
 {
 	sdlTypePtr type;
 	xmlNodePtr ret = NULL;
@@ -3226,7 +3226,7 @@ xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNo
 	type = enc->sdl_type;
 
 	if (type == NULL) {
-		ret = guess_xml_convert(enc, data, style, parent TSRMLS_CC);
+		ret = guess_xml_convert(enc, data, style, parent);
 		if (style == SOAP_ENCODED) {
 			set_ns_and_type(ret, enc);
 		}
@@ -3258,16 +3258,16 @@ xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNo
 	switch(type->kind) {
 		case XSD_TYPEKIND_SIMPLE:
 			if (type->encode && enc != &type->encode->details) {
-				ret = master_to_xml(type->encode, data, style, parent TSRMLS_CC);
+				ret = master_to_xml(type->encode, data, style, parent);
 			} else {
-				ret = guess_xml_convert(enc, data, style, parent TSRMLS_CC);
+				ret = guess_xml_convert(enc, data, style, parent);
 			}
 			break;
 		case XSD_TYPEKIND_LIST:
-			ret = to_xml_list(enc, data, style, parent TSRMLS_CC);
+			ret = to_xml_list(enc, data, style, parent);
 			break;
 		case XSD_TYPEKIND_UNION:
-			ret = to_xml_union(enc, data, style, parent TSRMLS_CC);
+			ret = to_xml_union(enc, data, style, parent);
 			break;
 		case XSD_TYPEKIND_COMPLEX:
 		case XSD_TYPEKIND_RESTRICTION:
@@ -3275,9 +3275,9 @@ xmlNodePtr sdl_guess_convert_xml(encodeTypePtr enc, zval *data, int style, xmlNo
 			if (type->encode &&
 			    (type->encode->details.type == IS_ARRAY ||
 			     type->encode->details.type == SOAP_ENC_ARRAY)) {
-				return to_xml_array(enc, data, style, parent TSRMLS_CC);
+				return to_xml_array(enc, data, style, parent);
 			} else {
-				return to_xml_object(enc, data, style, parent TSRMLS_CC);
+				return to_xml_object(enc, data, style, parent);
 			}
 			break;
 		default:
@@ -3401,8 +3401,7 @@ xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns)
 	}
 	if (xmlns == NULL) {
 		xmlChar* prefix;
-        TSRMLS_FETCH();
-
+        
 		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 {
@@ -3445,7 +3444,6 @@ static void set_xsi_type(xmlNodePtr node, char *type)
 
 void encode_reset_ns()
 {
-	TSRMLS_FETCH();
 	SOAP_GLOBAL(cur_uniq_ns) = 0;
 	SOAP_GLOBAL(cur_uniq_ref) = 0;
 	if (SOAP_GLOBAL(ref_map)) {
@@ -3458,7 +3456,6 @@ void encode_reset_ns()
 
 void encode_finish()
 {
-	TSRMLS_FETCH();
 	SOAP_GLOBAL(cur_uniq_ns) = 0;
 	SOAP_GLOBAL(cur_uniq_ref) = 0;
 	if (SOAP_GLOBAL(ref_map)) {
@@ -3471,7 +3468,6 @@ void encode_finish()
 encodePtr get_conversion(int encode)
 {
 	encodePtr enc;
-	TSRMLS_FETCH();
 
 	if ((enc = zend_hash_index_find_ptr(&SOAP_GLOBAL(defEncIndex), encode)) == NULL) {
 		soap_error0(E_ERROR,  "Encoding: Cannot find encoding");
@@ -3496,7 +3492,7 @@ static int is_map(zval *array)
 	return FALSE;
 }
 
-static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TSRMLS_DC)
+static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type)
 {
 	HashTable *ht;
 	int i, cur_type, prev_type, different;
@@ -3598,7 +3594,6 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS
 
 static void get_type_str(xmlNodePtr node, const char* ns, const char* type, smart_str* ret)
 {
-	TSRMLS_FETCH();
 
 	if (ns) {
 		xmlNsPtr xmlns;