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