/*

+----------------------------------------------------------------------+

| PHP Version 5 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2014 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Sterling Hughes <sterling@php.net> |

| Marcus Boerger <helly@php.net> |

| Rob Richards <rrichards@php.net> |

+----------------------------------------------------------------------+

*/

/* $Id$ */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "php.h"

#if HAVE_LIBXML && HAVE_SIMPLEXML

#include "php_ini.h"

#include "ext/standard/info.h"

#include "ext/standard/php_string.h"

#include "php_simplexml.h"

#include "php_simplexml_exports.h"

#include "zend_exceptions.h"

#include "zend_interfaces.h"

#include "sxe.h"

#define SXE_ELEMENT_BY_NAME 0

zend_class_entry *sxe_class_entry = NULL;

PHP_SXE_API zend_class_entry *sxe_get_element_class_entry() /* {{{ */

{

return sxe_class_entry;

}

/* }}} */

#define SXE_ME(func, arg_info, flags) PHP_ME(simplexml_element, func, arg_info, flags)

#define SXE_MALIAS(func, alias, arg_info, flags) PHP_MALIAS(simplexml_element, func, alias, arg_info, flags)

#define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)

static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC);

static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data TSRMLS_DC);

static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data TSRMLS_DC);

static zval *sxe_get_value(zval *z, zval *rv TSRMLS_DC);

static void php_sxe_iterator_dtor(zend_object_iterator *iter TSRMLS_DC);

static int php_sxe_iterator_valid(zend_object_iterator *iter TSRMLS_DC);

static zval *php_sxe_iterator_current_data(zend_object_iterator *iter TSRMLS_DC);

static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC);

static void php_sxe_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC);

static void php_sxe_iterator_rewind(zend_object_iterator *iter TSRMLS_DC);

/* {{{ _node_as_zval()

*/

static void _node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE_ITER itertype, char *name, const xmlChar *nsprefix, int isprefix TSRMLS_DC)

{

php_sxe_object *subnode;

subnode = php_sxe_object_new(sxe->zo.ce TSRMLS_CC);

subnode->document = sxe->document;

subnode->document->refcount++;

subnode->iter.type = itertype;

if (name) {

subnode->iter.name = xmlStrdup((xmlChar *)name);

}

if (nsprefix && *nsprefix) {

subnode->iter.nsprefix = xmlStrdup(nsprefix);

subnode->iter.isprefix = isprefix;

}

php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL TSRMLS_CC);

ZVAL_OBJ(value, &subnode->zo);

}

/* }}} */

#define APPEND_PREV_ELEMENT(__c, __v) \

if ((__c) == 1) { \

array_init(return_value); \

add_next_index_zval(return_value, __v); \

}

#define APPEND_CUR_ELEMENT(__c, __v) \

if (++(__c) > 1) { \

add_next_index_zval(return_value, __v); \

}

#define GET_NODE(__s, __n) { \

if ((__s)->node && (__s)->node->node) { \

__n = (__s)->node->node; \

} else { \

__n = NULL; \

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Node no longer exists"); \

} \

}

static xmlNodePtr php_sxe_get_first_node(php_sxe_object *sxe, xmlNodePtr node TSRMLS_DC) /* {{{ */

{

php_sxe_object *intern;

xmlNodePtr retnode = NULL;

if (sxe && sxe->iter.type != SXE_ITER_NONE) {

php_sxe_reset_iterator(sxe, 1 TSRMLS_CC);

if (!Z_ISUNDEF(sxe->iter.data)) {

intern = Z_SXEOBJ_P(&sxe->iter.data);

GET_NODE(intern, retnode)

}

return retnode;

} else {

return node;

}

}

/* }}} */

static inline int match_ns(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name, int prefix) /* {{{ */

{

if (name == NULL && (node->ns == NULL || node->ns->prefix == NULL)) {

return 1;

}

if (node->ns && !xmlStrcmp(prefix ? node->ns->prefix : node->ns->href, name)) {

return 1;

}

return 0;

}

/* }}} */

static xmlNodePtr sxe_get_element_by_offset(php_sxe_object *sxe, long offset, xmlNodePtr node, long *cnt) /* {{{ */

