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 *);
/* }}} */
/* {{{ 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;
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);
}
/* }}} */
/* {{{ 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]);
}
}
/* }}} */
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++;
}
/* }}} */
-/* {{{ 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 {
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);
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;
}
/* }}} */
}
/* }}} */
-/* {{{ _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;
}
/* }}} */
{
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);
}
}
/* }}} */
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]);
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;
}
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);
}
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
{
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);
}
}
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;
}
{
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);
}
}
{
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);
}
}
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);
}
/* }}} */
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);
}
zval_add_ref(&parser->object);
#endif */
- ALLOC_ZVAL(parser->object);
- MAKE_COPY_ZVAL(&mythis, parser->object);
+ ZVAL_COPY(&parser->object, mythis);
RETVAL_TRUE;
}
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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;
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));
}
/* }}} */
str = (char *)XML_ErrorString((int)code);
if (str) {
- RETVAL_STRING(str, 1);
+ RETVAL_STRING(str);
}
}
/* }}} */
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));
}
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));
}
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));
}
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;
}
/* }}} */
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;
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");
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);
}
/* }}} */
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);
}
/* }}} */
projects / php / commitdiff