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