{

long nodendx = 0;

if (sxe->iter.type == SXE_ITER_NONE) {

if (offset == 0) {

if (cnt) {

*cnt = 0;

}

return node;

} else {

return NULL;

}

}

while (node && nodendx <= offset) {

SKIP_TEXT(node)

if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (sxe->iter.type == SXE_ITER_CHILD || (

sxe->iter.type == SXE_ITER_ELEMENT && !xmlStrcmp(node->name, sxe->iter.name))) {

if (nodendx == offset) {

break;

}

nodendx++;

}

}

next_iter:

node = node->next;

}

if (cnt) {

*cnt = nodendx;

}

return node;

}

/* }}} */

static xmlNodePtr sxe_find_element_by_name(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name TSRMLS_DC) /* {{{ */

{

while (node) {

SKIP_TEXT(node)

if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (!xmlStrcmp(node->name, name)) {

return node;

}

}

next_iter:

node = node->next;

}

return NULL;

} /* }}} */

static xmlNodePtr sxe_get_element_by_name(php_sxe_object *sxe, xmlNodePtr node, char **name, SXE_ITER *type TSRMLS_DC) /* {{{ */

{

int orgtype;

xmlNodePtr orgnode = node;

xmlNodePtr retnode = NULL;

if (sxe->iter.type != SXE_ITER_ATTRLIST)

{

orgtype = sxe->iter.type;

if (sxe->iter.type == SXE_ITER_NONE) {

sxe->iter.type = SXE_ITER_CHILD;

}

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

sxe->iter.type = orgtype;

}

if (sxe->iter.type == SXE_ITER_ELEMENT) {

orgnode = sxe_find_element_by_name(sxe, node, sxe->iter.name TSRMLS_CC);

if (!orgnode) {

return NULL;

}

node = orgnode->children;

}

while (node) {

SKIP_TEXT(node)

if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (!xmlStrcmp(node->name, (xmlChar *)*name)) {

if (1||retnode)

{

*type = SXE_ITER_ELEMENT;

return orgnode;

}

retnode = node;

}

}

next_iter:

node = node->next;

}

if (retnode)

{

*type = SXE_ITER_NONE;

*name = NULL;

return retnode;

}

return NULL;

}

/* }}} */

/* {{{ sxe_prop_dim_read()

*/

static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv TSRMLS_DC)

{

php_sxe_object *sxe;

char *name;

xmlNodePtr node;

xmlAttrPtr attr = NULL;

zval tmp_zv;

int nodendx = 0;

int test = 0;

sxe = Z_SXEOBJ_P(object);

if (!member || Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type != SXE_ITER_ATTRLIST) {

attribs = 0;

elements = 1;

} else if (!member) {

/* This happens when the user did: $sxe[]->foo = $value */

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot create unnamed attribute");

return NULL;

}

name = NULL;

} else {

if (Z_TYPE_P(member) != IS_STRING) {

tmp_zv = *member;

zval_copy_ctor(&tmp_zv);

member = &tmp_zv;

convert_to_string(member);

}

name = Z_STRVAL_P(member);

}

GET_NODE(sxe, node);

if (sxe->iter.type == SXE_ITER_ATTRLIST) {

attribs = 1;

elements = 0;

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = (xmlAttrPtr)node;

test = sxe->iter.name != NULL;

} else if (sxe->iter.type != SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = node ? node->properties : NULL;

test = 0;

if (!member && node && node->parent &&

node->parent->type == XML_DOCUMENT_NODE) {

/* This happens when the user did: $sxe[]->foo = $value */

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot create unnamed attribute");

return NULL;

}

}

ZVAL_UNDEF(rv);

if (node) {

if (attribs) {

if (Z_TYPE_P(member) != IS_LONG || sxe->iter.type == SXE_ITER_ATTRLIST) {

if (Z_TYPE_P(member) == IS_LONG) {

while (attr && nodendx <= Z_LVAL_P(member)) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (nodendx == Z_LVAL_P(member)) {

_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

break;

}

nodendx++;

}

attr = attr->next;

}

} else {

while (attr) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)name) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

break;

}

attr = attr->next;

}

}

}

}

