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