Refactor XML (incompleted)

2 files changed, 337 insertions, 405 deletions

diff --git a/ext/xml/php_xml.h b/ext/xml/php_xml.h
index 0fc25739c4..0195bb5836 100644
--- a/ext/xml/php_xml.h
+++ b/ext/xml/php_xml.h
@@ -44,22 +44,22 @@ ZEND_BEGIN_MODULE_GLOBALS(xml)
 ZEND_END_MODULE_GLOBALS(xml)
 
 typedef struct {
-	int index;
 	int case_folding;
 	XML_Parser parser;
 	XML_Char *target_encoding;
 
-	zval *startElementHandler;
-	zval *endElementHandler;
-	zval *characterDataHandler;
-	zval *processingInstructionHandler;
-	zval *defaultHandler;
-	zval *unparsedEntityDeclHandler;
-	zval *notationDeclHandler;
-	zval *externalEntityRefHandler;
-	zval *unknownEncodingHandler;	
-	zval *startNamespaceDeclHandler;
-	zval *endNamespaceDeclHandler;
+	zval index;
+	zval startElementHandler;
+	zval endElementHandler;
+	zval characterDataHandler;
+	zval processingInstructionHandler;
+	zval defaultHandler;
+	zval unparsedEntityDeclHandler;
+	zval notationDeclHandler;
+	zval externalEntityRefHandler;
+	zval unknownEncodingHandler;	
+	zval startNamespaceDeclHandler;
+	zval endNamespaceDeclHandler;
 
 	zend_function *startElementPtr;
 	zend_function *endElementPtr;
@@ -73,14 +73,14 @@ typedef struct {
 	zend_function *startNamespaceDeclPtr;
 	zend_function *endNamespaceDeclPtr;
 
-	zval *object;
+	zval object;
 
-	zval *data;
-	zval *info;
+	zval data;
+	zval info;
 	int level;
 	int toffset;
 	int curtag;
-	zval **ctag;
+	zval *ctag;
 	char **ltags;
 	int lastwasopen;
 	int skipwhite;
@@ -133,9 +133,9 @@ PHP_FUNCTION(utf8_encode);
 PHP_FUNCTION(utf8_decode);
 PHP_FUNCTION(xml_parse_into_struct);
 
-PHPAPI char *_xml_zval_strdup(zval *val);
-PHPAPI char *xml_utf8_decode(const XML_Char *, int, int *, const XML_Char *);
-PHPAPI char *xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char *encoding);
+PHPAPI char *_xml_zval_strdup(zval *);
+PHPAPI zend_string *xml_utf8_decode(const XML_Char *, int, const XML_Char *);
+PHPAPI zend_string *xml_utf8_encode(const char *, int, const XML_Char *);
 
 #endif /* HAVE_LIBEXPAT */
 
diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index 845cde426e..76b6dd2146 100644
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -71,17 +71,17 @@ PHP_MINIT_FUNCTION(xml);
 PHP_MINFO_FUNCTION(xml);
 static PHP_GINIT_FUNCTION(xml);
 
-static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC);
-static void xml_set_handler(zval **, zval **);
+static void xml_parser_dtor(zend_resource *rsrc TSRMLS_DC);
+static void xml_set_handler(zval *, zval *);
 inline static unsigned short xml_encode_iso_8859_1(unsigned char);
 inline static char xml_decode_iso_8859_1(unsigned short);
 inline static unsigned short xml_encode_us_ascii(unsigned char);
 inline static char xml_decode_us_ascii(unsigned short);
-static zval *xml_call_handler(xml_parser *, zval *, zend_function *, int, zval **);
-static zval *_xml_xmlchar_zval(const XML_Char *, int, const XML_Char *);
+static void xml_call_handler(xml_parser *, zval *, zend_function *, int, zval *, zval *);
+static void _xml_xmlchar_zval(const XML_Char *, int, const XML_Char *, zval *);
 static int _xml_xmlcharlen(const XML_Char *);
 static void _xml_add_to_info(xml_parser *parser,char *name);
-inline static char *_xml_decode_tag(xml_parser *parser, const char *tag);
+inline static zend_string *_xml_decode_tag(xml_parser *parser, const char *tag);
 
 void _xml_startElementHandler(void *, const XML_Char *, const XML_Char **);
 void _xml_endElementHandler(void *, const XML_Char *);
@@ -373,53 +373,21 @@ PHP_MINFO_FUNCTION(xml)
 /* }}} */
 
 /* {{{ extension-internal functions */
-static zval *_xml_resource_zval(long value)
-{
-	zval *ret;
-	TSRMLS_FETCH();
-
-	MAKE_STD_ZVAL(ret);
-
-	Z_TYPE_P(ret) = IS_RESOURCE;
-	Z_LVAL_P(ret) = value;
-
-	zend_list_addref(value);
-
-	return ret;
-}
-
-static zval *_xml_string_zval(const char *str)
-{
-	zval *ret;
-	int len = strlen(str);
-	MAKE_STD_ZVAL(ret);
-
-	Z_TYPE_P(ret) = IS_STRING;
-	Z_STRLEN_P(ret) = len;
-	Z_STRVAL_P(ret) = estrndup(str, len);
-	return ret;
-}
 
-static zval *_xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding)
+static void _xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding, zval *ret)
 {
-	zval *ret;
-	MAKE_STD_ZVAL(ret);
-	
 	if (s == NULL) {
 		ZVAL_FALSE(ret);
-		return ret;
 	}
 	if (len == 0) {
 		len = _xml_xmlcharlen(s);
 	}
-	Z_TYPE_P(ret) = IS_STRING;
-	Z_STRVAL_P(ret) = xml_utf8_decode(s, len, &Z_STRLEN_P(ret), encoding);
-	return ret;
+	ZVAL_STRINGL(ret, (char *)s, len);
 }
 /* }}} */
 
 /* {{{ xml_parser_dtor() */
-static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void xml_parser_dtor(zend_resource *rsrc TSRMLS_DC)
 {
 	xml_parser *parser = (xml_parser *)rsrc->ptr;
 	
@@ -432,43 +400,43 @@ static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 			efree(parser->ltags[ inx ]);
 		efree(parser->ltags);
 	}