if (elements) {

if (!sxe->node) {

php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, node, NULL TSRMLS_CC);

}

if (!member || Z_TYPE_P(member) == IS_LONG) {

long cnt = 0;

xmlNodePtr mynode = node;

if (sxe->iter.type == SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

}

if (sxe->iter.type == SXE_ITER_NONE) {

if (member && Z_LVAL_P(member) > 0) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element %s number %ld when only 0 such elements exist", mynode->name, Z_LVAL_P(member));

}

} else if (member) {

node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);

} else {

node = NULL;

}

if (node) {

_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

} else if (type == BP_VAR_W || type == BP_VAR_RW) {

if (member && cnt < Z_LVAL_P(member)) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element %s number %ld when only %ld such elements exist", mynode->name, Z_LVAL_P(member), cnt);

}

node = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, NULL);

_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

}

} else {

#if SXE_ELEMENT_BY_NAME

int newtype;

GET_NODE(sxe, node);

node = sxe_get_element_by_name(sxe, node, &name, &newtype TSRMLS_CC);

if (node) {

_node_as_zval(sxe, node, rv, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

}

#else

_node_as_zval(sxe, node, rv, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

#endif

}

}

}

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

if (Z_ISUNDEF_P(rv)) {

ZVAL_COPY_VALUE(rv, &EG(uninitialized_zval));

}

return rv;

}

/* }}} */

/* {{{ sxe_property_read()

*/

static zval *sxe_property_read(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)

{

return sxe_prop_dim_read(object, member, 1, 0, type, rv TSRMLS_CC);

}

/* }}} */

/* {{{ sxe_dimension_read()

*/

static zval *sxe_dimension_read(zval *object, zval *offset, int type, zval *rv TSRMLS_DC)

{

return sxe_prop_dim_read(object, offset, 0, 1, type, rv TSRMLS_CC);

}

/* }}} */

/* {{{ change_node_zval()

*/

static void change_node_zval(xmlNodePtr node, zval *value TSRMLS_DC)

{

zval value_copy;

xmlChar *buffer;

int buffer_len;

if (!value)

{

xmlNodeSetContentLen(node, (xmlChar *)"", 0);

return;

}

switch (Z_TYPE_P(value)) {

case IS_LONG:

case IS_FALSE:

case IS_TRUE:

case IS_DOUBLE:

case IS_NULL:

if (Z_REFCOUNT_P(value) > 1) {

value_copy = *value;

zval_copy_ctor(&value_copy);

value = &value_copy;

}

convert_to_string(value);

/* break missing intentionally */

case IS_STRING:

buffer = xmlEncodeEntitiesReentrant(node->doc, (xmlChar *)Z_STRVAL_P(value));

buffer_len = xmlStrlen(buffer);

/* check for NULL buffer in case of memory error in xmlEncodeEntitiesReentrant */

if (buffer) {

xmlNodeSetContentLen(node, buffer, buffer_len);

xmlFree(buffer);

}

if (value == &value_copy) {

zval_dtor(value);

}

break;

default:

php_error_docref(NULL TSRMLS_CC, E_WARNING, "It is not possible to assign complex types to nodes");

break;

}

}

/* }}} */

/* {{{ sxe_property_write()

*/

static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode TSRMLS_DC)

{

php_sxe_object *sxe;

xmlNodePtr node;

xmlNodePtr newnode = NULL;

xmlNodePtr mynode;

xmlNodePtr tempnode;

xmlAttrPtr attr = NULL;

int counter = 0;

int is_attr = 0;

int nodendx = 0;

int test = 0;

int new_value = 0;

long cnt = 0;

int retval = SUCCESS;

zval tmp_zv, trim_zv, zval_copy;

sxe = Z_SXEOBJ_P(object);

if (!member || Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type != SXE_ITER_ATTRLIST) {

attribs = 0;

elements = 1;

} else if (!member) {

/* This happens when the user did: $sxe[] = $value

* and could also be E_PARSE, but we use this only during parsing

* and this is during runtime.

*/

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot create unnamed attribute");

return FAILURE;

}

} else {

if (Z_TYPE_P(member) != IS_STRING) {

trim_zv = *member;

zval_copy_ctor(&trim_zv);

convert_to_string(&trim_zv);

php_trim(Z_STRVAL(trim_zv), Z_STRLEN(trim_zv), NULL, 0, &tmp_zv, 3 TSRMLS_CC);

zval_dtor(&trim_zv);

member = &tmp_zv;

}

if (!Z_STRLEN_P(member)) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot write or create unnamed %s", attribs ? "attribute" : "element");

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

return FAILURE;

}

}

