Annotation of embedaddon/php/ext/dom/php_dom.c, revision 1.1.1.3
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: Christian Stocker <chregu@php.net> |
16: | Rob Richards <rrichards@php.net> |
17: | Marcus Borger <helly@php.net> |
18: +----------------------------------------------------------------------+
19: */
20:
1.1.1.2 misho 21: /* $Id$ */
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_DOM
29: #include "ext/standard/php_rand.h"
30: #include "php_dom.h"
31: #include "dom_properties.h"
32: #include "zend_interfaces.h"
33:
34: #include "ext/standard/info.h"
35: #define PHP_XPATH 1
36: #define PHP_XPTR 2
37:
38: /* {{{ class entries */
39: zend_class_entry *dom_node_class_entry;
40: zend_class_entry *dom_domexception_class_entry;
41: zend_class_entry *dom_domstringlist_class_entry;
42: zend_class_entry *dom_namelist_class_entry;
43: zend_class_entry *dom_domimplementationlist_class_entry;
44: zend_class_entry *dom_domimplementationsource_class_entry;
45: zend_class_entry *dom_domimplementation_class_entry;
46: zend_class_entry *dom_documentfragment_class_entry;
47: zend_class_entry *dom_document_class_entry;
48: zend_class_entry *dom_nodelist_class_entry;
49: zend_class_entry *dom_namednodemap_class_entry;
50: zend_class_entry *dom_characterdata_class_entry;
51: zend_class_entry *dom_attr_class_entry;
52: zend_class_entry *dom_element_class_entry;
53: zend_class_entry *dom_text_class_entry;
54: zend_class_entry *dom_comment_class_entry;
55: zend_class_entry *dom_typeinfo_class_entry;
56: zend_class_entry *dom_userdatahandler_class_entry;
57: zend_class_entry *dom_domerror_class_entry;
58: zend_class_entry *dom_domerrorhandler_class_entry;
59: zend_class_entry *dom_domlocator_class_entry;
60: zend_class_entry *dom_domconfiguration_class_entry;
61: zend_class_entry *dom_cdatasection_class_entry;
62: zend_class_entry *dom_documenttype_class_entry;
63: zend_class_entry *dom_notation_class_entry;
64: zend_class_entry *dom_entity_class_entry;
65: zend_class_entry *dom_entityreference_class_entry;
66: zend_class_entry *dom_processinginstruction_class_entry;
67: zend_class_entry *dom_string_extend_class_entry;
68: #if defined(LIBXML_XPATH_ENABLED)
69: zend_class_entry *dom_xpath_class_entry;
70: #endif
71: zend_class_entry *dom_namespace_node_class_entry;
72: /* }}} */
73:
74: zend_object_handlers dom_object_handlers;
75:
76: static HashTable classes;
77: /* {{{ prop handler tables */
78: static HashTable dom_domstringlist_prop_handlers;
79: static HashTable dom_namelist_prop_handlers;
80: static HashTable dom_domimplementationlist_prop_handlers;
81: static HashTable dom_document_prop_handlers;
82: static HashTable dom_node_prop_handlers;
83: static HashTable dom_nodelist_prop_handlers;
84: static HashTable dom_namednodemap_prop_handlers;
85: static HashTable dom_characterdata_prop_handlers;
86: static HashTable dom_attr_prop_handlers;
87: static HashTable dom_element_prop_handlers;
88: static HashTable dom_text_prop_handlers;
89: static HashTable dom_typeinfo_prop_handlers;
90: static HashTable dom_domerror_prop_handlers;
91: static HashTable dom_domlocator_prop_handlers;
92: static HashTable dom_documenttype_prop_handlers;
93: static HashTable dom_notation_prop_handlers;
94: static HashTable dom_entity_prop_handlers;
95: static HashTable dom_processinginstruction_prop_handlers;
96: static HashTable dom_namespace_node_prop_handlers;
97: #if defined(LIBXML_XPATH_ENABLED)
98: static HashTable dom_xpath_prop_handlers;
99: #endif
100: /* }}} */
101:
102: typedef int (*dom_read_t)(dom_object *obj, zval **retval TSRMLS_DC);
103: typedef int (*dom_write_t)(dom_object *obj, zval *newval TSRMLS_DC);
104:
105: typedef struct _dom_prop_handler {
106: dom_read_t read_func;
107: dom_write_t write_func;
108: } dom_prop_handler;
109:
110: /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
111: int dom_node_is_read_only(xmlNodePtr node) {
112: switch (node->type) {
113: case XML_ENTITY_REF_NODE:
114: case XML_ENTITY_NODE:
115: case XML_DOCUMENT_TYPE_NODE:
116: case XML_NOTATION_NODE:
117: case XML_DTD_NODE:
118: case XML_ELEMENT_DECL:
119: case XML_ATTRIBUTE_DECL:
120: case XML_ENTITY_DECL:
121: case XML_NAMESPACE_DECL:
122: return SUCCESS;
123: break;
124: default:
125: if (node->doc == NULL) {
126: return SUCCESS;
127: } else {
128: return FAILURE;
129: }
130: }
131: }
132: /* }}} end dom_node_is_read_only */
133:
134: /* {{{ int dom_node_children_valid(xmlNodePtr node) */
135: int dom_node_children_valid(xmlNodePtr node) {
136: switch (node->type) {
137: case XML_DOCUMENT_TYPE_NODE:
138: case XML_DTD_NODE:
139: case XML_PI_NODE:
140: case XML_COMMENT_NODE:
141: case XML_TEXT_NODE:
142: case XML_CDATA_SECTION_NODE:
143: case XML_NOTATION_NODE:
144: return FAILURE;
145: break;
146: default:
147: return SUCCESS;
148: }
149: }
150: /* }}} end dom_node_children_valid */
151:
152: /* {{{ dom_get_doc_props() */
153: dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
154: {
155: dom_doc_propsptr doc_props;
156:
157: if (document && document->doc_props) {
158: return document->doc_props;
159: } else {
160: doc_props = emalloc(sizeof(libxml_doc_props));
161: doc_props->formatoutput = 0;
162: doc_props->validateonparse = 0;
163: doc_props->resolveexternals = 0;
164: doc_props->preservewhitespace = 1;
165: doc_props->substituteentities = 0;
166: doc_props->stricterror = 1;
167: doc_props->recover = 0;
168: doc_props->classmap = NULL;
169: if (document) {
170: document->doc_props = doc_props;
171: }
172: return doc_props;
173: }
174: }
175:
176: static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
177: {
178: dom_doc_propsptr source, dest;
179:
180: if (source_doc && dest_doc) {
181:
182: source = dom_get_doc_props(source_doc);
183: dest = dom_get_doc_props(dest_doc);
184:
185: dest->formatoutput = source->formatoutput;
186: dest->validateonparse = source->validateonparse;
187: dest->resolveexternals = source->resolveexternals;
188: dest->preservewhitespace = source->preservewhitespace;
189: dest->substituteentities = source->substituteentities;
190: dest->stricterror = source->stricterror;
191: dest->recover = source->recover;
192: if (source->classmap) {
193: ALLOC_HASHTABLE(dest->classmap);
194: zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
195: zend_hash_copy(dest->classmap, source->classmap, NULL, NULL, sizeof(zend_class_entry *));
196: }
197:
198: }
199: }
200:
201: int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce TSRMLS_DC)
202: {
203: dom_doc_propsptr doc_props;
204:
205: if (document) {
206: doc_props = dom_get_doc_props(document);
207: if (doc_props->classmap == NULL) {
208: if (ce == NULL) {
209: return SUCCESS;
210: }
211: ALLOC_HASHTABLE(doc_props->classmap);
212: zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
213: }
214: if (ce) {
215: return zend_hash_update(doc_props->classmap, basece->name, basece->name_length + 1, &ce, sizeof(zend_class_entry *), NULL);
216: } else {
217: zend_hash_del(doc_props->classmap, basece->name, basece->name_length + 1);
218: }
219: }
220: return SUCCESS;
221: }
222:
223: zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece TSRMLS_DC)
224: {
225: dom_doc_propsptr doc_props;
226: zend_class_entry **ce = NULL;
227:
228: if (document) {
229: doc_props = dom_get_doc_props(document);
230: if (doc_props->classmap) {
231: if (zend_hash_find(doc_props->classmap, basece->name, basece->name_length + 1, (void**) &ce) == SUCCESS) {
232: return *ce;
233: }
234: }
235: }
236:
237: return basece;
238: }
239: /* }}} */
240:
241: /* {{{ dom_get_strict_error() */
242: int dom_get_strict_error(php_libxml_ref_obj *document) {
243: int stricterror;
244: dom_doc_propsptr doc_props;
245:
246: doc_props = dom_get_doc_props(document);
247: stricterror = doc_props->stricterror;
248: if (document == NULL) {
249: efree(doc_props);
250: }
251:
252: return stricterror;
253: }
254: /* }}} */
255:
256: /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
257: PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
258: {
259: if (obj && obj->ptr != NULL) {
260: return ((php_libxml_node_ptr *)obj->ptr)->node;
261: } else {
262: return NULL;
263: }
264: }
265: /* }}} end dom_object_get_node */
266:
267: /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
268: PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
269: {
270: if (obj && obj->_private != NULL) {
271: return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
272: } else {
273: return NULL;
274: }
275: }
276: /* }}} end php_dom_object_get_data */
277:
278: /* {{{ dom_read_na */
279: static int dom_read_na(dom_object *obj, zval **retval TSRMLS_DC)
280: {
281: *retval = NULL;
282: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
283: return FAILURE;
284: }
285: /* }}} */
286:
287: /* {{{ dom_write_na */
288: static int dom_write_na(dom_object *obj, zval *newval TSRMLS_DC)
289: {
290: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot write property");
291: return FAILURE;
292: }
293: /* }}} */
294:
295: /* {{{ dom_register_prop_handler */
296: static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_read_t read_func, dom_write_t write_func TSRMLS_DC)
297: {
298: dom_prop_handler hnd;
299:
300: hnd.read_func = read_func ? read_func : dom_read_na;
301: hnd.write_func = write_func ? write_func : dom_write_na;
302: zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(dom_prop_handler), NULL);
303: }
304: /* }}} */
305:
1.1.1.2 misho 306: static zval **dom_get_property_ptr_ptr(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
1.1 misho 307: {
308: dom_object *obj;
309: zval tmp_member;
310: zval **retval = NULL;
311: dom_prop_handler *hnd;
312: zend_object_handlers *std_hnd;
313: int ret = FAILURE;
314:
315: if (member->type != IS_STRING) {
316: tmp_member = *member;
317: zval_copy_ctor(&tmp_member);
318: convert_to_string(&tmp_member);
319: member = &tmp_member;
320: }
321:
322: obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
323:
324: if (obj->prop_handler != NULL) {
325: ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
326: }
327: if (ret == FAILURE) {
328: std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 329: retval = std_hnd->get_property_ptr_ptr(object, member, key TSRMLS_CC);
1.1 misho 330: }
331:
332: if (member == &tmp_member) {
333: zval_dtor(member);
334: }
335: return retval;
336: }
337: /* }}} */
338:
339: /* {{{ dom_read_property */
1.1.1.2 misho 340: zval *dom_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
1.1 misho 341: {
342: dom_object *obj;
343: zval tmp_member;
344: zval *retval;
345: dom_prop_handler *hnd;
346: zend_object_handlers *std_hnd;
347: int ret;
348:
349: if (member->type != IS_STRING) {
350: tmp_member = *member;
351: zval_copy_ctor(&tmp_member);
352: convert_to_string(&tmp_member);
353: member = &tmp_member;
354: }
355:
356: ret = FAILURE;
357: obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
358:
359: if (obj->prop_handler != NULL) {
360: ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
361: } else if (instanceof_function(obj->std.ce, dom_node_class_entry TSRMLS_CC)) {
362: php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", obj->std.ce->name);
363: }
364: if (ret == SUCCESS) {
365: ret = hnd->read_func(obj, &retval TSRMLS_CC);
366: if (ret == SUCCESS) {
367: /* ensure we're creating a temporary variable */
368: Z_SET_REFCOUNT_P(retval, 0);
369: Z_UNSET_ISREF_P(retval);
370: } else {
371: retval = EG(uninitialized_zval_ptr);
372: }
373: } else {
374: std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 375: retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
1.1 misho 376: }
377:
378: if (member == &tmp_member) {
379: zval_dtor(member);
380: }
381: return retval;
382: }
383: /* }}} */
384:
385: /* {{{ dom_write_property */
1.1.1.2 misho 386: void dom_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
1.1 misho 387: {
388: dom_object *obj;
389: zval tmp_member;
390: dom_prop_handler *hnd;
391: zend_object_handlers *std_hnd;
392: int ret;
393:
394: if (member->type != IS_STRING) {
395: tmp_member = *member;
396: zval_copy_ctor(&tmp_member);
397: convert_to_string(&tmp_member);
398: member = &tmp_member;
399: }
400:
401: ret = FAILURE;
402: obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
403:
404: if (obj->prop_handler != NULL) {
405: ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
406: }
407: if (ret == SUCCESS) {
408: hnd->write_func(obj, value TSRMLS_CC);
409: } else {
410: std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 411: std_hnd->write_property(object, member, value, key TSRMLS_CC);
1.1 misho 412: }
413:
414: if (member == &tmp_member) {
415: zval_dtor(member);
416: }
417: }
418: /* }}} */
419:
420: /* {{{ dom_property_exists */
1.1.1.2 misho 421: static int dom_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
1.1 misho 422: {
423: dom_object *obj;
424: zval tmp_member;
425: dom_prop_handler *hnd;
426: zend_object_handlers *std_hnd;
427: int ret, retval=0;
428:
429: if (member->type != IS_STRING) {
430: tmp_member = *member;
431: zval_copy_ctor(&tmp_member);
432: convert_to_string(&tmp_member);
433: member = &tmp_member;
434: }
435:
436: ret = FAILURE;
437: obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
438:
439: if (obj->prop_handler != NULL) {
440: ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
441: }
442: if (ret == SUCCESS) {
443: zval *tmp;
444:
445: if (check_empty == 2) {
446: retval = 1;
447: } else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
448: Z_SET_REFCOUNT_P(tmp, 1);
449: Z_UNSET_ISREF_P(tmp);
450: if (check_empty == 1) {
451: retval = zend_is_true(tmp);
452: } else if (check_empty == 0) {
453: retval = (Z_TYPE_P(tmp) != IS_NULL);
454: }
455: zval_ptr_dtor(&tmp);
456: }
457: } else {
458: std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 459: retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
1.1 misho 460: }
461:
462: if (member == &tmp_member) {
463: zval_dtor(member);
464: }
465: return retval;
466: }
467: /* }}} */
468:
1.1.1.2 misho 469: static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
470: {
471: dom_object *obj = zend_object_store_get_object(object TSRMLS_CC);
472: HashTable *debug_info,
473: *prop_handlers = obj->prop_handler,
474: *std_props;
475: HashPosition pos;
476: dom_prop_handler *entry;
477: zval *object_value,
478: *null_value;
479:
480: *is_temp = 1;
481:
482: ALLOC_HASHTABLE(debug_info);
483: ZEND_INIT_SYMTABLE_EX(debug_info, 32, 0);
484:
485: std_props = zend_std_get_properties(object TSRMLS_CC);
486: zend_hash_copy(debug_info, std_props, (copy_ctor_func_t)zval_add_ref,
487: NULL, sizeof(zval*));
488:
489: if (!prop_handlers) {
490: return debug_info;
491: }
492:
493: ALLOC_INIT_ZVAL(object_value);
494: ZVAL_STRING(object_value, "(object value omitted)", 1);
495:
496: ALLOC_INIT_ZVAL(null_value);
497: ZVAL_NULL(null_value);
498:
499: for (zend_hash_internal_pointer_reset_ex(prop_handlers, &pos);
500: zend_hash_get_current_data_ex(prop_handlers, (void **)&entry, &pos)
501: == SUCCESS;
502: zend_hash_move_forward_ex(prop_handlers, &pos)) {
503: zval *value;
504: char *string_key = NULL;
505: uint string_length = 0;
506: ulong num_key;
507:
508: if (entry->read_func(obj, &value TSRMLS_CC) == FAILURE) {
509: continue;
510: }
511:
512: if (zend_hash_get_current_key_ex(prop_handlers, &string_key,
513: &string_length, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
514: continue;
515: }
516:
517: if (value == EG(uninitialized_zval_ptr)) {
518: value = null_value;
519: } else if (Z_TYPE_P(value) == IS_OBJECT) {
520: /* these are zvalues create on demand, with refcount and is_ref
521: * status left in an uninitalized stated */
522: zval_dtor(value);
523: efree(value);
524:
525: value = object_value;
526: } else {
527: /* see comment above */
528: Z_SET_REFCOUNT_P(value, 0);
529: Z_UNSET_ISREF_P(value);
530: }
531:
532: zval_add_ref(&value);
533: zend_hash_add(debug_info, string_key, string_length,
534: &value, sizeof(zval *), NULL);
535: }
536:
537: zval_ptr_dtor(&null_value);
538: zval_ptr_dtor(&object_value);
539:
540: return debug_info;
541: }
542: /* }}} */
543:
544: static HashTable* dom_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
545: {
546: return dom_get_debug_info_helper(object, is_temp TSRMLS_CC);
547: }
548: /* }}} */
549:
1.1 misho 550: void *php_dom_export_node(zval *object TSRMLS_DC) /* {{{ */
551: {
552: php_libxml_node_object *intern;
553: xmlNodePtr nodep = NULL;
554:
555: intern = (php_libxml_node_object *)zend_object_store_get_object(object TSRMLS_CC);
556: if (intern && intern->node) {
557: nodep = intern->node->node;
558: }
559:
560: return nodep;
561: }
562: /* }}} */
563:
564: /* {{{ proto somNode dom_import_simplexml(sxeobject node)
565: Get a simplexml_element object from dom to allow for processing */
566: PHP_FUNCTION(dom_import_simplexml)
567: {
568: zval *node;
569: xmlNodePtr nodep = NULL;
570: php_libxml_node_object *nodeobj;
571: int ret;
572:
573: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &node) == FAILURE) {
574: return;
575: }
576:
577: nodeobj = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
578: nodep = php_libxml_import_node(node TSRMLS_CC);
579:
580: if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
1.1.1.2 misho 581: DOM_RET_OBJ((xmlNodePtr) nodep, &ret, (dom_object *)nodeobj);
1.1 misho 582: } else {
583: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
584: RETURN_NULL();
585: }
586: }
587: /* }}} */
588:
589: zend_object_value dom_objects_store_clone_obj(zval *zobject TSRMLS_DC) /* {{{ */
590: {
591: zend_object_value retval;
592: void *new_object;
593: dom_object *intern;
594: dom_object *old_object;
595: struct _store_object *obj;
596: zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
597:
598: obj = &EG(objects_store).object_buckets[handle].bucket.obj;
599:
600: if (obj->clone == NULL) {
601: php_error(E_ERROR, "Trying to clone an uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
602: }
603:
604: obj->clone(obj->object, &new_object TSRMLS_CC);
605:
606: retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
607: intern = (dom_object *) new_object;
608: intern->handle = retval.handle;
609: retval.handlers = Z_OBJ_HT_P(zobject);
610:
611: old_object = (dom_object *) obj->object;
612: zend_objects_clone_members(&intern->std, retval, &old_object->std, intern->handle TSRMLS_CC);
613:
614: return retval;
615: }
616: /* }}} */
617:
618: /* {{{ arginfo */
619: ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_import_simplexml, 0, 0, 1)
620: ZEND_ARG_INFO(0, node)
621: ZEND_END_ARG_INFO()
622: /* }}} */
623:
624: static const zend_function_entry dom_functions[] = {
625: PHP_FE(dom_import_simplexml, arginfo_dom_import_simplexml)
626: PHP_FE_END
627: };
628:
629: static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
630: return &dom_object_handlers;
631: }
632:
633: static const zend_module_dep dom_deps[] = {
634: ZEND_MOD_REQUIRED("libxml")
635: ZEND_MOD_CONFLICTS("domxml")
636: ZEND_MOD_END
637: };
638:
639: zend_module_entry dom_module_entry = { /* {{{ */
640: STANDARD_MODULE_HEADER_EX, NULL,
641: dom_deps,
642: "dom",
643: dom_functions,
644: PHP_MINIT(dom),
645: PHP_MSHUTDOWN(dom),
646: NULL,
647: NULL,
648: PHP_MINFO(dom),
649: DOM_API_VERSION, /* Extension versionnumber */
650: STANDARD_MODULE_PROPERTIES
651: };
652: /* }}} */
653:
654: #ifdef COMPILE_DL_DOM
655: ZEND_GET_MODULE(dom)
656: #endif
657:
658: /* {{{ PHP_MINIT_FUNCTION(dom) */
659: PHP_MINIT_FUNCTION(dom)
660: {
661: zend_class_entry ce;
662:
663: memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
664: dom_object_handlers.read_property = dom_read_property;
665: dom_object_handlers.write_property = dom_write_property;
666: dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
667: dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
668: dom_object_handlers.has_property = dom_property_exists;
1.1.1.2 misho 669: dom_object_handlers.get_debug_info = dom_get_debug_info;
1.1 misho 670:
671: zend_hash_init(&classes, 0, NULL, NULL, 1);
672:
673: INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
674: dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
675: dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
676: zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
677:
678: REGISTER_DOM_CLASS(ce, "DOMStringList", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
679:
680: zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, NULL, 1);
681: dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL TSRMLS_CC);
682: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domstringlist_prop_handlers, sizeof(dom_domstringlist_prop_handlers), NULL);
683:
684: REGISTER_DOM_CLASS(ce, "DOMNameList", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
685:
686: zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, NULL, 1);
687: dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL TSRMLS_CC);
688: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namelist_prop_handlers, sizeof(dom_namelist_prop_handlers), NULL);
689:
690: REGISTER_DOM_CLASS(ce, "DOMImplementationList", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
691:
692: zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, NULL, 1);
693: dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL TSRMLS_CC);
694: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domimplementationlist_prop_handlers, sizeof(dom_domimplementationlist_prop_handlers), NULL);
695:
696: REGISTER_DOM_CLASS(ce, "DOMImplementationSource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
697: REGISTER_DOM_CLASS(ce, "DOMImplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
698:
699: REGISTER_DOM_CLASS(ce, "DOMNode", NULL, php_dom_node_class_functions, dom_node_class_entry);
700:
701: zend_hash_init(&dom_node_prop_handlers, 0, NULL, NULL, 1);
702: dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
703: dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
704: dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
705: dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
706: dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", dom_node_child_nodes_read, NULL TSRMLS_CC);
707: dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", dom_node_first_child_read, NULL TSRMLS_CC);
708: dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", dom_node_last_child_read, NULL TSRMLS_CC);
709: dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", dom_node_previous_sibling_read, NULL TSRMLS_CC);
710: dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", dom_node_next_sibling_read, NULL TSRMLS_CC);
711: dom_register_prop_handler(&dom_node_prop_handlers, "attributes", dom_node_attributes_read, NULL TSRMLS_CC);
712: dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
713: dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
714: dom_register_prop_handler(&dom_node_prop_handlers, "prefix", dom_node_prefix_read, dom_node_prefix_write TSRMLS_CC);
715: dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
716: dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL TSRMLS_CC);
717: dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write TSRMLS_CC);
718: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
719:
720: REGISTER_DOM_CLASS(ce, "DOMNameSpaceNode", NULL, NULL, dom_namespace_node_class_entry);
721:
722: zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, NULL, 1);
723: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
724: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL TSRMLS_CC);
725: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
726: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", dom_node_prefix_read, NULL TSRMLS_CC);
727: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
728: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
729: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
730: dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
731: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namespace_node_prop_handlers, sizeof(dom_namespace_node_prop_handlers), NULL);
732:
733: REGISTER_DOM_CLASS(ce, "DOMDocumentFragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
734: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
735:
736: REGISTER_DOM_CLASS(ce, "DOMDocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
737: zend_hash_init(&dom_document_prop_handlers, 0, NULL, NULL, 1);
738: dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL TSRMLS_CC);
739: dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL TSRMLS_CC);
740: dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL TSRMLS_CC);
741: dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
742: dom_register_prop_handler(&dom_document_prop_handlers, "encoding", dom_document_encoding_read, dom_document_encoding_write TSRMLS_CC);
743: dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
744: dom_register_prop_handler(&dom_document_prop_handlers, "standalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
745: dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
746: dom_register_prop_handler(&dom_document_prop_handlers, "version", dom_document_version_read, dom_document_version_write TSRMLS_CC);
747: dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", dom_document_version_read, dom_document_version_write TSRMLS_CC);
748: dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", dom_document_strict_error_checking_read, dom_document_strict_error_checking_write TSRMLS_CC);
749: dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", dom_document_document_uri_read, dom_document_document_uri_write TSRMLS_CC);
750: dom_register_prop_handler(&dom_document_prop_handlers, "config", dom_document_config_read, NULL TSRMLS_CC);
751: dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", dom_document_format_output_read, dom_document_format_output_write TSRMLS_CC);
752: dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", dom_document_validate_on_parse_read, dom_document_validate_on_parse_write TSRMLS_CC);
753: dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", dom_document_resolve_externals_read, dom_document_resolve_externals_write TSRMLS_CC);
754: dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write TSRMLS_CC);
755: dom_register_prop_handler(&dom_document_prop_handlers, "recover", dom_document_recover_read, dom_document_recover_write TSRMLS_CC);
756: dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", dom_document_substitue_entities_read, dom_document_substitue_entities_write TSRMLS_CC);
757:
758: zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
759: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_document_prop_handlers, sizeof(dom_document_prop_handlers), NULL);
760:
761: INIT_CLASS_ENTRY(ce, "DOMNodeList", php_dom_nodelist_class_functions);
762: ce.create_object = dom_nnodemap_objects_new;
763: dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
764: dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
765: zend_class_implements(dom_nodelist_class_entry TSRMLS_CC, 1, zend_ce_traversable);
766:
767: zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, 1);
768: dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL TSRMLS_CC);
769: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_nodelist_prop_handlers, sizeof(dom_nodelist_prop_handlers), NULL);
770:
771: INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", php_dom_namednodemap_class_functions);
772: ce.create_object = dom_nnodemap_objects_new;
773: dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
774: dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
775: zend_class_implements(dom_namednodemap_class_entry TSRMLS_CC, 1, zend_ce_traversable);
776:
777: zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, 1);
778: dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL TSRMLS_CC);
779: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namednodemap_prop_handlers, sizeof(dom_namednodemap_prop_handlers), NULL);
780:
781: REGISTER_DOM_CLASS(ce, "DOMCharacterData", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
782:
783: zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, NULL, 1);
784: dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write TSRMLS_CC);
785: dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL TSRMLS_CC);
786: zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
787: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_characterdata_prop_handlers), NULL);
788:
789: REGISTER_DOM_CLASS(ce, "DOMAttr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
790:
791: zend_hash_init(&dom_attr_prop_handlers, 0, NULL, NULL, 1);
792: dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL TSRMLS_CC);
793: dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL TSRMLS_CC);
794: dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write TSRMLS_CC);
795: dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL TSRMLS_CC);
796: dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL TSRMLS_CC);
797: zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
798: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_attr_prop_handlers, sizeof(dom_attr_prop_handlers), NULL);
799:
800: REGISTER_DOM_CLASS(ce, "DOMElement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
801:
802: zend_hash_init(&dom_element_prop_handlers, 0, NULL, NULL, 1);
803: dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL TSRMLS_CC);
804: dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL TSRMLS_CC);
805: zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
806: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_element_prop_handlers, sizeof(dom_element_prop_handlers), NULL);
807:
808: REGISTER_DOM_CLASS(ce, "DOMText", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
809:
810: zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, 1);
811: dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL TSRMLS_CC);
812: zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
813: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_text_prop_handlers), NULL);
814:
815: REGISTER_DOM_CLASS(ce, "DOMComment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
816: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
817:
818: REGISTER_DOM_CLASS(ce, "DOMTypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
819:
820: zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, NULL, 1);
821: dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL TSRMLS_CC);
822: dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL TSRMLS_CC);
823: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_typeinfo_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
824:
825: REGISTER_DOM_CLASS(ce, "DOMUserDataHandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
826: REGISTER_DOM_CLASS(ce, "DOMDomError", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
827:
828: zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, NULL, 1);
829: dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL TSRMLS_CC);
830: dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL TSRMLS_CC);
831: dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL TSRMLS_CC);
832: dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL TSRMLS_CC);
833: dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL TSRMLS_CC);
834: dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL TSRMLS_CC);
835: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domerror_prop_handlers, sizeof(dom_domerror_prop_handlers), NULL);
836:
837: REGISTER_DOM_CLASS(ce, "DOMErrorHandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
838: REGISTER_DOM_CLASS(ce, "DOMLocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
839:
840: zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, NULL, 1);
841: dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL TSRMLS_CC);
842: dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL TSRMLS_CC);
843: dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL TSRMLS_CC);
844: dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL TSRMLS_CC);
845: dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL TSRMLS_CC);
846: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domlocator_prop_handlers, sizeof(dom_domlocator_prop_handlers), NULL);
847:
848: REGISTER_DOM_CLASS(ce, "DOMConfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
849: REGISTER_DOM_CLASS(ce, "DOMCdataSection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
850: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
851:
852: REGISTER_DOM_CLASS(ce, "DOMDocumentType", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
853:
854: zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, NULL, 1);
855: dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL TSRMLS_CC);
856: dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL TSRMLS_CC);
857: dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL TSRMLS_CC);
858: dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL TSRMLS_CC);
859: dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL TSRMLS_CC);
860: dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL TSRMLS_CC);
861: zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
862: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_documenttype_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
863:
864: REGISTER_DOM_CLASS(ce, "DOMNotation", dom_node_class_entry, php_dom_notation_class_functions, dom_notation_class_entry);
865:
866: zend_hash_init(&dom_notation_prop_handlers, 0, NULL, NULL, 1);
867: dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL TSRMLS_CC);
868: dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL TSRMLS_CC);
869: zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
870: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_notation_prop_handlers, sizeof(dom_notation_prop_handlers), NULL);
871:
872: REGISTER_DOM_CLASS(ce, "DOMEntity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
873:
874: zend_hash_init(&dom_entity_prop_handlers, 0, NULL, NULL, 1);
875: dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL TSRMLS_CC);
876: dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL TSRMLS_CC);
877: dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL TSRMLS_CC);
878: dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write TSRMLS_CC);
879: dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write TSRMLS_CC);
880: dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write TSRMLS_CC);
881: zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
882:
883: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_entity_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
884:
885: REGISTER_DOM_CLASS(ce, "DOMEntityReference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
886: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
887:
888: REGISTER_DOM_CLASS(ce, "DOMProcessingInstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
889:
890: zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, NULL, 1);
891: dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL TSRMLS_CC);
892: dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write TSRMLS_CC);
893: zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
894: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_processinginstruction_prop_handlers, sizeof(dom_processinginstruction_prop_handlers), NULL);
895:
896: REGISTER_DOM_CLASS(ce, "DOMStringExtend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
897:
898: #if defined(LIBXML_XPATH_ENABLED)
899: INIT_CLASS_ENTRY(ce, "DOMXPath", php_dom_xpath_class_functions);
900: ce.create_object = dom_xpath_objects_new;
901: dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
902:
903: zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, 1);
904: dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL TSRMLS_CC);
905: zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_xpath_prop_handlers, sizeof(dom_xpath_prop_handlers), NULL);
906: #endif
907:
908: REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE", XML_ELEMENT_NODE, CONST_CS | CONST_PERSISTENT);
909: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NODE", XML_ATTRIBUTE_NODE, CONST_CS | CONST_PERSISTENT);
910: REGISTER_LONG_CONSTANT("XML_TEXT_NODE", XML_TEXT_NODE, CONST_CS | CONST_PERSISTENT);
911: REGISTER_LONG_CONSTANT("XML_CDATA_SECTION_NODE", XML_CDATA_SECTION_NODE, CONST_CS | CONST_PERSISTENT);
912: REGISTER_LONG_CONSTANT("XML_ENTITY_REF_NODE", XML_ENTITY_REF_NODE, CONST_CS | CONST_PERSISTENT);
913: REGISTER_LONG_CONSTANT("XML_ENTITY_NODE", XML_ENTITY_NODE, CONST_CS | CONST_PERSISTENT);
914: REGISTER_LONG_CONSTANT("XML_PI_NODE", XML_PI_NODE, CONST_CS | CONST_PERSISTENT);
915: REGISTER_LONG_CONSTANT("XML_COMMENT_NODE", XML_COMMENT_NODE, CONST_CS | CONST_PERSISTENT);
916: REGISTER_LONG_CONSTANT("XML_DOCUMENT_NODE", XML_DOCUMENT_NODE, CONST_CS | CONST_PERSISTENT);
917: REGISTER_LONG_CONSTANT("XML_DOCUMENT_TYPE_NODE", XML_DOCUMENT_TYPE_NODE, CONST_CS | CONST_PERSISTENT);
918: REGISTER_LONG_CONSTANT("XML_DOCUMENT_FRAG_NODE", XML_DOCUMENT_FRAG_NODE, CONST_CS | CONST_PERSISTENT);
919: REGISTER_LONG_CONSTANT("XML_NOTATION_NODE", XML_NOTATION_NODE, CONST_CS | CONST_PERSISTENT);
920: REGISTER_LONG_CONSTANT("XML_HTML_DOCUMENT_NODE", XML_HTML_DOCUMENT_NODE, CONST_CS | CONST_PERSISTENT);
921: REGISTER_LONG_CONSTANT("XML_DTD_NODE", XML_DTD_NODE, CONST_CS | CONST_PERSISTENT);
922: REGISTER_LONG_CONSTANT("XML_ELEMENT_DECL_NODE", XML_ELEMENT_DECL, CONST_CS | CONST_PERSISTENT);
923: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_DECL_NODE", XML_ATTRIBUTE_DECL, CONST_CS | CONST_PERSISTENT);
924: REGISTER_LONG_CONSTANT("XML_ENTITY_DECL_NODE", XML_ENTITY_DECL, CONST_CS | CONST_PERSISTENT);
925: REGISTER_LONG_CONSTANT("XML_NAMESPACE_DECL_NODE", XML_NAMESPACE_DECL, CONST_CS | CONST_PERSISTENT);
926: #ifdef XML_GLOBAL_NAMESPACE
927: REGISTER_LONG_CONSTANT("XML_GLOBAL_NAMESPACE", XML_GLOBAL_NAMESPACE, CONST_CS | CONST_PERSISTENT);
928: #endif
929: REGISTER_LONG_CONSTANT("XML_LOCAL_NAMESPACE", XML_LOCAL_NAMESPACE, CONST_CS | CONST_PERSISTENT);
930: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_CDATA", XML_ATTRIBUTE_CDATA, CONST_CS | CONST_PERSISTENT);
931: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ID", XML_ATTRIBUTE_ID, CONST_CS | CONST_PERSISTENT);
932: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREF", XML_ATTRIBUTE_IDREF, CONST_CS | CONST_PERSISTENT);
933: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREFS", XML_ATTRIBUTE_IDREFS, CONST_CS | CONST_PERSISTENT);
934: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENTITY", XML_ATTRIBUTE_ENTITIES, CONST_CS | CONST_PERSISTENT);
935: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKEN", XML_ATTRIBUTE_NMTOKEN, CONST_CS | CONST_PERSISTENT);
936: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKENS", XML_ATTRIBUTE_NMTOKENS, CONST_CS | CONST_PERSISTENT);
937: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENUMERATION", XML_ATTRIBUTE_ENUMERATION, CONST_CS | CONST_PERSISTENT);
938: REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NOTATION", XML_ATTRIBUTE_NOTATION, CONST_CS | CONST_PERSISTENT);
939:
940: /* DOMException Codes */
941: REGISTER_LONG_CONSTANT("DOM_PHP_ERR", PHP_ERR, CONST_CS | CONST_PERSISTENT);
942: REGISTER_LONG_CONSTANT("DOM_INDEX_SIZE_ERR", INDEX_SIZE_ERR, CONST_CS | CONST_PERSISTENT);
943: REGISTER_LONG_CONSTANT("DOMSTRING_SIZE_ERR", DOMSTRING_SIZE_ERR, CONST_CS | CONST_PERSISTENT);
944: REGISTER_LONG_CONSTANT("DOM_HIERARCHY_REQUEST_ERR", HIERARCHY_REQUEST_ERR, CONST_CS | CONST_PERSISTENT);
945: REGISTER_LONG_CONSTANT("DOM_WRONG_DOCUMENT_ERR", WRONG_DOCUMENT_ERR, CONST_CS | CONST_PERSISTENT);
946: REGISTER_LONG_CONSTANT("DOM_INVALID_CHARACTER_ERR", INVALID_CHARACTER_ERR, CONST_CS | CONST_PERSISTENT);
947: REGISTER_LONG_CONSTANT("DOM_NO_DATA_ALLOWED_ERR", NO_DATA_ALLOWED_ERR, CONST_CS | CONST_PERSISTENT);
948: REGISTER_LONG_CONSTANT("DOM_NO_MODIFICATION_ALLOWED_ERR", NO_MODIFICATION_ALLOWED_ERR, CONST_CS | CONST_PERSISTENT);
949: REGISTER_LONG_CONSTANT("DOM_NOT_FOUND_ERR", NOT_FOUND_ERR, CONST_CS | CONST_PERSISTENT);
950: REGISTER_LONG_CONSTANT("DOM_NOT_SUPPORTED_ERR", NOT_SUPPORTED_ERR, CONST_CS | CONST_PERSISTENT);
951: REGISTER_LONG_CONSTANT("DOM_INUSE_ATTRIBUTE_ERR", INUSE_ATTRIBUTE_ERR, CONST_CS | CONST_PERSISTENT);
952: REGISTER_LONG_CONSTANT("DOM_INVALID_STATE_ERR", INVALID_STATE_ERR, CONST_CS | CONST_PERSISTENT);
953: REGISTER_LONG_CONSTANT("DOM_SYNTAX_ERR", SYNTAX_ERR, CONST_CS | CONST_PERSISTENT);
954: REGISTER_LONG_CONSTANT("DOM_INVALID_MODIFICATION_ERR", INVALID_MODIFICATION_ERR, CONST_CS | CONST_PERSISTENT);
955: REGISTER_LONG_CONSTANT("DOM_NAMESPACE_ERR", NAMESPACE_ERR, CONST_CS | CONST_PERSISTENT);
956: REGISTER_LONG_CONSTANT("DOM_INVALID_ACCESS_ERR", INVALID_ACCESS_ERR, CONST_CS | CONST_PERSISTENT);
957: REGISTER_LONG_CONSTANT("DOM_VALIDATION_ERR", VALIDATION_ERR, CONST_CS | CONST_PERSISTENT);
958:
959: php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
960:
961: return SUCCESS;
962: }
963: /* }}} */
964:
965: /* {{{ */
966: PHP_MINFO_FUNCTION(dom)
967: {
968: php_info_print_table_start();
969: php_info_print_table_row(2, "DOM/XML", "enabled");
970: php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
971: php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
972: #if defined(LIBXML_HTML_ENABLED)
973: php_info_print_table_row(2, "HTML Support", "enabled");
974: #endif
975: #if defined(LIBXML_XPATH_ENABLED)
976: php_info_print_table_row(2, "XPath Support", "enabled");
977: #endif
978: #if defined(LIBXML_XPTR_ENABLED)
979: php_info_print_table_row(2, "XPointer Support", "enabled");
980: #endif
981: #ifdef LIBXML_SCHEMAS_ENABLED
982: php_info_print_table_row(2, "Schema Support", "enabled");
983: php_info_print_table_row(2, "RelaxNG Support", "enabled");
984: #endif
985: php_info_print_table_end();
986: }
987: /* }}} */
988:
989: PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
990: {
991: zend_hash_destroy(&dom_domstringlist_prop_handlers);
992: zend_hash_destroy(&dom_namelist_prop_handlers);
993: zend_hash_destroy(&dom_domimplementationlist_prop_handlers);
994: zend_hash_destroy(&dom_document_prop_handlers);
995: zend_hash_destroy(&dom_node_prop_handlers);
996: zend_hash_destroy(&dom_namespace_node_prop_handlers);
997: zend_hash_destroy(&dom_nodelist_prop_handlers);
998: zend_hash_destroy(&dom_namednodemap_prop_handlers);
999: zend_hash_destroy(&dom_characterdata_prop_handlers);
1000: zend_hash_destroy(&dom_attr_prop_handlers);
1001: zend_hash_destroy(&dom_element_prop_handlers);
1002: zend_hash_destroy(&dom_text_prop_handlers);
1003: zend_hash_destroy(&dom_typeinfo_prop_handlers);
1004: zend_hash_destroy(&dom_domerror_prop_handlers);
1005: zend_hash_destroy(&dom_domlocator_prop_handlers);
1006: zend_hash_destroy(&dom_documenttype_prop_handlers);
1007: zend_hash_destroy(&dom_notation_prop_handlers);
1008: zend_hash_destroy(&dom_entity_prop_handlers);
1009: zend_hash_destroy(&dom_processinginstruction_prop_handlers);
1010: #if defined(LIBXML_XPATH_ENABLED)
1011: zend_hash_destroy(&dom_xpath_prop_handlers);
1012: #endif
1013: zend_hash_destroy(&classes);
1014:
1015: /* If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
1016: uncomment the following line, this will tell you the amount of not freed memory
1017: and the total used memory into apaches error_log */
1018: /* xmlMemoryDump();*/
1019:
1020: return SUCCESS;
1021: }
1022: /* }}} */
1023:
1024: /* {{{ node_list_unlink */
1025: void node_list_unlink(xmlNodePtr node TSRMLS_DC)
1026: {
1027: dom_object *wrapper;
1028:
1029: while (node != NULL) {
1030:
1031: wrapper = php_dom_object_get_data(node);
1032:
1033: if (wrapper != NULL ) {
1034: xmlUnlinkNode(node);
1035: } else {
1036: if (node->type == XML_ENTITY_REF_NODE)
1037: break;
1038: node_list_unlink(node->children TSRMLS_CC);
1039:
1040: switch (node->type) {
1041: case XML_ATTRIBUTE_DECL:
1042: case XML_DTD_NODE:
1043: case XML_DOCUMENT_TYPE_NODE:
1044: case XML_ENTITY_DECL:
1045: case XML_ATTRIBUTE_NODE:
1046: case XML_TEXT_NODE:
1047: break;
1048: default:
1049: node_list_unlink((xmlNodePtr) node->properties TSRMLS_CC);
1050: }
1051:
1052: }
1053:
1054: node = node->next;
1055: }
1056: }
1057: /* }}} end node_list_unlink */
1058:
1059: #if defined(LIBXML_XPATH_ENABLED)
1060: /* {{{ dom_xpath_objects_free_storage */
1061: void dom_xpath_objects_free_storage(void *object TSRMLS_DC)
1062: {
1063: dom_xpath_object *intern = (dom_xpath_object *)object;
1064:
1065: zend_object_std_dtor(&intern->std TSRMLS_CC);
1066:
1067: if (intern->ptr != NULL) {
1068: xmlXPathFreeContext((xmlXPathContextPtr) intern->ptr);
1069: php_libxml_decrement_doc_ref((php_libxml_node_object *) intern TSRMLS_CC);
1070: intern->ptr = NULL;
1071: }
1072:
1073: if (intern->registered_phpfunctions) {
1074: zend_hash_destroy(intern->registered_phpfunctions);
1075: FREE_HASHTABLE(intern->registered_phpfunctions);
1076: }
1077:
1078: if (intern->node_list) {
1079: zend_hash_destroy(intern->node_list);
1080: FREE_HASHTABLE(intern->node_list);
1081: }
1082:
1083: efree(object);
1084: }
1085: /* }}} */
1086: #endif
1087:
1088: /* {{{ dom_objects_free_storage */
1089: void dom_objects_free_storage(void *object TSRMLS_DC)
1090: {
1091: dom_object *intern = (dom_object *)object;
1092: int retcount;
1093:
1094: zend_object_std_dtor(&intern->std TSRMLS_CC);
1095:
1096: if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
1097: if (((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_DOCUMENT_NODE && ((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_HTML_DOCUMENT_NODE) {
1098: php_libxml_node_decrement_resource((php_libxml_node_object *) intern TSRMLS_CC);
1099: } else {
1100: php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
1101: retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
1102: }
1103: intern->ptr = NULL;
1104: }
1105:
1106: efree(object);
1107: }
1108: /* }}} */
1109:
1110: void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns TSRMLS_DC) /* {{{ */
1111: {
1112: dom_nnodemap_object *mapptr;
1113: zval *baseobj = NULL;
1114:
1115: mapptr = (dom_nnodemap_object *)intern->ptr;
1116: if (basenode) {
1117: MAKE_STD_ZVAL(baseobj);
1118: baseobj->type = IS_OBJECT;
1119: Z_SET_ISREF_P(baseobj);
1120: baseobj->value.obj.handle = basenode->handle;
1121: baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
1122: zval_copy_ctor(baseobj);
1123: }
1124: mapptr->baseobjptr = baseobj;
1125: mapptr->baseobj = basenode;
1126: mapptr->nodetype = ntype;
1127: mapptr->ht = ht;
1128: mapptr->local = local;
1129: mapptr->ns = ns;
1130:
1131: }
1132: /* }}} */
1133:
1134: static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy TSRMLS_DC) /* {{{ */
1135: {
1136: zend_class_entry *base_class;
1137: dom_object *intern;
1138:
1139: if (instanceof_function(class_type, dom_xpath_class_entry TSRMLS_CC)) {
1140: intern = emalloc(sizeof(dom_xpath_object));
1141: memset(intern, 0, sizeof(dom_xpath_object));
1142: } else {
1143: intern = emalloc(sizeof(dom_object));
1144: }
1145: intern->ptr = NULL;
1146: intern->prop_handler = NULL;
1147: intern->document = NULL;
1148:
1149: base_class = class_type;
1150: while(base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
1151: base_class = base_class->parent;
1152: }
1153:
1154: zend_hash_find(&classes, base_class->name, base_class->name_length + 1, (void **) &intern->prop_handler);
1155:
1156: zend_object_std_init(&intern->std, class_type TSRMLS_CC);
1157: if (hash_copy) {
1.1.1.2 misho 1158: object_properties_init(&intern->std, class_type);
1.1 misho 1159: }
1160:
1161: return intern;
1162: }
1163: /* }}} */
1164:
1165: /* {{{ dom_objects_clone */
1166: void dom_objects_clone(void *object, void **object_clone TSRMLS_DC)
1167: {
1168: dom_object *intern = (dom_object *) object;
1169: dom_object *clone;
1170: xmlNodePtr node;
1171: xmlNodePtr cloned_node;
1172:
1173: clone = dom_objects_set_class(intern->std.ce, 0 TSRMLS_CC);
1174:
1175: if (instanceof_function(intern->std.ce, dom_node_class_entry TSRMLS_CC)) {
1176: node = (xmlNodePtr)dom_object_get_node((dom_object *) object);
1177: if (node != NULL) {
1178: cloned_node = xmlDocCopyNode(node, node->doc, 1);
1179: if (cloned_node != NULL) {
1180: /* If we cloned a document then we must create new doc proxy */
1181: if (cloned_node->doc == node->doc) {
1182: clone->document = intern->document;
1183: }
1184: php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc TSRMLS_CC);
1185: php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone TSRMLS_CC);
1186: if (intern->document != clone->document) {
1187: dom_copy_doc_props(intern->document, clone->document);
1188: }
1189: }
1190:
1191: }
1192: }
1193:
1194: *object_clone = (void *) clone;
1195: }
1196: /* }}} */
1197:
1198: /* {{{ dom_objects_new */
1199: zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
1200: {
1201: zend_object_value retval;
1202: dom_object *intern;
1203:
1204: intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
1205:
1206: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_objects_free_storage, dom_objects_clone TSRMLS_CC);
1207: intern->handle = retval.handle;
1208: retval.handlers = dom_get_obj_handlers(TSRMLS_C);
1209:
1210: return retval;
1211: }
1212: /* }}} */
1213:
1214: #if defined(LIBXML_XPATH_ENABLED)
1215: /* {{{ zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC) */
1216: zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
1217: {
1218: zend_object_value retval;
1219: dom_xpath_object *intern;
1220:
1221: intern = (dom_xpath_object *)dom_objects_set_class(class_type, 1 TSRMLS_CC);
1222: intern->registerPhpFunctions = 0;
1223: intern->registered_phpfunctions = NULL;
1224: intern->node_list = NULL;
1225:
1226: ALLOC_HASHTABLE(intern->registered_phpfunctions);
1227: zend_hash_init(intern->registered_phpfunctions, 0, NULL, ZVAL_PTR_DTOR, 0);
1228:
1229: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_xpath_objects_free_storage, dom_objects_clone TSRMLS_CC);
1230: intern->handle = retval.handle;
1231: retval.handlers = dom_get_obj_handlers(TSRMLS_C);
1232:
1233: return retval;
1234: }
1235: /* }}} */
1236: #endif
1237:
1238: static void dom_nnodemap_object_dtor(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
1239: {
1240: zval *baseobj;
1241: dom_object *intern;
1242: dom_nnodemap_object *objmap;
1243:
1244: intern = (dom_object *)object;
1245: objmap = (dom_nnodemap_object *)intern->ptr;
1246:
1247: if (objmap) {
1248: if (objmap->local) {
1249: xmlFree(objmap->local);
1250: }
1251: if (objmap->ns) {
1252: xmlFree(objmap->ns);
1253: }
1254: if (objmap->baseobjptr) {
1255: baseobj = objmap->baseobjptr;
1256: zval_ptr_dtor((zval **)&baseobj);
1257: }
1258: efree(objmap);
1259: intern->ptr = NULL;
1260: }
1261:
1262:
1263: }
1264: /* }}} */
1265:
1266: void dom_nnodemap_objects_free_storage(void *object TSRMLS_DC) /* {{{ */
1267: {
1268: dom_object *intern = (dom_object *)object;
1269:
1270: php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
1271:
1272: zend_object_std_dtor(&intern->std TSRMLS_CC);
1273:
1274: efree(object);
1275: }
1276: /* }}} */
1277:
1278: zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
1279: {
1280: zend_object_value retval;
1281: dom_object *intern;
1282: dom_nnodemap_object *objmap;
1283:
1284: intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
1285: intern->ptr = emalloc(sizeof(dom_nnodemap_object));
1286: objmap = (dom_nnodemap_object *)intern->ptr;
1287: objmap->baseobj = NULL;
1288: objmap->baseobjptr = NULL;
1289: objmap->nodetype = 0;
1290: objmap->ht = NULL;
1291: objmap->local = NULL;
1292: objmap->ns = NULL;
1293:
1294: retval.handle = zend_objects_store_put(intern, dom_nnodemap_object_dtor, (zend_objects_free_object_storage_t)dom_nnodemap_objects_free_storage, dom_objects_clone TSRMLS_CC);
1295: intern->handle = retval.handle;
1296: retval.handlers = dom_get_obj_handlers(TSRMLS_C);
1297:
1298: return retval;
1299: }
1300: /* }}} */
1301:
1302: void php_dom_create_interator(zval *return_value, int ce_type TSRMLS_DC) /* {{{ */
1303: {
1304: zend_class_entry *ce;
1305:
1306: if (ce_type == DOM_NAMEDNODEMAP) {
1307: ce = dom_namednodemap_class_entry;
1308: } else {
1309: ce = dom_nodelist_class_entry;
1310: }
1311:
1312: object_init_ex(return_value, ce);
1313: }
1314: /* }}} */
1315:
1316: /* {{{ php_dom_create_object */
1.1.1.2 misho 1317: PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *return_value, dom_object *domobj TSRMLS_DC)
1.1 misho 1318: {
1319: zval *wrapper;
1320: zend_class_entry *ce;
1321: dom_object *intern;
1322:
1323: *found = 0;
1324:
1325: if (!obj) {
1326: ALLOC_ZVAL(wrapper);
1327: ZVAL_NULL(wrapper);
1328: return wrapper;
1329: }
1330:
1331: if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
1332: return_value->type = IS_OBJECT;
1333: Z_SET_ISREF_P(return_value);
1334: return_value->value.obj.handle = intern->handle;
1335: return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
1336: zval_copy_ctor(return_value);
1337: *found = 1;
1338: return return_value;
1339: }
1340:
1341: wrapper = return_value;
1342:
1343: switch (obj->type) {
1344: case XML_DOCUMENT_NODE:
1345: case XML_HTML_DOCUMENT_NODE:
1346: {
1347: ce = dom_document_class_entry;
1348: break;
1349: }
1350: case XML_DTD_NODE:
1351: case XML_DOCUMENT_TYPE_NODE:
1352: {
1353: ce = dom_documenttype_class_entry;
1354: break;
1355: }
1356: case XML_ELEMENT_NODE:
1357: {
1358: ce = dom_element_class_entry;
1359: break;
1360: }
1361: case XML_ATTRIBUTE_NODE:
1362: {
1363: ce = dom_attr_class_entry;
1364: break;
1365: }
1366: case XML_TEXT_NODE:
1367: {
1368: ce = dom_text_class_entry;
1369: break;
1370: }
1371: case XML_COMMENT_NODE:
1372: {
1373: ce = dom_comment_class_entry;
1374: break;
1375: }
1376: case XML_PI_NODE:
1377: {
1378: ce = dom_processinginstruction_class_entry;
1379: break;
1380: }
1381: case XML_ENTITY_REF_NODE:
1382: {
1383: ce = dom_entityreference_class_entry;
1384: break;
1385: }
1386: case XML_ENTITY_DECL:
1387: case XML_ELEMENT_DECL:
1388: {
1389: ce = dom_entity_class_entry;
1390: break;
1391: }
1392: case XML_CDATA_SECTION_NODE:
1393: {
1394: ce = dom_cdatasection_class_entry;
1395: break;
1396: }
1397: case XML_DOCUMENT_FRAG_NODE:
1398: {
1399: ce = dom_documentfragment_class_entry;
1400: break;
1401: }
1402: case XML_NOTATION_NODE:
1403: {
1404: ce = dom_notation_class_entry;
1405: break;
1406: }
1407: case XML_NAMESPACE_DECL:
1408: {
1409: ce = dom_namespace_node_class_entry;
1410: break;
1411: }
1412: default:
1413: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d", Z_TYPE_P(obj));
1414: ZVAL_NULL(wrapper);
1415: return wrapper;
1416: }
1417:
1418: if (domobj && domobj->document) {
1419: ce = dom_get_doc_classmap(domobj->document, ce TSRMLS_CC);
1420: }
1421: object_init_ex(wrapper, ce);
1422:
1423: intern = (dom_object *)zend_objects_get_address(wrapper TSRMLS_CC);
1424: if (obj->doc != NULL) {
1425: if (domobj != NULL) {
1426: intern->document = domobj->document;
1427: }
1428: php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc TSRMLS_CC);
1429: }
1430:
1431: php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern TSRMLS_CC);
1432: return (wrapper);
1433: }
1434: /* }}} end php_domobject_new */
1435:
1436: void php_dom_create_implementation(zval **retval TSRMLS_DC) {
1437: object_init_ex(*retval, dom_domimplementation_class_entry);
1438: }
1439:
1440: /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
1441: int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child)
1442: {
1443: xmlNodePtr nodep;
1444:
1445: if (parent == NULL || child == NULL || child->doc != parent->doc) {
1446: return SUCCESS;
1447: }
1448:
1449: nodep = parent;
1450:
1451: while (nodep) {
1452: if (nodep == child) {
1453: return FAILURE;
1454: }
1455: nodep = nodep->parent;
1456: }
1457:
1458: return SUCCESS;
1459: }
1460: /* }}} end dom_hierarchy */
1461:
1462: /* {{{ dom_has_feature(char *feature, char *version) */
1463: int dom_has_feature(char *feature, char *version)
1464: {
1465: int retval = 0;
1466:
1467: if (!(strcmp (version, "1.0") && strcmp (version,"2.0") && strcmp(version, ""))) {
1468: if ((!strcasecmp(feature, "Core") && !strcmp (version, "1.0")) || !strcasecmp(feature, "XML"))
1469: retval = 1;
1470: }
1471:
1472: return retval;
1473: }
1474: /* }}} end dom_has_feature */
1475:
1476: xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index) /* {{{ */
1477: {
1478: xmlNodePtr ret = NULL;
1479:
1480: while (nodep != NULL && (*cur <= index || index == -1)) {
1481: if (nodep->type == XML_ELEMENT_NODE) {
1482: if (xmlStrEqual(nodep->name, (xmlChar *)local) || xmlStrEqual((xmlChar *)"*", (xmlChar *)local)) {
1483: if (ns == NULL || (nodep->ns != NULL && (xmlStrEqual(nodep->ns->href, (xmlChar *)ns) || xmlStrEqual((xmlChar *)"*", (xmlChar *)ns)))) {
1484: if (*cur == index) {
1485: ret = nodep;
1486: break;
1487: }
1488: (*cur)++;
1489: }
1490: }
1491: ret = dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, cur, index);
1492: if (ret != NULL) {
1493: break;
1494: }
1495: }
1496: nodep = nodep->next;
1497: }
1498: return ret;
1499: }
1500: /* }}} */
1501: /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
1502:
1503: /* {{{ void dom_normalize (xmlNodePtr nodep TSRMLS_DC) */
1504: void dom_normalize (xmlNodePtr nodep TSRMLS_DC)
1505: {
1506: xmlNodePtr child, nextp, newnextp;
1507: xmlAttrPtr attr;
1508: xmlChar *strContent;
1509:
1510: child = nodep->children;
1511: while(child != NULL) {
1512: switch (child->type) {
1513: case XML_TEXT_NODE:
1514: nextp = child->next;
1515: while (nextp != NULL) {
1516: if (nextp->type == XML_TEXT_NODE) {
1517: newnextp = nextp->next;
1518: strContent = xmlNodeGetContent(nextp);
1519: xmlNodeAddContent(child, strContent);
1520: xmlFree(strContent);
1521: xmlUnlinkNode(nextp);
1522: php_libxml_node_free_resource(nextp TSRMLS_CC);
1523: nextp = newnextp;
1524: } else {
1525: break;
1526: }
1527: }
1528: break;
1529: case XML_ELEMENT_NODE:
1530: dom_normalize (child TSRMLS_CC);
1531: attr = child->properties;
1532: while (attr != NULL) {
1533: dom_normalize((xmlNodePtr) attr TSRMLS_CC);
1534: attr = attr->next;
1535: }
1536: break;
1537: case XML_ATTRIBUTE_NODE:
1538: dom_normalize (child TSRMLS_CC);
1539: break;
1540: default:
1541: break;
1542: }
1543: child = child->next;
1544: }
1545: }
1546: /* }}} end dom_normalize */
1547:
1548:
1549: /* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
1550: void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
1551: xmlNs *cur;
1552:
1553: if (doc == NULL)
1554: return;
1555:
1556: if (doc->oldNs == NULL) {
1557: doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
1558: if (doc->oldNs == NULL) {
1559: return;
1560: }
1561: memset(doc->oldNs, 0, sizeof(xmlNs));
1562: doc->oldNs->type = XML_LOCAL_NAMESPACE;
1563: doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE);
1564: doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml");
1565: }
1566:
1567: cur = doc->oldNs;
1568: while (cur->next != NULL) {
1569: cur = cur->next;
1570: }
1571: cur->next = ns;
1572: }
1573: /* }}} end dom_set_old_ns */
1574:
1575: /*
1576: http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1577:
1578: NAMESPACE_ERR: Raised if
1579:
1580: 1. the qualifiedName is a malformed qualified name
1581: 2. the qualifiedName has a prefix and the namespaceURI is null
1582: */
1583:
1584: /* {{{ int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) */
1585: int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
1586: if (name_len == 0) {
1587: return NAMESPACE_ERR;
1588: }
1589:
1590: *localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
1591: if (*localname == NULL) {
1592: *localname = (char *)xmlStrdup((xmlChar *)qname);
1593: if (*prefix == NULL && uri_len == 0) {
1594: return 0;
1595: }
1596: }
1597:
1598: /* 1 */
1599: if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
1600: return NAMESPACE_ERR;
1601: }
1602:
1603: /* 2 */
1604: if (*prefix != NULL && uri_len == 0) {
1605: return NAMESPACE_ERR;
1606: }
1607:
1608: return 0;
1609: }
1610: /* }}} */
1611:
1612: /*
1613: http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1614:
1615: NAMESPACE_ERR: Raised if
1616:
1617: 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
1618: 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from "http://www.w3.org/2000/xmlns/"
1619: 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the qualifiedName nor its prefix is "xmlns".
1620: */
1621:
1622: /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
1623: xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
1624: xmlNsPtr nsptr = NULL;
1625:
1626: *errorcode = 0;
1627:
1628: if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
1629: (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
1630: (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
1631: nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
1632: }
1633:
1634: if (nsptr == NULL) {
1635: *errorcode = NAMESPACE_ERR;
1636: }
1637:
1638: return nsptr;
1639:
1640: }
1641: /* }}} end dom_get_ns */
1642:
1643: /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
1644: xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
1645: xmlNsPtr cur;
1646: xmlNs *ret = NULL;
1647: if (node == NULL)
1648: return NULL;
1649:
1650: if (localName == NULL || xmlStrEqual(localName, (xmlChar *)"")) {
1651: cur = node->nsDef;
1652: while (cur != NULL) {
1653: if (cur->prefix == NULL && cur->href != NULL) {
1654: ret = cur;
1655: break;
1656: }
1657: cur = cur->next;
1658: }
1659: } else {
1660: cur = node->nsDef;
1661: while (cur != NULL) {
1662: if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
1663: ret = cur;
1664: break;
1665: }
1666: cur = cur->next;
1667: }
1668: }
1669: return ret;
1670: }
1671: /* }}} end dom_get_nsdecl */
1672:
1673: #endif /* HAVE_DOM */
1674:
1675: /*
1676: * Local variables:
1677: * tab-width: 4
1678: * c-basic-offset: 4
1679: * End:
1680: * vim600: noet sw=4 ts=4 fdm=marker
1681: * vim<600: noet sw=4 ts=4
1682: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_dom.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / dom