-	if (parser->startElementHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->startElementHandler)) {
 		zval_ptr_dtor(&parser->startElementHandler);
 	}
-	if (parser->endElementHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->endElementHandler)) {
 		zval_ptr_dtor(&parser->endElementHandler);
 	}
-	if (parser->characterDataHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->characterDataHandler)) {
 		zval_ptr_dtor(&parser->characterDataHandler);
 	}
-	if (parser->processingInstructionHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->processingInstructionHandler)) {
 		zval_ptr_dtor(&parser->processingInstructionHandler);
 	}
-	if (parser->defaultHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->defaultHandler)) {
 		zval_ptr_dtor(&parser->defaultHandler);
 	}
-	if (parser->unparsedEntityDeclHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->unparsedEntityDeclHandler)) {
 		zval_ptr_dtor(&parser->unparsedEntityDeclHandler);
 	}
-	if (parser->notationDeclHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->notationDeclHandler)) {
 		zval_ptr_dtor(&parser->notationDeclHandler);
 	}
-	if (parser->externalEntityRefHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->externalEntityRefHandler)) {
 		zval_ptr_dtor(&parser->externalEntityRefHandler);
 	}
-	if (parser->unknownEncodingHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->unknownEncodingHandler)) {
 		zval_ptr_dtor(&parser->unknownEncodingHandler);
 	}
-	if (parser->startNamespaceDeclHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->startNamespaceDeclHandler)) {
 		zval_ptr_dtor(&parser->startNamespaceDeclHandler);
 	}