GET_NODE(sxe, node);

if (sxe->iter.type == SXE_ITER_ATTRLIST) {

attribs = 1;

elements = 0;

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = (xmlAttrPtr)node;

test = sxe->iter.name != NULL;

} else if (sxe->iter.type != SXE_ITER_CHILD) {

mynode = node;

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = node ? node->properties : NULL;

test = 0;

if (!member && node && node->parent &&

node->parent->type == XML_DOCUMENT_NODE) {

/* This happens when the user did: $sxe[] = $value

* and could also be E_PARSE, but we use this only during parsing

* and this is during runtime.

*/

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot create unnamed attribute");

return FAILURE;

}

if (attribs && !node && sxe->iter.type == SXE_ITER_ELEMENT) {

node = xmlNewChild(mynode, mynode->ns, sxe->iter.name, NULL);

attr = node->properties;

}

}

mynode = node;

if (value) {

switch (Z_TYPE_P(value)) {

case IS_LONG:

case IS_FALSE:

case IS_TRUE:

case IS_DOUBLE:

case IS_NULL:

if (Z_TYPE_P(value) != IS_STRING) {

ZVAL_DUP(&zval_copy, value);

value = &zval_copy;

convert_to_string(value);

new_value = 1;

}

break;

case IS_STRING:

break;

case IS_OBJECT:

if (Z_OBJCE_P(value) == sxe_class_entry) {

//???

value = sxe_get_value(value, &zval_copy TSRMLS_CC);

//INIT_PZVAL(value);

new_value = 1;

break;

}

/* break is missing intentionally */

default:

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

zend_error(E_WARNING, "It is not yet possible to assign complex types to %s", attribs ? "attributes" : "properties");

return FAILURE;

}

}

if (node) {

if (attribs) {

if (Z_TYPE_P(member) == IS_LONG) {

while (attr && nodendx <= Z_LVAL_P(member)) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (nodendx == Z_LVAL_P(member)) {

is_attr = 1;

++counter;

break;

}

nodendx++;

}

attr = attr->next;

}

} else {

while (attr) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

is_attr = 1;

++counter;

break;

}

attr = attr->next;

}

}

}

if (elements) {

if (!member || Z_TYPE_P(member) == IS_LONG) {

if (node->type == XML_ATTRIBUTE_NODE) {

php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot create duplicate attribute");

return FAILURE;

}

if (sxe->iter.type == SXE_ITER_NONE) {

newnode = node;

++counter;

if (member && Z_LVAL_P(member) > 0) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element %s number %ld when only 0 such elements exist", mynode->name, Z_LVAL_P(member));

retval = FAILURE;

}

} else if (member) {

newnode = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);

if (newnode) {

++counter;

}

}

} else {

node = node->children;

while (node) {

SKIP_TEXT(node);

if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {

newnode = node;

++counter;

}

next_iter:

node = node->next;

}

}

}

if (counter == 1) {

if (is_attr) {

newnode = (xmlNodePtr) attr;

}

if (value) {

while ((tempnode = (xmlNodePtr) newnode->children)) {

xmlUnlinkNode(tempnode);

php_libxml_node_free_resource((xmlNodePtr) tempnode TSRMLS_CC);

}

change_node_zval(newnode, value TSRMLS_CC);

}

} else if (counter > 1) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot assign to an array of nodes (duplicate subnodes or attr detected)");

retval = FAILURE;

} else if (elements) {

if (!node) {

if (!member || Z_TYPE_P(member) == IS_LONG) {

newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);

} else {

newnode = xmlNewTextChild(mynode, mynode->ns, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);

}

} else if (!member || Z_TYPE_P(member) == IS_LONG) {

if (member && cnt < Z_LVAL_P(member)) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element %s number %ld when only %ld such elements exist", mynode->name, Z_LVAL_P(member), cnt);

retval = FAILURE;

}

newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);

}

} else if (attribs) {

if (Z_TYPE_P(member) == IS_LONG) {

php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot change attribute number %ld when only %d attributes exist", Z_LVAL_P(member), nodendx);

retval = FAILURE;

} else {

newnode = (xmlNodePtr)xmlNewProp(node, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);

}

}

}

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

if (pnewnode) {

*pnewnode = newnode;

}

if (new_value) {

zval_ptr_dtor(value);

}

return retval;

}

/* }}} */

/* {{{ sxe_property_write()

*/

static void sxe_property_write(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)

{

sxe_prop_dim_write(object, member, value, 1, 0, NULL TSRMLS_CC);

}

/* }}} */

/* {{{ sxe_dimension_write()

*/

static void sxe_dimension_write(zval *object, zval *offset, zval *value TSRMLS_DC)

{

sxe_prop_dim_write(object, offset, value, 0, 1, NULL TSRMLS_CC);

}

/* }}} */

static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, zend_uint cache_slot TSRMLS_DC) /* {{{ */

{

php_sxe_object *sxe;

xmlNodePtr node;

zval ret;

char *name;

SXE_ITER type;

sxe = Z_SXEOBJ_P(object);

GET_NODE(sxe, node);

convert_to_string(member);

name = Z_STRVAL_P(member);

node = sxe_get_element_by_name(sxe, node, &name, &type TSRMLS_CC);

if (node) {

return NULL;

}

if (sxe_prop_dim_write(object, member, NULL, 1, 0, &node TSRMLS_CC) != SUCCESS) {

return NULL;

}

type = SXE_ITER_NONE;

name = NULL;

_node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);

sxe = Z_SXEOBJ_P(&ret);

if (!Z_ISUNDEF(sxe->tmp)) {

zval_ptr_dtor(&sxe->tmp);

}

ZVAL_COPY_VALUE(&sxe->tmp, &ret);

//???? Z_SET_ISREF_P(return_value);

return &sxe->tmp;

}

/* }}} */

/* {{{ sxe_prop_dim_exists()

*/

static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend_bool elements, zend_bool attribs TSRMLS_DC)

{

php_sxe_object *sxe;

xmlNodePtr node;

xmlAttrPtr attr = NULL;

int exists = 0;

int test = 0;

zval tmp_zv;

if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {

tmp_zv = *member;

zval_copy_ctor(&tmp_zv);

member = &tmp_zv;

convert_to_string(member);

}

sxe = Z_SXEOBJ_P(object);

GET_NODE(sxe, node);

if (Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type != SXE_ITER_ATTRLIST) {

attribs = 0;

elements = 1;

if (sxe->iter.type == SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

}

}

}

if (sxe->iter.type == SXE_ITER_ATTRLIST) {

attribs = 1;

elements = 0;

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = (xmlAttrPtr)node;

test = sxe->iter.name != NULL;

} else if (sxe->iter.type != SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = node ? node->properties : NULL;

test = 0;

}

if (node) {

if (attribs) {

if (Z_TYPE_P(member) == IS_LONG) {

int nodendx = 0;

while (attr && nodendx <= Z_LVAL_P(member)) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (nodendx == Z_LVAL_P(member)) {

exists = 1;

break;

}

nodendx++;

}

attr = attr->next;

}

} else {

while (attr) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

exists = 1;

break;

}

attr = attr->next;

}

}

if (exists && check_empty == 1 &&

(!attr->children || !attr->children->content || !attr->children->content[0] || !xmlStrcmp(attr->children->content, "0")) ) {

/* Attribute with no content in it's text node */

exists = 0;

}

}

if (elements) {

if (Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type == SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

}

node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);

}

else {

node = node->children;

while (node) {

xmlNodePtr nnext;

nnext = node->next;

if ((node->type == XML_ELEMENT_NODE) && !xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {

break;

}

node = nnext;

}

}

if (node) {

exists = 1;

if (check_empty == 1 &&

(!node->children || (node->children->type == XML_TEXT_NODE && !node->children->next &&

(!node->children->content || !node->children->content[0] || !xmlStrcmp(node->children->content, "0")))) ) {

exists = 0;

}

}

}

}

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

