PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/simplexml - simplexml.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 1086 1292 84.1 %
Date: 2016-08-24 Functions: 72 75 96.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2016 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.01 of the PHP license,      |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_01.txt                                  |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Authors: Sterling Hughes <sterling@php.net>                          |
      16             :   |          Marcus Boerger <helly@php.net>                              |
      17             :   |          Rob Richards <rrichards@php.net>                            |
      18             :   +----------------------------------------------------------------------+
      19             : */
      20             : 
      21             : /* $Id: 622ff3b6ec6cf038bc4ad0d2fd9986481480df9f $ */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             : #include "config.h"
      25             : #endif
      26             : 
      27             : #include "php.h"
      28             : #if HAVE_LIBXML && HAVE_SIMPLEXML
      29             : 
      30             : #include "php_ini.h"
      31             : #include "ext/standard/info.h"
      32             : #include "ext/standard/php_string.h"
      33             : #include "php_simplexml.h"
      34             : #include "php_simplexml_exports.h"
      35             : #include "zend_exceptions.h"
      36             : #include "zend_interfaces.h"
      37             : #include "sxe.h"
      38             : 
      39             : #define SXE_ELEMENT_BY_NAME 0
      40             : 
      41             : zend_class_entry *sxe_class_entry = NULL;
      42             : 
      43           0 : PHP_SXE_API zend_class_entry *sxe_get_element_class_entry() /* {{{ */
      44             : {
      45           0 :         return sxe_class_entry;
      46             : }
      47             : /* }}} */
      48             : 
      49             : #define SXE_ME(func, arg_info, flags) PHP_ME(simplexml_element, func, arg_info, flags)
      50             : #define SXE_MALIAS(func, alias, arg_info, flags) PHP_MALIAS(simplexml_element, func, alias, arg_info, flags)
      51             : 
      52             : #define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)
      53             : 
      54             : static php_sxe_object* php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count);
      55             : static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data);
      56             : static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data);
      57             : static zval *sxe_get_value(zval *z, zval *rv);
      58             : static void php_sxe_iterator_dtor(zend_object_iterator *iter);
      59             : static int php_sxe_iterator_valid(zend_object_iterator *iter);
      60             : static zval *php_sxe_iterator_current_data(zend_object_iterator *iter);
      61             : static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key);
      62             : static void php_sxe_iterator_move_forward(zend_object_iterator *iter);
      63             : static void php_sxe_iterator_rewind(zend_object_iterator *iter);
      64             : 
      65             : /* {{{ _node_as_zval()
      66             :  */
      67      401216 : static void _node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE_ITER itertype, char *name, const xmlChar *nsprefix, int isprefix)
      68             : {
      69             :         php_sxe_object *subnode;
      70             : 
      71      401216 :         subnode = php_sxe_object_new(sxe->zo.ce, sxe->fptr_count);
      72      401216 :         subnode->document = sxe->document;
      73      401216 :         subnode->document->refcount++;
      74      401216 :         subnode->iter.type = itertype;
      75      401216 :         if (name) {
      76      200369 :                 subnode->iter.name = (xmlChar*)estrdup(name);
      77             :         }
      78      401216 :         if (nsprefix && *nsprefix) {
      79         121 :                 subnode->iter.nsprefix = (xmlChar*)estrdup((char*)nsprefix);
      80         121 :                 subnode->iter.isprefix = isprefix;
      81             :         }
      82             : 
      83      401216 :         php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL);
      84             : 
      85      401216 :         ZVAL_OBJ(value, &subnode->zo);
      86      401216 : }
      87             : /* }}} */
      88             : 
      89             : #define GET_NODE(__s, __n) { \
      90             :         if ((__s)->node && (__s)->node->node) { \
      91             :                 __n = (__s)->node->node; \
      92             :         } else { \
      93             :                 __n = NULL; \
      94             :                 php_error_docref(NULL, E_WARNING, "Node no longer exists"); \
      95             :         } \
      96             : }
      97             : 
      98      401342 : static xmlNodePtr php_sxe_get_first_node(php_sxe_object *sxe, xmlNodePtr node) /* {{{ */
      99             : {
     100             :         php_sxe_object *intern;
     101      401342 :         xmlNodePtr retnode = NULL;
     102             : 
     103      401342 :         if (sxe && sxe->iter.type != SXE_ITER_NONE) {
     104      200450 :                 php_sxe_reset_iterator(sxe, 1);
     105      400900 :                 if (!Z_ISUNDEF(sxe->iter.data)) {
     106      200391 :                         intern = Z_SXEOBJ_P(&sxe->iter.data);
     107      200391 :                         GET_NODE(intern, retnode)
     108             :                 }
     109      200450 :                 return retnode;
     110             :         } else {
     111      200892 :                 return node;
     112             :         }
     113             : }
     114             : /* }}} */
     115             : 
     116      201141 : static inline int match_ns(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name, int prefix) /* {{{ */
     117             : {
     118      201141 :         if (name == NULL && (node->ns == NULL || node->ns->prefix == NULL)) {
     119      201037 :                 return 1;
     120             :         }
     121             : 
     122         104 :         if (node->ns && !xmlStrcmp(prefix ? node->ns->prefix : node->ns->href, name)) {
     123          62 :                 return 1;
     124             :         }
     125             : 
     126          42 :         return 0;
     127             : }
     128             : /* }}} */
     129             : 
     130         108 : static xmlNodePtr sxe_get_element_by_offset(php_sxe_object *sxe, zend_long offset, xmlNodePtr node, zend_long *cnt) /* {{{ */
     131             : {
     132         108 :         zend_long nodendx = 0;
     133             : 
     134         108 :         if (sxe->iter.type == SXE_ITER_NONE) {
     135           0 :                 if (offset == 0) {
     136           0 :                         if (cnt) {
     137           0 :                                 *cnt = 0;
     138             :                         }
     139           0 :                         return node;
     140             :                 } else {
     141           0 :                         return NULL;
     142             :                 }
     143             :         }
     144         343 :         while (node && nodendx <= offset) {
     145         221 :                 SKIP_TEXT(node)
     146         162 :                 if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     147         483 :                         if (sxe->iter.type == SXE_ITER_CHILD || (
     148         322 :                                 sxe->iter.type == SXE_ITER_ELEMENT && !xmlStrcmp(node->name, sxe->iter.name))) {
     149         157 :                                 if (nodendx == offset) {
     150          94 :                                         break;
     151             :                                 }
     152          63 :                                 nodendx++;
     153             :                         }
     154             :                 }
     155             : next_iter:
     156         127 :                 node = node->next;
     157             :         }
     158             : 
     159         108 :         if (cnt) {
     160         102 :                 *cnt = nodendx;
     161             :         }
     162             : 
     163         108 :         return node;
     164             : }
     165             : /* }}} */
     166             : 
     167           0 : static xmlNodePtr sxe_find_element_by_name(php_sxe_object *sxe, xmlNodePtr node, xmlChar *name) /* {{{ */
     168             : {
     169           0 :         while (node) {
     170           0 :                 SKIP_TEXT(node)
     171           0 :                 if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     172           0 :                         if (!xmlStrcmp(node->name, name)) {
     173           0 :                                 return node;
     174             :                         }
     175             :                 }
     176             : next_iter:
     177           0 :                 node = node->next;
     178             :         }
     179           0 :         return NULL;
     180             : } /* }}} */
     181             : 
     182          40 : static xmlNodePtr sxe_get_element_by_name(php_sxe_object *sxe, xmlNodePtr node, char **name, SXE_ITER *type) /* {{{ */
     183             : {
     184             :         int         orgtype;
     185          40 :         xmlNodePtr  orgnode = node;
     186          40 :         xmlNodePtr  retnode = NULL;
     187             : 
     188          40 :         if (sxe->iter.type != SXE_ITER_ATTRLIST)
     189             :         {
     190          40 :                 orgtype = sxe->iter.type;
     191          40 :                 if (sxe->iter.type == SXE_ITER_NONE) {
     192          40 :                         sxe->iter.type = SXE_ITER_CHILD;
     193             :                 }
     194          40 :                 node = php_sxe_get_first_node(sxe, node);
     195          40 :                 sxe->iter.type = orgtype;
     196             :         }
     197             : 
     198          40 :         if (sxe->iter.type == SXE_ITER_ELEMENT) {
     199           0 :                 orgnode = sxe_find_element_by_name(sxe, node, sxe->iter.name);
     200           0 :                 if (!orgnode) {
     201           0 :                         return NULL;
     202             :                 }
     203           0 :                 node = orgnode->children;
     204             :         }
     205             : 
     206          89 :         while (node) {
     207          37 :                 SKIP_TEXT(node)
     208          33 :                 if (node->type == XML_ELEMENT_NODE && match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     209          33 :                         if (!xmlStrcmp(node->name, (xmlChar *)*name)) {
     210             :                                 if (1||retnode)
     211             :                                 {
     212          28 :                                         *type = SXE_ITER_ELEMENT;
     213          28 :                                         return orgnode;
     214             :                                 }
     215             :                                 retnode = node;
     216             :                         }
     217             :                 }
     218             : next_iter:
     219           9 :                 node = node->next;
     220             :         }
     221             : 
     222          12 :         if (retnode)
     223             :         {
     224           0 :                 *type = SXE_ITER_NONE;
     225           0 :                 *name = NULL;
     226           0 :                 return retnode;
     227             :         }
     228             : 
     229          12 :         return NULL;
     230             : }
     231             : /* }}} */
     232             : 
     233             : /* {{{ sxe_prop_dim_read()
     234             :  */
     235      200531 : static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv)
     236             : {
     237             :         php_sxe_object *sxe;
     238             :         char           *name;
     239             :         xmlNodePtr      node;
     240      200531 :         xmlAttrPtr      attr = NULL;
     241             :         zval            tmp_zv;
     242      200531 :         int             nodendx = 0;
     243      200531 :         int             test = 0;
     244             : 
     245      200531 :         sxe = Z_SXEOBJ_P(object);
     246             : 
     247      200531 :         if (!member) {
     248           2 :                 if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     249             :                         /* This happens when the user did: $sxe[]->foo = $value */
     250           0 :                         zend_throw_error(NULL, "Cannot create unnamed attribute");
     251           0 :                         return &EG(uninitialized_zval);
     252             :                 }
     253           2 :                 goto long_dim;
     254             :         } else {
     255      200529 :                 ZVAL_DEREF(member);
     256      200529 :                 if (Z_TYPE_P(member) == IS_LONG) {
     257         101 :                         if (sxe->iter.type != SXE_ITER_ATTRLIST) {
     258             : long_dim:
     259         103 :                                 attribs = 0;
     260         103 :                                 elements = 1;
     261             :                         }
     262         103 :                         name = NULL;
     263             :                 } else {
     264      200428 :                         if (Z_TYPE_P(member) != IS_STRING) {
     265           0 :                                 ZVAL_STR(&tmp_zv, zval_get_string(member));
     266           0 :                                 member = &tmp_zv;
     267             :                         }
     268      200428 :                         name = Z_STRVAL_P(member);
     269             :                 }
     270             :         }
     271             : 
     272      200531 :         GET_NODE(sxe, node);
     273             : 
     274      200531 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     275           5 :                 attribs = 1;
     276           5 :                 elements = 0;
     277           5 :                 node = php_sxe_get_first_node(sxe, node);
     278           5 :                 attr = (xmlAttrPtr)node;
     279           5 :                 test = sxe->iter.name != NULL;
     280      200526 :         } else if (sxe->iter.type != SXE_ITER_CHILD) {
     281      200498 :                 node = php_sxe_get_first_node(sxe, node);
     282      200498 :                 attr = node ? node->properties : NULL;
     283      200498 :                 test = 0;
     284      200500 :                 if (!member && node && node->parent &&
     285           2 :                     node->parent->type == XML_DOCUMENT_NODE) {
     286             :                         /* This happens when the user did: $sxe[]->foo = $value */
     287           0 :                         zend_throw_error(NULL, "Cannot create unnamed attribute");
     288           0 :                         return &EG(uninitialized_zval);
     289             :                 }
     290             :         }
     291             : 
     292      200531 :         ZVAL_UNDEF(rv);
     293             : 
     294      200531 :         if (node) {
     295      200519 :                 if (attribs) {
     296          78 :                         if (Z_TYPE_P(member) != IS_LONG || sxe->iter.type == SXE_ITER_ATTRLIST) {
     297          78 :                                 if (Z_TYPE_P(member) == IS_LONG) {
     298           0 :                                         while (attr && nodendx <= Z_LVAL_P(member)) {
     299           0 :                                                 if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     300           0 :                                                         if (nodendx == Z_LVAL_P(member)) {
     301           0 :                                                                 _node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
     302           0 :                                                                 break;
     303             :                                                         }
     304           0 :                                                         nodendx++;
     305             :                                                 }
     306           0 :                                                 attr = attr->next;
     307             :                                         }
     308             :                                 } else {
     309         174 :                                         while (attr) {
     310          84 :                                                 if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)name) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     311          66 :                                                         _node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
     312          66 :                                                         break;
     313             :                                                 }
     314          18 :                                                 attr = attr->next;
     315             :                                         }
     316             :                                 }
     317             :                         }
     318             :                 }
     319             : 
     320      200519 :                 if (elements) {
     321      200441 :                         if (!sxe->node) {
     322           0 :                                 php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, node, NULL);
     323             :                         }
     324      400983 :                         if (!member || Z_TYPE_P(member) == IS_LONG) {
     325         103 :                                 zend_long cnt = 0;
     326         103 :                                 xmlNodePtr mynode = node;
     327             : 
     328         103 :                                 if (sxe->iter.type == SXE_ITER_CHILD) {
     329           0 :                                         node = php_sxe_get_first_node(sxe, node);
     330             :                                 }
     331         103 :                                 if (sxe->iter.type == SXE_ITER_NONE) {
     332           4 :                                         if (member && Z_LVAL_P(member) > 0) {
     333           0 :                                                 php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only 0 such elements exist", mynode->name, Z_LVAL_P(member));
     334             :                                         }
     335          99 :                                 } else if (member) {
     336          99 :                                         node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);
     337             :                                 } else {
     338           0 :                                         node = NULL;
     339             :                                 }
     340         103 :                                 if (node) {
     341          94 :                                         _node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
     342           9 :                                 } else if (type == BP_VAR_W || type == BP_VAR_RW) {
     343           1 :                                         if (member && cnt < Z_LVAL_P(member)) {
     344           0 :                                                 php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only " ZEND_LONG_FMT " such elements exist", mynode->name, Z_LVAL_P(member), cnt);
     345             :                                         }
     346           1 :                                         node = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, NULL);
     347           1 :                                         _node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix);
     348             :                                 }
     349             :                         } else {
     350             : #if SXE_ELEMENT_BY_NAME
     351             :                                 int newtype;
     352             : 
     353             :                                 GET_NODE(sxe, node);
     354             :                                 node = sxe_get_element_by_name(sxe, node, &name, &newtype);
     355             :                                 if (node) {
     356             :                                         _node_as_zval(sxe, node, rv, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix);
     357             :                                 }
     358             : #else
     359      200338 :                                 _node_as_zval(sxe, node, rv, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix);
     360             : #endif
     361             :                         }
     362             :                 }
     363             :         }
     364             : 
     365      200531 :         if (member == &tmp_zv) {
     366             :                 zval_dtor(&tmp_zv);
     367             :         }
     368             : 
     369      200531 :         if (Z_ISUNDEF_P(rv)) {
     370          32 :                 ZVAL_COPY_VALUE(rv, &EG(uninitialized_zval));
     371             :         }
     372             : 
     373      200531 :         return rv;
     374             : }
     375             : /* }}} */
     376             : 
     377             : /* {{{ sxe_property_read()
     378             :  */
     379      200346 : static zval *sxe_property_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)
     380             : {
     381      200346 :         return sxe_prop_dim_read(object, member, 1, 0, type, rv);
     382             : }
     383             : /* }}} */
     384             : 
     385             : /* {{{ sxe_dimension_read()
     386             :  */
     387         185 : static zval *sxe_dimension_read(zval *object, zval *offset, int type, zval *rv)
     388             : {
     389         185 :         return sxe_prop_dim_read(object, offset, 0, 1, type, rv);
     390             : }
     391             : /* }}} */
     392             : 
     393             : /* {{{ change_node_zval()
     394             :  */
     395          25 : static void change_node_zval(xmlNodePtr node, zval *value)
     396             : {
     397             :         zval value_copy;
     398             :         xmlChar *buffer;
     399             :         int buffer_len;
     400             : 
     401          25 :         if (!value)
     402             :         {
     403           0 :                 xmlNodeSetContentLen(node, (xmlChar *)"", 0);
     404           0 :                 return;
     405             :         }
     406          25 :         switch (Z_TYPE_P(value)) {
     407             :                 case IS_LONG:
     408             :                 case IS_FALSE:
     409             :                 case IS_TRUE:
     410             :                 case IS_DOUBLE:
     411             :                 case IS_NULL:
     412           0 :                         if (Z_REFCOUNT_P(value) > 1) {
     413           0 :                                 value_copy = *value;
     414             :                                 zval_copy_ctor(&value_copy);
     415           0 :                                 value = &value_copy;
     416             :                         }
     417           0 :                         convert_to_string(value);
     418             :                         /* break missing intentionally */
     419             :                 case IS_STRING:
     420          25 :                         buffer = xmlEncodeEntitiesReentrant(node->doc, (xmlChar *)Z_STRVAL_P(value));
     421          25 :                         buffer_len = xmlStrlen(buffer);
     422             :                         /* check for NULL buffer in case of memory error in xmlEncodeEntitiesReentrant */
     423          25 :                         if (buffer) {
     424          25 :                                 xmlNodeSetContentLen(node, buffer, buffer_len);
     425          25 :                                 xmlFree(buffer);
     426             :                         }
     427          25 :                         if (value == &value_copy) {
     428             :                                 zval_dtor(value);
     429             :                         }
     430          25 :                         break;
     431             :                 default:
     432           0 :                         php_error_docref(NULL, E_WARNING, "It is not possible to assign complex types to nodes");
     433             :                         break;
     434             :         }
     435             : }
     436             : /* }}} */
     437             : 
     438             : /* {{{ sxe_property_write()
     439             :  */
     440          74 : static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode)
     441             : {
     442             :         php_sxe_object *sxe;
     443             :         xmlNodePtr      node;
     444          74 :         xmlNodePtr      newnode = NULL;
     445             :         xmlNodePtr      mynode;
     446             :         xmlNodePtr              tempnode;
     447          74 :         xmlAttrPtr      attr = NULL;
     448          74 :         int             counter = 0;
     449          74 :         int             is_attr = 0;
     450          74 :         int                             nodendx = 0;
     451          74 :         int             test = 0;
     452          74 :         int                             new_value = 0;
     453          74 :         zend_long            cnt = 0;
     454          74 :         int                             retval = SUCCESS;
     455             :         zval            tmp_zv, zval_copy;
     456             :         zend_string    *trim_str;
     457             : 
     458          74 :         sxe = Z_SXEOBJ_P(object);
     459             : 
     460          74 :         if (!member) {
     461           1 :                 if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     462             :                         /* This happens when the user did: $sxe[] = $value
     463             :                          * and could also be E_PARSE, but we use this only during parsing
     464             :                          * and this is during runtime.
     465             :                          */
     466           0 :                         zend_throw_error(NULL, "Cannot create unnamed attribute");
     467           0 :                         return FAILURE;
     468             :                 }
     469           1 :                 goto long_dim;
     470             :         } else {
     471          73 :                 ZVAL_DEREF(member);
     472          73 :                 if (Z_TYPE_P(member) == IS_LONG) {
     473           5 :                         if (sxe->iter.type != SXE_ITER_ATTRLIST) {
     474             : long_dim:
     475           6 :                                 attribs = 0;
     476           6 :                                 elements = 1;
     477             :                         }
     478             :                 } else {
     479          68 :                         if (Z_TYPE_P(member) != IS_STRING) {
     480           1 :                                 trim_str = zval_get_string(member);
     481           1 :                                 ZVAL_STR(&tmp_zv, php_trim(trim_str, NULL, 0, 3));
     482             :                                 zend_string_release(trim_str);
     483           1 :                                 member = &tmp_zv;
     484             :                         }
     485             : 
     486          68 :                         if (!Z_STRLEN_P(member)) {
     487           3 :                                 php_error_docref(NULL, E_WARNING, "Cannot write or create unnamed %s", attribs ? "attribute" : "element");
     488           3 :                                 if (member == &tmp_zv) {
     489             :                                         zval_dtor(&tmp_zv);
     490             :                                 }
     491           3 :                                 return FAILURE;
     492             :                         }
     493             :                 }
     494             :         }
     495             : 
     496          71 :         GET_NODE(sxe, node);
     497             : 
     498          71 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     499           0 :                 attribs = 1;
     500           0 :                 elements = 0;
     501           0 :                 node = php_sxe_get_first_node(sxe, node);
     502           0 :                 attr = (xmlAttrPtr)node;
     503           0 :                 test = sxe->iter.name != NULL;
     504          71 :         } else if (sxe->iter.type != SXE_ITER_CHILD) {
     505          71 :                 mynode = node;
     506          71 :                 node = php_sxe_get_first_node(sxe, node);
     507          71 :                 attr = node ? node->properties : NULL;
     508          71 :                 test = 0;
     509          72 :                 if (!member && node && node->parent &&
     510           1 :                     node->parent->type == XML_DOCUMENT_NODE) {
     511             :                         /* This happens when the user did: $sxe[] = $value
     512             :                          * and could also be E_PARSE, but we use this only during parsing
     513             :                          * and this is during runtime.
     514             :                          */
     515           1 :                         zend_throw_error(NULL, "Cannot create unnamed attribute");
     516           1 :                         return FAILURE;
     517             :                 }
     518          70 :                 if (attribs && !node && sxe->iter.type == SXE_ITER_ELEMENT) {
     519           0 :                         node = xmlNewChild(mynode, mynode->ns, sxe->iter.name, NULL);
     520           0 :                         attr = node->properties;
     521             :                 }
     522             :         }
     523             : 
     524          70 :         mynode = node;
     525             : 
     526          70 :         if (value) {
     527          59 :                 switch (Z_TYPE_P(value)) {
     528             :                         case IS_LONG:
     529             :                         case IS_FALSE:
     530             :                         case IS_TRUE:
     531             :                         case IS_DOUBLE:
     532             :                         case IS_NULL:
     533          10 :                                 if (Z_TYPE_P(value) != IS_STRING) {
     534          10 :                                         ZVAL_COPY(&zval_copy, value);
     535          10 :                                         value = &zval_copy;
     536          10 :                                         convert_to_string(value);
     537          10 :                                         new_value = 1;
     538             :                                 }
     539          10 :                                 break;
     540             :                         case IS_STRING:
     541          47 :                                 break;
     542             :                         case IS_OBJECT:
     543           2 :                                 if (Z_OBJCE_P(value) == sxe_class_entry) {
     544           1 :                                         value = sxe_get_value(value, &zval_copy);
     545           1 :                                         new_value = 1;
     546           1 :                                         break;
     547             :                                 }
     548             :                                 /* break is missing intentionally */
     549             :                         default:
     550           1 :                                 if (member == &tmp_zv) {
     551             :                                         zval_dtor(&tmp_zv);
     552             :                                 }
     553           1 :                                 zend_error(E_WARNING, "It is not yet possible to assign complex types to %s", attribs ? "attributes" : "properties");
     554           1 :                                 return FAILURE;
     555             :                 }
     556             :         }
     557             : 
     558          69 :         if (node) {
     559          69 :                 if (attribs) {
     560          31 :                         if (Z_TYPE_P(member) == IS_LONG) {
     561           0 :                                 while (attr && nodendx <= Z_LVAL_P(member)) {
     562           0 :                                         if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     563           0 :                                                 if (nodendx == Z_LVAL_P(member)) {
     564           0 :                                                         is_attr = 1;
     565           0 :                                                         ++counter;
     566           0 :                                                         break;
     567             :                                                 }
     568           0 :                                                 nodendx++;
     569             :                                         }
     570           0 :                                         attr = attr->next;
     571             :                                 }
     572             :                         } else {
     573          77 :                                 while (attr) {
     574          30 :                                         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)) {
     575          15 :                                                 is_attr = 1;
     576          15 :                                                 ++counter;
     577          15 :                                                 break;
     578             :                                         }
     579          15 :                                         attr = attr->next;
     580             :                                 }
     581             :                         }
     582             : 
     583             :                 }
     584             : 
     585          69 :                 if (elements) {
     586          81 :                         if (!member || Z_TYPE_P(member) == IS_LONG) {
     587           5 :                                 if (node->type == XML_ATTRIBUTE_NODE) {
     588           0 :                                         zend_throw_error(NULL, "Cannot create duplicate attribute");
     589           0 :                                         if (new_value) {
     590           0 :                                                 zval_ptr_dtor(value);
     591             :                                         }
     592           0 :                                         return FAILURE;
     593             :                                 }
     594             : 
     595           5 :                                 if (sxe->iter.type == SXE_ITER_NONE) {
     596           2 :                                         newnode = node;
     597           2 :                                         ++counter;
     598           2 :                                         if (member && Z_LVAL_P(member) > 0) {
     599           0 :                                                 php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only 0 such elements exist", mynode->name, Z_LVAL_P(member));
     600           0 :                                                 retval = FAILURE;
     601             :                                         }
     602           3 :                                 } else if (member) {
     603           3 :                                         newnode = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);
     604           3 :                                         if (newnode) {
     605           0 :                                                 ++counter;
     606             :                                         }
     607             :                                 }
     608             :                         } else {
     609          33 :                                 node = node->children;
     610         132 :                                 while (node) {
     611          66 :                                         SKIP_TEXT(node);
     612             : 
     613          35 :                                         if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {
     614           8 :                                                 newnode = node;
     615           8 :                                                 ++counter;
     616             :                                         }
     617             : 
     618             : next_iter:
     619          66 :                                         node = node->next;
     620             :                                 }
     621             :                         }
     622             :                 }
     623             : 
     624          69 :                 if (counter == 1) {
     625          25 :                         if (is_attr) {
     626          15 :                                 newnode = (xmlNodePtr) attr;
     627             :                         }
     628          25 :                         if (value) {
     629          73 :                                 while ((tempnode = (xmlNodePtr) newnode->children)) {
     630          23 :                                         xmlUnlinkNode(tempnode);
     631          23 :                                         php_libxml_node_free_resource((xmlNodePtr) tempnode);
     632             :                                 }
     633          25 :                                 change_node_zval(newnode, value);
     634             :                         }
     635          44 :                 } else if (counter > 1) {
     636           0 :                         php_error_docref(NULL, E_WARNING, "Cannot assign to an array of nodes (duplicate subnodes or attr detected)");
     637           0 :                         retval = FAILURE;
     638          44 :                 } else if (elements) {
     639          28 :                         if (!node) {
     640          50 :                                 if (!member || Z_TYPE_P(member) == IS_LONG) {
     641           0 :                                         newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
     642             :                                 } else {
     643          25 :                                         newnode = xmlNewTextChild(mynode, mynode->ns, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
     644             :                                 }
     645           6 :                         } else if (!member || Z_TYPE_P(member) == IS_LONG) {
     646           3 :                                 if (member && cnt < Z_LVAL_P(member)) {
     647           1 :                                         php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only " ZEND_LONG_FMT " such elements exist", mynode->name, Z_LVAL_P(member), cnt);
     648           1 :                                         retval = FAILURE;
     649             :                                 }
     650           3 :                                 newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
     651             :                         }
     652          16 :                 } else if (attribs) {
     653          16 :                         if (Z_TYPE_P(member) == IS_LONG) {
     654           0 :                                 php_error_docref(NULL, E_WARNING, "Cannot change attribute number " ZEND_LONG_FMT " when only %d attributes exist", Z_LVAL_P(member), nodendx);
     655           0 :                                 retval = FAILURE;
     656             :                         } else {
     657          16 :                                 newnode = (xmlNodePtr)xmlNewProp(node, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
     658             :                         }
     659             :                 }
     660             :         }
     661             : 
     662          69 :         if (member == &tmp_zv) {
     663             :                 zval_dtor(&tmp_zv);
     664             :         }
     665          69 :         if (pnewnode) {
     666          11 :                 *pnewnode = newnode;
     667             :         }
     668          69 :         if (new_value) {
     669          11 :                 zval_ptr_dtor(value);
     670             :         }
     671          69 :         return retval;
     672             : }
     673             : /* }}} */
     674             : 
     675             : /* {{{ sxe_property_write()
     676             :  */
     677          24 : static void sxe_property_write(zval *object, zval *member, zval *value, void **cache_slot)
     678             : {
     679          24 :         sxe_prop_dim_write(object, member, value, 1, 0, NULL);
     680          24 : }
     681             : /* }}} */
     682             : 
     683             : /* {{{ sxe_dimension_write()
     684             :  */
     685          38 : static void sxe_dimension_write(zval *object, zval *offset, zval *value)
     686             : {
     687          38 :         sxe_prop_dim_write(object, offset, value, 0, 1, NULL);
     688          38 : }
     689             : /* }}} */
     690             : 
     691          40 : static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, void **cache_slot) /* {{{ */
     692             : {
     693             :         php_sxe_object *sxe;
     694             :         xmlNodePtr      node;
     695             :         zval            ret;
     696             :         char           *name;
     697             :         SXE_ITER        type;
     698             : 
     699          40 :         sxe = Z_SXEOBJ_P(object);
     700             : 
     701          40 :         GET_NODE(sxe, node);
     702          40 :         convert_to_string(member);
     703          40 :         name = Z_STRVAL_P(member);
     704          40 :         node = sxe_get_element_by_name(sxe, node, &name, &type);
     705          40 :         if (node) {
     706          28 :                 return NULL;
     707             :         }
     708          12 :         if (sxe_prop_dim_write(object, member, NULL, 1, 0, &node) != SUCCESS) {
     709           1 :                 return NULL;
     710             :         }
     711          11 :         type = SXE_ITER_NONE;
     712          11 :         name = NULL;
     713             : 
     714          11 :         _node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix);
     715             : 
     716          22 :         if (!Z_ISUNDEF(sxe->tmp)) {
     717           0 :                 zval_ptr_dtor(&sxe->tmp);
     718             :         }
     719             : 
     720          11 :         ZVAL_COPY_VALUE(&sxe->tmp, &ret);
     721             : 
     722          11 :         return &sxe->tmp;
     723             : }
     724             : /* }}} */
     725             : 
     726             : /* {{{ sxe_prop_dim_exists()
     727             :  */
     728          31 : static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend_bool elements, zend_bool attribs)
     729             : {
     730             :         php_sxe_object *sxe;
     731             :         xmlNodePtr      node;
     732          31 :         xmlAttrPtr      attr = NULL;
     733          31 :         int                             exists = 0;
     734          31 :         int             test = 0;
     735             :         zval            tmp_zv;
     736             : 
     737          39 :         if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {
     738           2 :                 ZVAL_STR(&tmp_zv, zval_get_string(member));
     739           1 :                 member = &tmp_zv;
     740             :         }
     741             : 
     742          31 :         sxe = Z_SXEOBJ_P(object);
     743             : 
     744          31 :         GET_NODE(sxe, node);
     745             : 
     746          31 :         if (Z_TYPE_P(member) == IS_LONG) {
     747           7 :                 if (sxe->iter.type != SXE_ITER_ATTRLIST) {
     748           5 :                         attribs = 0;
     749           5 :                         elements = 1;
     750           5 :                         if (sxe->iter.type == SXE_ITER_CHILD) {
     751           0 :                                 node = php_sxe_get_first_node(sxe, node);
     752             :                         }
     753             :                 }
     754             :         }
     755             : 
     756          31 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     757           3 :                 attribs = 1;
     758           3 :                 elements = 0;
     759           3 :                 node = php_sxe_get_first_node(sxe, node);
     760           3 :                 attr = (xmlAttrPtr)node;
     761           3 :                 test = sxe->iter.name != NULL;
     762          28 :         } else if (sxe->iter.type != SXE_ITER_CHILD) {
     763          28 :                 node = php_sxe_get_first_node(sxe, node);
     764          28 :                 attr = node ? node->properties : NULL;
     765          28 :                 test = 0;
     766             :         }
     767             : 
     768          31 :         if (node) {
     769          26 :                 if (attribs) {
     770           5 :                         if (Z_TYPE_P(member) == IS_LONG) {
     771           1 :                                 int     nodendx = 0;
     772             : 
     773           2 :                                 while (attr && nodendx <= Z_LVAL_P(member)) {
     774           1 :                                         if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     775           1 :                                                 if (nodendx == Z_LVAL_P(member)) {
     776           1 :                                                         exists = 1;
     777           1 :                                                         break;
     778             :                                                 }
     779           0 :                                                 nodendx++;
     780             :                                         }
     781           0 :                                         attr = attr->next;
     782             :                                 }
     783             :                         } else {
     784          11 :                                 while (attr) {
     785           4 :                                         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)) {
     786           1 :                                                 exists = 1;
     787           1 :                                                 break;
     788             :                                         }
     789             : 
     790           3 :                                         attr = attr->next;
     791             :                                 }
     792             :                         }
     793           5 :                         if (exists && check_empty == 1 &&
     794           0 :                                 (!attr->children || !attr->children->content || !attr->children->content[0] || !xmlStrcmp(attr->children->content, (const xmlChar *) "0")) ) {
     795             :                                 /* Attribute with no content in it's text node */
     796           0 :                                 exists = 0;
     797             :                         }
     798             :                 }
     799             : 
     800          26 :                 if (elements) {
     801          21 :                         if (Z_TYPE_P(member) == IS_LONG) {
     802           5 :                                 if (sxe->iter.type == SXE_ITER_CHILD) {
     803           0 :                                         node = php_sxe_get_first_node(sxe, node);
     804             :                                 }
     805           5 :                                 node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);
     806             :                         }
     807             :                         else {
     808          16 :                                 node = node->children;
     809          71 :                                 while (node) {
     810             :                                         xmlNodePtr nnext;
     811          48 :                                         nnext = node->next;
     812          48 :                                         if ((node->type == XML_ELEMENT_NODE) && !xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {
     813           9 :                                                 break;
     814             :                                         }
     815          39 :                                         node = nnext;
     816             :                                 }
     817             :                         }
     818          21 :                         if (node) {
     819          12 :                                 exists = 1;
     820          12 :                                 if (check_empty == 1 &&
     821           0 :                                         (!node->children || (node->children->type == XML_TEXT_NODE && !node->children->next &&
     822           0 :                                          (!node->children->content || !node->children->content[0] || !xmlStrcmp(node->children->content, (const xmlChar *) "0")))) ) {
     823           0 :                                         exists = 0;
     824             :                                 }
     825             :                         }
     826             :                 }
     827             :         }
     828             : 
     829          31 :         if (member == &tmp_zv) {
     830             :                 zval_dtor(&tmp_zv);
     831             :         }
     832             : 
     833          31 :         return exists;
     834             : }
     835             : /* }}} */
     836             : 
     837             : /* {{{ sxe_property_exists()
     838             :  */
     839          18 : static int sxe_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
     840             : {
     841          18 :         return sxe_prop_dim_exists(object, member, check_empty, 1, 0);
     842             : }
     843             : /* }}} */
     844             : 
     845             : /* {{{ sxe_dimension_exists()
     846             :  */
     847          13 : static int sxe_dimension_exists(zval *object, zval *member, int check_empty)
     848             : {
     849          13 :         return sxe_prop_dim_exists(object, member, check_empty, 0, 1);
     850             : }
     851             : /* }}} */
     852             : 
     853             : /* {{{ sxe_prop_dim_delete()
     854             :  */
     855           7 : static void sxe_prop_dim_delete(zval *object, zval *member, zend_bool elements, zend_bool attribs)
     856             : {
     857             :         php_sxe_object *sxe;
     858             :         xmlNodePtr      node;
     859             :         xmlNodePtr      nnext;
     860           7 :         xmlAttrPtr      attr = NULL;
     861             :         xmlAttrPtr      anext;
     862             :         zval            tmp_zv;
     863           7 :         int             test = 0;
     864             : 
     865           9 :         if (Z_TYPE_P(member) != IS_STRING && Z_TYPE_P(member) != IS_LONG) {
     866           0 :                 ZVAL_STR(&tmp_zv, zval_get_string(member));
     867           0 :                 member = &tmp_zv;
     868             :         }
     869             : 
     870           7 :         sxe = Z_SXEOBJ_P(object);
     871             : 
     872           7 :         GET_NODE(sxe, node);
     873             : 
     874           7 :         if (Z_TYPE_P(member) == IS_LONG) {
     875           2 :                 if (sxe->iter.type != SXE_ITER_ATTRLIST) {
     876           1 :                         attribs = 0;
     877           1 :                         elements = 1;
     878           1 :                         if (sxe->iter.type == SXE_ITER_CHILD) {
     879           0 :                                 node = php_sxe_get_first_node(sxe, node);
     880             :                         }
     881             :                 }
     882             :         }
     883             : 
     884           7 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
     885           1 :                 attribs = 1;
     886           1 :                 elements = 0;
     887           1 :                 node = php_sxe_get_first_node(sxe, node);
     888           1 :                 attr = (xmlAttrPtr)node;
     889           1 :                 test = sxe->iter.name != NULL;
     890           6 :         } else if (sxe->iter.type != SXE_ITER_CHILD) {
     891           6 :                 node = php_sxe_get_first_node(sxe, node);
     892           6 :                 attr = node ? node->properties : NULL;
     893           6 :                 test = 0;
     894             :         }
     895             : 
     896           7 :         if (node) {
     897           7 :                 if (attribs) {
     898           6 :                         if (Z_TYPE_P(member) == IS_LONG) {
     899           1 :                                 int     nodendx = 0;
     900             : 
     901           2 :                                 while (attr && nodendx <= Z_LVAL_P(member)) {
     902           1 :                                         if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
     903           1 :                                                 if (nodendx == Z_LVAL_P(member)) {
     904           1 :                                                         xmlUnlinkNode((xmlNodePtr) attr);
     905           1 :                                                         php_libxml_node_free_resource((xmlNodePtr) attr);
     906           1 :                                                         break;
     907             :                                                 }
     908           0 :                                                 nodendx++;
     909             :                                         }
     910           0 :                                         attr = attr->next;
     911             :                                 }
     912             :                         } else {
     913          13 :                                 while (attr) {
     914           8 :                                         anext = attr->next;
     915           8 :                                         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)) {
     916           5 :                                                 xmlUnlinkNode((xmlNodePtr) attr);
     917           5 :                                                 php_libxml_node_free_resource((xmlNodePtr) attr);
     918           5 :                                                 break;
     919             :                                         }
     920           3 :                                         attr = anext;
     921             :                                 }
     922             :                         }
     923             :                 }
     924             : 
     925           7 :                 if (elements) {
     926           1 :                         if (Z_TYPE_P(member) == IS_LONG) {
     927           1 :                                 if (sxe->iter.type == SXE_ITER_CHILD) {
     928           0 :                                         node = php_sxe_get_first_node(sxe, node);
     929             :                                 }
     930           1 :                                 node = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, NULL);
     931           1 :                                 if (node) {
     932           1 :                                         xmlUnlinkNode(node);
     933           1 :                                         php_libxml_node_free_resource(node);
     934             :                                 }
     935             :                         } else {
     936           0 :                                 node = node->children;
     937           0 :                                 while (node) {
     938           0 :                                         nnext = node->next;
     939             : 
     940           0 :                                         SKIP_TEXT(node);
     941             : 
     942           0 :                                         if (!xmlStrcmp(node->name, (xmlChar *)Z_STRVAL_P(member))) {
     943           0 :                                                 xmlUnlinkNode(node);
     944           0 :                                                 php_libxml_node_free_resource(node);
     945             :                                         }
     946             : 
     947             : next_iter:
     948           0 :                                         node = nnext;
     949             :                                 }
     950             :                         }
     951             :                 }
     952             :         }
     953             : 
     954           7 :         if (member == &tmp_zv) {
     955             :                 zval_dtor(&tmp_zv);
     956             :         }
     957           7 : }
     958             : /* }}} */
     959             : 
     960             : /* {{{ sxe_property_delete()
     961             :  */
     962           0 : static void sxe_property_delete(zval *object, zval *member, void **cache_slot)
     963             : {
     964           0 :         sxe_prop_dim_delete(object, member, 1, 0);
     965           0 : }
     966             : /* }}} */
     967             : 
     968             : /* {{{ sxe_dimension_unset()
     969             :  */
     970           7 : static void sxe_dimension_delete(zval *object, zval *offset)
     971             : {
     972           7 :         sxe_prop_dim_delete(object, offset, 0, 1);
     973           7 : }
     974             : /* }}} */
     975             : 
     976         122 : static inline zend_string *sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) /* {{{ */
     977             : {
     978         122 :         xmlChar *tmp = xmlNodeListGetString(doc, list, inLine);
     979             :         zend_string *res;
     980             : 
     981         122 :         if (tmp) {
     982         242 :                 res = zend_string_init((char*)tmp, strlen((char *)tmp), 0);
     983         121 :                 xmlFree(tmp);
     984             :         } else {
     985           1 :                 res = ZSTR_EMPTY_ALLOC();
     986             :         }
     987             : 
     988         122 :         return res;
     989             : }
     990             : /* }}} */
     991             : 
     992             : /* {{{ _get_base_node_value()
     993             :  */
     994         196 : static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix)
     995             : {
     996             :         php_sxe_object *subnode;
     997             :         xmlChar        *contents;
     998             : 
     999         243 :         if (node->children && node->children->type == XML_TEXT_NODE && !xmlIsBlankNode(node->children)) {
    1000          47 :                 contents = xmlNodeListGetString(node->doc, node->children, 1);
    1001          47 :                 if (contents) {
    1002          94 :                         ZVAL_STRING(value, (char *)contents);
    1003          47 :                         xmlFree(contents);
    1004             :                 }
    1005             :         } else {
    1006         149 :                 subnode = php_sxe_object_new(sxe_ref->zo.ce, sxe_ref->fptr_count);
    1007         149 :                 subnode->document = sxe_ref->document;
    1008         149 :                 subnode->document->refcount++;
    1009         149 :                 if (nsprefix && *nsprefix) {
    1010           1 :                         subnode->iter.nsprefix = (xmlChar*)estrdup((char *)nsprefix);
    1011           1 :                         subnode->iter.isprefix = isprefix;
    1012             :                 }
    1013         149 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL);
    1014             : 
    1015         149 :                 ZVAL_OBJ(value, &subnode->zo);
    1016             :                 /*zval_add_ref(value);*/
    1017             :         }
    1018         196 : }
    1019             : /* }}} */
    1020             : 
    1021         261 : static void sxe_properties_add(HashTable *rv, char *name, int namelen, zval *value) /* {{{ */
    1022             : {
    1023             :         zend_string *key;
    1024             :         zval  *data_ptr;
    1025             :         zval  newptr;
    1026             : 
    1027         522 :         key = zend_string_init(name, namelen, 0);
    1028         261 :         if ((data_ptr = zend_hash_find(rv, key)) != NULL) {
    1029           8 :                 if (Z_TYPE_P(data_ptr) == IS_ARRAY) {
    1030           2 :                         zend_hash_next_index_insert_new(Z_ARRVAL_P(data_ptr), value);
    1031             :                 } else {
    1032           6 :                         array_init(&newptr);
    1033           6 :                         zend_hash_next_index_insert_new(Z_ARRVAL(newptr), data_ptr);
    1034           6 :                         zend_hash_next_index_insert_new(Z_ARRVAL(newptr), value);
    1035           6 :                         ZVAL_ARR(data_ptr, Z_ARR(newptr));
    1036             :                 }
    1037             :         } else {
    1038         253 :                 zend_hash_add_new(rv, key, value);
    1039             :         }
    1040             :         zend_string_release(key);
    1041         261 : }
    1042             : /* }}} */
    1043             : 
    1044          19 : static int sxe_prop_is_empty(zval *object) /* {{{ */
    1045             : {
    1046             :         php_sxe_object  *sxe;
    1047             :         xmlNodePtr       node;
    1048             :         xmlAttrPtr       attr;
    1049             :         zval             iter_data;
    1050             :         int              test;
    1051             :         int              is_empty;
    1052             : 
    1053          19 :         sxe = Z_SXEOBJ_P(object);
    1054             : 
    1055          19 :         GET_NODE(sxe, node);
    1056          19 :         if (!node) {
    1057           0 :                 return 1;
    1058             :         }
    1059             : 
    1060          19 :         if (sxe->iter.type == SXE_ITER_ELEMENT) {
    1061           3 :                 node = php_sxe_get_first_node(sxe, node);
    1062             :         }
    1063          19 :         if (!node || node->type != XML_ENTITY_DECL) {
    1064          19 :                 attr = node ? (xmlAttrPtr)node->properties : NULL;
    1065          19 :                 test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
    1066          38 :                 while (attr) {
    1067           3 :                         if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
    1068           3 :                                 return 0;
    1069             :                         }
    1070           0 :                         attr = attr->next;
    1071             :                 }
    1072             :         }
    1073             : 
    1074          16 :         GET_NODE(sxe, node);
    1075          16 :         node = php_sxe_get_first_node(sxe, node);
    1076          16 :         is_empty = 1;
    1077          16 :         ZVAL_UNDEF(&iter_data);
    1078          16 :         if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
    1079          10 :                 if (node->type == XML_ATTRIBUTE_NODE) {
    1080           1 :                         return 0;
    1081           9 :                 } else if (sxe->iter.type != SXE_ITER_CHILD) {
    1082          18 :                         if (sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || node->children->next || node->children->children || node->parent->children == node->parent->last) {
    1083           9 :                                 node = node->children;
    1084             :                         } else {
    1085           0 :                                 ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
    1086           0 :                                 ZVAL_UNDEF(&sxe->iter.data);
    1087           0 :                                 node = php_sxe_reset_iterator(sxe, 0);
    1088             :                         }
    1089             :                 }
    1090             : 
    1091          20 :                 while (node) {
    1092          12 :                         if (node->children != NULL || node->prev != NULL || node->next != NULL) {
    1093           4 :                                 SKIP_TEXT(node);
    1094             :                         } else {
    1095           6 :                                 if (node->type == XML_TEXT_NODE) {
    1096           6 :                                         const xmlChar *cur = node->content;
    1097           6 :                                         if (*cur != 0) {
    1098           6 :                                                 is_empty = 0;
    1099           6 :                                                 break;
    1100             :                                         }
    1101           0 :                                         goto next_iter;
    1102             :                                 }
    1103             :                         }
    1104             : 
    1105           2 :                         if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
    1106           0 :                                 goto next_iter;
    1107             :                         }
    1108             : 
    1109           2 :                         if (!node->name) {
    1110           0 :                                 goto next_iter;
    1111             :                         }
    1112             : 
    1113           2 :                         is_empty = 0;
    1114           2 :                         break;
    1115             : next_iter:
    1116           2 :                         if (!Z_ISUNDEF(iter_data)) {
    1117           0 :                                 node = php_sxe_iterator_fetch(sxe, node->next, 0);
    1118             :                         } else {
    1119           2 :                                 node = node->next;
    1120             :                         }
    1121             :                 }
    1122             :         }
    1123             : 
    1124          15 :         if (!Z_ISUNDEF(iter_data)) {
    1125           0 :                 if (!Z_ISUNDEF(sxe->iter.data)) {
    1126           0 :                         zval_ptr_dtor(&sxe->iter.data);
    1127             :                 }
    1128           0 :                 ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
    1129             :         }
    1130             : 
    1131          15 :         return is_empty;
    1132             : }
    1133             : /* }}} */
    1134             : 
    1135         287 : static HashTable *sxe_get_prop_hash(zval *object, int is_debug) /* {{{ */
    1136             : {
    1137             :         zval            value;
    1138             :         zval            zattr;
    1139             :         HashTable       *rv;
    1140             :         php_sxe_object  *sxe;
    1141             :         char            *name;
    1142             :         xmlNodePtr       node;
    1143             :         xmlAttrPtr       attr;
    1144             :         int              namelen;
    1145             :         int              test;
    1146             :         char                     use_iter;
    1147             :         zval             iter_data;
    1148             : 
    1149         287 :         use_iter = 0;
    1150             : 
    1151         287 :         sxe = Z_SXEOBJ_P(object);
    1152             : 
    1153         287 :         if (is_debug) {
    1154         242 :                 ALLOC_HASHTABLE(rv);
    1155         242 :                 zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
    1156          45 :         } else if (sxe->properties) {
    1157          18 :                 zend_hash_clean(sxe->properties);
    1158          18 :                 rv = sxe->properties;
    1159             :         } else {
    1160          27 :                 ALLOC_HASHTABLE(rv);
    1161          27 :                 zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
    1162          27 :                 sxe->properties = rv;
    1163             :         }
    1164             : 
    1165         287 :         GET_NODE(sxe, node);
    1166         287 :         if (!node) {
    1167           0 :                 return rv;
    1168             :         }
    1169         287 :         if (is_debug || sxe->iter.type != SXE_ITER_CHILD) {
    1170         287 :                 if (sxe->iter.type == SXE_ITER_ELEMENT) {
    1171          27 :                         node = php_sxe_get_first_node(sxe, node);
    1172             :                 }
    1173         287 :                 if (!node || node->type != XML_ENTITY_DECL) {
    1174         287 :                         attr = node ? (xmlAttrPtr)node->properties : NULL;
    1175         287 :                         ZVAL_UNDEF(&zattr);
    1176         287 :                         test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
    1177         690 :                         while (attr) {
    1178         116 :                                 if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
    1179          84 :                                         ZVAL_STR(&value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1));
    1180          84 :                                         namelen = xmlStrlen(attr->name);
    1181          84 :                                         if (Z_ISUNDEF(zattr)) {
    1182          75 :                                                 array_init(&zattr);
    1183          75 :                                                 sxe_properties_add(rv, "@attributes", sizeof("@attributes") - 1, &zattr);
    1184             :                                         }
    1185          84 :                                         add_assoc_zval_ex(&zattr, (char*)attr->name, namelen, &value);
    1186             :                                 }
    1187         116 :                                 attr = attr->next;
    1188             :                         }
    1189             :                 }
    1190             :         }
    1191             : 
    1192         287 :         GET_NODE(sxe, node);
    1193         287 :         node = php_sxe_get_first_node(sxe, node);
    1194             : 
    1195         287 :         if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
    1196         265 :                 if (node->type == XML_ATTRIBUTE_NODE) {
    1197          32 :                         ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node->children, 1));
    1198          32 :                         zend_hash_next_index_insert(rv, &value);
    1199          32 :                         node = NULL;
    1200         233 :                 } else if (sxe->iter.type != SXE_ITER_CHILD) {
    1201             : 
    1202         451 :                         if ( sxe->iter.type == SXE_ITER_NONE || !node->children || !node->parent || !node->next || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
    1203         222 :                                 node = node->children;
    1204             :                         } else {
    1205           7 :                                 ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
    1206           7 :                                 ZVAL_UNDEF(&sxe->iter.data);
    1207             : 
    1208           7 :                                 node = php_sxe_reset_iterator(sxe, 0);
    1209             : 
    1210           7 :                                 use_iter = 1;
    1211             :                         }
    1212             :                 }
    1213             : 
    1214         933 :                 while (node) {
    1215         583 :                         if (node->children != NULL || node->prev != NULL || node->next != NULL) {
    1216         376 :                                 SKIP_TEXT(node);
    1217             :                         } else {
    1218          27 :                                 if (node->type == XML_TEXT_NODE) {
    1219           7 :                                         const xmlChar *cur = node->content;
    1220             : 
    1221           7 :                                         if (*cur != 0) {
    1222           6 :                                                 ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node, 1));
    1223           6 :                                                 zend_hash_next_index_insert(rv, &value);
    1224             :                                         }
    1225           7 :                                         goto next_iter;
    1226             :                                 }
    1227             :                         }
    1228             : 
    1229         200 :                         if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
    1230           3 :                                 goto next_iter;
    1231             :                         }
    1232             : 
    1233         197 :                         name = (char *) node->name;
    1234         197 :                         if (!name) {
    1235           1 :                                 goto next_iter;
    1236             :                         } else {
    1237         196 :                                 namelen = xmlStrlen(node->name);
    1238             :                         }
    1239             : 
    1240         196 :                         _get_base_node_value(sxe, node, &value, sxe->iter.nsprefix, sxe->iter.isprefix);
    1241             : 
    1242         196 :                         if ( use_iter ) {
    1243          10 :                                 zend_hash_next_index_insert(rv, &value);
    1244             :                         } else {
    1245         186 :                                 sxe_properties_add(rv, name, namelen, &value);
    1246             :                         }
    1247             : next_iter:
    1248         403 :                         if (use_iter) {
    1249          10 :                                 node = php_sxe_iterator_fetch(sxe, node->next, 0);
    1250             :                         } else {
    1251         393 :                                 node = node->next;
    1252             :                         }
    1253             :                 }
    1254             :         }
    1255             : 
    1256         287 :         if (use_iter) {
    1257          14 :                 if (!Z_ISUNDEF(sxe->iter.data)) {
    1258           0 :                         zval_ptr_dtor(&sxe->iter.data);
    1259             :                 }
    1260           7 :                 ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
    1261             :         }
    1262             : 
    1263         287 :         return rv;
    1264             : }
    1265             : /* }}} */
    1266             : 
    1267        4000 : static HashTable *sxe_get_gc(zval *object, zval **table, int *n) /* {{{ */ {
    1268             :         php_sxe_object *sxe;
    1269        4000 :         sxe = Z_SXEOBJ_P(object);
    1270             : 
    1271        4000 :         *table = NULL;
    1272        4000 :         *n = 0;
    1273        4000 :         return sxe->properties;
    1274             : }
    1275             : /* }}} */
    1276             : 
    1277          45 : static HashTable *sxe_get_properties(zval *object) /* {{{ */
    1278             : {
    1279          45 :         return sxe_get_prop_hash(object, 0);
    1280             : }
    1281             : /* }}} */
    1282             : 
    1283         242 : static HashTable * sxe_get_debug_info(zval *object, int *is_temp) /* {{{ */
    1284             : {
    1285         242 :         *is_temp = 1;
    1286         242 :         return sxe_get_prop_hash(object, 1);
    1287             : }
    1288             : /* }}} */
    1289             : 
    1290           3 : static int sxe_objects_compare(zval *object1, zval *object2) /* {{{ */
    1291             : {
    1292             :         php_sxe_object *sxe1;
    1293             :         php_sxe_object *sxe2;
    1294             : 
    1295           3 :         sxe1 = Z_SXEOBJ_P(object1);
    1296           3 :         sxe2 = Z_SXEOBJ_P(object2);
    1297             : 
    1298           3 :         if (sxe1->node == NULL) {
    1299           0 :                 if (sxe2->node) {
    1300           0 :                         return 1;
    1301           0 :                 } else if (sxe1->document->ptr == sxe2->document->ptr) {
    1302           0 :                         return 0;
    1303             :                 }
    1304             :         } else {
    1305           3 :                 return !(sxe1->node == sxe2->node);
    1306             :         }
    1307           0 :         return 1;
    1308             : }
    1309             : /* }}} */
    1310             : 
    1311             : /* {{{ proto array SimpleXMLElement::xpath(string path)
    1312             :    Runs XPath query on the XML data */
    1313          23 : SXE_METHOD(xpath)
    1314             : {
    1315             :         php_sxe_object    *sxe;
    1316             :         zval               value;
    1317             :         char              *query;
    1318             :         size_t                query_len;
    1319             :         int                i;
    1320          23 :         int                nsnbr = 0;
    1321          23 :         xmlNsPtr          *ns = NULL;
    1322             :         xmlXPathObjectPtr  retval;
    1323             :         xmlNodeSetPtr      result;
    1324             :         xmlNodePtr                 nodeptr;
    1325             : 
    1326          23 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &query, &query_len) == FAILURE) {
    1327           0 :                 return;
    1328             :         }
    1329             : 
    1330          46 :         sxe = Z_SXEOBJ_P(getThis());
    1331             : 
    1332          23 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
    1333           0 :                 return; /* attributes don't have attributes */
    1334             :         }
    1335             : 
    1336          23 :         if (!sxe->xpath) {
    1337          13 :                 sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
    1338             :         }
    1339          23 :         if (!sxe->node) {
    1340           1 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL);
    1341           1 :                 if (!sxe->node) {
    1342           1 :                         RETURN_FALSE;
    1343             :                 }
    1344             :         }
    1345             : 
    1346          22 :         nodeptr = php_sxe_get_first_node(sxe, sxe->node->node);
    1347             : 
    1348          22 :         sxe->xpath->node = nodeptr;
    1349             : 
    1350          22 :         ns = xmlGetNsList((xmlDocPtr) sxe->document->ptr, nodeptr);
    1351          22 :         if (ns != NULL) {
    1352          18 :                 while (ns[nsnbr] != NULL) {
    1353           6 :                         nsnbr++;
    1354             :                 }
    1355             :         }
    1356             : 
    1357          22 :         sxe->xpath->namespaces = ns;
    1358          22 :         sxe->xpath->nsNr = nsnbr;
    1359             : 
    1360          22 :         retval = xmlXPathEval((xmlChar *)query, sxe->xpath);
    1361          22 :         if (ns != NULL) {
    1362           6 :                 xmlFree(ns);
    1363           6 :                 sxe->xpath->namespaces = NULL;
    1364           6 :                 sxe->xpath->nsNr = 0;
    1365             :         }
    1366             : 
    1367          22 :         if (!retval) {
    1368           1 :                 RETURN_FALSE;
    1369             :         }
    1370             : 
    1371          21 :         result = retval->nodesetval;
    1372             : 
    1373          21 :         array_init(return_value);
    1374             : 
    1375          21 :         if (result != NULL) {
    1376          69 :                 for (i = 0; i < result->nodeNr; ++i) {
    1377          50 :                         nodeptr = result->nodeTab[i];
    1378          50 :                         if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
    1379             :                                 /**
    1380             :                                  * Detect the case where the last selector is text(), simplexml
    1381             :                                  * always accesses the text() child by default, therefore we assign
    1382             :                                  * to the parent node.
    1383             :                                  */
    1384          50 :                                 if (nodeptr->type == XML_TEXT_NODE) {
    1385           0 :                                         _node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_NONE, NULL, NULL, 0);
    1386          50 :                                 } else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
    1387          20 :                                         _node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0);
    1388             :                                 } else {
    1389          30 :                                         _node_as_zval(sxe, nodeptr, &value, SXE_ITER_NONE, NULL, NULL, 0);
    1390             :                                 }
    1391             : 
    1392          50 :                                 add_next_index_zval(return_value, &value);
    1393             :                         }
    1394             :                 }
    1395             :         }
    1396             : 
    1397          21 :         xmlXPathFreeObject(retval);
    1398             : }
    1399             : /* }}} */
    1400             : 
    1401             : /* {{{ proto bool SimpleXMLElement::registerXPathNamespace(string prefix, string ns)
    1402             :    Creates a prefix/ns context for the next XPath query */
    1403           1 : SXE_METHOD(registerXPathNamespace)
    1404             : {
    1405             :         php_sxe_object    *sxe;
    1406             :         size_t prefix_len, ns_uri_len;
    1407             :         char *prefix, *ns_uri;
    1408             : 
    1409           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &prefix, &prefix_len, &ns_uri, &ns_uri_len) == FAILURE) {
    1410           0 :                 return;
    1411             :         }
    1412             : 
    1413           2 :         sxe = Z_SXEOBJ_P(getThis());
    1414           1 :         if (!sxe->xpath) {
    1415           1 :                 sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
    1416             :         }
    1417             : 
    1418           1 :         if (xmlXPathRegisterNs(sxe->xpath, (xmlChar *)prefix, (xmlChar *)ns_uri) != 0) {
    1419           0 :                 RETURN_FALSE
    1420             :         }
    1421           1 :         RETURN_TRUE;
    1422             : }
    1423             : 
    1424             : /* }}} */
    1425             : 
    1426             : /* {{{ proto string SimpleXMLElement::asXML([string filename])
    1427             :    Return a well-formed XML string based on SimpleXML element */
    1428          32 : SXE_METHOD(asXML)
    1429             : {
    1430             :         php_sxe_object     *sxe;
    1431             :         xmlNodePtr          node;
    1432             :         xmlOutputBufferPtr  outbuf;
    1433             :         xmlChar            *strval;
    1434             :         int                 strval_len;
    1435             :         char               *filename;
    1436             :         size_t                 filename_len;
    1437             : 
    1438          32 :         if (ZEND_NUM_ARGS() > 1) {
    1439           0 :                 RETURN_FALSE;
    1440             :         }
    1441             : 
    1442          32 :         if (ZEND_NUM_ARGS() == 1) {
    1443           0 :                 if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &filename, &filename_len) == FAILURE) {
    1444           0 :                         RETURN_FALSE;
    1445             :                 }
    1446             : 
    1447           0 :                 sxe = Z_SXEOBJ_P(getThis());
    1448           0 :                 GET_NODE(sxe, node);
    1449           0 :                 node = php_sxe_get_first_node(sxe, node);
    1450             : 
    1451           0 :                 if (node) {
    1452           0 :                         if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
    1453             :                                 int bytes;
    1454           0 :                                 bytes = xmlSaveFile(filename, (xmlDocPtr) sxe->document->ptr);
    1455           0 :                                 if (bytes == -1) {
    1456           0 :                                         RETURN_FALSE;
    1457             :                                 } else {
    1458           0 :                                         RETURN_TRUE;
    1459             :                                 }
    1460             :                         } else {
    1461           0 :                                 outbuf = xmlOutputBufferCreateFilename(filename, NULL, 0);
    1462             : 
    1463           0 :                                 if (outbuf == NULL) {
    1464           0 :                                         RETURN_FALSE;
    1465             :                                 }
    1466             : 
    1467           0 :                                 xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, NULL);
    1468           0 :                                 xmlOutputBufferClose(outbuf);
    1469           0 :                                 RETURN_TRUE;
    1470             :                         }
    1471             :                 } else {
    1472           0 :                         RETURN_FALSE;
    1473             :                 }
    1474             :         }
    1475             : 
    1476          64 :         sxe = Z_SXEOBJ_P(getThis());
    1477          32 :         GET_NODE(sxe, node);
    1478          32 :         node = php_sxe_get_first_node(sxe, node);
    1479             : 
    1480          32 :         if (node) {
    1481          51 :                 if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
    1482          19 :                         xmlDocDumpMemoryEnc((xmlDocPtr) sxe->document->ptr, &strval, &strval_len, (const char *) ((xmlDocPtr) sxe->document->ptr)->encoding);
    1483          38 :                         RETVAL_STRINGL((char *)strval, strval_len);
    1484          19 :                         xmlFree(strval);
    1485             :                 } else {
    1486             :                         /* Should we be passing encoding information instead of NULL? */
    1487          13 :                         outbuf = xmlAllocOutputBuffer(NULL);
    1488             : 
    1489          13 :                         if (outbuf == NULL) {
    1490           0 :                                 RETURN_FALSE;
    1491             :                         }
    1492             : 
    1493          13 :                         xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, (const char *) ((xmlDocPtr) sxe->document->ptr)->encoding);
    1494          13 :                         xmlOutputBufferFlush(outbuf);
    1495             : #ifdef LIBXML2_NEW_BUFFER
    1496             :                         RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf));
    1497             : #else
    1498          26 :                         RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use);
    1499             : #endif
    1500          13 :                         xmlOutputBufferClose(outbuf);
    1501             :                 }
    1502             :         } else {
    1503           0 :                 RETVAL_FALSE;
    1504             :         }
    1505             : }
    1506             : /* }}} */
    1507             : 
    1508             : #define SXE_NS_PREFIX(ns) (ns->prefix ? (char*)ns->prefix : "")
    1509             : 
    1510          38 : static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns) /* {{{ */
    1511             : {
    1512          38 :         char *prefix = SXE_NS_PREFIX(ns);
    1513          76 :         zend_string *key = zend_string_init(prefix, strlen(prefix), 0);
    1514             :         zval zv;
    1515             : 
    1516          38 :         if (!zend_hash_exists(Z_ARRVAL_P(return_value), key)) {
    1517          66 :                 ZVAL_STRING(&zv, (char*)ns->href);
    1518          33 :                 zend_hash_add_new(Z_ARRVAL_P(return_value), key, &zv);
    1519             :         }
    1520             :         zend_string_release(key);
    1521          38 : }
    1522             : /* }}} */
    1523             : 
    1524          22 : static void sxe_add_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value) /* {{{ */
    1525             : {
    1526             :         xmlAttrPtr  attr;
    1527             : 
    1528          22 :         if (node->ns) {
    1529          15 :                 sxe_add_namespace_name(return_value, node->ns);
    1530             :         }
    1531             : 
    1532          22 :         attr = node->properties;
    1533          45 :         while (attr) {
    1534           1 :                 if (attr->ns) {
    1535           1 :                         sxe_add_namespace_name(return_value, attr->ns);
    1536             :                 }
    1537           1 :                 attr = attr->next;
    1538             :         }
    1539             : 
    1540          22 :         if (recursive) {
    1541          12 :                 node = node->children;
    1542          48 :                 while (node) {
    1543          24 :                         if (node->type == XML_ELEMENT_NODE) {
    1544          10 :                                 sxe_add_namespaces(sxe, node, recursive, return_value);
    1545             :                         }
    1546          24 :                         node = node->next;
    1547             :                 }
    1548             :         }
    1549          22 : } /* }}} */
    1550             : 
    1551             : /* {{{ proto string SimpleXMLElement::getNamespaces([bool recursve])
    1552             :    Return all namespaces in use */
    1553          12 : SXE_METHOD(getNamespaces)
    1554             : {
    1555          12 :         zend_bool           recursive = 0;
    1556             :         php_sxe_object     *sxe;
    1557             :         xmlNodePtr          node;
    1558             : 
    1559          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &recursive) == FAILURE) {
    1560           0 :                 return;
    1561             :         }
    1562             : 
    1563          12 :         array_init(return_value);
    1564             : 
    1565          24 :         sxe = Z_SXEOBJ_P(getThis());
    1566          12 :         GET_NODE(sxe, node);
    1567          12 :         node = php_sxe_get_first_node(sxe, node);
    1568             : 
    1569          12 :         if (node) {
    1570          12 :                 if (node->type == XML_ELEMENT_NODE) {
    1571          12 :                         sxe_add_namespaces(sxe, node, recursive, return_value);
    1572           0 :                 } else if (node->type == XML_ATTRIBUTE_NODE && node->ns) {
    1573           0 :                         sxe_add_namespace_name(return_value, node->ns);
    1574             :                 }
    1575             :         }
    1576             : }
    1577             : /* }}} */
    1578             : 
    1579          98 : static void sxe_add_registered_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value) /* {{{ */
    1580             : {
    1581             :         xmlNsPtr ns;
    1582             : 
    1583          98 :         if (node->type == XML_ELEMENT_NODE) {
    1584          42 :                 ns = node->nsDef;
    1585         106 :                 while (ns != NULL) {
    1586          22 :                         sxe_add_namespace_name(return_value, ns);
    1587          22 :                         ns = ns->next;
    1588             :                 }
    1589          42 :                 if (recursive) {
    1590          33 :                         node = node->children;
    1591         148 :                         while (node) {
    1592          82 :                                 sxe_add_registered_namespaces(sxe, node, recursive, return_value);
    1593          82 :                                 node = node->next;
    1594             :                         }
    1595             :                 }
    1596             :         }
    1597          98 : }
    1598             : /* }}} */
    1599             : 
    1600             : /* {{{ proto string SimpleXMLElement::getDocNamespaces([bool recursive [, bool from_root])
    1601             :    Return all namespaces registered with document */
    1602          17 : SXE_METHOD(getDocNamespaces)
    1603             : {
    1604          17 :         zend_bool           recursive = 0, from_root = 1;
    1605             :         php_sxe_object     *sxe;
    1606             :         xmlNodePtr          node;
    1607             : 
    1608          17 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|bb", &recursive, &from_root) == FAILURE) {
    1609           0 :                 return;
    1610             :         }
    1611             : 
    1612          34 :         sxe = Z_SXEOBJ_P(getThis());
    1613          17 :         if(from_root){
    1614          11 :                 node = xmlDocGetRootElement((xmlDocPtr)sxe->document->ptr);
    1615             :         }else{
    1616           6 :                 GET_NODE(sxe, node);
    1617             :         }
    1618             : 
    1619          17 :         if (node == NULL) {
    1620           1 :                 RETURN_FALSE;
    1621             :         }
    1622             : 
    1623          16 :         array_init(return_value);
    1624          16 :         sxe_add_registered_namespaces(sxe, node, recursive, return_value);
    1625             : }
    1626             : /* }}} */
    1627             : 
    1628             : /* {{{ proto object SimpleXMLElement::children([string ns [, bool is_prefix]])
    1629             :    Finds children of given node */
    1630          92 : SXE_METHOD(children)
    1631             : {
    1632             :         php_sxe_object *sxe;
    1633          92 :         char           *nsprefix = NULL;
    1634          92 :         size_t             nsprefix_len = 0;
    1635             :         xmlNodePtr      node;
    1636          92 :         zend_bool       isprefix = 0;
    1637             : 
    1638          92 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
    1639           0 :                 return;
    1640             :         }
    1641             : 
    1642         184 :         sxe = Z_SXEOBJ_P(getThis());
    1643             : 
    1644          92 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
    1645           0 :                 return; /* attributes don't have attributes */
    1646             :         }
    1647             : 
    1648          92 :         GET_NODE(sxe, node);
    1649          92 :         node = php_sxe_get_first_node(sxe, node);
    1650             : 
    1651          92 :         _node_as_zval(sxe, node, return_value, SXE_ITER_CHILD, NULL, (xmlChar *)nsprefix, isprefix);
    1652             : 
    1653             : }
    1654             : /* }}} */
    1655             : 
    1656             : /* {{{ proto object SimpleXMLElement::getName()
    1657             :    Finds children of given node */
    1658          55 : SXE_METHOD(getName)
    1659             : {
    1660             :         php_sxe_object *sxe;
    1661             :         xmlNodePtr      node;
    1662             :         int             namelen;
    1663             : 
    1664         110 :         sxe = Z_SXEOBJ_P(getThis());
    1665             : 
    1666          55 :         GET_NODE(sxe, node);
    1667          55 :         node = php_sxe_get_first_node(sxe, node);
    1668          55 :         if (node) {
    1669          55 :                 namelen = xmlStrlen(node->name);
    1670         110 :                 RETURN_STRINGL((char*)node->name, namelen);
    1671             :         } else {
    1672           0 :                 RETURN_EMPTY_STRING();
    1673             :         }
    1674             : }
    1675             : /* }}} */
    1676             : 
    1677             : /* {{{ proto array SimpleXMLElement::attributes([string ns [, bool is_prefix]])
    1678             :    Identifies an element's attributes */
    1679          39 : SXE_METHOD(attributes)
    1680             : {
    1681             :         php_sxe_object *sxe;
    1682          39 :         char           *nsprefix = NULL;
    1683          39 :         size_t             nsprefix_len = 0;
    1684             :         xmlNodePtr      node;
    1685          39 :         zend_bool       isprefix = 0;
    1686             : 
    1687          39 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
    1688           0 :                 return;
    1689             :         }
    1690             : 
    1691          78 :         sxe = Z_SXEOBJ_P(getThis());
    1692          39 :         GET_NODE(sxe, node);
    1693             : 
    1694          39 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
    1695           0 :                 return; /* attributes don't have attributes */
    1696             :         }
    1697             : 
    1698          39 :         node = php_sxe_get_first_node(sxe, node);
    1699             : 
    1700          39 :         _node_as_zval(sxe, node, return_value, SXE_ITER_ATTRLIST, NULL, (xmlChar *)nsprefix, isprefix);
    1701             : }
    1702             : /* }}} */
    1703             : 
    1704             : /* {{{ proto void SimpleXMLElement::addChild(string qName [, string value [, string ns]])
    1705             :    Add Element with optional namespace information */
    1706          12 : SXE_METHOD(addChild)
    1707             : {
    1708             :         php_sxe_object *sxe;
    1709          12 :         char           *qname, *value = NULL, *nsuri = NULL;
    1710          12 :         size_t             qname_len, value_len = 0, nsuri_len = 0;
    1711             :         xmlNodePtr      node, newnode;
    1712          12 :         xmlNsPtr        nsptr = NULL;
    1713          12 :         xmlChar        *localname, *prefix = NULL;
    1714             : 
    1715          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!s!",
    1716             :                 &qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
    1717           0 :                 return;
    1718             :         }
    1719             : 
    1720          12 :         if (qname_len == 0) {
    1721           0 :                 php_error_docref(NULL, E_WARNING, "Element name is required");
    1722           0 :                 return;
    1723             :         }
    1724             : 
    1725          24 :         sxe = Z_SXEOBJ_P(getThis());
    1726          12 :         GET_NODE(sxe, node);
    1727             : 
    1728          12 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
    1729           1 :                 php_error_docref(NULL, E_WARNING, "Cannot add element to attributes");
    1730           1 :                 return;
    1731             :         }
    1732             : 
    1733          11 :         node = php_sxe_get_first_node(sxe, node);
    1734             : 
    1735          11 :         if (node == NULL) {
    1736           0 :                 php_error_docref(NULL, E_WARNING, "Cannot add child. Parent is not a permanent member of the XML tree");
    1737           0 :                 return;
    1738             :         }
    1739             : 
    1740          11 :         localname = xmlSplitQName2((xmlChar *)qname, &prefix);
    1741          11 :         if (localname == NULL) {
    1742           8 :                 localname = xmlStrdup((xmlChar *)qname);
    1743             :         }
    1744             : 
    1745          11 :         newnode = xmlNewChild(node, NULL, localname, (xmlChar *)value);
    1746             : 
    1747          11 :         if (nsuri != NULL) {
    1748           5 :                 if (nsuri_len == 0) {
    1749           1 :                         newnode->ns = NULL;
    1750           1 :                         nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
    1751             :                 } else {
    1752           4 :                         nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
    1753           4 :                         if (nsptr == NULL) {
    1754           2 :                                 nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
    1755             :                         }
    1756           4 :                         newnode->ns = nsptr;
    1757             :                 }
    1758             :         }
    1759             : 
    1760          11 :         _node_as_zval(sxe, newnode, return_value, SXE_ITER_NONE, (char *)localname, prefix, 0);
    1761             : 
    1762          11 :         xmlFree(localname);
    1763          11 :         if (prefix != NULL) {
    1764           3 :                 xmlFree(prefix);
    1765             :         }
    1766             : }
    1767             : /* }}} */
    1768             : 
    1769             : /* {{{ proto void SimpleXMLElement::addAttribute(string qName, string value [,string ns])
    1770             :    Add Attribute with optional namespace information */
    1771          11 : SXE_METHOD(addAttribute)
    1772             : {
    1773             :         php_sxe_object *sxe;
    1774          11 :         char           *qname, *value = NULL, *nsuri = NULL;
    1775          11 :         size_t             qname_len, value_len = 0, nsuri_len = 0;
    1776             :         xmlNodePtr      node;
    1777          11 :         xmlAttrPtr      attrp = NULL;
    1778          11 :         xmlNsPtr        nsptr = NULL;
    1779          11 :         xmlChar        *localname, *prefix = NULL;
    1780             : 
    1781          11 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|s!",
    1782             :                 &qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
    1783           0 :                 return;
    1784             :         }
    1785             : 
    1786          11 :         if (qname_len == 0) {
    1787           1 :                 php_error_docref(NULL, E_WARNING, "Attribute name is required");
    1788           1 :                 return;
    1789             :         }
    1790             : 
    1791          20 :         sxe = Z_SXEOBJ_P(getThis());
    1792          10 :         GET_NODE(sxe, node);
    1793             : 
    1794          10 :         node = php_sxe_get_first_node(sxe, node);
    1795             : 
    1796          10 :         if (node && node->type != XML_ELEMENT_NODE) {
    1797           0 :                 node = node->parent;
    1798             :         }
    1799             : 
    1800          10 :         if (node == NULL) {
    1801           1 :                 php_error_docref(NULL, E_WARNING, "Unable to locate parent Element");
    1802           1 :                 return;
    1803             :         }
    1804             : 
    1805           9 :         localname = xmlSplitQName2((xmlChar *)qname, &prefix);
    1806           9 :         if (localname == NULL) {
    1807           6 :                 if (nsuri_len > 0) {
    1808           1 :                         if (prefix != NULL) {
    1809           0 :                                 xmlFree(prefix);
    1810             :                         }
    1811           1 :                         php_error_docref(NULL, E_WARNING, "Attribute requires prefix for namespace");
    1812           1 :                         return;
    1813             :                 }
    1814           5 :                 localname = xmlStrdup((xmlChar *)qname);
    1815             :         }
    1816             : 
    1817           8 :         attrp = xmlHasNsProp(node, localname, (xmlChar *)nsuri);
    1818           8 :         if (attrp != NULL && attrp->type != XML_ATTRIBUTE_DECL) {
    1819           1 :                 xmlFree(localname);
    1820           1 :                 if (prefix != NULL) {
    1821           1 :                         xmlFree(prefix);
    1822             :                 }
    1823           1 :                 php_error_docref(NULL, E_WARNING, "Attribute already exists");
    1824           1 :                 return;
    1825             :         }
    1826             : 
    1827           7 :         if (nsuri != NULL) {
    1828           2 :                 nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
    1829           2 :                 if (nsptr == NULL) {
    1830           2 :                         nsptr = xmlNewNs(node, (xmlChar *)nsuri, prefix);
    1831             :                 }
    1832             :         }
    1833             : 
    1834           7 :         attrp = xmlNewNsProp(node, nsptr, localname, (xmlChar *)value);
    1835             : 
    1836           7 :         xmlFree(localname);
    1837           7 :         if (prefix != NULL) {
    1838           2 :                 xmlFree(prefix);
    1839             :         }
    1840             : }
    1841             : /* }}} */
    1842             : 
    1843             : /* {{{ cast_object()
    1844             :  */
    1845      200184 : static int cast_object(zval *object, int type, char *contents)
    1846             : {
    1847      200184 :         if (contents) {
    1848      400332 :                 ZVAL_STRINGL(object, contents, strlen(contents));
    1849             :         } else {
    1850          18 :                 ZVAL_NULL(object);
    1851             :         }
    1852             : 
    1853      200184 :         switch (type) {
    1854             :                 case IS_STRING:
    1855      200179 :                         convert_to_string(object);
    1856      200179 :                         break;
    1857             :                 case _IS_BOOL:
    1858           0 :                         convert_to_boolean(object);
    1859           0 :                         break;
    1860             :                 case IS_LONG:
    1861           3 :                         convert_to_long(object);
    1862           3 :                         break;
    1863             :                 case IS_DOUBLE:
    1864           2 :                         convert_to_double(object);
    1865           2 :                         break;
    1866             :                 default:
    1867           0 :                         return FAILURE;
    1868             :         }
    1869      200184 :         return SUCCESS;
    1870             : }
    1871             : /* }}} */
    1872             : 
    1873             : /* {{{ sxe_object_cast()
    1874             :  */
    1875      200208 : static int sxe_object_cast_ex(zval *readobj, zval *writeobj, int type)
    1876             : {
    1877             :         php_sxe_object *sxe;
    1878      200208 :         xmlChar        *contents = NULL;
    1879             :         xmlNodePtr          node;
    1880             :         int rv;
    1881             : 
    1882      200208 :         sxe = Z_SXEOBJ_P(readobj);
    1883             : 
    1884      200208 :         if (type == _IS_BOOL) {
    1885          24 :                 node = php_sxe_get_first_node(sxe, NULL);
    1886          24 :                 if (node) {
    1887           5 :                         ZVAL_TRUE(writeobj);
    1888             :                 } else {
    1889          19 :                         ZVAL_BOOL(writeobj, !sxe_prop_is_empty(readobj));
    1890             :                 }
    1891          24 :                 return SUCCESS;
    1892             :         }
    1893             : 
    1894      200184 :         if (sxe->iter.type != SXE_ITER_NONE) {
    1895      200058 :                 node = php_sxe_get_first_node(sxe, NULL);
    1896      200058 :                 if (node) {
    1897      200053 :                         contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, node->children, 1);
    1898             :                 }
    1899             :         } else {
    1900         126 :                 if (!sxe->node) {
    1901           0 :                         if (sxe->document) {
    1902           0 :                                 php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL);
    1903             :                         }
    1904             :                 }
    1905             : 
    1906         126 :                 if (sxe->node && sxe->node->node) {
    1907         126 :                         if (sxe->node->node->children) {
    1908         119 :                                 contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, sxe->node->node->children, 1);
    1909             :                         }
    1910             :                 }
    1911             :         }
    1912             : 
    1913      200184 :         if (readobj == writeobj) {
    1914           0 :                 zval_ptr_dtor(readobj);
    1915             :         }
    1916             : 
    1917      200184 :         rv = cast_object(writeobj, type, (char *)contents);
    1918             : 
    1919      200184 :         if (contents) {
    1920      200166 :                 xmlFree(contents);
    1921             :         }
    1922             : 
    1923      200184 :         return rv;
    1924             : }
    1925             : /* }}} */
    1926             : 
    1927             : /*  {{{ Variant of sxe_object_cast_ex that handles overwritten __toString() method */
    1928      200199 : static int sxe_object_cast(zval *readobj, zval *writeobj, int type)
    1929             : {
    1930      400369 :         if (type == IS_STRING
    1931      200170 :                 && zend_std_cast_object_tostring(readobj, writeobj, IS_STRING) == SUCCESS
    1932             :         ) {
    1933      200170 :                 return SUCCESS;
    1934             :         }
    1935             : 
    1936          29 :         return sxe_object_cast_ex(readobj, writeobj, type);
    1937             : }
    1938             : /* }}} */
    1939             : 
    1940             : /* {{{ proto object SimpleXMLElement::__toString()
    1941             :    Returns the string content */
    1942      200170 : SXE_METHOD(__toString)
    1943             : {
    1944      400340 :         if (sxe_object_cast_ex(getThis(), return_value, IS_STRING) != SUCCESS) {
    1945           0 :                 zval_ptr_dtor(return_value);
    1946           0 :                 RETURN_EMPTY_STRING();
    1947             :         }
    1948             : }
    1949             : /* }}} */
    1950             : 
    1951          23 : static int php_sxe_count_elements_helper(php_sxe_object *sxe, zend_long *count) /* {{{ */
    1952             : {
    1953             :         xmlNodePtr      node;
    1954             :         zval            data;
    1955             : 
    1956          23 :         *count = 0;
    1957             : 
    1958          23 :         ZVAL_COPY_VALUE(&data, &sxe->iter.data);
    1959          23 :         ZVAL_UNDEF(&sxe->iter.data);
    1960             : 
    1961          23 :         node = php_sxe_reset_iterator(sxe, 0);
    1962             : 
    1963          77 :         while (node)
    1964             :         {
    1965          31 :                 (*count)++;
    1966          31 :                 node = php_sxe_iterator_fetch(sxe, node->next, 0);
    1967             :         }
    1968             : 
    1969          46 :         if (!Z_ISUNDEF(sxe->iter.data)) {
    1970           0 :                 zval_ptr_dtor(&sxe->iter.data);
    1971             :         }
    1972          23 :         ZVAL_COPY_VALUE(&sxe->iter.data, &data);
    1973             : 
    1974          23 :         return SUCCESS;
    1975             : }
    1976             : /* }}} */
    1977             : 
    1978          23 : static int sxe_count_elements(zval *object, zend_long *count) /* {{{ */
    1979             : {
    1980             :         php_sxe_object  *intern;
    1981          23 :         intern = Z_SXEOBJ_P(object);
    1982          23 :         if (intern->fptr_count) {
    1983             :                 zval rv;
    1984           4 :                 zend_call_method_with_0_params(object, intern->zo.ce, &intern->fptr_count, "count", &rv);
    1985           4 :                 if (!Z_ISUNDEF(rv)) {
    1986           4 :                         *count = zval_get_long(&rv);
    1987           4 :                         zval_ptr_dtor(&rv);
    1988           4 :                         return SUCCESS;
    1989             :                 }
    1990           0 :                 return FAILURE;
    1991             :         }
    1992          19 :         return php_sxe_count_elements_helper(intern, count);
    1993             : }
    1994             : /* }}} */
    1995             : 
    1996             : /* {{{ proto int SimpleXMLElement::count()
    1997             :  Get number of child elements */
    1998           4 : SXE_METHOD(count)
    1999             : {
    2000           4 :         zend_long count = 0;
    2001           8 :         php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
    2002             : 
    2003           4 :         if (zend_parse_parameters_none() == FAILURE) {
    2004           0 :                 return;
    2005             :         }
    2006             : 
    2007           4 :         php_sxe_count_elements_helper(sxe, &count);
    2008             : 
    2009           4 :         RETURN_LONG(count);
    2010             : }
    2011             : /* }}} */
    2012             : 
    2013           9 : static zval *sxe_get_value(zval *z, zval *rv) /* {{{ */
    2014             : {
    2015           9 :         if (sxe_object_cast_ex(z, rv, IS_STRING) == FAILURE) {
    2016           0 :                 zend_error(E_ERROR, "Unable to cast node to string");
    2017             :                 /* FIXME: Should not be fatal */
    2018             :         }
    2019             : 
    2020           9 :         return rv;
    2021             : }
    2022             : /* }}} */
    2023             : 
    2024             : static zend_object_handlers sxe_object_handlers = { /* {{{ */
    2025             :         ZEND_OBJECTS_STORE_HANDLERS,
    2026             :         sxe_property_read,
    2027             :         sxe_property_write,
    2028             :         sxe_dimension_read,
    2029             :         sxe_dimension_write,
    2030             :         sxe_property_get_adr,
    2031             :         sxe_get_value,                  /* get */
    2032             :         NULL,
    2033             :         sxe_property_exists,
    2034             :         sxe_property_delete,
    2035             :         sxe_dimension_exists,
    2036             :         sxe_dimension_delete,
    2037             :         sxe_get_properties,
    2038             :         NULL, /* zend_get_std_object_handlers()->get_method,*/
    2039             :         NULL, /* zend_get_std_object_handlers()->call_method,*/
    2040             :         NULL, /* zend_get_std_object_handlers()->get_constructor, */
    2041             :         NULL, /* zend_get_std_object_handlers()->get_class_name,*/
    2042             :         sxe_objects_compare,
    2043             :         sxe_object_cast,
    2044             :         sxe_count_elements,
    2045             :         sxe_get_debug_info,
    2046             :         NULL,
    2047             :         sxe_get_gc,
    2048             :         NULL,
    2049             :         NULL
    2050             : };
    2051             : /* }}} */
    2052             : 
    2053             : /* {{{ sxe_object_clone()
    2054             :  */
    2055             : static zend_object *
    2056           7 : sxe_object_clone(zval *object)
    2057             : {
    2058           7 :         php_sxe_object *sxe = Z_SXEOBJ_P(object);
    2059             :         php_sxe_object *clone;
    2060           7 :         xmlNodePtr nodep = NULL;
    2061           7 :         xmlDocPtr docp = NULL;
    2062             : 
    2063           7 :         clone = php_sxe_object_new(sxe->zo.ce, sxe->fptr_count);
    2064           7 :         clone->document = sxe->document;
    2065           7 :         if (clone->document) {
    2066           7 :                 clone->document->refcount++;
    2067           7 :                 docp = clone->document->ptr;
    2068             :         }
    2069             : 
    2070           7 :         clone->iter.isprefix = sxe->iter.isprefix;
    2071           7 :         if (sxe->iter.name != NULL) {
    2072           1 :                 clone->iter.name = (xmlChar*)estrdup((char*)sxe->iter.name);
    2073             :         }
    2074           7 :         if (sxe->iter.nsprefix != NULL) {
    2075           0 :                 clone->iter.nsprefix = (xmlChar*)estrdup((char*)sxe->iter.nsprefix);
    2076             :         }
    2077           7 :         clone->iter.type = sxe->iter.type;
    2078             : 
    2079           7 :         if (sxe->node) {
    2080           7 :                 nodep = xmlDocCopyNode(sxe->node->node, docp, 1);
    2081             :         }
    2082             : 
    2083           7 :         php_libxml_increment_node_ptr((php_libxml_node_object *)clone, nodep, NULL);
    2084             : 
    2085           7 :         return &clone->zo;
    2086             : }
    2087             : /* }}} */
    2088             : 
    2089             : /* {{{ sxe_object_dtor()
    2090             :  */
    2091      403534 : static void sxe_object_dtor(zend_object *object)
    2092             : {
    2093             :         /* dtor required to cleanup iterator related data properly */
    2094             :         php_sxe_object *sxe;
    2095             : 
    2096      403534 :         sxe = php_sxe_fetch_object(object);
    2097             : 
    2098      807068 :         if (!Z_ISUNDEF(sxe->iter.data)) {
    2099      200345 :                 zval_ptr_dtor(&sxe->iter.data);
    2100      200345 :                 ZVAL_UNDEF(&sxe->iter.data);
    2101             :         }
    2102             : 
    2103      403534 :         if (sxe->iter.name) {
    2104      200370 :                 efree(sxe->iter.name);
    2105      200370 :                 sxe->iter.name = NULL;
    2106             :         }
    2107      403534 :         if (sxe->iter.nsprefix) {
    2108         124 :                 efree(sxe->iter.nsprefix);
    2109         124 :                 sxe->iter.nsprefix = NULL;
    2110             :         }
    2111      807068 :         if (!Z_ISUNDEF(sxe->tmp)) {
    2112          11 :                 zval_ptr_dtor(&sxe->tmp);
    2113          11 :                 ZVAL_UNDEF(&sxe->tmp);
    2114             :         }
    2115      403534 : }
    2116             : /* }}} */
    2117             : 
    2118             : /* {{{ sxe_object_free_storage()
    2119             :  */
    2120      403536 : static void sxe_object_free_storage(zend_object *object)
    2121             : {
    2122             :         php_sxe_object *sxe;
    2123             : 
    2124      403536 :         sxe = php_sxe_fetch_object(object);
    2125             : 
    2126      403536 :         zend_object_std_dtor(&sxe->zo);
    2127             : 
    2128      403536 :         php_libxml_node_decrement_resource((php_libxml_node_object *)sxe);
    2129             : 
    2130      403536 :         if (sxe->xpath) {
    2131          14 :                 xmlXPathFreeContext(sxe->xpath);
    2132             :         }
    2133             : 
    2134      403536 :         if (sxe->properties) {
    2135          27 :                 zend_hash_destroy(sxe->properties);
    2136          27 :                 FREE_HASHTABLE(sxe->properties);
    2137             :         }
    2138      403536 : }
    2139             : /* }}} */
    2140             : 
    2141             : /* {{{ php_sxe_find_fptr_count()
    2142             :  */
    2143        2162 : static zend_function* php_sxe_find_fptr_count(zend_class_entry *ce)
    2144             : {
    2145        2162 :         zend_function *fptr_count = NULL;
    2146        2162 :         zend_class_entry *parent = ce;
    2147        2162 :         int inherited = 0;
    2148             : 
    2149        4337 :         while (parent) {
    2150        2175 :                 if (parent == sxe_class_entry) {
    2151        2162 :                         break;
    2152             :                 }
    2153          13 :                 parent = parent->parent;
    2154          13 :                 inherited = 1;
    2155             :         }
    2156             : 
    2157        2162 :         if (inherited) {
    2158          22 :                 fptr_count = zend_hash_str_find_ptr(&ce->function_table, "count", sizeof("count") - 1);
    2159          11 :                 if (fptr_count->common.scope == parent) {
    2160           9 :                         fptr_count = NULL;
    2161             :                 }
    2162             :         }
    2163             : 
    2164        2162 :         return fptr_count;
    2165             : }
    2166             : /* }}} */
    2167             : 
    2168             : /* {{{ php_sxe_object_new()
    2169             :  */
    2170      403536 : static php_sxe_object* php_sxe_object_new(zend_class_entry *ce, zend_function *fptr_count)
    2171             : {
    2172             :         php_sxe_object *intern;
    2173             : 
    2174      403536 :         intern = ecalloc(1, sizeof(php_sxe_object) + zend_object_properties_size(ce));
    2175             : 
    2176      403536 :         intern->iter.type = SXE_ITER_NONE;
    2177      403536 :         intern->iter.nsprefix = NULL;
    2178      403536 :         intern->iter.name = NULL;
    2179      403536 :         intern->fptr_count = fptr_count;
    2180             : 
    2181      403536 :         zend_object_std_init(&intern->zo, ce);
    2182      403536 :         object_properties_init(&intern->zo, ce);
    2183      403536 :         intern->zo.handlers = &sxe_object_handlers;
    2184             : 
    2185      403536 :         return intern;
    2186             : }
    2187             : /* }}} */
    2188             : 
    2189             : /* {{{ sxe_object_new()
    2190             :  */
    2191             : PHP_SXE_API zend_object *
    2192        2028 : sxe_object_new(zend_class_entry *ce)
    2193             : {
    2194             :         php_sxe_object    *intern;
    2195             : 
    2196        2028 :         intern = php_sxe_object_new(ce, php_sxe_find_fptr_count(ce));
    2197        2028 :         return &intern->zo;
    2198             : }
    2199             : /* }}} */
    2200             : 
    2201             : /* {{{ proto simplemxml_element simplexml_load_file(string filename [, string class_name [, int options [, string ns [, bool is_prefix]]]])
    2202             :    Load a filename and return a simplexml_element object to allow for processing */
    2203          10 : PHP_FUNCTION(simplexml_load_file)
    2204             : {
    2205             :         php_sxe_object *sxe;
    2206             :         char           *filename;
    2207             :         size_t             filename_len;
    2208             :         xmlDocPtr       docp;
    2209          10 :         char           *ns = NULL;
    2210          10 :         size_t             ns_len = 0;
    2211          10 :         zend_long            options = 0;
    2212          10 :         zend_class_entry *ce= sxe_class_entry;
    2213             :         zend_function    *fptr_count;
    2214          10 :         zend_bool       isprefix = 0;
    2215             : 
    2216          10 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "p|C!lsb", &filename, &filename_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
    2217           1 :                 return;
    2218             :         }
    2219             : 
    2220           9 :         if (ZEND_LONG_EXCEEDS_INT(options)) {
    2221           0 :                 php_error_docref(NULL, E_WARNING, "Invalid options");
    2222           0 :                 RETURN_FALSE;
    2223             :         }
    2224             : 
    2225           9 :         docp = xmlReadFile(filename, NULL, (int)options);
    2226             : 
    2227           9 :         if (!docp) {
    2228           2 :                 RETURN_FALSE;
    2229             :         }
    2230             : 
    2231           7 :         if (!ce) {
    2232           0 :                 ce = sxe_class_entry;
    2233           0 :                 fptr_count = NULL;
    2234             :         } else {
    2235           7 :                 fptr_count = php_sxe_find_fptr_count(ce);
    2236             :         }
    2237           7 :         sxe = php_sxe_object_new(ce, fptr_count);
    2238           7 :         sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
    2239           7 :         sxe->iter.isprefix = isprefix;
    2240           7 :         php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
    2241           7 :         php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
    2242             : 
    2243           7 :         ZVAL_OBJ(return_value, &sxe->zo);
    2244             : }
    2245             : /* }}} */
    2246             : 
    2247             : /* {{{ proto simplemxml_element simplexml_load_string(string data [, string class_name [, int options [, string ns [, bool is_prefix]]]])
    2248             :    Load a string and return a simplexml_element object to allow for processing */
    2249         131 : PHP_FUNCTION(simplexml_load_string)
    2250             : {
    2251             :         php_sxe_object *sxe;
    2252             :         char           *data;
    2253             :         size_t             data_len;
    2254             :         xmlDocPtr       docp;
    2255         131 :         char           *ns = NULL;
    2256         131 :         size_t             ns_len = 0;
    2257         131 :         zend_long            options = 0;
    2258         131 :         zend_class_entry *ce= sxe_class_entry;
    2259             :         zend_function    *fptr_count;
    2260         131 :         zend_bool       isprefix = 0;
    2261             : 
    2262         131 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|C!lsb", &data, &data_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
    2263           1 :                 return;
    2264             :         }
    2265             : 
    2266         130 :         if (ZEND_SIZE_T_INT_OVFL(data_len)) {
    2267           0 :                 php_error_docref(NULL, E_WARNING, "Data is too long");
    2268           0 :                 RETURN_FALSE;
    2269             :         }
    2270         130 :         if (ZEND_SIZE_T_INT_OVFL(ns_len)) {
    2271           0 :                 php_error_docref(NULL, E_WARNING, "Namespace is too long");
    2272           0 :                 RETURN_FALSE;
    2273             :         }
    2274         130 :         if (ZEND_LONG_EXCEEDS_INT(options)) {
    2275           1 :                 php_error_docref(NULL, E_WARNING, "Invalid options");
    2276           1 :                 RETURN_FALSE;
    2277             :         }
    2278             : 
    2279         129 :         docp = xmlReadMemory(data, (int)data_len, NULL, NULL, (int)options);
    2280             : 
    2281         129 :         if (!docp) {
    2282           2 :                 RETURN_FALSE;
    2283             :         }
    2284             : 
    2285         127 :         if (!ce) {
    2286           2 :                 ce = sxe_class_entry;
    2287           2 :                 fptr_count = NULL;
    2288             :         } else {
    2289         125 :                 fptr_count = php_sxe_find_fptr_count(ce);
    2290             :         }
    2291         127 :         sxe = php_sxe_object_new(ce, fptr_count);
    2292         127 :         sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
    2293         127 :         sxe->iter.isprefix = isprefix;
    2294         127 :         php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
    2295         127 :         php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
    2296             : 
    2297         127 :         ZVAL_OBJ(return_value, &sxe->zo);
    2298             : }
    2299             : /* }}} */
    2300             : 
    2301             : /* {{{ proto SimpleXMLElement::__construct(string data [, int options [, bool data_is_url [, string ns [, bool is_prefix]]]])
    2302             :    SimpleXMLElement constructor */
    2303        2027 : SXE_METHOD(__construct)
    2304             : {
    2305        4054 :         php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
    2306        2027 :         char           *data, *ns = NULL;
    2307        2027 :         size_t             data_len, ns_len = 0;
    2308             :         xmlDocPtr       docp;
    2309        2027 :         zend_long            options = 0;
    2310        2027 :         zend_bool       is_url = 0, isprefix = 0;
    2311             : 
    2312        2027 :         if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s|lbsb", &data, &data_len, &options, &is_url, &ns, &ns_len, &isprefix) == FAILURE) {
    2313           0 :                 return;
    2314             :         }
    2315             : 
    2316        2027 :         if (ZEND_SIZE_T_INT_OVFL(data_len)) {
    2317           0 :                 php_error_docref(NULL, E_WARNING, "Data is too long");
    2318           0 :                 RETURN_FALSE;
    2319             :         }
    2320        2027 :         if (ZEND_SIZE_T_INT_OVFL(ns_len)) {
    2321           0 :                 php_error_docref(NULL, E_WARNING, "Namespace is too long");
    2322           0 :                 RETURN_FALSE;
    2323             :         }
    2324        2027 :         if (ZEND_LONG_EXCEEDS_INT(options)) {
    2325           0 :                 php_error_docref(NULL, E_WARNING, "Invalid options");
    2326           0 :                 RETURN_FALSE;
    2327             :         }
    2328             : 
    2329        2027 :         docp = is_url ? xmlReadFile(data, NULL, (int)options) : xmlReadMemory(data, (int)data_len, NULL, NULL, (int)options);
    2330             : 
    2331        2027 :         if (!docp) {
    2332           0 :                 ((php_libxml_node_object *)sxe)->document = NULL;
    2333           0 :                 zend_throw_exception(zend_ce_exception, "String could not be parsed as XML", 0);
    2334           0 :                 return;
    2335             :         }
    2336             : 
    2337        2027 :         sxe->iter.nsprefix = ns_len ? (xmlChar*)estrdup(ns) : NULL;
    2338        2027 :         sxe->iter.isprefix = isprefix;
    2339        2027 :         php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp);
    2340        2027 :         php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL);
    2341             : }
    2342             : /* }}} */
    2343             : 
    2344             : zend_object_iterator_funcs php_sxe_iterator_funcs = { /* {{{ */
    2345             :         php_sxe_iterator_dtor,
    2346             :         php_sxe_iterator_valid,
    2347             :         php_sxe_iterator_current_data,
    2348             :         php_sxe_iterator_current_key,
    2349             :         php_sxe_iterator_move_forward,
    2350             :         php_sxe_iterator_rewind,
    2351             :         NULL
    2352             : };
    2353             : /* }}} */
    2354             : 
    2355      200754 : static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data) /* {{{ */
    2356             : {
    2357      200754 :         xmlChar *prefix  = sxe->iter.nsprefix;
    2358      200754 :         int isprefix  = sxe->iter.isprefix;
    2359             : 
    2360      200754 :         if (sxe->iter.type == SXE_ITER_ATTRLIST) {
    2361          80 :                 if (sxe->iter.name) {
    2362          58 :                         while (node) {
    2363          38 :                                 if (node->type == XML_ATTRIBUTE_NODE) {
    2364          38 :                                         if (!xmlStrcmp(node->name, sxe->iter.name) && match_ns(sxe, node, prefix, isprefix)) {
    2365          20 :                                                 break;
    2366             :                                         }
    2367             :                                 }
    2368          18 :                                 node = node->next;
    2369             :                         }
    2370             :                 } else {
    2371         125 :                         while (node) {
    2372          32 :                                 if (node->type == XML_ATTRIBUTE_NODE) {
    2373          32 :                                         if (match_ns(sxe, node, prefix, isprefix)) {
    2374          27 :                                                 break;
    2375             :                                         }
    2376             :                                 }
    2377           5 :                                 node = node->next;
    2378             :                         }
    2379             :                 }
    2380      401102 :         } else if (sxe->iter.type == SXE_ITER_ELEMENT && sxe->iter.name) {
    2381      401495 :                 while (node) {
    2382      201002 :                         if (node->type == XML_ELEMENT_NODE) {
    2383      200522 :                                 if (!xmlStrcmp(node->name, sxe->iter.name) && match_ns(sxe, node, prefix, isprefix)) {
    2384      200363 :                                         break;
    2385             :                                 }
    2386             :                         }
    2387         639 :                         node = node->next;
    2388             :                 }
    2389             :         } else {
    2390         711 :                 while (node) {
    2391         364 :                         if (node->type == XML_ELEMENT_NODE) {
    2392         164 :                                 if (match_ns(sxe, node, prefix, isprefix)) {
    2393         145 :                                         break;
    2394             :                                 }
    2395             :                         }
    2396         219 :                         node = node->next;
    2397             :                 }
    2398             :         }
    2399             : 
    2400      200754 :         if (node && use_data) {
    2401      200514 :                 _node_as_zval(sxe, node, &sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix);
    2402             :         }
    2403             : 
    2404      200754 :         return node;
    2405             : }
    2406             : /* }}} */
    2407             : 
    2408      200590 : static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data) /* {{{ */
    2409             : {
    2410             :         xmlNodePtr node;
    2411             : 
    2412      401180 :         if (!Z_ISUNDEF(sxe->iter.data)) {
    2413          46 :                 zval_ptr_dtor(&sxe->iter.data);
    2414          46 :                 ZVAL_UNDEF(&sxe->iter.data);
    2415             :         }
    2416             : 
    2417      200590 :         GET_NODE(sxe, node)
    2418             : 
    2419      200590 :         if (node) {
    2420      200590 :                 switch (sxe->iter.type) {
    2421             :                         case SXE_ITER_ELEMENT:
    2422             :                         case SXE_ITER_CHILD:
    2423             :                         case SXE_ITER_NONE:
    2424      200529 :                                 node = node->children;
    2425      200529 :                                 break;
    2426             :                         case SXE_ITER_ATTRLIST:
    2427          61 :                                 node = (xmlNodePtr) node->properties;
    2428             :                 }
    2429      200590 :                 return php_sxe_iterator_fetch(sxe, node, use_data);
    2430             :         }
    2431           0 :         return NULL;
    2432             : }
    2433             : /* }}} */
    2434             : 
    2435         104 : zend_object_iterator *php_sxe_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */
    2436             : {
    2437             :         php_sxe_iterator *iterator;
    2438             : 
    2439         104 :         if (by_ref) {
    2440           0 :                 zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
    2441             :         }
    2442         104 :         iterator = emalloc(sizeof(php_sxe_iterator));
    2443         104 :         zend_iterator_init(&iterator->intern);
    2444             : 
    2445         104 :         ZVAL_COPY(&iterator->intern.data, object);
    2446         104 :         iterator->intern.funcs = &php_sxe_iterator_funcs;
    2447         104 :         iterator->sxe = Z_SXEOBJ_P(object);
    2448             : 
    2449         104 :         return (zend_object_iterator*)iterator;
    2450             : }
    2451             : /* }}} */
    2452             : 
    2453         104 : static void php_sxe_iterator_dtor(zend_object_iterator *iter) /* {{{ */
    2454             : {
    2455         104 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2456             : 
    2457             :         /* cleanup handled in sxe_object_dtor as we dont always have an iterator wrapper */
    2458         208 :         if (!Z_ISUNDEF(iterator->intern.data)) {
    2459         104 :                 zval_ptr_dtor(&iterator->intern.data);
    2460             :         }
    2461         104 : }
    2462             : /* }}} */
    2463             : 
    2464         234 : static int php_sxe_iterator_valid(zend_object_iterator *iter) /* {{{ */
    2465             : {
    2466         234 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2467             : 
    2468         468 :         return Z_ISUNDEF(iterator->sxe->iter.data) ? FAILURE : SUCCESS;
    2469             : }
    2470             : /* }}} */
    2471             : 
    2472         112 : static zval *php_sxe_iterator_current_data(zend_object_iterator *iter) /* {{{ */
    2473             : {
    2474         112 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2475             : 
    2476         112 :         return &iterator->sxe->iter.data;
    2477             : }
    2478             : /* }}} */
    2479             : 
    2480          59 : static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key) /* {{{ */
    2481             : {
    2482          59 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2483          59 :         zval *curobj = &iterator->sxe->iter.data;
    2484          59 :         php_sxe_object *intern = Z_SXEOBJ_P(curobj);
    2485             : 
    2486          59 :         xmlNodePtr curnode = NULL;
    2487          59 :         if (intern != NULL && intern->node != NULL) {
    2488          59 :                 curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->node)->node;
    2489             :         }
    2490             : 
    2491          59 :         if (curnode) {
    2492         118 :                 ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
    2493             :         } else {
    2494           0 :                 ZVAL_NULL(key);
    2495             :         }
    2496          59 : }
    2497             : /* }}} */
    2498             : 
    2499         123 : PHP_SXE_API void php_sxe_move_forward_iterator(php_sxe_object *sxe) /* {{{ */
    2500             : {
    2501         123 :         xmlNodePtr      node = NULL;
    2502             :         php_sxe_object  *intern;
    2503             : 
    2504         246 :         if (!Z_ISUNDEF(sxe->iter.data)) {
    2505         123 :                 intern = Z_SXEOBJ_P(&sxe->iter.data);
    2506         123 :                 GET_NODE(intern, node)
    2507         123 :                 zval_ptr_dtor(&sxe->iter.data);
    2508         123 :                 ZVAL_UNDEF(&sxe->iter.data);
    2509             :         }
    2510             : 
    2511         123 :         if (node) {
    2512         123 :                 php_sxe_iterator_fetch(sxe, node->next, 1);
    2513             :         }
    2514         123 : }
    2515             : /* }}} */
    2516             : 
    2517         123 : static void php_sxe_iterator_move_forward(zend_object_iterator *iter) /* {{{ */
    2518             : {
    2519         123 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2520         123 :         php_sxe_move_forward_iterator(iterator->sxe);
    2521         123 : }
    2522             : /* }}} */
    2523             : 
    2524         110 : static void php_sxe_iterator_rewind(zend_object_iterator *iter) /* {{{ */
    2525             : {
    2526             :         php_sxe_object  *sxe;
    2527             : 
    2528         110 :         php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
    2529         110 :         sxe = iterator->sxe;
    2530             : 
    2531         110 :         php_sxe_reset_iterator(sxe, 1);
    2532         110 : }
    2533             : /* }}} */
    2534             : 
    2535           2 : void *simplexml_export_node(zval *object) /* {{{ */
    2536             : {
    2537             :         php_sxe_object *sxe;
    2538             :         xmlNodePtr node;
    2539             : 
    2540           2 :         sxe = Z_SXEOBJ_P(object);
    2541           2 :         GET_NODE(sxe, node);
    2542           2 :         return php_sxe_get_first_node(sxe, node);
    2543             : }
    2544             : /* }}} */
    2545             : 
    2546             : /* {{{ proto simplemxml_element simplexml_import_dom(domNode node [, string class_name])
    2547             :    Get a simplexml_element object from dom to allow for processing */
    2548           2 : PHP_FUNCTION(simplexml_import_dom)
    2549             : {
    2550             :         php_sxe_object *sxe;
    2551             :         zval *node;
    2552             :         php_libxml_node_object *object;
    2553           2 :         xmlNodePtr              nodep = NULL;
    2554           2 :         zend_class_entry *ce = sxe_class_entry;
    2555             :         zend_function    *fptr_count;
    2556             : 
    2557           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|C!", &node, &ce) == FAILURE) {
    2558           0 :                 return;
    2559             :         }
    2560             : 
    2561           2 :         object = Z_LIBXML_NODE_P(node);
    2562             : 
    2563           2 :         nodep = php_libxml_import_node(node);
    2564             : 
    2565           2 :         if (nodep) {
    2566           2 :                 if (nodep->doc == NULL) {
    2567           0 :                         php_error_docref(NULL, E_WARNING, "Imported Node must have associated Document");
    2568           0 :                         RETURN_NULL();
    2569             :                 }
    2570           2 :                 if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
    2571           2 :                         nodep = xmlDocGetRootElement((xmlDocPtr) nodep);
    2572             :                 }
    2573             :         }
    2574             : 
    2575           4 :         if (nodep && nodep->type == XML_ELEMENT_NODE) {
    2576           2 :                 if (!ce) {
    2577           0 :                         ce = sxe_class_entry;
    2578           0 :                         fptr_count = NULL;
    2579             :                 } else {
    2580           2 :                         fptr_count = php_sxe_find_fptr_count(ce);
    2581             :                 }
    2582           2 :                 sxe = php_sxe_object_new(ce, fptr_count);
    2583           2 :                 sxe->document = object->document;
    2584           2 :                 php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, nodep->doc);
    2585           2 :                 php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, nodep, NULL);
    2586             : 
    2587           2 :                 ZVAL_OBJ(return_value, &sxe->zo);
    2588             :         } else {
    2589           0 :                 php_error_docref(NULL, E_WARNING, "Invalid Nodetype to import");
    2590           0 :                 RETVAL_NULL();
    2591             :         }
    2592             : }
    2593             : /* }}} */
    2594             : 
    2595             : /* {{{ arginfo */
    2596             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_file, 0, 0, 1)
    2597             :         ZEND_ARG_INFO(0, filename)
    2598             :         ZEND_ARG_INFO(0, class_name)
    2599             :         ZEND_ARG_INFO(0, options)
    2600             :         ZEND_ARG_INFO(0, ns)
    2601             :         ZEND_ARG_INFO(0, is_prefix)
    2602             : ZEND_END_ARG_INFO()
    2603             : 
    2604             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_string, 0, 0, 1)
    2605             :         ZEND_ARG_INFO(0, data)
    2606             :         ZEND_ARG_INFO(0, class_name)
    2607             :         ZEND_ARG_INFO(0, options)
    2608             :         ZEND_ARG_INFO(0, ns)
    2609             :         ZEND_ARG_INFO(0, is_prefix)
    2610             : ZEND_END_ARG_INFO()
    2611             : 
    2612             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_import_dom, 0, 0, 1)
    2613             :         ZEND_ARG_INFO(0, node)
    2614             :         ZEND_ARG_INFO(0, class_name)
    2615             : ZEND_END_ARG_INFO()
    2616             : 
    2617             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_xpath, 0, 0, 1)
    2618             :         ZEND_ARG_INFO(0, path)
    2619             : ZEND_END_ARG_INFO()
    2620             : 
    2621             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_registerxpathnamespace, 0, 0, 2)
    2622             :         ZEND_ARG_INFO(0, prefix)
    2623             :         ZEND_ARG_INFO(0, ns)
    2624             : ZEND_END_ARG_INFO()
    2625             : 
    2626             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_asxml, 0, 0, 0)
    2627             :         ZEND_ARG_INFO(0, filename)
    2628             : ZEND_END_ARG_INFO()
    2629             : 
    2630             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getnamespaces, 0, 0, 0)
    2631             :         ZEND_ARG_INFO(0, recursve)
    2632             : ZEND_END_ARG_INFO()
    2633             : 
    2634             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getdocnamespaces, 0, 0, 0)
    2635             :         ZEND_ARG_INFO(0, recursve)
    2636             :         ZEND_ARG_INFO(0, from_root)
    2637             : ZEND_END_ARG_INFO()
    2638             : 
    2639             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_children, 0, 0, 0)
    2640             :         ZEND_ARG_INFO(0, ns)
    2641             :         ZEND_ARG_INFO(0, is_prefix)
    2642             : ZEND_END_ARG_INFO()
    2643             : 
    2644             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement__construct, 0, 0, 1)
    2645             :         ZEND_ARG_INFO(0, data)
    2646             :         ZEND_ARG_INFO(0, options)
    2647             :         ZEND_ARG_INFO(0, data_is_url)
    2648             :         ZEND_ARG_INFO(0, ns)
    2649             :         ZEND_ARG_INFO(0, is_prefix)
    2650             : ZEND_END_ARG_INFO()
    2651             : 
    2652             : ZEND_BEGIN_ARG_INFO(arginfo_simplexmlelement__void, 0)
    2653             : ZEND_END_ARG_INFO()
    2654             : 
    2655             : ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_addchild, 0, 0, 1)
    2656             :         ZEND_ARG_INFO(0, name)
    2657             :         ZEND_ARG_INFO(0, value)
    2658             :         ZEND_ARG_INFO(0, ns)
    2659             : ZEND_END_ARG_INFO()
    2660             : /* }}} */
    2661             : 
    2662             : const zend_function_entry simplexml_functions[] = { /* {{{ */
    2663             :         PHP_FE(simplexml_load_file,     arginfo_simplexml_load_file)
    2664             :         PHP_FE(simplexml_load_string,   arginfo_simplexml_load_string)
    2665             :         PHP_FE(simplexml_import_dom,    arginfo_simplexml_import_dom)
    2666             :         PHP_FE_END
    2667             : };
    2668             : /* }}} */
    2669             : 
    2670             : static const zend_module_dep simplexml_deps[] = { /* {{{ */
    2671             :         ZEND_MOD_REQUIRED("libxml")
    2672             :         ZEND_MOD_REQUIRED("spl")
    2673             :         ZEND_MOD_END
    2674             : };
    2675             : /* }}} */
    2676             : 
    2677             : zend_module_entry simplexml_module_entry = { /* {{{ */
    2678             :         STANDARD_MODULE_HEADER_EX, NULL,
    2679             :         simplexml_deps,
    2680             :         "SimpleXML",
    2681             :         simplexml_functions,
    2682             :         PHP_MINIT(simplexml),
    2683             :         PHP_MSHUTDOWN(simplexml),
    2684             :         NULL,
    2685             :         NULL,
    2686             :         PHP_MINFO(simplexml),
    2687             :         PHP_SIMPLEXML_VERSION,
    2688             :         STANDARD_MODULE_PROPERTIES
    2689             : };
    2690             : /* }}} */
    2691             : 
    2692             : #ifdef COMPILE_DL_SIMPLEXML
    2693             : ZEND_GET_MODULE(simplexml)
    2694             : #endif
    2695             : 
    2696             : /* the method table */
    2697             : /* each method can have its own parameters and visibility */
    2698             : static const zend_function_entry sxe_functions[] = { /* {{{ */
    2699             :         SXE_ME(__construct,            arginfo_simplexmlelement__construct, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) /* must be called */
    2700             :         SXE_ME(asXML,                  arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
    2701             :         SXE_MALIAS(saveXML, asXML,         arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
    2702             :         SXE_ME(xpath,                  arginfo_simplexmlelement_xpath, ZEND_ACC_PUBLIC)
    2703             :         SXE_ME(registerXPathNamespace, arginfo_simplexmlelement_registerxpathnamespace, ZEND_ACC_PUBLIC)
    2704             :         SXE_ME(attributes,             arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
    2705             :         SXE_ME(children,               arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
    2706             :         SXE_ME(getNamespaces,          arginfo_simplexmlelement_getnamespaces, ZEND_ACC_PUBLIC)
    2707             :         SXE_ME(getDocNamespaces,       arginfo_simplexmlelement_getdocnamespaces, ZEND_ACC_PUBLIC)
    2708             :         SXE_ME(getName,                arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
    2709             :         SXE_ME(addChild,               arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
    2710             :         SXE_ME(addAttribute,           arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
    2711             :         SXE_ME(__toString,             arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
    2712             :         SXE_ME(count,                  arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
    2713             :         PHP_FE_END
    2714             : };
    2715             : /* }}} */
    2716             : 
    2717             : /* {{{ PHP_MINIT_FUNCTION(simplexml)
    2718             :  */
    2719       23504 : PHP_MINIT_FUNCTION(simplexml)
    2720             : {
    2721             :         zend_class_entry sxe;
    2722             : 
    2723       23504 :         INIT_CLASS_ENTRY(sxe, "SimpleXMLElement", sxe_functions);
    2724       23504 :         sxe.create_object = sxe_object_new;
    2725       23504 :         sxe_class_entry = zend_register_internal_class(&sxe);
    2726       23504 :         sxe_class_entry->get_iterator = php_sxe_get_iterator;
    2727       23504 :         sxe_class_entry->iterator_funcs.funcs = &php_sxe_iterator_funcs;
    2728       23504 :         zend_class_implements(sxe_class_entry, 1, zend_ce_traversable);
    2729       23504 :         sxe_object_handlers.offset = XtOffsetOf(php_sxe_object, zo);
    2730       23504 :         sxe_object_handlers.dtor_obj = sxe_object_dtor;
    2731       23504 :         sxe_object_handlers.free_obj = sxe_object_free_storage;
    2732       23504 :         sxe_object_handlers.clone_obj = sxe_object_clone;
    2733       23504 :         sxe_object_handlers.get_method = zend_get_std_object_handlers()->get_method;
    2734       23504 :         sxe_object_handlers.get_constructor = zend_get_std_object_handlers()->get_constructor;
    2735       23504 :         sxe_object_handlers.get_class_name = zend_get_std_object_handlers()->get_class_name;
    2736       23504 :         sxe_class_entry->serialize = zend_class_serialize_deny;
    2737       23504 :         sxe_class_entry->unserialize = zend_class_unserialize_deny;
    2738             : 
    2739       23504 :         php_libxml_register_export(sxe_class_entry, simplexml_export_node);
    2740             : 
    2741       23504 :         PHP_MINIT(sxe)(INIT_FUNC_ARGS_PASSTHRU);
    2742             : 
    2743       23504 :         return SUCCESS;
    2744             : }
    2745             : /* }}} */
    2746             : 
    2747             : /* {{{ PHP_MSHUTDOWN_FUNCTION(simplexml)
    2748             :  */
    2749       23544 : PHP_MSHUTDOWN_FUNCTION(simplexml)
    2750             : {
    2751       23544 :         sxe_class_entry = NULL;
    2752       23544 :         return SUCCESS;
    2753             : }
    2754             : /* }}} */
    2755             : 
    2756             : /* {{{ PHP_MINFO_FUNCTION(simplexml)
    2757             :  */
    2758         150 : PHP_MINFO_FUNCTION(simplexml)
    2759             : {
    2760         150 :         php_info_print_table_start();
    2761         150 :         php_info_print_table_header(2, "Simplexml support", "enabled");
    2762         150 :         php_info_print_table_row(2, "Revision", "$Id: 622ff3b6ec6cf038bc4ad0d2fd9986481480df9f $");
    2763         150 :         php_info_print_table_row(2, "Schema support",
    2764             : #ifdef LIBXML_SCHEMAS_ENABLED
    2765             :                 "enabled");
    2766             : #else
    2767             :                 "not available");
    2768             : #endif
    2769         150 :         php_info_print_table_end();
    2770         150 : }
    2771             : /* }}} */
    2772             : 
    2773             : #endif
    2774             : 
    2775             : /**
    2776             :  * Local Variables:
    2777             :  * c-basic-offset: 4
    2778             :  * tab-width: 4
    2779             :  * indent-tabs-mode: t
    2780             :  * End:
    2781             :  * vim600: fdm=marker
    2782             :  * vim: noet sw=4 ts=4
    2783             :  */

Generated by: LCOV version 1.10

Generated at Wed, 24 Aug 2016 12:20:29 +0000 (19 hours ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.