-	if (parser->endNamespaceDeclHandler) {
+	if (!ZVAL_IS_UNDEF(&parser->endNamespaceDeclHandler)) {
 		zval_ptr_dtor(&parser->endNamespaceDeclHandler);
 	}
 	if (parser->baseURI) {
 		efree(parser->baseURI);
 	}
-	if (parser->object) {
+	if (!ZVAL_IS_UNDEF(&parser->object)) {
 		zval_ptr_dtor(&parser->object);
 	}
 
@@ -477,88 +445,65 @@ static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 /* }}} */
 
 /* {{{ xml_set_handler() */
-static void xml_set_handler(zval **handler, zval **data)
+static void xml_set_handler(zval *handler, zval *data)
 {
 	/* If we have already a handler, release it */
-	if (*handler) {
+	if (handler) {
 		zval_ptr_dtor(handler);
 	}
 
 	/* IS_ARRAY might indicate that we're using array($obj, 'method') syntax */
-	if (Z_TYPE_PP(data) != IS_ARRAY && Z_TYPE_PP(data) != IS_OBJECT) {
-
+	if (Z_TYPE_P(data) != IS_ARRAY && Z_TYPE_P(data) != IS_OBJECT) {
 		convert_to_string_ex(data);
-		if (Z_STRLEN_PP(data) == 0) {
-			*handler = NULL;
+		if (Z_STRLEN_P(data) == 0) {
+			ZVAL_UNDEF(handler);
 			return;
 		}
 	}
 
-	zval_add_ref(data);
-
-	*handler = *data;
+	ZVAL_COPY(handler, data);
 }
 /* }}} */
 
 /* {{{ xml_call_handler() */
-static zval *xml_call_handler(xml_parser *parser, zval *handler, zend_function *function_ptr, int argc, zval **argv)
+static void xml_call_handler(xml_parser *parser, zval *handler, zend_function *function_ptr, int argc, zval *argv, zval *retval)
 {
 	int i;	
 	TSRMLS_FETCH();
 
 	if (parser && handler && !EG(exception)) {
-		zval ***args;
-		zval *retval;
 		int result;
 		zend_fcall_info fci;
 
-		args = safe_emalloc(sizeof(zval **), argc, 0);
-		for (i = 0; i < argc; i++) {
-			args[i] = &argv[i];
-		}
-		
 		fci.size = sizeof(fci);
 		fci.function_table = EG(function_table);
-		fci.function_name = handler;
+		ZVAL_COPY_VALUE(&fci.function_name, handler);
 		fci.symbol_table = NULL;
-		fci.object_ptr = parser->object;
-		fci.retval_ptr_ptr = &retval;
+		fci.object = Z_OBJ(parser->object);
+		fci.retval = retval;
 		fci.param_count = argc;
-		fci.params = args;
+		fci.params = argv;
 		fci.no_separation = 0;
 		/*fci.function_handler_cache = &function_ptr;*/
 
 		result = zend_call_function(&fci, NULL TSRMLS_CC);
 		if (result == FAILURE) {
-			zval **method;
-			zval **obj;
+			zval *method;
+			zval *obj;
 
 			if (Z_TYPE_P(handler) == IS_STRING) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(handler));
-			} else if (zend_hash_index_find(Z_ARRVAL_P(handler), 0, (void **) &obj) == SUCCESS &&
-					   zend_hash_index_find(Z_ARRVAL_P(handler), 1, (void **) &method) == SUCCESS &&
-					   Z_TYPE_PP(obj) == IS_OBJECT &&
-					   Z_TYPE_PP(method) == IS_STRING) {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s::%s()", Z_OBJCE_PP(obj)->name, Z_STRVAL_PP(method));
+			} else if ((obj = zend_hash_index_find(Z_ARRVAL_P(handler), 0)) != NULL &&
+					   (method = zend_hash_index_find(Z_ARRVAL_P(handler), 1)) != NULL &&
+					   Z_TYPE_P(obj) == IS_OBJECT &&
+					   Z_TYPE_P(method) == IS_STRING) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s::%s()", Z_OBJCE_P(obj)->name->val, Z_STRVAL_P(method));
 			} else 
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler");
 		}
-
-		for (i = 0; i < argc; i++) {
-			zval_ptr_dtor(args[i]);
-		}
-		efree(args);
-
-		if (result == FAILURE) {
-			return NULL;
-		} else {
-			return EG(exception) ? NULL : retval;
-		}
-	} else {
-		for (i = 0; i < argc; i++) {
-			zval_ptr_dtor(&argv[i]);
-		}
-		return NULL;
+	} 
+	for (i = 0; i < argc; i++) {
+		zval_ptr_dtor(&argv[i]);
 	}
 }
 /* }}} */
@@ -597,7 +542,7 @@ static xml_encoding *xml_get_encoding(const XML_Char *name)
 	xml_encoding *enc = &xml_encodings[0];
 
 	while (enc && enc->name) {
-		if (strcasecmp(name, enc->name) == 0) {
+		if (strcasecmp((char *)name, (char *)enc->name) == 0) {
 			return enc;
 		}
 		enc++;
@@ -606,16 +551,15 @@ static xml_encoding *xml_get_encoding(const XML_Char *name)
 }
 /* }}} */
 
-/* {{{ xml_utf8_encode */
-PHPAPI char *xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char *encoding)
+/* {{{ xml_utf8_encode() */
+PHPAPI zend_string *xml_utf8_encode(const char *s, int len, const XML_Char *encoding)
 {
 	int pos = len;
-	char *newbuf;
+	zend_string *str;
 	unsigned int c;
 	unsigned short (*encoder)(unsigned char) = NULL;
 	xml_encoding *enc = xml_get_encoding(encoding);
 
-	*newlen = 0;
 	if (enc) {
 		encoder = enc->encoding_function;
 	} else {
@@ -625,64 +569,62 @@ PHPAPI char *xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char
 	if (encoder == NULL) {
 		/* If no encoder function was specified, return the data as-is.
 		 */
-		newbuf = emalloc(len + 1);
-		memcpy(newbuf, s, len);
-		*newlen = len;
-		newbuf[*newlen] = '\0';
-		return newbuf;
+		str = STR_INIT(s, len, 0);
+		return str;
 	}
 	/* This is the theoretical max (will never get beyond len * 2 as long
 	 * as we are converting from single-byte characters, though) */
-	newbuf = safe_emalloc(len, 4, 1);
+	str = STR_ALLOC(len * 4, 0);
+	str->len = 0;
 	while (pos > 0) {
 		c = encoder ? encoder((unsigned char)(*s)) : (unsigned short)(*s);
 		if (c < 0x80) {
-			newbuf[(*newlen)++] = (char) c;
+			str->val[str->len++] = (char) c;
 		} else if (c < 0x800) {
-			newbuf[(*newlen)++] = (0xc0 | (c >> 6));
-			newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
+			str->val[str->len++] = (0xc0 | (c >> 6));
+			str->val[str->len++] = (0x80 | (c & 0x3f));
 		} else if (c < 0x10000) {
-			newbuf[(*newlen)++] = (0xe0 | (c >> 12));
-			newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
-			newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
+			str->val[str->len++] = (0xe0 | (c >> 12));
+			str->val[str->len++] = (0xc0 | ((c >> 6) & 0x3f));
+			str->val[str->len++] = (0x80 | (c & 0x3f));
 		} else if (c < 0x200000) {
-			newbuf[(*newlen)++] = (0xf0 | (c >> 18));
-			newbuf[(*newlen)++] = (0xe0 | ((c >> 12) & 0x3f));
-			newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
-			newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
+			str->val[str->len++] = (0xf0 | (c >> 18));
+			str->val[str->len++] = (0xe0 | ((c >> 12) & 0x3f));
+			str->val[str->len++] = (0xc0 | ((c >> 6) & 0x3f));
+			str->val[str->len++] = (0x80 | (c & 0x3f));
 		}
 		pos--;
 		s++;
 	}
-	newbuf[*newlen] = 0;
-	newbuf = erealloc(newbuf, (*newlen)+1);
-	return newbuf;
+	str->val[str->len] = '\0';
+	str = STR_REALLOC(str, str->len, 0);
+	return str;
 }
 /* }}} */
 
-/* {{{ xml_utf8_decode */
-PHPAPI char *xml_utf8_decode(const XML_Char *s, int len, int *newlen, const XML_Char *encoding)
+/* {{{ xml_utf8_decode() */
+PHPAPI zend_string *xml_utf8_decode(const XML_Char *s, int len, const XML_Char *encoding)
 {
 	size_t pos = 0;
-	char *newbuf = emalloc(len + 1);
 	unsigned int c;
 	char (*decoder)(unsigned short) = NULL;
 	xml_encoding *enc = xml_get_encoding(encoding);
+	zend_string *str;
 
-	*newlen = 0;
 	if (enc) {
 		decoder = enc->decoding_function;
 	}
+
 	if (decoder == NULL) {
 		/* If the target encoding was unknown, or no decoder function
 		 * was specified, return the UTF-8-encoded data as-is.
 		 */
-		memcpy(newbuf, s, len);
-		*newlen = len;
-		newbuf[*newlen] = '\0';
-		return newbuf;
+		str = STR_INIT((char *)s, len, 0);
+		return str;
 	}
 
+	str = STR_ALLOC(len, 0);
+	str->len = 0;
 	while (pos < (size_t)len) {
 		int status = FAILURE;
 		c = php_next_utf8_char((const unsigned char*)s, (size_t) len, &pos, &status);
@@ -691,14 +633,14 @@ PHPAPI char *xml_utf8_decode(const XML_Char *s, int len, int *newlen, const XML_
 			c = '?';
 		}
 
-		newbuf[*newlen] = decoder ? decoder(c) : c;
-		++*newlen;
+		str->val[str->len++] = decoder ? decoder(c) : c;
 	}
-	if (*newlen < len) {
-		newbuf = erealloc(newbuf, *newlen + 1);
+	str->val[str->len] = '\0';
+	if (str->len < len) {
+		str = STR_REALLOC(str, str->len, 0);
 	}
-	newbuf[*newlen] = '\0';
-	return newbuf;
+
+	return str;
 }
 /* }}} */
 
@@ -728,42 +670,39 @@ PHPAPI char *_xml_zval_strdup(zval *val)
 }
 /* }}} */
 
-/* {{{ _xml_add_to_info */
+/* {{{ _xml_add_to_info() */
 static void _xml_add_to_info(xml_parser *parser,char *name)
 {
-	zval **element, *values;
+	zval *element;
 
-	if (! parser->info) {
+	if (ZVAL_IS_UNDEF(&parser->info)) {
 		return;
 	}
 
-	if (zend_hash_find(Z_ARRVAL_P(parser->info),name,strlen(name) + 1,(void **) &element) == FAILURE) {
-		MAKE_STD_ZVAL(values);
-		
-		array_init(values);
-		
-		zend_hash_update(Z_ARRVAL_P(parser->info), name, strlen(name)+1, (void *) &values, sizeof(zval*), (void **) &element);
+	if ((element = zend_hash_str_find(Z_ARRVAL(parser->info),name, strlen(name))) == NULL) {
+		zval values;
+		array_init(&values);
+		element = zend_hash_str_update(Z_ARRVAL(parser->info), name, strlen(name), &values);
 	} 
 			
-	add_next_index_long(*element,parser->curtag);
+	add_next_index_long(element, parser->curtag);
 	
 	parser->curtag++;
 }
 /* }}} */
 
 /* {{{ _xml_decode_tag() */
-static char *_xml_decode_tag(xml_parser *parser, const char *tag)
+static zend_string *_xml_decode_tag(xml_parser *parser, const char *tag)
 {
-	char *newstr;
-	int out_len;
+	zend_string *str;
 
-	newstr = xml_utf8_decode(tag, strlen(tag), &out_len, parser->target_encoding);
+	str = xml_utf8_decode((const XML_Char *)tag, strlen(tag), parser->target_encoding);
 
 	if (parser->case_folding) {
-		php_strtoupper(newstr, out_len);
+		php_strtoupper(str->val, str->len);
 	}
 
-	return newstr;
+	return str;
 }
 /* }}} */
 
@@ -772,90 +711,83 @@ void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Ch
 {
 	xml_parser *parser = (xml_parser *)userData;
 	const char **attrs = (const char **) attributes;
-	char *tag_name;
-	char *att, *val;
-	int val_len;
-	zval *retval, *args[3];
+	zend_string *att, *tag_name, *val;
+	zval retval, args[3];
 
 	if (parser) {
 		parser->level++;
 
-		tag_name = _xml_decode_tag(parser, name);
+		tag_name = _xml_decode_tag(parser, (const char *)name);
 
-		if (parser->startElementHandler) {
-			args[0] = _xml_resource_zval(parser->index);
-			args[1] = _xml_string_zval(((char *) tag_name) + parser->toffset);
-			MAKE_STD_ZVAL(args[2]);
-			array_init(args[2]);
+		if (!ZVAL_IS_UNDEF(&parser->startElementHandler)) {
+			ZVAL_COPY(&args[0], &parser->index);
+			ZVAL_STRING(&args[1], tag_name->val + parser->toffset);
+			array_init(&args[2]);
 
 			while (attributes && *attributes) {
-				att = _xml_decode_tag(parser, attributes[0]);
-				val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
+				att = _xml_decode_tag(parser, (const char *)attributes[0]);
+				val = xml_utf8_decode(attributes[1], strlen((char *)attributes[1]), parser->target_encoding);
 
 				// TODO: avoid reallocation ???
-				add_assoc_stringl(args[2], att, val, val_len);
-				efree(val);
+				add_assoc_str(&args[2], att->val, val);
 
 				attributes += 2;
 
-				efree(att);
+				STR_RELEASE(att);
 			}
 			
-			if ((retval = xml_call_handler(parser, parser->startElementHandler, parser->startElementPtr, 3, args))) {
+			xml_call_handler(parser, &parser->startElementHandler, parser->startElementPtr, 3, args, &retval);
+			if (!ZVAL_IS_UNDEF(&retval)) {
 				zval_ptr_dtor(&retval);
 			}
 		} 
 
-		if (parser->data) {
+		if (!ZVAL_IS_UNDEF(&parser->data)) {
 			if (parser->level <= XML_MAXLEVEL)  {
-				zval *tag, *atr;
+				zval tag, atr;
 				int atcnt = 0;
 
-				MAKE_STD_ZVAL(tag);
-				MAKE_STD_ZVAL(atr);
+				array_init(&tag);
+				array_init(&atr);
 
-				array_init(tag);
-				array_init(atr);
+				_xml_add_to_info(parser, tag_name->val + parser->toffset);
 
-				_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
+				add_assoc_string(&tag, "tag", tag_name->val + parser->toffset); /* cast to avoid gcc-warning */
+				add_assoc_string(&tag, "type", "open");
+				add_assoc_long(&tag, "level", parser->level);
 
-				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
-				add_assoc_string(tag,"type","open");
-				add_assoc_long(tag,"level",parser->level);
-
-				parser->ltags[parser->level-1] = estrdup(tag_name);
+				parser->ltags[parser->level-1] = estrdup(tag_name->val);
 				parser->lastwasopen = 1;
 
 				attributes = (const XML_Char **) attrs;
 
 				while (attributes && *attributes) {
-					att = _xml_decode_tag(parser, attributes[0]);
-					val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
+					att = _xml_decode_tag(parser, (const char *)attributes[0]);
+					val = xml_utf8_decode(attributes[1], strlen((char *)attributes[1]), parser->target_encoding);
 
 					// TODO: avoid reallocation ???
-					add_assoc_stringl(atr,att,val,val_len);
-					efree(val);
+					add_assoc_str(&atr, att->val, val);
 
 					atcnt++;
 					attributes += 2;
 
-					efree(att);
+					STR_RELEASE(att);
 				}
 
 				if (atcnt) {
-					zend_hash_add(Z_ARRVAL_P(tag),"attributes",sizeof("attributes"),&atr,sizeof(zval*),NULL);
+					zend_hash_str_add(Z_ARRVAL(tag), "attributes", sizeof("attributes") - 1, &atr);
 				} else {
 					zval_ptr_dtor(&atr);
 				}
 
-				zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),(void *) &parser->ctag);
+				parser->ctag = zend_hash_next_index_insert(Z_ARRVAL(parser->data), &tag);
 			} else if (parser->level == (XML_MAXLEVEL + 1)) {
 				TSRMLS_FETCH();
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Maximum depth exceeded - Results truncated");
 			}
 		}
 
-		efree(tag_name);
+		STR_RELEASE(tag_name);
 	}
 }
 /* }}} */
@@ -864,45 +796,44 @@ void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Ch
 void _xml_endElementHandler(void *userData, const XML_Char *name)
 {
 	xml_parser *parser = (xml_parser *)userData;
-	char *tag_name;
+	zend_string *tag_name;
 
 	if (parser) {
-		zval *retval, *args[2];
+		zval retval, args[2];
 
-		tag_name = _xml_decode_tag(parser, name);
+		tag_name = _xml_decode_tag(parser, (const char *)name);
 
-		if (parser->endElementHandler) {
-			args[0] = _xml_resource_zval(parser->index);
-			args[1] = _xml_string_zval(((char *) tag_name) + parser->toffset);
+		if (!ZVAL_IS_UNDEF(&parser->endElementHandler)) {
+			ZVAL_COPY(&args[0], &parser->index);
+			ZVAL_STRING(&args[1], (tag_name->val) + parser->toffset);
 
-			if ((retval = xml_call_handler(parser, parser->endElementHandler, parser->endElementPtr, 2, args))) {
+			xml_call_handler(parser, &parser->endElementHandler, parser->endElementPtr, 2, args, &retval);
+			if (ZVAL_IS_UNDEF(&retval)) {
 				zval_ptr_dtor(&retval);
 			}
 		} 
 
-		if (parser->data) {
-			zval *tag;
+		if (!ZVAL_IS_UNDEF(&parser->data)) {
+			zval tag;
 
 			if (parser->lastwasopen) {
-				add_assoc_string(*(parser->ctag),"type","complete");
+				add_assoc_string(parser->ctag, "type", "complete");
 			} else {
-				MAKE_STD_ZVAL(tag);
-
-				array_init(tag);
+				array_init(&tag);
 				  
-				_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
+				_xml_add_to_info(parser, tag_name->val + parser->toffset);
 
-				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
-				add_assoc_string(tag,"type","close");
-				add_assoc_long(tag,"level",parser->level);
+				add_assoc_string(&tag, "tag", tag_name->val + parser->toffset); /* cast to avoid gcc-warning */
+				add_assoc_string(&tag, "type", "close");
+				add_assoc_long(&tag, "level", parser->level);
 				  
-				zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
+				zend_hash_next_index_insert(Z_ARRVAL(parser->data), &tag);
 			}
 
 			parser->lastwasopen = 0;
 		}
 
-		efree(tag_name);
+		STR_RELEASE(tag_name);
 
 		if ((parser->ltags) && (parser->level <= XML_MAXLEVEL)) {
 			efree(parser->ltags[parser->level-1]);
@@ -919,33 +850,32 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 	xml_parser *parser = (xml_parser *)userData;
 
 	if (parser) {
-		zval *retval, *args[2];
+		zval retval, args[2];
 
-		if (parser->characterDataHandler) {
-			args[0] = _xml_resource_zval(parser->index);
-			args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
-			if ((retval = xml_call_handler(parser, parser->characterDataHandler, parser->characterDataPtr, 2, args))) {
+		if (!ZVAL_IS_UNDEF(&parser->characterDataHandler)) {
+			ZVAL_COPY(&args[0], &parser->index);
+			_xml_xmlchar_zval(s, len, parser->target_encoding, &args[1]);
+			xml_call_handler(parser, &parser->characterDataHandler, parser->characterDataPtr, 2, args, &retval);
+			if (!ZVAL_IS_UNDEF(&retval)) {
 				zval_ptr_dtor(&retval);
 			}
 		} 
 
-		if (parser->data) {
+		if (!ZVAL_IS_UNDEF(&parser->data)) {
 			int i;
 			int doprint = 0;
-
-			char *decoded_value;
-			int decoded_len;
-			
-			decoded_value = xml_utf8_decode(s,len,&decoded_len,parser->target_encoding);
-			for (i = 0; i < decoded_len; i++) {
-				switch (decoded_value[i]) {
-				case ' ':
-				case '\t':
-				case '\n':
-					continue;
-				default:
-					doprint = 1;
-					break;
+			zend_string *decoded_value;
+
+			decoded_value = xml_utf8_decode(s, len, parser->target_encoding);
+			for (i = 0; i < decoded_value->len; i++) {
+				switch (decoded_value->val[i]) {
+					case ' ':
+					case '\t':
+					case '\n':
+						continue;
+					default:
+						doprint = 1;
+						break;
 				}
 				if (doprint) {
 					break;
@@ -953,65 +883,58 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 			}
 			if (doprint || (! parser->skipwhite)) {
 				if (parser->lastwasopen) {
-					zval **myval;
+					zval *myval;
 					
 					/* check if the current tag already has a value - if yes append to that! */
-					if (zend_hash_find(Z_ARRVAL_PP(parser->ctag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
-						int newlen = Z_STRLEN_PP(myval) + decoded_len;
-						Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
-						strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
-						Z_STRLEN_PP(myval) += decoded_len;
-						efree(decoded_value);
+					if ((myval = zend_hash_str_find(Z_ARRVAL_P(parser->ctag), "value", sizeof("value") - 1))) {
+						int newlen = Z_STRLEN_P(myval) + decoded_value->len;
+						Z_STR_P(myval) = STR_REALLOC(Z_STR_P(myval), newlen, 0);
+						strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - decoded_value->len,
+								decoded_value->val, decoded_value->len + 1);
+						STR_RELEASE(decoded_value);
 					} else {
 						// TODO: avoid reallocation ???
-						add_assoc_string(*(parser->ctag),"value",decoded_value);
-						efree(decoded_value);
+						add_assoc_str(parser->ctag, "value", decoded_value);
 					}
 					
 				} else {
-					zval *tag;
-					zval **curtag, **mytype, **myval;
-					HashPosition hpos=NULL;
-
-					zend_hash_internal_pointer_end_ex(Z_ARRVAL_P(parser->data), &hpos);
-
-					if (hpos && (zend_hash_get_current_data_ex(Z_ARRVAL_P(parser->data), (void **) &curtag, &hpos) == SUCCESS)) {
-						if (zend_hash_find(Z_ARRVAL_PP(curtag),"type",sizeof("type"),(void **) &mytype) == SUCCESS) {
-							if (!strcmp(Z_STRVAL_PP(mytype), "cdata")) {
-								if (zend_hash_find(Z_ARRVAL_PP(curtag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
-									int newlen = Z_STRLEN_PP(myval) + decoded_len;
-									Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
-									strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
-									Z_STRLEN_PP(myval) += decoded_len;
-									efree(decoded_value);
+					zval tag;
+					zval *curtag, *mytype, *myval;
+
+					ZEND_HASH_FOREACH_VAL(Z_ARRVAL(parser->data), curtag) {
+						if ((mytype = zend_hash_str_find(Z_ARRVAL_P(curtag),"type", sizeof("type") - 1))) {
+							if (!strcmp(Z_STRVAL_P(mytype), "cdata")) {
+								if ((myval = zend_hash_str_find(Z_ARRVAL_P(curtag), "value", sizeof("value") - 1))) {
+									int newlen = Z_STRLEN_P(myval) + decoded_value->len;
+									Z_STR_P(myval) = STR_REALLOC(Z_STR_P(myval), newlen, 0);
+									strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - decoded_value->len,
+											decoded_value->val, decoded_value->len + 1);
+									STR_RELEASE(decoded_value);
 									return;
 								}
 							}
 						}
-					}
+					} ZEND_HASH_FOREACH_END();
 
 					if (parser->level <= XML_MAXLEVEL) {
-						MAKE_STD_ZVAL(tag);
-
-						array_init(tag);
+						array_init(&tag);
 
 						_xml_add_to_info(parser,parser->ltags[parser->level-1] + parser->toffset);
 
-						add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset);
+						add_assoc_string(&tag, "tag", parser->ltags[parser->level-1] + parser->toffset);
 						// TODO: avoid reallocation ???
-						add_assoc_string(tag,"value",decoded_value);
-						efree(decoded_value);
-						add_assoc_string(tag,"type","cdata");
-						add_assoc_long(tag,"level",parser->level);
+						add_assoc_str(&tag, "value", decoded_value);
+						add_assoc_string(&tag, "type", "cdata");
+						add_assoc_long(&tag, "level", parser->level);
 
-						zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
+						zend_hash_next_index_insert(Z_ARRVAL(parser->data), &tag);
 					} else if (parser->level == (XML_MAXLEVEL + 1)) {
 						TSRMLS_FETCH();
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Maximum depth exceeded - Results truncated");
 					}
 				}
 			} else {
-				efree(decoded_value);
+				STR_RELEASE(decoded_value);
 			}
 		}
 	}
@@ -1023,13 +946,14 @@ void _xml_processingInstructionHandler(void *userData, const XML_Char *target, c
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->processingInstructionHandler) {
-		zval *retval, *args[3];
+	if (parser && !ZVAL_IS_UNDEF(&parser->processingInstructionHandler)) {
+		zval retval, args[3];
 
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(target, 0, parser->target_encoding);
-		args[2] = _xml_xmlchar_zval(data, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->processingInstructionHandler, parser->processingInstructionPtr, 3, args))) {
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(target, 0, parser->target_encoding, &args[1]);
+		_xml_xmlchar_zval(data, 0, parser->target_encoding, &args[2]);
+		xml_call_handler(parser, &parser->processingInstructionHandler, parser->processingInstructionPtr, 3, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1041,12 +965,13 @@ void _xml_defaultHandler(void *userData, const XML_Char *s, int len)
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->defaultHandler) {
-		zval *retval, *args[2];
+	if (parser && !ZVAL_IS_UNDEF(&parser->defaultHandler)) {
+		zval retval, args[2];
 
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->defaultHandler, parser->defaultPtr, 2, args))) {
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(s, len, parser->target_encoding, &args[1]);
+		xml_call_handler(parser, &parser->defaultHandler, parser->defaultPtr, 2, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1063,16 +988,17 @@ void _xml_unparsedEntityDeclHandler(void *userData,
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->unparsedEntityDeclHandler) {
-		zval *retval, *args[6];
-
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(entityName, 0, parser->target_encoding);
-		args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
-		args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
-		args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
-		args[5] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->unparsedEntityDeclHandler, parser->unparsedEntityDeclPtr, 6, args))) {
+	if (parser && !ZVAL_IS_UNDEF(&parser->unparsedEntityDeclHandler)) {
+		zval retval, args[6];
+
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(entityName, 0, parser->target_encoding, &args[1]);
+		_xml_xmlchar_zval(base, 0, parser->target_encoding, &args[2]);
+		_xml_xmlchar_zval(systemId, 0, parser->target_encoding, &args[3]);
+		_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
+		_xml_xmlchar_zval(notationName, 0, parser->target_encoding, &args[5]);
+		xml_call_handler(parser, &parser->unparsedEntityDeclHandler, parser->unparsedEntityDeclPtr, 6, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1088,15 +1014,16 @@ void _xml_notationDeclHandler(void *userData,
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->notationDeclHandler) {
-		zval *retval, *args[5];
+	if (parser && !ZVAL_IS_UNDEF(&parser->notationDeclHandler)) {
+		zval retval, args[5];
 
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
-		args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
-		args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
-		args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->notationDeclHandler, parser->notationDeclPtr, 5, args))) {
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(notationName, 0, parser->target_encoding, &args[1]);
+		_xml_xmlchar_zval(base, 0, parser->target_encoding, &args[2]);
+		_xml_xmlchar_zval(systemId, 0, parser->target_encoding, &args[3]);
+		_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
+		xml_call_handler(parser, &parser->notationDeclHandler, parser->notationDeclPtr, 5, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1113,18 +1040,18 @@ int _xml_externalEntityRefHandler(XML_Parser parserPtr,
 	xml_parser *parser = XML_GetUserData(parserPtr);
 	int ret = 0; /* abort if no handler is set (should be configurable?) */
 
-	if (parser && parser->externalEntityRefHandler) {
-		zval *retval, *args[5];
-
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(openEntityNames, 0, parser->target_encoding);
-		args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
-		args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
-		args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->externalEntityRefHandler, parser->externalEntityRefPtr, 5, args))) {
-			convert_to_long(retval);
-			ret = Z_LVAL_P(retval);
-			efree(retval);
+	if (parser && !ZVAL_IS_UNDEF(&parser->externalEntityRefHandler)) {
+		zval retval, args[5];
+
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(openEntityNames, 0, parser->target_encoding, &args[1]);
+		_xml_xmlchar_zval(base, 0, parser->target_encoding, &args[2]);
+		_xml_xmlchar_zval(systemId, 0, parser->target_encoding, &args[3]);
+		_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
+		xml_call_handler(parser, &parser->externalEntityRefHandler, parser->externalEntityRefPtr, 5, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			convert_to_long(&retval);
+			ret = Z_LVAL(retval);
 		} else {
 			ret = 0;
 		}
@@ -1138,13 +1065,14 @@ void _xml_startNamespaceDeclHandler(void *userData,const XML_Char *prefix, const
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->startNamespaceDeclHandler) {
-		zval *retval, *args[3];
+	if (parser && !ZVAL_IS_UNDEF(&parser->startNamespaceDeclHandler)) {
+		zval retval, args[3];
 
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
-		args[2] = _xml_xmlchar_zval(uri, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->startNamespaceDeclHandler, parser->startNamespaceDeclPtr, 3, args))) {
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(prefix, 0, parser->target_encoding, &args[1]);
+		_xml_xmlchar_zval(uri, 0, parser->target_encoding, &args[2]);
+		xml_call_handler(parser, &parser->startNamespaceDeclHandler, parser->startNamespaceDeclPtr, 3, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1156,12 +1084,13 @@ void _xml_endNamespaceDeclHandler(void *userData, const XML_Char *prefix)
 {
 	xml_parser *parser = (xml_parser *)userData;
 
-	if (parser && parser->endNamespaceDeclHandler) {
-		zval *retval, *args[2];
+	if (parser && !ZVAL_IS_UNDEF(&parser->endNamespaceDeclHandler)) {
+		zval retval, args[2];
 
-		args[0] = _xml_resource_zval(parser->index);
-		args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
-		if ((retval = xml_call_handler(parser, parser->endNamespaceDeclHandler, parser->endNamespaceDeclPtr, 2, args))) {
+		ZVAL_COPY(&args[0], &parser->index);
+		_xml_xmlchar_zval(prefix, 0, parser->target_encoding, &args[1]);
+		xml_call_handler(parser, &parser->endNamespaceDeclHandler, parser->endNamespaceDeclPtr, 2, args, &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 	}
@@ -1218,13 +1147,12 @@ static void php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAMETERS, int ns_supp
 
 	parser->target_encoding = encoding;
 	parser->case_folding = 1;
-	parser->object = NULL;
 	parser->isparsing = 0;
 
 	XML_SetUserData(parser->parser, parser);
 
-	ZEND_REGISTER_RESOURCE(return_value, parser,le_xml_parser);
-	parser->index = Z_LVAL_P(return_value);
+	ZEND_REGISTER_RESOURCE(return_value, parser, le_xml_parser);
+	ZVAL_COPY(&parser->index, return_value);
 }
 /* }}} */
 
@@ -1255,10 +1183,10 @@ PHP_FUNCTION(xml_set_object)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	/* please leave this commented - or ask thies@thieso.net before doing it (again) */
-	if (parser->object) {
+	if (!ZVAL_IS_UNDEF(&parser->object)) {
 		zval_ptr_dtor(&parser->object);
 	}
 
@@ -1267,8 +1195,7 @@ PHP_FUNCTION(xml_set_object)
 	zval_add_ref(&parser->object); 
 #endif */
 
-	ALLOC_ZVAL(parser->object);
-	MAKE_COPY_ZVAL(&mythis, parser->object);
+	ZVAL_COPY(&parser->object, mythis);
 
 	RETVAL_TRUE;
 }
@@ -1279,13 +1206,13 @@ PHP_FUNCTION(xml_set_object)
 PHP_FUNCTION(xml_set_element_handler)
 {
 	xml_parser *parser;
-	zval *pind, **shdl, **ehdl;
+	zval *pind, *shdl, *ehdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZZ", &pind, &shdl, &ehdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz", &pind, &shdl, &ehdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->startElementHandler, shdl);
 	xml_set_handler(&parser->endElementHandler, ehdl);
@@ -1299,13 +1226,13 @@ PHP_FUNCTION(xml_set_element_handler)
 PHP_FUNCTION(xml_set_character_data_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->characterDataHandler, hdl);
 	XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
@@ -1318,13 +1245,13 @@ PHP_FUNCTION(xml_set_character_data_handler)
 PHP_FUNCTION(xml_set_processing_instruction_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->processingInstructionHandler, hdl);
 	XML_SetProcessingInstructionHandler(parser->parser, _xml_processingInstructionHandler);
@@ -1337,12 +1264,13 @@ PHP_FUNCTION(xml_set_processing_instruction_handler)
 PHP_FUNCTION(xml_set_default_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->defaultHandler, hdl);
 	XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
@@ -1355,13 +1283,13 @@ PHP_FUNCTION(xml_set_default_handler)
 PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->unparsedEntityDeclHandler, hdl);
 	XML_SetUnparsedEntityDeclHandler(parser->parser, _xml_unparsedEntityDeclHandler);
@@ -1374,12 +1302,12 @@ PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)
 PHP_FUNCTION(xml_set_notation_decl_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->notationDeclHandler, hdl);
 	XML_SetNotationDeclHandler(parser->parser, _xml_notationDeclHandler);
@@ -1392,12 +1320,12 @@ PHP_FUNCTION(xml_set_notation_decl_handler)
 PHP_FUNCTION(xml_set_external_entity_ref_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->externalEntityRefHandler, hdl);
 	XML_SetExternalEntityRefHandler(parser->parser, (void *) _xml_externalEntityRefHandler);
@@ -1410,13 +1338,13 @@ PHP_FUNCTION(xml_set_external_entity_ref_handler)
 PHP_FUNCTION(xml_set_start_namespace_decl_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->startNamespaceDeclHandler, hdl);
 	XML_SetStartNamespaceDeclHandler(parser->parser, _xml_startNamespaceDeclHandler);
@@ -1429,13 +1357,13 @@ PHP_FUNCTION(xml_set_start_namespace_decl_handler)
 PHP_FUNCTION(xml_set_end_namespace_decl_handler)
 {
 	xml_parser *parser;
-	zval *pind, **hdl;
+	zval *pind, *hdl;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &pind, &hdl) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	xml_set_handler(&parser->endNamespaceDeclHandler, hdl);
 	XML_SetEndNamespaceDeclHandler(parser->parser, _xml_endNamespaceDeclHandler);
@@ -1456,7 +1384,7 @@ PHP_FUNCTION(xml_parse)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pind, &data, &data_len, &isFinal) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	parser->isparsing = 1;
 	ret = XML_Parse(parser->parser, data, data_len, isFinal);
@@ -1472,28 +1400,29 @@ PHP_FUNCTION(xml_parse)
 PHP_FUNCTION(xml_parse_into_struct)
 {
 	xml_parser *parser;
-	zval *pind, **xdata, **info = NULL;
+	zval *pind, *xdata, *info = NULL;
 	char *data;
 	int data_len, ret;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|Z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz|z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
 		return;
 	}
 	
 	if (info) {	
-		zval_dtor(*info);
-		array_init(*info);
+		zval_ptr_dtor(info);
+		array_init(info);
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
-	zval_dtor(*xdata);
-	array_init(*xdata);
+	ZVAL_DEREF(xdata);
+	zval_ptr_dtor(xdata);
+	array_init(xdata);
 
-	parser->data = *xdata;
+	ZVAL_COPY_VALUE(&parser->data, xdata);
 	
 	if (info) {
-		parser->info = *info;
+		ZVAL_COPY_VALUE(&parser->info, info);
 	}
 	
 	parser->level = 0;
@@ -1521,9 +1450,10 @@ PHP_FUNCTION(xml_get_error_code)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
 
-	RETVAL_LONG((long)XML_GetErrorCode(parser->parser));
+	ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
+
+	RETURN_LONG((long)XML_GetErrorCode(parser->parser));
 }
 /* }}} */
 
@@ -1540,7 +1470,7 @@ PHP_FUNCTION(xml_error_string)
 
 	str = (char *)XML_ErrorString((int)code);
 	if (str) {
-		RETVAL_STRING(str, 1);
+		RETVAL_STRING(str);
 	}
 }
 /* }}} */
@@ -1555,7 +1485,8 @@ PHP_FUNCTION(xml_get_current_line_number)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	RETVAL_LONG(XML_GetCurrentLineNumber(parser->parser));
 }
@@ -1571,7 +1502,8 @@ PHP_FUNCTION(xml_get_current_column_number)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	RETVAL_LONG(XML_GetCurrentColumnNumber(parser->parser));
 }
@@ -1587,7 +1519,8 @@ PHP_FUNCTION(xml_get_current_byte_index)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	RETVAL_LONG(XML_GetCurrentByteIndex(parser->parser));
 }
@@ -1604,18 +1537,16 @@ PHP_FUNCTION(xml_parser_free)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	if (parser->isparsing == 1) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parser cannot be freed while it is parsing.");
 		RETURN_FALSE;
 	}
 
-	if (zend_list_delete(parser->index) == FAILURE) {
-		RETURN_FALSE;
-	}
-
-	RETVAL_TRUE;
+	zend_list_close(Z_RES(parser->index));
+	ZVAL_UNDEF(&parser->index);
+	RETURN_TRUE;
 }
 /* }}} */
 
@@ -1624,33 +1555,34 @@ PHP_FUNCTION(xml_parser_free)
 PHP_FUNCTION(xml_parser_set_option)
 {
 	xml_parser *parser;
-	zval *pind, **val;
+	zval *pind, *val;
 	long opt;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlZ", &pind, &opt, &val) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &pind, &opt, &val) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	switch (opt) {
 		case PHP_XML_OPTION_CASE_FOLDING:
 			convert_to_long_ex(val);
-			parser->case_folding = Z_LVAL_PP(val);
+			parser->case_folding = Z_LVAL_P(val);
 			break;
 		case PHP_XML_OPTION_SKIP_TAGSTART:
 			convert_to_long_ex(val);
-			parser->toffset = Z_LVAL_PP(val);
+			parser->toffset = Z_LVAL_P(val);
 			break;
 		case PHP_XML_OPTION_SKIP_WHITE:
 			convert_to_long_ex(val);
-			parser->skipwhite = Z_LVAL_PP(val);
+			parser->skipwhite = Z_LVAL_P(val);
 			break;
 		case PHP_XML_OPTION_TARGET_ENCODING: {
 			xml_encoding *enc;
 			convert_to_string_ex(val);
-			enc = xml_get_encoding(Z_STRVAL_PP(val));
+			enc = xml_get_encoding(Z_STRVAL_P(val));
 			if (enc == NULL) {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported target encoding \"%s\"", Z_STRVAL_PP(val));
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported target encoding \"%s\"", Z_STRVAL_P(val));
 				RETURN_FALSE;
 			}
 			parser->target_encoding = enc->name;
@@ -1676,14 +1608,14 @@ PHP_FUNCTION(xml_parser_get_option)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pind, &opt) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
+	ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
 
 	switch (opt) {
 		case PHP_XML_OPTION_CASE_FOLDING:
 			RETURN_LONG(parser->case_folding);
 			break;
 		case PHP_XML_OPTION_TARGET_ENCODING:
-			RETURN_STRING(parser->target_encoding, 1);
+			RETURN_STRING((char *)parser->target_encoding);
 			break;
 		default:
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option");
@@ -1700,18 +1632,18 @@ PHP_FUNCTION(xml_parser_get_option)
 PHP_FUNCTION(utf8_encode)
 {
 	char *arg;
-	XML_Char *encoded;
-	int arg_len, len;
+	int arg_len;
+	zend_string *encoded;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
 		return;
 	}
 
-	encoded = xml_utf8_encode(arg, arg_len, &len, "ISO-8859-1");
+	encoded = xml_utf8_encode(arg, arg_len, "ISO-8859-1");
 	if (encoded == NULL) {
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL(encoded, len, 0);
+	RETURN_STR(encoded);
 }
 /* }}} */
 
@@ -1720,18 +1652,18 @@ PHP_FUNCTION(utf8_encode)
 PHP_FUNCTION(utf8_decode)
 {
 	char *arg;
-	XML_Char *decoded;
-	int arg_len, len;
+	int arg_len;
+	zend_string *decoded;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
 		return;
 	}
 
-	decoded = xml_utf8_decode(arg, arg_len, &len, "ISO-8859-1");
+	decoded = xml_utf8_decode(arg, arg_len, "ISO-8859-1");
 	if (decoded == NULL) {
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL(decoded, len, 0);
+	RETURN_STR(decoded);
 }
 /* }}} */