#define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)
static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC);
-static zend_object_value php_sxe_register_object(php_sxe_object * TSRMLS_DC);
+static zend_object *php_sxe_register_object(php_sxe_object * 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 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 void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data 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);
php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL TSRMLS_CC);
- value->type = IS_OBJECT;
- value->value.obj = php_sxe_register_object(subnode TSRMLS_CC);
+ ZVAL_OBJ(value, php_sxe_register_object(subnode TSRMLS_CC));
}
/* }}} */
if (sxe && sxe->iter.type != SXE_ITER_NONE) {
php_sxe_reset_iterator(sxe, 1 TSRMLS_CC);
- if (sxe->iter.data) {
- intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ intern = Z_SXEOBJ_P(&sxe->iter.data);
GET_NODE(intern, retnode)
}
return retnode;
/* {{{ sxe_prop_dim_read()
*/
-static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type TSRMLS_DC)
+static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv TSRMLS_DC)
{
- zval *return_value;
php_sxe_object *sxe;
char *name;
xmlNodePtr node;
int nodendx = 0;
int test = 0;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
if (!member || Z_TYPE_P(member) == IS_LONG) {
if (sxe->iter.type != SXE_ITER_ATTRLIST) {
}
}
- MAKE_STD_ZVAL(return_value);
- ZVAL_NULL(return_value);
+ ZVAL_UNDEF(rv);
if (node) {
if (attribs) {
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, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
break;
}
nodendx++;
} 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, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
break;
}
attr = attr->next;
node = NULL;
}
if (node) {
- _node_as_zval(sxe, node, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _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, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
}
} else {
#if SXE_ELEMENT_BY_NAME
GET_NODE(sxe, node);
node = sxe_get_element_by_name(sxe, node, &name, &newtype TSRMLS_CC);
if (node) {
- _node_as_zval(sxe, node, return_value, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, node, rv, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
}
#else
- _node_as_zval(sxe, node, return_value, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, node, rv, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
#endif
}
}
}
- Z_SET_REFCOUNT_P(return_value, 0);
- Z_UNSET_ISREF_P(return_value);
-
if (member == &tmp_zv) {
zval_dtor(&tmp_zv);
}
- if (Z_TYPE_P(return_value) == IS_NULL) {
- FREE_ZVAL(return_value);
- return_value = &EG(uninitialized_zval);
+
+ if (ZVAL_IS_NULL(rv)) {
+ return &EG(uninitialized_zval);
}
- return return_value;
+ return rv;
}
/* }}} */
/* {{{ sxe_property_read()
*/
-static zval * sxe_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+static zval *sxe_property_read(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC)
{
- return sxe_prop_dim_read(object, member, 1, 0, type TSRMLS_CC);
+ 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 TSRMLS_DC)
+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 TSRMLS_CC);
+ return sxe_prop_dim_read(object, offset, 0, 1, type, rv TSRMLS_CC);
}
/* }}} */
int retval = SUCCESS;
zval tmp_zv, trim_zv, value_copy;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
if (!member || Z_TYPE_P(member) == IS_LONG) {
if (sxe->iter.type != SXE_ITER_ATTRLIST) {
case IS_OBJECT:
if (Z_OBJCE_P(value) == sxe_class_entry) {
value = sxe_get_value(value TSRMLS_CC);
- INIT_PZVAL(value);
+ //???
+ //INIT_PZVAL(value);
new_value = 1;
break;
}
*pnewnode = newnode;
}
if (value && value == &value_copy) {
- zval_dtor(value);
+ zval_ptr_dtor(value);
}
if (new_value) {
- zval_ptr_dtor(&value);
+ zval_ptr_dtor(value);
}
return retval;
}
}
/* }}} */
-static zval** sxe_property_get_adr(zval *object, zval *member, int fetch_type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, const zend_literal *key TSRMLS_DC) /* {{{ */
{
php_sxe_object *sxe;
xmlNodePtr node;
- zval *return_value;
+ zval ret;
char *name;
SXE_ITER type;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
GET_NODE(sxe, node);
convert_to_string(member);
type = SXE_ITER_NONE;
name = NULL;
- MAKE_STD_ZVAL(return_value);
- _node_as_zval(sxe, node, return_value, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+ _node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
- sxe = php_sxe_fetch_object(return_value TSRMLS_CC);
- if (sxe->tmp) {
+ sxe = Z_SXEOBJ_P(&ret);
+ if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
zval_ptr_dtor(&sxe->tmp);
}
- sxe->tmp = return_value;
- Z_SET_ISREF_P(return_value);
+
+ ZVAL_COPY_VALUE(&sxe->tmp, &ret);
+ //???? Z_SET_ISREF_P(return_value);
return &sxe->tmp;
}
convert_to_string(member);
}
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
GET_NODE(sxe, node);
convert_to_string(member);
}
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
GET_NODE(sxe, node);
}
/* }}} */
-static inline char * sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) /* {{{ */
+static inline zend_string * sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) /* {{{ */
{
xmlChar *tmp = xmlNodeListGetString(doc, list, inLine);
- char *res;
+ zend_string *res;
if (tmp) {
- res = estrdup((char*)tmp);
+ res = STR_INIT((char*)tmp, strlen((char *)tmp), 0);
xmlFree(tmp);
} else {
res = STR_EMPTY_ALLOC();
/* {{{ _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)
+static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix TSRMLS_DC)
{
php_sxe_object *subnode;
xmlChar *contents;
- MAKE_STD_ZVAL(*value);
-
if (node->children && node->children->type == XML_TEXT_NODE && !xmlIsBlankNode(node->children)) {
contents = xmlNodeListGetString(node->doc, node->children, 1);
if (contents) {
- ZVAL_STRING(*value, (char *)contents, 1);
+ ZVAL_STRING(value, (char *)contents);
xmlFree(contents);
}
} else {
}
php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL TSRMLS_CC);
- (*value)->type = IS_OBJECT;
- (*value)->value.obj = php_sxe_register_object(subnode TSRMLS_CC);
+ ZVAL_OBJ(value, php_sxe_register_object(subnode TSRMLS_CC));
/*zval_add_ref(value);*/
}
}
static void sxe_properties_add(HashTable *rv, char *name, int namelen, zval *value TSRMLS_DC) /* {{{ */
{
- zval **data_ptr;
- zval *newptr;
- ulong h = zend_hash_func(name, namelen);
+ zval *data_ptr;
+ zval newptr;
- if (zend_hash_quick_find(rv, name, namelen, h, (void **) &data_ptr) == SUCCESS) {
- if (Z_TYPE_PP(data_ptr) == IS_ARRAY) {
- zend_hash_next_index_insert(Z_ARRVAL_PP(data_ptr), &value, sizeof(zval *), NULL);
+ if ((data_ptr = zend_hash_str_find(rv, name, namelen)) != NULL) {
+ if (Z_TYPE_P(data_ptr) == IS_ARRAY) {
+ zend_hash_next_index_insert(Z_ARRVAL_P(data_ptr), value);
} else {
- MAKE_STD_ZVAL(newptr);
- array_init(newptr);
+ array_init(&newptr);
- zval_add_ref(data_ptr);
- zend_hash_next_index_insert(Z_ARRVAL_P(newptr), data_ptr, sizeof(zval *), NULL);
- zend_hash_next_index_insert(Z_ARRVAL_P(newptr), &value, sizeof(zval *), NULL);
+ if (Z_REFCOUNTED_P(data_ptr)) {
+ Z_ADDREF_P(data_ptr);
+ }
+ zend_hash_next_index_insert(Z_ARRVAL(newptr), data_ptr);
+ zend_hash_next_index_insert(Z_ARRVAL(newptr), value);
- zend_hash_quick_update(rv, name, namelen, h, &newptr, sizeof(zval *), NULL);
+ zend_hash_str_update(rv, name, namelen, &newptr);
}
} else {
- zend_hash_quick_update(rv, name, namelen, h, &value, sizeof(zval *), NULL);
+ zend_hash_str_update(rv, name, namelen, value);
}
}
/* }}} */
-static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{{ */
+static HashTable *sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{{ */
{
- zval *value;
- zval *zattr;
+ zval value;
+ zval zattr;
HashTable *rv;
php_sxe_object *sxe;
char *name;
xmlAttrPtr attr;
int namelen;
int test;
- char use_iter;
- zval *iter_data = NULL;
+ char use_iter;
+ zval iter_data;
use_iter = 0;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
if (is_debug) {
ALLOC_HASHTABLE(rv);
zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
- }
- else if (sxe->properties) {
+ } else if (sxe->properties) {
zend_hash_clean(sxe->properties);
rv = sxe->properties;
} else {
}
if (!node || node->type != XML_ENTITY_DECL) {
attr = node ? (xmlAttrPtr)node->properties : NULL;
- zattr = NULL;
+ ZVAL_UNDEF(&zattr);
test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
while (attr) {
if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
- MAKE_STD_ZVAL(value);
- ZVAL_STRING(value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1), 0);
- namelen = xmlStrlen(attr->name) + 1;
- if (!zattr) {
- MAKE_STD_ZVAL(zattr);
- array_init(zattr);
- sxe_properties_add(rv, "@attributes", sizeof("@attributes"), zattr TSRMLS_CC);
+ ZVAL_STR(&value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1));
+ namelen = xmlStrlen(attr->name);
+ if (ZVAL_IS_UNDEF(&zattr)) {
+ array_init(&zattr);
+ sxe_properties_add(rv, "@attributes", sizeof("@attributes") - 1, &zattr TSRMLS_CC);
}
- add_assoc_zval_ex(zattr, (char*)attr->name, namelen, value);
+ add_assoc_zval_ex(&zattr, (char*)attr->name, namelen, &value);
}
attr = attr->next;
}
if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
if (node->type == XML_ATTRIBUTE_NODE) {
- MAKE_STD_ZVAL(value);
- ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node->children, 1), 0);
- zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+ ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node->children, 1));
+ zend_hash_next_index_insert(rv, &value);
node = NULL;
} else if (sxe->iter.type != SXE_ITER_CHILD) {
if ( !node->children || !node->parent || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
node = node->children;
} else {
- iter_data = sxe->iter.data;
- sxe->iter.data = NULL;
+ ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
+ ZVAL_UNDEF(&sxe->iter.data);
node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
const xmlChar *cur = node->content;
if (*cur != 0) {
- MAKE_STD_ZVAL(value);
- ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node, 1), 0);
- zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+ ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node, 1));
+ zend_hash_next_index_insert(rv, &value);
}
goto next_iter;
}
if (!name) {
goto next_iter;
} else {
- namelen = xmlStrlen(node->name) + 1;
+ namelen = xmlStrlen(node->name);
}
_get_base_node_value(sxe, node, &value, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
if ( use_iter ) {
- zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(rv, &value);
} else {
- sxe_properties_add(rv, name, namelen, value TSRMLS_CC);
+ sxe_properties_add(rv, name, namelen, &value TSRMLS_CC);
}
next_iter:
- if ( use_iter ) {
+ if (use_iter) {
node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
} else {
node = node->next;
}
}
- if ( use_iter ) {
- if (sxe->iter.data) {
+ if (use_iter) {
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
}
- sxe->iter.data = iter_data;
+ ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
}
return rv;
}
/* }}} */
-static HashTable * sxe_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /* {{{ */ {
- php_sxe_object *sxe;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+static HashTable *sxe_get_gc(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */ {
+ php_sxe_object *sxe;
+ sxe = Z_SXEOBJ_P(object);
*table = NULL;
*n = 0;
}
/* }}} */
-static HashTable * sxe_get_properties(zval *object TSRMLS_DC) /* {{{ */
+static HashTable *sxe_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
return sxe_get_prop_hash(object, 0 TSRMLS_CC);
}
php_sxe_object *sxe1;
php_sxe_object *sxe2;
- sxe1 = php_sxe_fetch_object(object1 TSRMLS_CC);
- sxe2 = php_sxe_fetch_object(object2 TSRMLS_CC);
+ sxe1 = Z_SXEOBJ_P(object1);
+ sxe2 = Z_SXEOBJ_P(object2);
if (sxe1->node == NULL) {
if (sxe2->node) {
SXE_METHOD(xpath)
{
php_sxe_object *sxe;
- zval *value;
+ zval value;
char *query;
int query_len;
int i;
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
if (sxe->iter.type == SXE_ITER_ATTRLIST) {
return; /* attributes don't have attributes */
for (i = 0; i < result->nodeNr; ++i) {
nodeptr = result->nodeTab[i];
if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
- MAKE_STD_ZVAL(value);
/**
* Detect the case where the last selector is text(), simplexml
* always accesses the text() child by default, therefore we assign
* to the parent node.
*/
if (nodeptr->type == XML_TEXT_NODE) {
- _node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
+ _node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
} else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
- _node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0 TSRMLS_CC);
+ _node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0 TSRMLS_CC);
} else {
- _node_as_zval(sxe, nodeptr, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
+ _node_as_zval(sxe, nodeptr, &value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
}
- add_next_index_zval(return_value, value);
+ add_next_index_zval(return_value, &value);
}
}
}
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
if (!sxe->xpath) {
sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
}
RETURN_FALSE;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
}
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
if (node) {
if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
xmlDocDumpMemoryEnc((xmlDocPtr) sxe->document->ptr, &strval, &strval_len, ((xmlDocPtr) sxe->document->ptr)->encoding);
- RETVAL_STRINGL((char *)strval, strval_len, 1);
+ RETVAL_STRINGL((char *)strval, strval_len);
xmlFree(strval);
} else {
/* Should we be passing encoding information instead of NULL? */
xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, ((xmlDocPtr) sxe->document->ptr)->encoding);
xmlOutputBufferFlush(outbuf);
#ifdef LIBXML2_NEW_BUFFER
- RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf), 1);
+ RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf));
#else
- RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use, 1);
+ RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use);
#endif
xmlOutputBufferClose(outbuf);
}
static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns) /* {{{ */
{
char *prefix = SXE_NS_PREFIX(ns);
- if (zend_hash_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix) + 1) == 0) {
+ if (zend_hash_str_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix)) == 0) {
add_assoc_string(return_value, prefix, (char*)ns->href, 1);
}
}
array_init(return_value);
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
array_init(return_value);
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
if(from_root){
node = xmlDocGetRootElement((xmlDocPtr)sxe->document->ptr);
}else{
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
if (sxe->iter.type == SXE_ITER_ATTRLIST) {
return; /* attributes don't have attributes */
xmlNodePtr node;
int namelen;
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
if (node) {
namelen = xmlStrlen(node->name);
- RETURN_STRINGL((char*)node->name, namelen, 1);
+ RETURN_STRINGL((char*)node->name, namelen);
} else {
RETURN_EMPTY_STRING();
}
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
if (sxe->iter.type == SXE_ITER_ATTRLIST) {
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
if (sxe->iter.type == SXE_ITER_ATTRLIST) {
return;
}
- sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(getThis());
GET_NODE(sxe, node);
node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
{
if (contents) {
- ZVAL_STRINGL(object, contents, strlen(contents), 1);
+ ZVAL_STRINGL(object, contents, strlen(contents));
} else {
ZVAL_NULL(object);
}
- Z_SET_REFCOUNT_P(object, 1);
- Z_UNSET_ISREF_P(object);
+ //???? Z_SET_REFCOUNT_P(object, 1);
+ //Z_UNSET_ISREF_P(object);
switch (type) {
case IS_STRING:
static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
{
php_sxe_object *sxe;
- xmlChar *contents = NULL;
+ xmlChar *contents = NULL;
xmlNodePtr node;
int rv;
HashTable *prop_hash;
- sxe = php_sxe_fetch_object(readobj TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(readobj);
if (type == IS_BOOL) {
node = php_sxe_get_first_node(sxe, NULL TSRMLS_CC);
prop_hash = sxe_get_prop_hash(readobj, 1 TSRMLS_CC);
- INIT_PZVAL(writeobj);
ZVAL_BOOL(writeobj, node != NULL || zend_hash_num_elements(prop_hash) > 0);
zend_hash_destroy(prop_hash);
efree(prop_hash);
}
if (readobj == writeobj) {
- INIT_PZVAL(writeobj);
- zval_dtor(readobj);
+ zval_ptr_dtor(readobj);
}
rv = cast_object(writeobj, type, (char *)contents TSRMLS_CC);
if (contents) {
xmlFree(contents);
}
+
return rv;
}
/* }}} */
Returns the string content */
SXE_METHOD(__toString)
{
- zval *result;
-
- ALLOC_INIT_ZVAL(result);
+ zval result;
- if (sxe_object_cast(getThis(), result, IS_STRING TSRMLS_CC) == SUCCESS) {
- RETURN_ZVAL(result, 1, 1);
+ if (sxe_object_cast(getThis(), &result, IS_STRING TSRMLS_CC) == SUCCESS) {
+ RETURN_ZVAL(&result, 0, 0);
} else {
zval_ptr_dtor(&result);
RETURN_EMPTY_STRING();
static int php_sxe_count_elements_helper(php_sxe_object *sxe, long *count TSRMLS_DC) /* {{{ */
{
- xmlNodePtr node;
- zval *data;
+ xmlNodePtr node;
+ zval data;
*count = 0;
- data = sxe->iter.data;
- sxe->iter.data = NULL;
+ ZVAL_COPY_VALUE(&data, &sxe->iter.data);
+ ZVAL_UNDEF(&sxe->iter.data);
node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
}
- if (sxe->iter.data) {
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
}
- sxe->iter.data = data;
+ ZVAL_COPY_VALUE(&sxe->iter.data, &data);
return SUCCESS;
}
static int sxe_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
{
php_sxe_object *intern;
- intern = php_sxe_fetch_object(object TSRMLS_CC);
+ intern = Z_SXEOBJ_P(object);
if (intern->fptr_count) {
- zval *rv;
- zend_call_method_with_0_params(&object, intern->zo.ce, &intern->fptr_count, "count", &rv);
- if (rv) {
- if (intern->tmp) {
+ zval rv;
+ zend_call_method_with_0_params(object, intern->zo.ce, &intern->fptr_count, "count", &rv);
+ if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!ZVAL_IS_UNDEF(&intern->tmp)) {
zval_ptr_dtor(&intern->tmp);
}
- MAKE_STD_ZVAL(intern->tmp);
- ZVAL_ZVAL(intern->tmp, rv, 1, 1);
- convert_to_long(intern->tmp);
- *count = (long) Z_LVAL_P(intern->tmp);
+ ZVAL_ZVAL(&intern->tmp, &rv, 0, 0);
+ convert_to_long(&intern->tmp);
+ *count = (long)Z_LVAL(intern->tmp);
return SUCCESS;
}
return FAILURE;
SXE_METHOD(count)
{
long count = 0;
- php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
if (zend_parse_parameters_none() == FAILURE) {
return;
static zval *sxe_get_value(zval *z TSRMLS_DC) /* {{{ */
{
+#if 0
+ ?????
zval *retval;
MAKE_STD_ZVAL(retval);
- if (sxe_object_cast(z, retval, IS_STRING TSRMLS_CC)==FAILURE) {
+ if (sxe_object_cast(z, retval, IS_STRING TSRMLS_CC) == FAILURE) {
zend_error(E_ERROR, "Unable to cast node to string");
/* FIXME: Should not be fatal */
}
Z_SET_REFCOUNT_P(retval, 0);
return retval;
+#endif
+ return NULL;
}
/* }}} */
/* {{{ sxe_object_clone()
*/
-static void
-sxe_object_clone(void *object, void **clone_ptr TSRMLS_DC)
+static zend_object *
+sxe_object_clone(zend_object *object TSRMLS_DC)
{
- php_sxe_object *sxe = (php_sxe_object *) object;
+ php_sxe_object *sxe = php_sxe_fetch_object(object);
php_sxe_object *clone;
xmlNodePtr nodep = NULL;
xmlDocPtr docp = NULL;
php_libxml_increment_node_ptr((php_libxml_node_object *)clone, nodep, NULL TSRMLS_CC);
- *clone_ptr = (void *) clone;
+ return &clone->zo;
}
/* }}} */
/* {{{ sxe_object_dtor()
*/
-static void sxe_object_dtor(void *object, zend_object_handle handle TSRMLS_DC)
+static void sxe_object_dtor(void *object TSRMLS_DC)
{
/* dtor required to cleanup iterator related data properly */
-
php_sxe_object *sxe;
- sxe = (php_sxe_object *) object;
+ sxe = php_sxe_fetch_object(object);
- if (sxe->iter.data) {
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
- sxe->iter.data = NULL;
+ ZVAL_UNDEF(&sxe->iter.data);
}
if (sxe->iter.name) {
xmlFree(sxe->iter.nsprefix);
sxe->iter.nsprefix = NULL;
}
- if (sxe->tmp) {
+ if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
zval_ptr_dtor(&sxe->tmp);
- sxe->tmp = NULL;
+ ZVAL_UNDEF(&sxe->tmp);
}
}
/* }}} */
{
php_sxe_object *sxe;
- sxe = (php_sxe_object *) object;
+ sxe = php_sxe_fetch_object(object);
-#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION > 5)
zend_object_std_dtor(&sxe->zo TSRMLS_CC);
-#else
- if (sxe->zo.guards) {
- zend_hash_destroy(sxe->zo.guards);
- FREE_HASHTABLE(sxe->zo.guards);
- }
-
- if (sxe->zo.properties) {
- zend_hash_destroy(sxe->zo.properties);
- FREE_HASHTABLE(sxe->zo.properties);
- }
-#endif
php_libxml_node_decrement_resource((php_libxml_node_object *)sxe TSRMLS_CC);
FREE_HASHTABLE(sxe->properties);
}
- efree(object);
+ efree(sxe);
}
/* }}} */
static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC)
{
php_sxe_object *intern;
- zend_class_entry *parent = ce;
+ zend_class_entry *parent = ce;
int inherited = 0;
- intern = ecalloc(1, sizeof(php_sxe_object));
+ intern = ecalloc(1, sizeof(php_sxe_object) + sizeof(zval) * (parent->default_properties_count - 1));
intern->iter.type = SXE_ITER_NONE;
intern->iter.nsprefix = NULL;
intern->iter.name = NULL;
intern->fptr_count = NULL;
-#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION > 5)
zend_object_std_init(&intern->zo, ce TSRMLS_CC);
-#else
- ALLOC_HASHTABLE(intern->zo.properties);
- zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
-
- intern->zo.ce = ce;
- intern->zo.guards = NULL;
-#endif
while (parent) {
if (parent == sxe_class_entry) {
}
if (inherited) {
- zend_hash_find(&ce->function_table, "count", sizeof("count"),(void **) &intern->fptr_count);
+ intern->fptr_count = zend_hash_str_find_ptr(&ce->function_table, "count", sizeof("count") - 1);
if (intern->fptr_count->common.scope == parent) {
intern->fptr_count = NULL;
}
/* {{{ php_sxe_register_object
*/
-static zend_object_value
+static zend_object *
php_sxe_register_object(php_sxe_object *intern TSRMLS_DC)
{
- zend_object_value rv;
-
- rv.handle = zend_objects_store_put(intern, sxe_object_dtor, (zend_objects_free_object_storage_t)sxe_object_free_storage, sxe_object_clone TSRMLS_CC);
- rv.handlers = (zend_object_handlers *) &sxe_object_handlers;
-
- return rv;
+ zend_objects_store_put(&intern->zo TSRMLS_CC);
+ return &intern->zo;
}
/* }}} */
/* {{{ sxe_object_new()
*/
-PHP_SXE_API zend_object_value
+PHP_SXE_API zend_object *
sxe_object_new(zend_class_entry *ce TSRMLS_DC)
{
php_sxe_object *intern;
docp = xmlReadFile(filename, NULL, options);
- if (! docp) {
+ if (!docp) {
RETURN_FALSE;
}
php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
- return_value->type = IS_OBJECT;
- return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+ ZVAL_OBJ(return_value, php_sxe_register_object(sxe TSRMLS_CC));
}
/* }}} */
docp = xmlReadMemory(data, data_len, NULL, NULL, options);
- if (! docp) {
+ if (!docp) {
RETURN_FALSE;
}
php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
- return_value->type = IS_OBJECT;
- return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+ ZVAL_OBJ(return_value, php_sxe_register_object(sxe TSRMLS_CC));
}
/* }}} */
SimpleXMLElement constructor */
SXE_METHOD(__construct)
{
- php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+ php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
char *data, *ns = NULL;
int data_len, ns_len = 0;
xmlDocPtr docp;
}
if (node && use_data) {
- ALLOC_INIT_ZVAL(sxe->iter.data);
- _node_as_zval(sxe, node, sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix TSRMLS_CC);
+ _node_as_zval(sxe, node, &sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix TSRMLS_CC);
}
return node;
{
xmlNodePtr node;
- if (sxe->iter.data) {
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
- sxe->iter.data = NULL;
+ ZVAL_UNDEF(&sxe->iter.data);
}
GET_NODE(sxe, node)
}
iterator = emalloc(sizeof(php_sxe_iterator));
- Z_ADDREF_P(object);
- iterator->intern.data = (void*)object;
+ ZVAL_COPY(&iterator->intern.data, object);
iterator->intern.funcs = &php_sxe_iterator_funcs;
- iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ iterator->sxe = Z_SXEOBJ_P(object);
return (zend_object_iterator*)iterator;
}
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
/* cleanup handled in sxe_object_dtor as we dont always have an iterator wrapper */
- if (iterator->intern.data) {
- zval_ptr_dtor((zval**)&iterator->intern.data);
+ if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+ zval_ptr_dtor(&iterator->intern.data);
}
efree(iterator);
{
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
- return iterator->sxe->iter.data ? SUCCESS : FAILURE;
+ return ZVAL_IS_UNDEF(&iterator->sxe->iter.data) ? FAILURE : SUCCESS;
}
/* }}} */
-static void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *php_sxe_iterator_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
{
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
- *data = &iterator->sxe->iter.data;
+ return &iterator->sxe->iter.data;
}
/* }}} */
static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
{
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
- zval *curobj = iterator->sxe->iter.data;
- php_sxe_object *intern = (php_sxe_object *)zend_object_store_get_object(curobj TSRMLS_CC);
+ zval *curobj = &iterator->sxe->iter.data;
+ php_sxe_object *intern = Z_SXEOBJ_P(curobj);
xmlNodePtr curnode = NULL;
if (intern != NULL && intern->node != NULL) {
}
if (curnode) {
- ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name), 1);
+ ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
} else {
ZVAL_NULL(key);
}
xmlNodePtr node = NULL;
php_sxe_object *intern;
- if (sxe->iter.data) {
- intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
+ if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ intern = Z_SXEOBJ_P(&sxe->iter.data);
GET_NODE(intern, node)
zval_ptr_dtor(&sxe->iter.data);
- sxe->iter.data = NULL;
+ ZVAL_UNDEF(&sxe->iter.data);
}
if (node) {
php_sxe_object *sxe;
xmlNodePtr node;
- sxe = php_sxe_fetch_object(object TSRMLS_CC);
+ sxe = Z_SXEOBJ_P(object);
GET_NODE(sxe, node);
return php_sxe_get_first_node(sxe, node TSRMLS_CC);
}
zval *node;
php_libxml_node_object *object;
xmlNodePtr nodep = NULL;
- zend_class_entry *ce= sxe_class_entry;
+ zend_class_entry *ce = sxe_class_entry;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|C!", &node, &ce) == FAILURE) {
return;
}
- object = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
+ object = (php_libxml_node_object *)Z_SXEOBJ_P(node);
nodep = php_libxml_import_node(node TSRMLS_CC);
php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, nodep->doc TSRMLS_CC);
php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, nodep, NULL TSRMLS_CC);
- return_value->type = IS_OBJECT;
- return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+ ZVAL_OBJ(return_value, php_sxe_register_object(sxe TSRMLS_CC));
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
RETVAL_NULL();
sxe_class_entry->get_iterator = php_sxe_get_iterator;
sxe_class_entry->iterator_funcs.funcs = &php_sxe_iterator_funcs;
zend_class_implements(sxe_class_entry TSRMLS_CC, 1, zend_ce_traversable);
+ sxe_object_handlers.dtor_obj = sxe_object_dtor;
+ sxe_object_handlers.free_obj = sxe_object_free_storage;
+ sxe_object_handlers.clone_obj = sxe_object_clone;
sxe_object_handlers.get_method = zend_get_std_object_handlers()->get_method;
sxe_object_handlers.get_constructor = zend_get_std_object_handlers()->get_constructor;
sxe_object_handlers.get_class_entry = zend_get_std_object_handlers()->get_class_entry;
projects / php / commitdiff