return exists;

}

/* }}} */

/* {{{ sxe_property_exists()

*/

static int sxe_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)

{

return sxe_prop_dim_exists(object, member, check_empty, 1, 0 TSRMLS_CC);

}

/* }}} */

/* {{{ sxe_property_exists()

*/

static int sxe_dimension_exists(zval *object, zval *member, int check_empty TSRMLS_DC)

{

return sxe_prop_dim_exists(object, member, check_empty, 0, 1 TSRMLS_CC);

}

/* }}} */

/* {{{ sxe_prop_dim_delete()

*/

static void sxe_prop_dim_delete(zval *object, zval *member, zend_bool elements, zend_bool attribs TSRMLS_DC)

{

php_sxe_object *sxe;

xmlNodePtr node;

xmlNodePtr nnext;

xmlAttrPtr attr = NULL;

xmlAttrPtr anext;

zval tmp_zv;

int test = 0;

if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {

tmp_zv = *member;

zval_copy_ctor(&tmp_zv);

member = &tmp_zv;

convert_to_string(member);

}

sxe = Z_SXEOBJ_P(object);

GET_NODE(sxe, node);

if (Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type != SXE_ITER_ATTRLIST) {

attribs = 0;

elements = 1;

if (sxe->iter.type == SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

}

}

}

if (sxe->iter.type == SXE_ITER_ATTRLIST) {

attribs = 1;

elements = 0;

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = (xmlAttrPtr)node;

test = sxe->iter.name != NULL;

} else if (sxe->iter.type != SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

attr = node ? node->properties : NULL;

test = 0;

}

if (node) {

if (attribs) {

if (Z_TYPE_P(member) == IS_LONG) {

int nodendx = 0;

while (attr && nodendx <= Z_LVAL_P(member)) {

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

if (nodendx == Z_LVAL_P(member)) {

xmlUnlinkNode((xmlNodePtr) attr);

php_libxml_node_free_resource((xmlNodePtr) attr TSRMLS_CC);

break;

}

nodendx++;

}

attr = attr->next;

}

} else {

while (attr) {

anext = attr->next;

if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)Z_STRVAL_P(member)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {

xmlUnlinkNode((xmlNodePtr) attr);

php_libxml_node_free_resource((xmlNodePtr) attr TSRMLS_CC);

break;

}

attr = anext;

}

}

}

if (elements) {

if (Z_TYPE_P(member) == IS_LONG) {

if (sxe->iter.type == SXE_ITER_CHILD) {

node = php_sxe_get_first_node(sxe, node TSRMLS_CC);

}

node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);

if (node) {

xmlUnlinkNode(node);

php_libxml_node_free_resource(node TSRMLS_CC);

}

} else {

node = node->children;

while (node) {

nnext = node->next;

SKIP_TEXT(node);

if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {

xmlUnlinkNode(node);

php_libxml_node_free_resource(node TSRMLS_CC);

}

next_iter:

node = nnext;

}

}

}

}

if (member == &tmp_zv) {

zval_dtor(&tmp_zv);

}

}

/* }}} */

/* {{{ sxe_property_delete()

*/

static void sxe_property_delete(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC)

{

sxe_prop_dim_delete(object, member, 1, 0 TSRMLS_CC);

}

/* }}} */

/* {{{ sxe_dimension_unset()

*/

static void sxe_dimension_delete(zval *object, zval *offset TSRMLS_DC)

{

sxe_prop_dim_delete(object, offset, 0, 1 TSRMLS_CC);

}

/* }}} */

static inline zend_string *sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine TSRMLS_DC) /* {{{ */

{

xmlChar *tmp = xmlNodeListGetString(doc, list, inLine);

zend_string *res;

if (tmp) {

res = STR_INIT((char*)tmp, strlen((char *)tmp), 0);

xmlFree(tmp);

} else {

res = STR_EMPTY_ALLOC();

}

return res;

}

/* }}} */

/* {{{ _get_base_node_value()

*/

static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix TSRMLS_DC)

{