Annotation of embedaddon/php/ext/simplexml/simplexml.c, revision 1.1.1.4
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.3 misho 5: | Copyright (c) 1997-2013 The PHP Group |
1.1 misho 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:
1.1.1.4 ! misho 21: /* $Id: 2358f2be6570ab413d0ead3a931a5365adf94af9 $ */
1.1 misho 22:
23: #ifdef HAVE_CONFIG_H
24: #include "config.h"
25: #endif
26:
27: #include "php.h"
28: #if HAVE_LIBXML && HAVE_SIMPLEXML
29:
30: #include "php_ini.h"
31: #include "ext/standard/info.h"
32: #include "ext/standard/php_string.h"
33: #include "php_simplexml.h"
34: #include "php_simplexml_exports.h"
35: #include "zend_exceptions.h"
36: #include "zend_interfaces.h"
37: #include "sxe.h"
38:
39: #define SXE_ELEMENT_BY_NAME 0
40:
41: zend_class_entry *sxe_class_entry = NULL;
42:
43: PHP_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:
54: static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC);
55: static zend_object_value php_sxe_register_object(php_sxe_object * TSRMLS_DC);
56: static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data TSRMLS_DC);
57: static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data TSRMLS_DC);
58: static zval *sxe_get_value(zval *z TSRMLS_DC);
59: static void php_sxe_iterator_dtor(zend_object_iterator *iter TSRMLS_DC);
60: static int php_sxe_iterator_valid(zend_object_iterator *iter TSRMLS_DC);
61: static void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC);
62: static int php_sxe_iterator_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC);
63: static void php_sxe_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC);
64: static void php_sxe_iterator_rewind(zend_object_iterator *iter TSRMLS_DC);
65:
66: /* {{{ _node_as_zval()
67: */
68: static void _node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE_ITER itertype, char *name, const xmlChar *nsprefix, int isprefix TSRMLS_DC)
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:
111: static 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:
129: static 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:
143: static 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: }
168: next_iter:
169: node = node->next;
170: }
171:
172: if (cnt) {
173: *cnt = nodendx;
174: }
175:
176: return node;
177: }
178: /* }}} */
179:
180: static 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: }
189: next_iter:
190: node = node->next;
191: }
192: return NULL;
193: } /* }}} */
194:
195: static 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: }
231: next_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: */
248: static 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: */
1.1.1.2 misho 392: static zval * sxe_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
1.1 misho 393: {
394: return sxe_prop_dim_read(object, member, 1, 0, type TSRMLS_CC);
395: }
396: /* }}} */
397:
398: /* {{{ sxe_dimension_read()
399: */
400: static 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: */
408: static 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: */
452: static 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:
621: next_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: */
1.1.1.2 misho 683: static void sxe_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
1.1 misho 684: {
685: sxe_prop_dim_write(object, member, value, 1, 0, NULL TSRMLS_CC);
686: }
687: /* }}} */
688:
689: /* {{{ sxe_dimension_write()
690: */
691: static 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:
1.1.1.2 misho 697: static zval** sxe_property_get_adr(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
1.1 misho 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: */
736: static 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: */
1.1.1.2 misho 849: static int sxe_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
1.1 misho 850: {
851: return sxe_prop_dim_exists(object, member, check_empty, 1, 0 TSRMLS_CC);
852: }
853: /* }}} */
854:
855: /* {{{ sxe_property_exists()
856: */
857: static 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: */
865: static 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:
959: next_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: */
1.1.1.2 misho 974: static void sxe_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
1.1 misho 975: {
976: sxe_prop_dim_delete(object, member, 1, 0 TSRMLS_CC);
977: }
978: /* }}} */
979:
980: /* {{{ sxe_dimension_unset()
981: */
982: static 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:
988: static 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: */
1006: static 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:
1036: static 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:
1061: static 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;
1.1.1.2 misho 1072: char use_iter;
1.1.1.4 ! misho 1073: zval *iter_data = NULL;
1.1.1.2 misho 1074:
1075: use_iter = 0;
1.1 misho 1076:
1077: sxe = php_sxe_fetch_object(object TSRMLS_CC);
1078:
1079: if (is_debug) {
1080: ALLOC_HASHTABLE(rv);
1081: zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
1082: }
1083: else if (sxe->properties) {
1084: zend_hash_clean(sxe->properties);
1085: rv = sxe->properties;
1086: } else {
1087: ALLOC_HASHTABLE(rv);
1088: zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
1089: sxe->properties = rv;
1090: }
1091:
1092: GET_NODE(sxe, node);
1093: if (!node) {
1094: return rv;
1095: }
1096: if (is_debug || sxe->iter.type != SXE_ITER_CHILD) {
1097: if (sxe->iter.type == SXE_ITER_ELEMENT) {
1098: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1099: }
1100: if (!node || node->type != XML_ENTITY_DECL) {
1101: attr = node ? (xmlAttrPtr)node->properties : NULL;
1102: zattr = NULL;
1103: test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
1104: while (attr) {
1105: if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
1106: MAKE_STD_ZVAL(value);
1107: ZVAL_STRING(value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1), 0);
1108: namelen = xmlStrlen(attr->name) + 1;
1109: if (!zattr) {
1110: MAKE_STD_ZVAL(zattr);
1111: array_init(zattr);
1112: sxe_properties_add(rv, "@attributes", sizeof("@attributes"), zattr TSRMLS_CC);
1113: }
1114: add_assoc_zval_ex(zattr, (char*)attr->name, namelen, value);
1115: }
1116: attr = attr->next;
1117: }
1118: }
1119: }
1120:
1121: GET_NODE(sxe, node);
1122: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1.1.1.2 misho 1123:
1.1 misho 1124: if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
1125: if (node->type == XML_ATTRIBUTE_NODE) {
1126: MAKE_STD_ZVAL(value);
1127: ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node->children, 1), 0);
1128: zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
1129: node = NULL;
1130: } else if (sxe->iter.type != SXE_ITER_CHILD) {
1.1.1.2 misho 1131:
1132: if ( !node->children || !node->parent || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
1133: node = node->children;
1134: } else {
1135: iter_data = sxe->iter.data;
1136: sxe->iter.data = NULL;
1137:
1138: node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
1139:
1140: use_iter = 1;
1141: }
1.1 misho 1142: }
1143:
1144: while (node) {
1145: if (node->children != NULL || node->prev != NULL || node->next != NULL) {
1146: SKIP_TEXT(node);
1147: } else {
1148: if (node->type == XML_TEXT_NODE) {
1149: const xmlChar *cur = node->content;
1150:
1151: if (*cur != 0) {
1152: MAKE_STD_ZVAL(value);
1153: ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node, 1), 0);
1154: zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
1155: }
1156: goto next_iter;
1157: }
1158: }
1159:
1160: if (node->type == XML_ELEMENT_NODE && (! match_ns(sxe, node, sxe->iter.nsprefix, sxe->iter.isprefix))) {
1161: goto next_iter;
1162: }
1163:
1164: name = (char *) node->name;
1165: if (!name) {
1166: goto next_iter;
1167: } else {
1168: namelen = xmlStrlen(node->name) + 1;
1169: }
1170:
1171: _get_base_node_value(sxe, node, &value, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
1172:
1.1.1.2 misho 1173: if ( use_iter ) {
1174: zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
1175: } else {
1176: sxe_properties_add(rv, name, namelen, value TSRMLS_CC);
1177: }
1.1 misho 1178: next_iter:
1.1.1.2 misho 1179: if ( use_iter ) {
1180: node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
1181: } else {
1182: node = node->next;
1183: }
1184: }
1185: }
1186:
1187: if ( use_iter ) {
1188: if (sxe->iter.data) {
1189: zval_ptr_dtor(&sxe->iter.data);
1.1 misho 1190: }
1.1.1.2 misho 1191: sxe->iter.data = iter_data;
1.1 misho 1192: }
1193:
1194: return rv;
1195: }
1196: /* }}} */
1197:
1.1.1.3 misho 1198: static HashTable * sxe_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /* {{{ */ {
1199: php_sxe_object *sxe;
1200: sxe = php_sxe_fetch_object(object TSRMLS_CC);
1201:
1202: *table = NULL;
1203: *n = 0;
1204: return sxe->properties;
1205: }
1206: /* }}} */
1207:
1.1 misho 1208: static HashTable * sxe_get_properties(zval *object TSRMLS_DC) /* {{{ */
1209: {
1210: return sxe_get_prop_hash(object, 0 TSRMLS_CC);
1211: }
1212: /* }}} */
1213:
1214: static HashTable * sxe_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
1215: {
1216: *is_temp = 1;
1217: return sxe_get_prop_hash(object, 1 TSRMLS_CC);
1218: }
1219: /* }}} */
1220:
1221: static int sxe_objects_compare(zval *object1, zval *object2 TSRMLS_DC) /* {{{ */
1222: {
1223: php_sxe_object *sxe1;
1224: php_sxe_object *sxe2;
1225:
1226: sxe1 = php_sxe_fetch_object(object1 TSRMLS_CC);
1227: sxe2 = php_sxe_fetch_object(object2 TSRMLS_CC);
1228:
1229: if (sxe1->node == NULL) {
1230: if (sxe2->node) {
1231: return 1;
1232: } else if (sxe1->document->ptr == sxe2->document->ptr) {
1233: return 0;
1234: }
1235: } else {
1236: return !(sxe1->node == sxe2->node);
1237: }
1238: return 1;
1239: }
1240: /* }}} */
1241:
1242: /* {{{ proto array SimpleXMLElement::xpath(string path)
1243: Runs XPath query on the XML data */
1244: SXE_METHOD(xpath)
1245: {
1246: php_sxe_object *sxe;
1247: zval *value;
1248: char *query;
1249: int query_len;
1250: int i;
1251: int nsnbr = 0;
1252: xmlNsPtr *ns = NULL;
1253: xmlXPathObjectPtr retval;
1254: xmlNodeSetPtr result;
1255: xmlNodePtr nodeptr;
1256:
1257: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &query, &query_len) == FAILURE) {
1258: return;
1259: }
1260:
1261: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1262:
1263: if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1264: return; /* attributes don't have attributes */
1265: }
1266:
1267: if (!sxe->xpath) {
1268: sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
1269: }
1270: if (!sxe->node) {
1271: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL TSRMLS_CC);
1272: }
1273:
1274: nodeptr = php_sxe_get_first_node(sxe, sxe->node->node TSRMLS_CC);
1275:
1276: sxe->xpath->node = nodeptr;
1277:
1278: ns = xmlGetNsList((xmlDocPtr) sxe->document->ptr, nodeptr);
1279: if (ns != NULL) {
1280: while (ns[nsnbr] != NULL) {
1281: nsnbr++;
1282: }
1283: }
1284:
1285: sxe->xpath->namespaces = ns;
1286: sxe->xpath->nsNr = nsnbr;
1287:
1288: retval = xmlXPathEval((xmlChar *)query, sxe->xpath);
1289: if (ns != NULL) {
1290: xmlFree(ns);
1291: sxe->xpath->namespaces = NULL;
1292: sxe->xpath->nsNr = 0;
1293: }
1294:
1295: if (!retval) {
1296: RETURN_FALSE;
1297: }
1298:
1299: result = retval->nodesetval;
1300:
1301: array_init(return_value);
1302:
1303: if (result != NULL) {
1304: for (i = 0; i < result->nodeNr; ++i) {
1305: nodeptr = result->nodeTab[i];
1306: if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
1307: MAKE_STD_ZVAL(value);
1308: /**
1309: * Detect the case where the last selector is text(), simplexml
1310: * always accesses the text() child by default, therefore we assign
1311: * to the parent node.
1312: */
1313: if (nodeptr->type == XML_TEXT_NODE) {
1314: _node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
1315: } else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
1316: _node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0 TSRMLS_CC);
1317: } else {
1318: _node_as_zval(sxe, nodeptr, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
1319: }
1320:
1321: add_next_index_zval(return_value, value);
1322: }
1323: }
1324: }
1325:
1326: xmlXPathFreeObject(retval);
1327: }
1328: /* }}} */
1329:
1330: /* {{{ proto bool SimpleXMLElement::registerXPathNamespace(string prefix, string ns)
1331: Creates a prefix/ns context for the next XPath query */
1332: SXE_METHOD(registerXPathNamespace)
1333: {
1334: php_sxe_object *sxe;
1335: int prefix_len, ns_uri_len;
1336: char *prefix, *ns_uri;
1337:
1338: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &prefix, &prefix_len, &ns_uri, &ns_uri_len) == FAILURE) {
1339: return;
1340: }
1341:
1342: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1343: if (!sxe->xpath) {
1344: sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
1345: }
1346:
1347: if (xmlXPathRegisterNs(sxe->xpath, (xmlChar *)prefix, (xmlChar *)ns_uri) != 0) {
1348: RETURN_FALSE
1349: }
1350: RETURN_TRUE;
1351: }
1352:
1353: /* }}} */
1354:
1355: /* {{{ proto string SimpleXMLElement::asXML([string filename])
1356: Return a well-formed XML string based on SimpleXML element */
1357: SXE_METHOD(asXML)
1358: {
1359: php_sxe_object *sxe;
1360: xmlNodePtr node;
1361: xmlOutputBufferPtr outbuf;
1362: xmlChar *strval;
1363: int strval_len;
1364: char *filename;
1365: int filename_len;
1366:
1367: if (ZEND_NUM_ARGS() > 1) {
1368: RETURN_FALSE;
1369: }
1370:
1371: if (ZEND_NUM_ARGS() == 1) {
1.1.1.2 misho 1372: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
1.1 misho 1373: RETURN_FALSE;
1374: }
1375:
1376: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1377: GET_NODE(sxe, node);
1378: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1379:
1380: if (node) {
1381: if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
1382: int bytes;
1383: bytes = xmlSaveFile(filename, (xmlDocPtr) sxe->document->ptr);
1384: if (bytes == -1) {
1385: RETURN_FALSE;
1386: } else {
1387: RETURN_TRUE;
1388: }
1389: } else {
1390: outbuf = xmlOutputBufferCreateFilename(filename, NULL, 0);
1391:
1392: if (outbuf == NULL) {
1393: RETURN_FALSE;
1394: }
1395:
1396: xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, NULL);
1397: xmlOutputBufferClose(outbuf);
1398: RETURN_TRUE;
1399: }
1400: } else {
1401: RETURN_FALSE;
1402: }
1403: }
1404:
1405: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1406: GET_NODE(sxe, node);
1407: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1408:
1409: if (node) {
1410: if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
1411: xmlDocDumpMemoryEnc((xmlDocPtr) sxe->document->ptr, &strval, &strval_len, ((xmlDocPtr) sxe->document->ptr)->encoding);
1412: RETVAL_STRINGL((char *)strval, strval_len, 1);
1413: xmlFree(strval);
1414: } else {
1415: /* Should we be passing encoding information instead of NULL? */
1416: outbuf = xmlAllocOutputBuffer(NULL);
1417:
1418: if (outbuf == NULL) {
1419: RETURN_FALSE;
1420: }
1421:
1422: xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, ((xmlDocPtr) sxe->document->ptr)->encoding);
1423: xmlOutputBufferFlush(outbuf);
1.1.1.3 misho 1424: #ifdef LIBXML2_NEW_BUFFER
1425: RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf), 1);
1426: #else
1.1 misho 1427: RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use, 1);
1.1.1.3 misho 1428: #endif
1.1 misho 1429: xmlOutputBufferClose(outbuf);
1430: }
1431: } else {
1432: RETVAL_FALSE;
1433: }
1434: }
1435: /* }}} */
1436:
1437: #define SXE_NS_PREFIX(ns) (ns->prefix ? (char*)ns->prefix : "")
1438:
1439: static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns) /* {{{ */
1440: {
1441: char *prefix = SXE_NS_PREFIX(ns);
1442: if (zend_hash_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix) + 1) == 0) {
1443: add_assoc_string(return_value, prefix, (char*)ns->href, 1);
1444: }
1445: }
1446: /* }}} */
1447:
1448: static void sxe_add_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value TSRMLS_DC) /* {{{ */
1449: {
1450: xmlAttrPtr attr;
1451:
1452: if (node->ns) {
1453: sxe_add_namespace_name(return_value, node->ns);
1454: }
1455:
1456: attr = node->properties;
1457: while (attr) {
1458: if (attr->ns) {
1459: sxe_add_namespace_name(return_value, attr->ns);
1460: }
1461: attr = attr->next;
1462: }
1463:
1464: if (recursive) {
1465: node = node->children;
1466: while (node) {
1467: if (node->type == XML_ELEMENT_NODE) {
1468: sxe_add_namespaces(sxe, node, recursive, return_value TSRMLS_CC);
1469: }
1470: node = node->next;
1471: }
1472: }
1473: } /* }}} */
1474:
1475: /* {{{ proto string SimpleXMLElement::getNamespaces([bool recursve])
1476: Return all namespaces in use */
1477: SXE_METHOD(getNamespaces)
1478: {
1479: zend_bool recursive = 0;
1480: php_sxe_object *sxe;
1481: xmlNodePtr node;
1482:
1483: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &recursive) == FAILURE) {
1484: return;
1485: }
1486:
1487: array_init(return_value);
1488:
1489: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1490: GET_NODE(sxe, node);
1491: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1492:
1493: if (node) {
1494: if (node->type == XML_ELEMENT_NODE) {
1495: sxe_add_namespaces(sxe, node, recursive, return_value TSRMLS_CC);
1496: } else if (node->type == XML_ATTRIBUTE_NODE && node->ns) {
1497: sxe_add_namespace_name(return_value, node->ns);
1498: }
1499: }
1500: }
1501: /* }}} */
1502:
1503: static void sxe_add_registered_namespaces(php_sxe_object *sxe, xmlNodePtr node, zend_bool recursive, zval *return_value TSRMLS_DC) /* {{{ */
1504: {
1505: xmlNsPtr ns;
1506:
1507: if (node->type == XML_ELEMENT_NODE) {
1508: ns = node->nsDef;
1509: while (ns != NULL) {
1510: sxe_add_namespace_name(return_value, ns);
1511: ns = ns->next;
1512: }
1513: if (recursive) {
1514: node = node->children;
1515: while (node) {
1516: sxe_add_registered_namespaces(sxe, node, recursive, return_value TSRMLS_CC);
1517: node = node->next;
1518: }
1519: }
1520: }
1521: }
1522: /* }}} */
1523:
1.1.1.3 misho 1524: /* {{{ proto string SimpleXMLElement::getDocNamespaces([bool recursive [, bool from_root])
1.1 misho 1525: Return all namespaces registered with document */
1526: SXE_METHOD(getDocNamespaces)
1527: {
1.1.1.3 misho 1528: zend_bool recursive = 0, from_root = 1;
1.1 misho 1529: php_sxe_object *sxe;
1.1.1.3 misho 1530: xmlNodePtr node;
1.1 misho 1531:
1.1.1.3 misho 1532: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bb", &recursive, &from_root) == FAILURE) {
1.1 misho 1533: return;
1534: }
1535:
1536: array_init(return_value);
1537:
1538: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1.1.1.3 misho 1539: if(from_root){
1540: node = xmlDocGetRootElement((xmlDocPtr)sxe->document->ptr);
1541: }else{
1542: GET_NODE(sxe, node);
1543: }
1.1 misho 1544:
1.1.1.3 misho 1545: sxe_add_registered_namespaces(sxe, node, recursive, return_value TSRMLS_CC);
1.1 misho 1546: }
1547: /* }}} */
1548:
1549: /* {{{ proto object SimpleXMLElement::children([string ns [, bool is_prefix]])
1550: Finds children of given node */
1551: SXE_METHOD(children)
1552: {
1553: php_sxe_object *sxe;
1554: char *nsprefix = NULL;
1555: int nsprefix_len = 0;
1556: xmlNodePtr node;
1557: zend_bool isprefix = 0;
1558:
1559: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
1560: return;
1561: }
1562:
1563: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1564:
1565: if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1566: return; /* attributes don't have attributes */
1567: }
1568:
1569: GET_NODE(sxe, node);
1570: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1571:
1572: _node_as_zval(sxe, node, return_value, SXE_ITER_CHILD, NULL, (xmlChar *)nsprefix, isprefix TSRMLS_CC);
1573:
1574: }
1575: /* }}} */
1576:
1577: /* {{{ proto object SimpleXMLElement::getName()
1578: Finds children of given node */
1579: SXE_METHOD(getName)
1580: {
1581: php_sxe_object *sxe;
1582: xmlNodePtr node;
1583: int namelen;
1584:
1585: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1586:
1587: GET_NODE(sxe, node);
1588: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1589: if (node) {
1590: namelen = xmlStrlen(node->name);
1591: RETURN_STRINGL((char*)node->name, namelen, 1);
1592: } else {
1593: RETURN_EMPTY_STRING();
1594: }
1595: }
1596: /* }}} */
1597:
1598: /* {{{ proto array SimpleXMLElement::attributes([string ns [, bool is_prefix]])
1599: Identifies an element's attributes */
1600: SXE_METHOD(attributes)
1601: {
1602: php_sxe_object *sxe;
1603: char *nsprefix = NULL;
1604: int nsprefix_len = 0;
1605: xmlNodePtr node;
1606: zend_bool isprefix = 0;
1607:
1608: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!b", &nsprefix, &nsprefix_len, &isprefix) == FAILURE) {
1609: return;
1610: }
1611:
1612: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1613: GET_NODE(sxe, node);
1614:
1615: if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1616: return; /* attributes don't have attributes */
1617: }
1618:
1619: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1620:
1621: _node_as_zval(sxe, node, return_value, SXE_ITER_ATTRLIST, NULL, (xmlChar *)nsprefix, isprefix TSRMLS_CC);
1622: }
1623: /* }}} */
1624:
1625: /* {{{ proto void SimpleXMLElement::addChild(string qName [, string value [, string ns]])
1626: Add Element with optional namespace information */
1627: SXE_METHOD(addChild)
1628: {
1629: php_sxe_object *sxe;
1630: char *qname, *value = NULL, *nsuri = NULL;
1631: int qname_len, value_len = 0, nsuri_len = 0;
1632: xmlNodePtr node, newnode;
1633: xmlNsPtr nsptr = NULL;
1634: xmlChar *localname, *prefix = NULL;
1635:
1636: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!s!",
1637: &qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
1638: return;
1639: }
1640:
1641: if (qname_len == 0) {
1642: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Element name is required");
1643: return;
1644: }
1645:
1646: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1647: GET_NODE(sxe, node);
1648:
1649: if (sxe->iter.type == SXE_ITER_ATTRLIST) {
1650: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to attributes");
1651: return;
1652: }
1653:
1654: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1655:
1656: if (node == NULL) {
1657: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add child. Parent is not a permanent member of the XML tree");
1658: return;
1659: }
1660:
1661: localname = xmlSplitQName2((xmlChar *)qname, &prefix);
1662: if (localname == NULL) {
1663: localname = xmlStrdup((xmlChar *)qname);
1664: }
1665:
1666: newnode = xmlNewChild(node, NULL, localname, (xmlChar *)value);
1667:
1668: if (nsuri != NULL) {
1669: if (nsuri_len == 0) {
1670: newnode->ns = NULL;
1671: nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
1672: } else {
1673: nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
1674: if (nsptr == NULL) {
1675: nsptr = xmlNewNs(newnode, (xmlChar *)nsuri, prefix);
1676: }
1677: newnode->ns = nsptr;
1678: }
1679: }
1680:
1681: _node_as_zval(sxe, newnode, return_value, SXE_ITER_NONE, (char *)localname, prefix, 0 TSRMLS_CC);
1682:
1683: xmlFree(localname);
1684: if (prefix != NULL) {
1685: xmlFree(prefix);
1686: }
1687: }
1688: /* }}} */
1689:
1690: /* {{{ proto void SimpleXMLElement::addAttribute(string qName, string value [,string ns])
1691: Add Attribute with optional namespace information */
1692: SXE_METHOD(addAttribute)
1693: {
1694: php_sxe_object *sxe;
1695: char *qname, *value = NULL, *nsuri = NULL;
1696: int qname_len, value_len = 0, nsuri_len = 0;
1697: xmlNodePtr node;
1698: xmlAttrPtr attrp = NULL;
1699: xmlNsPtr nsptr = NULL;
1700: xmlChar *localname, *prefix = NULL;
1701:
1702: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s!",
1703: &qname, &qname_len, &value, &value_len, &nsuri, &nsuri_len) == FAILURE) {
1704: return;
1705: }
1706:
1707: if (qname_len == 0) {
1708: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute name is required");
1709: return;
1710: }
1711:
1712: sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1713: GET_NODE(sxe, node);
1714:
1715: node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
1716:
1717: if (node && node->type != XML_ELEMENT_NODE) {
1718: node = node->parent;
1719: }
1720:
1721: if (node == NULL) {
1722: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to locate parent Element");
1723: return;
1724: }
1725:
1726: localname = xmlSplitQName2((xmlChar *)qname, &prefix);
1727: if (localname == NULL) {
1728: if (nsuri_len > 0) {
1729: if (prefix != NULL) {
1730: xmlFree(prefix);
1731: }
1732: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute requires prefix for namespace");
1733: return;
1734: }
1735: localname = xmlStrdup((xmlChar *)qname);
1736: }
1737:
1738: attrp = xmlHasNsProp(node, localname, (xmlChar *)nsuri);
1739: if (attrp != NULL && attrp->type != XML_ATTRIBUTE_DECL) {
1740: xmlFree(localname);
1741: if (prefix != NULL) {
1742: xmlFree(prefix);
1743: }
1744: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute already exists");
1745: return;
1746: }
1747:
1748: if (nsuri != NULL) {
1749: nsptr = xmlSearchNsByHref(node->doc, node, (xmlChar *)nsuri);
1750: if (nsptr == NULL) {
1751: nsptr = xmlNewNs(node, (xmlChar *)nsuri, prefix);
1752: }
1753: }
1754:
1755: attrp = xmlNewNsProp(node, nsptr, localname, (xmlChar *)value);
1756:
1757: xmlFree(localname);
1758: if (prefix != NULL) {
1759: xmlFree(prefix);
1760: }
1761: }
1762: /* }}} */
1763:
1764: /* {{{ cast_object()
1765: */
1766: static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
1767: {
1768: if (contents) {
1769: ZVAL_STRINGL(object, contents, strlen(contents), 1);
1770: } else {
1771: ZVAL_NULL(object);
1772: }
1773: Z_SET_REFCOUNT_P(object, 1);
1774: Z_UNSET_ISREF_P(object);
1775:
1776: switch (type) {
1777: case IS_STRING:
1778: convert_to_string(object);
1779: break;
1780: case IS_BOOL:
1781: convert_to_boolean(object);
1782: break;
1783: case IS_LONG:
1784: convert_to_long(object);
1785: break;
1786: case IS_DOUBLE:
1787: convert_to_double(object);
1788: break;
1789: default:
1790: return FAILURE;
1791: }
1792: return SUCCESS;
1793: }
1794: /* }}} */
1795:
1796: /* {{{ sxe_object_cast()
1797: */
1798: static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
1799: {
1800: php_sxe_object *sxe;
1801: xmlChar *contents = NULL;
1802: xmlNodePtr node;
1803: int rv;
1804: HashTable *prop_hash;
1805:
1806: sxe = php_sxe_fetch_object(readobj TSRMLS_CC);
1807:
1808: if (type == IS_BOOL) {
1809: node = php_sxe_get_first_node(sxe, NULL TSRMLS_CC);
1810: prop_hash = sxe_get_prop_hash(readobj, 1 TSRMLS_CC);
1811: INIT_PZVAL(writeobj);
1812: ZVAL_BOOL(writeobj, node != NULL || zend_hash_num_elements(prop_hash) > 0);
1813: zend_hash_destroy(prop_hash);
1814: efree(prop_hash);
1815: return SUCCESS;
1816: }
1817:
1818: if (sxe->iter.type != SXE_ITER_NONE) {
1819: node = php_sxe_get_first_node(sxe, NULL TSRMLS_CC);
1820: if (node) {
1821: contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, node->children, 1);
1822: }
1823: } else {
1824: if (!sxe->node) {
1825: if (sxe->document) {
1826: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement((xmlDocPtr) sxe->document->ptr), NULL TSRMLS_CC);
1827: }
1828: }
1829:
1830: if (sxe->node && sxe->node->node) {
1831: if (sxe->node->node->children) {
1832: contents = xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, sxe->node->node->children, 1);
1833: }
1834: }
1835: }
1836:
1837: if (readobj == writeobj) {
1838: INIT_PZVAL(writeobj);
1839: zval_dtor(readobj);
1840: }
1841:
1842: rv = cast_object(writeobj, type, (char *)contents TSRMLS_CC);
1843:
1844: if (contents) {
1845: xmlFree(contents);
1846: }
1847: return rv;
1848: }
1849: /* }}} */
1850:
1851: /* {{{ proto object SimpleXMLElement::__toString() U
1852: Returns the string content */
1853: SXE_METHOD(__toString)
1854: {
1855: zval *result;
1856:
1857: ALLOC_INIT_ZVAL(result);
1858:
1859: if (sxe_object_cast(getThis(), result, IS_STRING TSRMLS_CC) == SUCCESS) {
1860: RETURN_ZVAL(result, 1, 1);
1861: } else {
1862: zval_ptr_dtor(&result);
1863: RETURN_EMPTY_STRING();
1864: }
1865: }
1866: /* }}} */
1867:
1868: static int php_sxe_count_elements_helper(php_sxe_object *sxe, long *count TSRMLS_DC) /* {{{ */
1869: {
1870: xmlNodePtr node;
1871: zval *data;
1872:
1873: *count = 0;
1874:
1875: data = sxe->iter.data;
1876: sxe->iter.data = NULL;
1877:
1878: node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
1879:
1880: while (node)
1881: {
1882: (*count)++;
1883: node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
1884: }
1885:
1886: if (sxe->iter.data) {
1887: zval_ptr_dtor(&sxe->iter.data);
1888: }
1889: sxe->iter.data = data;
1890:
1891: return SUCCESS;
1892: }
1893: /* }}} */
1894:
1895: static int sxe_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
1896: {
1897: php_sxe_object *intern;
1898: intern = php_sxe_fetch_object(object TSRMLS_CC);
1899: if (intern->fptr_count) {
1900: zval *rv;
1901: zend_call_method_with_0_params(&object, intern->zo.ce, &intern->fptr_count, "count", &rv);
1902: if (rv) {
1903: if (intern->tmp) {
1904: zval_ptr_dtor(&intern->tmp);
1905: }
1906: MAKE_STD_ZVAL(intern->tmp);
1907: ZVAL_ZVAL(intern->tmp, rv, 1, 1);
1908: convert_to_long(intern->tmp);
1909: *count = (long) Z_LVAL_P(intern->tmp);
1910: return SUCCESS;
1911: }
1912: return FAILURE;
1913: }
1914: return php_sxe_count_elements_helper(intern, count TSRMLS_CC);
1915: }
1916: /* }}} */
1917:
1918: /* {{{ proto int SimpleXMLElement::count()
1919: Get number of child elements */
1920: SXE_METHOD(count)
1921: {
1922: long count = 0;
1923: php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
1924:
1925: if (zend_parse_parameters_none() == FAILURE) {
1926: return;
1927: }
1928:
1929: php_sxe_count_elements_helper(sxe, &count TSRMLS_CC);
1930:
1931: RETURN_LONG(count);
1932: }
1933: /* }}} */
1934:
1935: static zval *sxe_get_value(zval *z TSRMLS_DC) /* {{{ */
1936: {
1937: zval *retval;
1938:
1939: MAKE_STD_ZVAL(retval);
1940:
1941: if (sxe_object_cast(z, retval, IS_STRING TSRMLS_CC)==FAILURE) {
1942: zend_error(E_ERROR, "Unable to cast node to string");
1943: /* FIXME: Should not be fatal */
1944: }
1945:
1946: Z_SET_REFCOUNT_P(retval, 0);
1947: return retval;
1948: }
1949: /* }}} */
1950:
1951: static zend_object_handlers sxe_object_handlers = { /* {{{ */
1952: ZEND_OBJECTS_STORE_HANDLERS,
1953: sxe_property_read,
1954: sxe_property_write,
1955: sxe_dimension_read,
1956: sxe_dimension_write,
1957: sxe_property_get_adr,
1958: sxe_get_value, /* get */
1959: NULL,
1960: sxe_property_exists,
1961: sxe_property_delete,
1962: sxe_dimension_exists,
1963: sxe_dimension_delete,
1964: sxe_get_properties,
1965: NULL, /* zend_get_std_object_handlers()->get_method,*/
1966: NULL, /* zend_get_std_object_handlers()->call_method,*/
1967: NULL, /* zend_get_std_object_handlers()->get_constructor, */
1968: NULL, /* zend_get_std_object_handlers()->get_class_entry,*/
1969: NULL, /* zend_get_std_object_handlers()->get_class_name,*/
1970: sxe_objects_compare,
1971: sxe_object_cast,
1972: sxe_count_elements,
1.1.1.3 misho 1973: sxe_get_debug_info,
1974: NULL,
1975: sxe_get_gc
1.1 misho 1976: };
1977: /* }}} */
1978:
1979: /* {{{ sxe_object_clone()
1980: */
1981: static void
1982: sxe_object_clone(void *object, void **clone_ptr TSRMLS_DC)
1983: {
1984: php_sxe_object *sxe = (php_sxe_object *) object;
1985: php_sxe_object *clone;
1986: xmlNodePtr nodep = NULL;
1987: xmlDocPtr docp = NULL;
1988:
1989: clone = php_sxe_object_new(sxe->zo.ce TSRMLS_CC);
1990: clone->document = sxe->document;
1991: if (clone->document) {
1992: clone->document->refcount++;
1993: docp = clone->document->ptr;
1994: }
1995:
1996: clone->iter.isprefix = sxe->iter.isprefix;
1997: if (sxe->iter.name != NULL) {
1998: clone->iter.name = xmlStrdup((xmlChar *)sxe->iter.name);
1999: }
2000: if (sxe->iter.nsprefix != NULL) {
2001: clone->iter.nsprefix = xmlStrdup((xmlChar *)sxe->iter.nsprefix);
2002: }
2003: clone->iter.type = sxe->iter.type;
2004:
2005: if (sxe->node) {
2006: nodep = xmlDocCopyNode(sxe->node->node, docp, 1);
2007: }
2008:
2009: php_libxml_increment_node_ptr((php_libxml_node_object *)clone, nodep, NULL TSRMLS_CC);
2010:
2011: *clone_ptr = (void *) clone;
2012: }
2013: /* }}} */
2014:
2015: /* {{{ sxe_object_dtor()
2016: */
2017: static void sxe_object_dtor(void *object, zend_object_handle handle TSRMLS_DC)
2018: {
2019: /* dtor required to cleanup iterator related data properly */
2020:
2021: php_sxe_object *sxe;
2022:
2023: sxe = (php_sxe_object *) object;
2024:
2025: if (sxe->iter.data) {
2026: zval_ptr_dtor(&sxe->iter.data);
2027: sxe->iter.data = NULL;
2028: }
2029:
2030: if (sxe->iter.name) {
2031: xmlFree(sxe->iter.name);
2032: sxe->iter.name = NULL;
2033: }
2034: if (sxe->iter.nsprefix) {
2035: xmlFree(sxe->iter.nsprefix);
2036: sxe->iter.nsprefix = NULL;
2037: }
2038: if (sxe->tmp) {
2039: zval_ptr_dtor(&sxe->tmp);
2040: sxe->tmp = NULL;
2041: }
2042: }
2043: /* }}} */
2044:
2045: /* {{{ sxe_object_free_storage()
2046: */
2047: static void sxe_object_free_storage(void *object TSRMLS_DC)
2048: {
2049: php_sxe_object *sxe;
2050:
2051: sxe = (php_sxe_object *) object;
2052:
2053: #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)
2054: zend_object_std_dtor(&sxe->zo TSRMLS_CC);
2055: #else
2056: if (sxe->zo.guards) {
2057: zend_hash_destroy(sxe->zo.guards);
2058: FREE_HASHTABLE(sxe->zo.guards);
2059: }
2060:
2061: if (sxe->zo.properties) {
2062: zend_hash_destroy(sxe->zo.properties);
2063: FREE_HASHTABLE(sxe->zo.properties);
2064: }
2065: #endif
2066:
2067: php_libxml_node_decrement_resource((php_libxml_node_object *)sxe TSRMLS_CC);
2068:
2069: if (sxe->xpath) {
2070: xmlXPathFreeContext(sxe->xpath);
2071: }
2072:
2073: if (sxe->properties) {
2074: zend_hash_destroy(sxe->properties);
2075: FREE_HASHTABLE(sxe->properties);
2076: }
2077:
2078: efree(object);
2079: }
2080: /* }}} */
2081:
2082: /* {{{ php_sxe_object_new()
2083: */
2084: static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC)
2085: {
2086: php_sxe_object *intern;
2087: zend_class_entry *parent = ce;
2088: int inherited = 0;
2089:
2090: intern = ecalloc(1, sizeof(php_sxe_object));
2091:
2092: intern->iter.type = SXE_ITER_NONE;
2093: intern->iter.nsprefix = NULL;
2094: intern->iter.name = NULL;
2095: intern->fptr_count = NULL;
2096:
2097: #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)
2098: zend_object_std_init(&intern->zo, ce TSRMLS_CC);
2099: #else
2100: ALLOC_HASHTABLE(intern->zo.properties);
2101: zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
2102:
2103: intern->zo.ce = ce;
2104: intern->zo.guards = NULL;
2105: #endif
2106:
2107: while (parent) {
2108: if (parent == sxe_class_entry) {
2109: break;
2110: }
2111:
2112: parent = parent->parent;
2113: inherited = 1;
2114: }
2115:
2116: if (inherited) {
2117: zend_hash_find(&ce->function_table, "count", sizeof("count"),(void **) &intern->fptr_count);
2118: if (intern->fptr_count->common.scope == parent) {
2119: intern->fptr_count = NULL;
2120: }
2121: }
2122:
2123: return intern;
2124: }
2125: /* }}} */
2126:
2127: /* {{{ php_sxe_register_object
2128: */
2129: static zend_object_value
2130: php_sxe_register_object(php_sxe_object *intern TSRMLS_DC)
2131: {
2132: zend_object_value rv;
2133:
2134: 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);
2135: rv.handlers = (zend_object_handlers *) &sxe_object_handlers;
2136:
2137: return rv;
2138: }
2139: /* }}} */
2140:
2141: /* {{{ sxe_object_new()
2142: */
2143: PHP_SXE_API zend_object_value
2144: sxe_object_new(zend_class_entry *ce TSRMLS_DC)
2145: {
2146: php_sxe_object *intern;
2147:
2148: intern = php_sxe_object_new(ce TSRMLS_CC);
2149: return php_sxe_register_object(intern TSRMLS_CC);
2150: }
2151: /* }}} */
2152:
2153: /* {{{ proto simplemxml_element simplexml_load_file(string filename [, string class_name [, int options [, string ns [, bool is_prefix]]]])
2154: Load a filename and return a simplexml_element object to allow for processing */
2155: PHP_FUNCTION(simplexml_load_file)
2156: {
2157: php_sxe_object *sxe;
2158: char *filename;
2159: int filename_len;
2160: xmlDocPtr docp;
2161: char *ns = NULL;
2162: int ns_len = 0;
2163: long options = 0;
2164: zend_class_entry *ce= sxe_class_entry;
2165: zend_bool isprefix = 0;
2166:
1.1.1.2 misho 2167: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|C!lsb", &filename, &filename_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
1.1 misho 2168: return;
2169: }
2170:
2171: docp = xmlReadFile(filename, NULL, options);
2172:
2173: if (! docp) {
2174: RETURN_FALSE;
2175: }
2176:
2177: if (!ce) {
2178: ce = sxe_class_entry;
2179: }
2180: sxe = php_sxe_object_new(ce TSRMLS_CC);
2181: sxe->iter.nsprefix = ns_len ? xmlStrdup((xmlChar *)ns) : NULL;
2182: sxe->iter.isprefix = isprefix;
2183: php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
2184: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
2185:
2186: return_value->type = IS_OBJECT;
2187: return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
2188: }
2189: /* }}} */
2190:
2191: /* {{{ proto simplemxml_element simplexml_load_string(string data [, string class_name [, int options [, string ns [, bool is_prefix]]]])
2192: Load a string and return a simplexml_element object to allow for processing */
2193: PHP_FUNCTION(simplexml_load_string)
2194: {
2195: php_sxe_object *sxe;
2196: char *data;
2197: int data_len;
2198: xmlDocPtr docp;
2199: char *ns = NULL;
2200: int ns_len = 0;
2201: long options = 0;
2202: zend_class_entry *ce= sxe_class_entry;
2203: zend_bool isprefix = 0;
2204:
2205: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|C!lsb", &data, &data_len, &ce, &options, &ns, &ns_len, &isprefix) == FAILURE) {
2206: return;
2207: }
2208:
2209: docp = xmlReadMemory(data, data_len, NULL, NULL, options);
2210:
2211: if (! docp) {
2212: RETURN_FALSE;
2213: }
2214:
2215: if (!ce) {
2216: ce = sxe_class_entry;
2217: }
2218: sxe = php_sxe_object_new(ce TSRMLS_CC);
2219: sxe->iter.nsprefix = ns_len ? xmlStrdup((xmlChar *)ns) : NULL;
2220: sxe->iter.isprefix = isprefix;
2221: php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
2222: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
2223:
2224: return_value->type = IS_OBJECT;
2225: return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
2226: }
2227: /* }}} */
2228:
2229: /* {{{ proto SimpleXMLElement::__construct(string data [, int options [, bool data_is_url [, string ns [, bool is_prefix]]]])
2230: SimpleXMLElement constructor */
2231: SXE_METHOD(__construct)
2232: {
2233: php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
2234: char *data, *ns = NULL;
2235: int data_len, ns_len = 0;
2236: xmlDocPtr docp;
2237: long options = 0;
2238: zend_bool is_url = 0, isprefix = 0;
2239: zend_error_handling error_handling;
2240:
2241: zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
2242: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lbsb", &data, &data_len, &options, &is_url, &ns, &ns_len, &isprefix) == FAILURE) {
2243: zend_restore_error_handling(&error_handling TSRMLS_CC);
2244: return;
2245: }
2246:
2247: zend_restore_error_handling(&error_handling TSRMLS_CC);
2248:
2249: docp = is_url ? xmlReadFile(data, NULL, options) : xmlReadMemory(data, data_len, NULL, NULL, options);
2250:
2251: if (!docp) {
2252: ((php_libxml_node_object *)sxe)->document = NULL;
2253: zend_throw_exception(zend_exception_get_default(TSRMLS_C), "String could not be parsed as XML", 0 TSRMLS_CC);
2254: return;
2255: }
2256:
2257: sxe->iter.nsprefix = ns_len ? xmlStrdup((xmlChar *)ns) : NULL;
2258: sxe->iter.isprefix = isprefix;
2259: php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
2260: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
2261: }
2262: /* }}} */
2263:
2264: zend_object_iterator_funcs php_sxe_iterator_funcs = { /* {{{ */
2265: php_sxe_iterator_dtor,
2266: php_sxe_iterator_valid,
2267: php_sxe_iterator_current_data,
2268: php_sxe_iterator_current_key,
2269: php_sxe_iterator_move_forward,
2270: php_sxe_iterator_rewind,
2271: };
2272: /* }}} */
2273:
2274: static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data TSRMLS_DC) /* {{{ */
2275: {
2276: xmlChar *prefix = sxe->iter.nsprefix;
2277: int isprefix = sxe->iter.isprefix;
2278: int test_elem = sxe->iter.type == SXE_ITER_ELEMENT && sxe->iter.name;
2279: int test_attr = sxe->iter.type == SXE_ITER_ATTRLIST && sxe->iter.name;
2280:
2281: while (node) {
2282: SKIP_TEXT(node);
2283: if (sxe->iter.type != SXE_ITER_ATTRLIST && node->type == XML_ELEMENT_NODE) {
2284: if ((!test_elem || !xmlStrcmp(node->name, sxe->iter.name)) && match_ns(sxe, node, prefix, isprefix)) {
2285: break;
2286: }
2287: } else if (node->type == XML_ATTRIBUTE_NODE) {
2288: if ((!test_attr || !xmlStrcmp(node->name, sxe->iter.name)) && match_ns(sxe, node, prefix, isprefix)) {
2289: break;
2290: }
2291: }
2292: next_iter:
2293: node = node->next;
2294: }
2295:
2296: if (node && use_data) {
2297: ALLOC_INIT_ZVAL(sxe->iter.data);
2298: _node_as_zval(sxe, node, sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix TSRMLS_CC);
2299: }
2300:
2301: return node;
2302: }
2303: /* }}} */
2304:
2305: static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data TSRMLS_DC) /* {{{ */
2306: {
2307: xmlNodePtr node;
2308:
2309: if (sxe->iter.data) {
2310: zval_ptr_dtor(&sxe->iter.data);
2311: sxe->iter.data = NULL;
2312: }
2313:
2314: GET_NODE(sxe, node)
2315:
2316: if (node) {
2317: switch (sxe->iter.type) {
2318: case SXE_ITER_ELEMENT:
2319: case SXE_ITER_CHILD:
2320: case SXE_ITER_NONE:
2321: node = node->children;
2322: break;
2323: case SXE_ITER_ATTRLIST:
2324: node = (xmlNodePtr) node->properties;
2325: }
2326: return php_sxe_iterator_fetch(sxe, node, use_data TSRMLS_CC);
2327: }
2328: return NULL;
2329: }
2330: /* }}} */
2331:
2332: zend_object_iterator *php_sxe_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
2333: {
2334: php_sxe_iterator *iterator;
2335:
2336: if (by_ref) {
2337: zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
2338: }
2339: iterator = emalloc(sizeof(php_sxe_iterator));
2340:
2341: Z_ADDREF_P(object);
2342: iterator->intern.data = (void*)object;
2343: iterator->intern.funcs = &php_sxe_iterator_funcs;
2344: iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC);
2345:
2346: return (zend_object_iterator*)iterator;
2347: }
2348: /* }}} */
2349:
2350: static void php_sxe_iterator_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
2351: {
2352: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2353:
2354: /* cleanup handled in sxe_object_dtor as we dont always have an iterator wrapper */
2355: if (iterator->intern.data) {
2356: zval_ptr_dtor((zval**)&iterator->intern.data);
2357: }
2358:
2359: efree(iterator);
2360: }
2361: /* }}} */
2362:
2363: static int php_sxe_iterator_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
2364: {
2365: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2366:
2367: return iterator->sxe->iter.data ? SUCCESS : FAILURE;
2368: }
2369: /* }}} */
2370:
2371: static void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
2372: {
2373: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2374:
2375: *data = &iterator->sxe->iter.data;
2376: }
2377: /* }}} */
2378:
2379: static int php_sxe_iterator_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC) /* {{{ */
2380: {
2381: zval *curobj;
2382: xmlNodePtr curnode = NULL;
2383: php_sxe_object *intern;
2384: int namelen;
2385:
2386: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2387: curobj = iterator->sxe->iter.data;
2388:
2389: intern = (php_sxe_object *)zend_object_store_get_object(curobj TSRMLS_CC);
2390: if (intern != NULL && intern->node != NULL) {
2391: curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->node)->node;
2392: }
2393: if (!curnode) {
2394: return HASH_KEY_NON_EXISTANT;
2395: }
2396:
2397: namelen = xmlStrlen(curnode->name);
2398: *str_key = estrndup((char *)curnode->name, namelen);
2399: *str_key_len = namelen + 1;
2400: return HASH_KEY_IS_STRING;
2401:
2402: }
2403: /* }}} */
2404:
2405: PHP_SXE_API void php_sxe_move_forward_iterator(php_sxe_object *sxe TSRMLS_DC) /* {{{ */
2406: {
2407: xmlNodePtr node = NULL;
2408: php_sxe_object *intern;
2409:
2410: if (sxe->iter.data) {
2411: intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
2412: GET_NODE(intern, node)
2413: zval_ptr_dtor(&sxe->iter.data);
2414: sxe->iter.data = NULL;
2415: }
2416:
2417: if (node) {
2418: php_sxe_iterator_fetch(sxe, node->next, 1 TSRMLS_CC);
2419: }
2420: }
2421: /* }}} */
2422:
2423: static void php_sxe_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
2424: {
2425: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2426: php_sxe_move_forward_iterator(iterator->sxe TSRMLS_CC);
2427: }
2428: /* }}} */
2429:
2430: static void php_sxe_iterator_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
2431: {
2432: php_sxe_object *sxe;
2433:
2434: php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
2435: sxe = iterator->sxe;
2436:
2437: php_sxe_reset_iterator(sxe, 1 TSRMLS_CC);
2438: }
2439: /* }}} */
2440:
2441: void *simplexml_export_node(zval *object TSRMLS_DC) /* {{{ */
2442: {
2443: php_sxe_object *sxe;
2444: xmlNodePtr node;
2445:
2446: sxe = php_sxe_fetch_object(object TSRMLS_CC);
2447: GET_NODE(sxe, node);
2448: return php_sxe_get_first_node(sxe, node TSRMLS_CC);
2449: }
2450: /* }}} */
2451:
2452: /* {{{ proto simplemxml_element simplexml_import_dom(domNode node [, string class_name])
2453: Get a simplexml_element object from dom to allow for processing */
2454: PHP_FUNCTION(simplexml_import_dom)
2455: {
2456: php_sxe_object *sxe;
2457: zval *node;
2458: php_libxml_node_object *object;
2459: xmlNodePtr nodep = NULL;
2460: zend_class_entry *ce= sxe_class_entry;
2461:
2462: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|C!", &node, &ce) == FAILURE) {
2463: return;
2464: }
2465:
2466: object = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
2467:
2468: nodep = php_libxml_import_node(node TSRMLS_CC);
2469:
2470: if (nodep) {
2471: if (nodep->doc == NULL) {
2472: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Imported Node must have associated Document");
2473: RETURN_NULL();
2474: }
2475: if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
2476: nodep = xmlDocGetRootElement((xmlDocPtr) nodep);
2477: }
2478: }
2479:
2480: if (nodep && nodep->type == XML_ELEMENT_NODE) {
2481: if (!ce) {
2482: ce = sxe_class_entry;
2483: }
2484: sxe = php_sxe_object_new(ce TSRMLS_CC);
2485: sxe->document = object->document;
2486: php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, nodep->doc TSRMLS_CC);
2487: php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, nodep, NULL TSRMLS_CC);
2488:
2489: return_value->type = IS_OBJECT;
2490: return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
2491: } else {
2492: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
2493: RETVAL_NULL();
2494: }
2495: }
2496: /* }}} */
2497:
2498: /* {{{ arginfo */
2499: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_file, 0, 0, 1)
2500: ZEND_ARG_INFO(0, filename)
2501: ZEND_ARG_INFO(0, class_name)
2502: ZEND_ARG_INFO(0, options)
2503: ZEND_ARG_INFO(0, ns)
2504: ZEND_ARG_INFO(0, is_prefix)
2505: ZEND_END_ARG_INFO()
2506:
2507: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_load_string, 0, 0, 1)
2508: ZEND_ARG_INFO(0, data)
2509: ZEND_ARG_INFO(0, class_name)
2510: ZEND_ARG_INFO(0, options)
2511: ZEND_ARG_INFO(0, ns)
2512: ZEND_ARG_INFO(0, is_prefix)
2513: ZEND_END_ARG_INFO()
2514:
2515: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexml_import_dom, 0, 0, 1)
2516: ZEND_ARG_INFO(0, node)
2517: ZEND_ARG_INFO(0, class_name)
2518: ZEND_END_ARG_INFO()
2519:
2520: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_xpath, 0, 0, 1)
2521: ZEND_ARG_INFO(0, path)
2522: ZEND_END_ARG_INFO()
2523:
2524: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_registerxpathnamespace, 0, 0, 2)
2525: ZEND_ARG_INFO(0, prefix)
2526: ZEND_ARG_INFO(0, ns)
2527: ZEND_END_ARG_INFO()
2528:
2529: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_asxml, 0, 0, 0)
2530: ZEND_ARG_INFO(0, filename)
2531: ZEND_END_ARG_INFO()
2532:
2533: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getnamespaces, 0, 0, 0)
2534: ZEND_ARG_INFO(0, recursve)
2535: ZEND_END_ARG_INFO()
2536:
1.1.1.3 misho 2537: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_getdocnamespaces, 0, 0, 0)
2538: ZEND_ARG_INFO(0, recursve)
2539: ZEND_ARG_INFO(0, from_root)
2540: ZEND_END_ARG_INFO()
2541:
1.1 misho 2542: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_children, 0, 0, 0)
2543: ZEND_ARG_INFO(0, ns)
2544: ZEND_ARG_INFO(0, is_prefix)
2545: ZEND_END_ARG_INFO()
2546:
2547: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement__construct, 0, 0, 1)
2548: ZEND_ARG_INFO(0, data)
2549: ZEND_ARG_INFO(0, options)
2550: ZEND_ARG_INFO(0, data_is_url)
2551: ZEND_ARG_INFO(0, ns)
2552: ZEND_ARG_INFO(0, is_prefix)
2553: ZEND_END_ARG_INFO()
2554:
2555: ZEND_BEGIN_ARG_INFO(arginfo_simplexmlelement__void, 0)
2556: ZEND_END_ARG_INFO()
2557:
2558: ZEND_BEGIN_ARG_INFO_EX(arginfo_simplexmlelement_addchild, 0, 0, 1)
2559: ZEND_ARG_INFO(0, name)
2560: ZEND_ARG_INFO(0, value)
2561: ZEND_ARG_INFO(0, ns)
2562: ZEND_END_ARG_INFO()
2563: /* }}} */
2564:
2565: const zend_function_entry simplexml_functions[] = { /* {{{ */
2566: PHP_FE(simplexml_load_file, arginfo_simplexml_load_file)
2567: PHP_FE(simplexml_load_string, arginfo_simplexml_load_string)
2568: PHP_FE(simplexml_import_dom, arginfo_simplexml_import_dom)
2569: PHP_FE_END
2570: };
2571: /* }}} */
2572:
2573: static const zend_module_dep simplexml_deps[] = { /* {{{ */
2574: ZEND_MOD_REQUIRED("libxml")
2575: ZEND_MOD_REQUIRED("spl")
2576: ZEND_MOD_END
2577: };
2578: /* }}} */
2579:
2580: zend_module_entry simplexml_module_entry = { /* {{{ */
2581: STANDARD_MODULE_HEADER_EX, NULL,
2582: simplexml_deps,
2583: "SimpleXML",
2584: simplexml_functions,
2585: PHP_MINIT(simplexml),
2586: PHP_MSHUTDOWN(simplexml),
2587: NULL,
2588: NULL,
2589: PHP_MINFO(simplexml),
2590: "0.1",
2591: STANDARD_MODULE_PROPERTIES
2592: };
2593: /* }}} */
2594:
2595: #ifdef COMPILE_DL_SIMPLEXML
2596: ZEND_GET_MODULE(simplexml)
2597: #endif
2598:
2599: /* the method table */
2600: /* each method can have its own parameters and visibility */
2601: static const zend_function_entry sxe_functions[] = { /* {{{ */
2602: SXE_ME(__construct, arginfo_simplexmlelement__construct, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) /* must be called */
2603: SXE_ME(asXML, arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
2604: SXE_MALIAS(saveXML, asXML, arginfo_simplexmlelement_asxml, ZEND_ACC_PUBLIC)
2605: SXE_ME(xpath, arginfo_simplexmlelement_xpath, ZEND_ACC_PUBLIC)
2606: SXE_ME(registerXPathNamespace, arginfo_simplexmlelement_registerxpathnamespace, ZEND_ACC_PUBLIC)
2607: SXE_ME(attributes, arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
2608: SXE_ME(children, arginfo_simplexmlelement_children, ZEND_ACC_PUBLIC)
2609: SXE_ME(getNamespaces, arginfo_simplexmlelement_getnamespaces, ZEND_ACC_PUBLIC)
1.1.1.3 misho 2610: SXE_ME(getDocNamespaces, arginfo_simplexmlelement_getdocnamespaces, ZEND_ACC_PUBLIC)
1.1 misho 2611: SXE_ME(getName, arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2612: SXE_ME(addChild, arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
2613: SXE_ME(addAttribute, arginfo_simplexmlelement_addchild, ZEND_ACC_PUBLIC)
2614: SXE_ME(__toString, arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2615: SXE_ME(count, arginfo_simplexmlelement__void, ZEND_ACC_PUBLIC)
2616: PHP_FE_END
2617: };
2618: /* }}} */
2619:
2620: /* {{{ PHP_MINIT_FUNCTION(simplexml)
2621: */
2622: PHP_MINIT_FUNCTION(simplexml)
2623: {
2624: zend_class_entry sxe;
2625:
2626: INIT_CLASS_ENTRY(sxe, "SimpleXMLElement", sxe_functions);
2627: sxe.create_object = sxe_object_new;
2628: sxe_class_entry = zend_register_internal_class(&sxe TSRMLS_CC);
2629: sxe_class_entry->get_iterator = php_sxe_get_iterator;
2630: sxe_class_entry->iterator_funcs.funcs = &php_sxe_iterator_funcs;
2631: zend_class_implements(sxe_class_entry TSRMLS_CC, 1, zend_ce_traversable);
2632: sxe_object_handlers.get_method = zend_get_std_object_handlers()->get_method;
2633: sxe_object_handlers.get_constructor = zend_get_std_object_handlers()->get_constructor;
2634: sxe_object_handlers.get_class_entry = zend_get_std_object_handlers()->get_class_entry;
2635: sxe_object_handlers.get_class_name = zend_get_std_object_handlers()->get_class_name;
2636: sxe_class_entry->serialize = zend_class_serialize_deny;
2637: sxe_class_entry->unserialize = zend_class_unserialize_deny;
2638:
2639: php_libxml_register_export(sxe_class_entry, simplexml_export_node);
2640:
2641: PHP_MINIT(sxe)(INIT_FUNC_ARGS_PASSTHRU);
2642:
2643: return SUCCESS;
2644: }
2645: /* }}} */
2646:
2647: /* {{{ PHP_MSHUTDOWN_FUNCTION(simplexml)
2648: */
2649: PHP_MSHUTDOWN_FUNCTION(simplexml)
2650: {
2651: sxe_class_entry = NULL;
2652: return SUCCESS;
2653: }
2654: /* }}} */
2655:
2656: /* {{{ PHP_MINFO_FUNCTION(simplexml)
2657: */
2658: PHP_MINFO_FUNCTION(simplexml)
2659: {
2660: php_info_print_table_start();
2661: php_info_print_table_header(2, "Simplexml support", "enabled");
1.1.1.4 ! misho 2662: php_info_print_table_row(2, "Revision", "$Id: 2358f2be6570ab413d0ead3a931a5365adf94af9 $");
1.1 misho 2663: php_info_print_table_row(2, "Schema support",
2664: #ifdef LIBXML_SCHEMAS_ENABLED
2665: "enabled");
2666: #else
2667: "not available");
2668: #endif
2669: php_info_print_table_end();
2670: }
2671: /* }}} */
2672:
2673: #endif
2674:
2675: /**
2676: * Local Variables:
2677: * c-basic-offset: 4
2678: * tab-width: 4
2679: * indent-tabs-mode: t
2680: * End:
2681: * vim600: fdm=marker
2682: * vim: noet sw=4 ts=4
2683: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>