PageRenderTime 59ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/ext/dom/php_dom.c

http://github.com/infusion/PHP
C | 1602 lines | 1238 code | 232 blank | 132 comment | 242 complexity | 77ba2c59f502884692e6b089299ed5bc MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause 
    

  1. /*
    2. 

  2.    +----------------------------------------------------------------------+
    3. 

  3.    | PHP Version 5                                                        |
    4. 

  4.    +----------------------------------------------------------------------+
    5. 

  5.    | Copyright (c) 1997-2011 The PHP Group                                |
    6. 

  6.    +----------------------------------------------------------------------+
    7. 

  7.    | This source file is subject to version 3.01 of the PHP license,      |
    8. 

  8.    | that is bundled with this package in the file LICENSE, and is        |
    9. 

  9.    | available through the world-wide-web at the following url:           |
    10. 

  10.    | http://www.php.net/license/3_01.txt                                  |
    11. 

  11.    | If you did not receive a copy of the PHP license and are unable to   |
    12. 

  12.    | obtain it through the world-wide-web, please send a note to          |
    13. 

  13.    | license@php.net so we can mail you a copy immediately.               |
    14. 

  14.    +----------------------------------------------------------------------+
    15. 

  15.    | Authors: Christian Stocker <chregu@php.net>                          |
    16. 

  16.    |          Rob Richards <rrichards@php.net>                            |
    17. 

  17.    |          Marcus Borger <helly@php.net>                               |
    18. 

  18.    +----------------------------------------------------------------------+
    19. 

  19. */
    20. 

  20. 

  21. /* $Id: php_dom.c 306939 2011-01-01 02:19:59Z felipe $ */
    22. 

  22. 

  23. #ifdef HAVE_CONFIG_H
    24. 

  24. #include "config.h"
    25. 

  25. #endif
    26. 

  26. 

  27. #include "php.h"
    28. 

  28. #if HAVE_LIBXML && HAVE_DOM
    29. 

  29. #include "ext/standard/php_rand.h"
    30. 

  30. #include "php_dom.h"
    31. 

  31. #include "dom_properties.h"
    32. 

  32. #include "zend_interfaces.h"
    33. 

  33. 

  34. #include "ext/standard/info.h"
    35. 

  35. #define PHP_XPATH 1
    36. 

  36. #define PHP_XPTR 2
    37. 

  37. 

  38. /* {{{ class entries */
    39. 

  39. zend_class_entry *dom_node_class_entry;
    40. 

  40. zend_class_entry *dom_domexception_class_entry;
    41. 

  41. zend_class_entry *dom_domstringlist_class_entry;
    42. 

  42. zend_class_entry *dom_namelist_class_entry;
    43. 

  43. zend_class_entry *dom_domimplementationlist_class_entry;
    44. 

  44. zend_class_entry *dom_domimplementationsource_class_entry;
    45. 

  45. zend_class_entry *dom_domimplementation_class_entry;
    46. 

  46. zend_class_entry *dom_documentfragment_class_entry;
    47. 

  47. zend_class_entry *dom_document_class_entry;
    48. 

  48. zend_class_entry *dom_nodelist_class_entry;
    49. 

  49. zend_class_entry *dom_namednodemap_class_entry;
    50. 

  50. zend_class_entry *dom_characterdata_class_entry;
    51. 

  51. zend_class_entry *dom_attr_class_entry;
    52. 

  52. zend_class_entry *dom_element_class_entry;
    53. 

  53. zend_class_entry *dom_text_class_entry;
    54. 

  54. zend_class_entry *dom_comment_class_entry;
    55. 

  55. zend_class_entry *dom_typeinfo_class_entry;
    56. 

  56. zend_class_entry *dom_userdatahandler_class_entry;
    57. 

  57. zend_class_entry *dom_domerror_class_entry;
    58. 

  58. zend_class_entry *dom_domerrorhandler_class_entry;
    59. 

  59. zend_class_entry *dom_domlocator_class_entry;
    60. 

  60. zend_class_entry *dom_domconfiguration_class_entry;
    61. 

  61. zend_class_entry *dom_cdatasection_class_entry;
    62. 

  62. zend_class_entry *dom_documenttype_class_entry;
    63. 

  63. zend_class_entry *dom_notation_class_entry;
    64. 

  64. zend_class_entry *dom_entity_class_entry;
    65. 

  65. zend_class_entry *dom_entityreference_class_entry;
    66. 

  66. zend_class_entry *dom_processinginstruction_class_entry;
    67. 

  67. zend_class_entry *dom_string_extend_class_entry;
    68. 

  68. #if defined(LIBXML_XPATH_ENABLED)
    69. 

  69. zend_class_entry *dom_xpath_class_entry;
    70. 

  70. #endif
    71. 

  71. zend_class_entry *dom_namespace_node_class_entry;
    72. 

  72. /* }}} */
    73. 

  73. 

  74. zend_object_handlers dom_object_handlers;
    75. 

  75. 

  76. static HashTable classes;
    77. 

  77. /* {{{ prop handler tables */
    78. 

  78. static HashTable dom_domstringlist_prop_handlers;
    79. 

  79. static HashTable dom_namelist_prop_handlers;
    80. 

  80. static HashTable dom_domimplementationlist_prop_handlers;
    81. 

  81. static HashTable dom_document_prop_handlers;
    82. 

  82. static HashTable dom_node_prop_handlers;
    83. 

  83. static HashTable dom_nodelist_prop_handlers;
    84. 

  84. static HashTable dom_namednodemap_prop_handlers;
    85. 

  85. static HashTable dom_characterdata_prop_handlers;
    86. 

  86. static HashTable dom_attr_prop_handlers;
    87. 

  87. static HashTable dom_element_prop_handlers;
    88. 

  88. static HashTable dom_text_prop_handlers;
    89. 

  89. static HashTable dom_typeinfo_prop_handlers;
    90. 

  90. static HashTable dom_domerror_prop_handlers;
    91. 

  91. static HashTable dom_domlocator_prop_handlers;
    92. 

  92. static HashTable dom_documenttype_prop_handlers;
    93. 

  93. static HashTable dom_notation_prop_handlers;
    94. 

  94. static HashTable dom_entity_prop_handlers;
    95. 

  95. static HashTable dom_processinginstruction_prop_handlers;
    96. 

  96. static HashTable dom_namespace_node_prop_handlers;
    97. 

  97. #if defined(LIBXML_XPATH_ENABLED)
    98. 

  98. static HashTable dom_xpath_prop_handlers;
    99. 

  99. #endif
    100. 

  100. /* }}} */
    101. 

  101. 

  102. typedef int (*dom_read_t)(dom_object *obj, zval **retval TSRMLS_DC);
    103. 

  103. typedef int (*dom_write_t)(dom_object *obj, zval *newval TSRMLS_DC);
    104. 

  104. 

  105. typedef struct _dom_prop_handler {
    106. 

  106. 	dom_read_t read_func;
    107. 

  107. 	dom_write_t write_func;
    108. 

  108. } dom_prop_handler;
    109. 

  109. 

  110. /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
    111. 

  111. int dom_node_is_read_only(xmlNodePtr node) {
    112. 

  112. 	switch (node->type) {
    113. 

  113. 		case XML_ENTITY_REF_NODE:
    114. 

  114. 		case XML_ENTITY_NODE:
    115. 

  115. 		case XML_DOCUMENT_TYPE_NODE:
    116. 

  116. 		case XML_NOTATION_NODE:
    117. 

  117. 		case XML_DTD_NODE:
    118. 

  118. 		case XML_ELEMENT_DECL:
    119. 

  119. 		case XML_ATTRIBUTE_DECL:
    120. 

  120. 		case XML_ENTITY_DECL:
    121. 

  121. 		case XML_NAMESPACE_DECL:
    122. 

  122. 			return SUCCESS;
    123. 

  123. 			break;
    124. 

  124. 		default:
    125. 

  125. 			if (node->doc == NULL) {
    126. 

  126. 				return SUCCESS;
    127. 

  127. 			} else {
    128. 

  128. 				return FAILURE;
    129. 

  129. 			}
    130. 

  130. 	}
    131. 

  131. }
    132. 

  132. /* }}} end dom_node_is_read_only */
    133. 

  133. 

  134. /* {{{ int dom_node_children_valid(xmlNodePtr node) */
    135. 

  135. int dom_node_children_valid(xmlNodePtr node) {
    136. 

  136. 	switch (node->type) {
    137. 

  137. 		case XML_DOCUMENT_TYPE_NODE:
    138. 

  138. 		case XML_DTD_NODE:
    139. 

  139. 		case XML_PI_NODE:
    140. 

  140. 		case XML_COMMENT_NODE:
    141. 

  141. 		case XML_TEXT_NODE:
    142. 

  142. 		case XML_CDATA_SECTION_NODE:
    143. 

  143. 		case XML_NOTATION_NODE:
    144. 

  144. 			return FAILURE;
    145. 

  145. 			break;
    146. 

  146. 		default:
    147. 

  147. 			return SUCCESS;
    148. 

  148. 	}
    149. 

  149. }
    150. 

  150. /* }}} end dom_node_children_valid */
    151. 

  151. 

  152. /* {{{ dom_get_doc_props() */
    153. 

  153. dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
    154. 

  154. {
    155. 

  155. 	dom_doc_propsptr doc_props;
    156. 

  156. 

  157. 	if (document && document->doc_props) {
    158. 

  158. 		return document->doc_props;
    159. 

  159. 	} else {
    160. 

  160. 		doc_props = emalloc(sizeof(libxml_doc_props));
    161. 

  161. 		doc_props->formatoutput = 0;
    162. 

  162. 		doc_props->validateonparse = 0;
    163. 

  163. 		doc_props->resolveexternals = 0;
    164. 

  164. 		doc_props->preservewhitespace = 1;
    165. 

  165. 		doc_props->substituteentities = 0;
    166. 

  166. 		doc_props->stricterror = 1;
    167. 

  167. 		doc_props->recover = 0;
    168. 

  168. 		doc_props->classmap = NULL;
    169. 

  169. 		if (document) {
    170. 

  170. 			document->doc_props = doc_props;
    171. 

  171. 		}
    172. 

  172. 		return doc_props;
    173. 

  173. 	}
    174. 

  174. }
    175. 

  175. 

  176. static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
    177. 

  177. {
    178. 

  178. 	dom_doc_propsptr source, dest;
    179. 

  179. 	
    180. 

  180. 	if (source_doc && dest_doc) {
    181. 

  181. 		
    182. 

  182. 		source = dom_get_doc_props(source_doc);
    183. 

  183. 		dest = dom_get_doc_props(dest_doc);
    184. 

  184. 

  185. 		dest->formatoutput = source->formatoutput;
    186. 

  186. 		dest->validateonparse = source->validateonparse;
    187. 

  187. 		dest->resolveexternals = source->resolveexternals;
    188. 

  188. 		dest->preservewhitespace = source->preservewhitespace;
    189. 

  189. 		dest->substituteentities = source->substituteentities;
    190. 

  190. 		dest->stricterror = source->stricterror;
    191. 

  191. 		dest->recover = source->recover;
    192. 

  192. 		if (source->classmap) {
    193. 

  193. 			ALLOC_HASHTABLE(dest->classmap);
    194. 

  194. 			zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
    195. 

  195. 			zend_hash_copy(dest->classmap, source->classmap, NULL, NULL, sizeof(zend_class_entry *));
    196. 

  196. 		}
    197. 

  197. 

  198. 	}
    199. 

  199. }
    200. 

  200. 

  201. int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce TSRMLS_DC)
    202. 

  202. {
    203. 

  203. 	dom_doc_propsptr doc_props;
    204. 

  204. 

  205. 	if (document) {
    206. 

  206. 		doc_props = dom_get_doc_props(document);
    207. 

  207. 		if (doc_props->classmap == NULL) {
    208. 

  208. 			if (ce == NULL) {
    209. 

  209. 				return SUCCESS;
    210. 

  210. 			}
    211. 

  211. 			ALLOC_HASHTABLE(doc_props->classmap);
    212. 

  212. 			zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
    213. 

  213. 		}
    214. 

  214. 		if (ce) {
    215. 

  215. 			return zend_hash_update(doc_props->classmap, basece->name, basece->name_length + 1, &ce, sizeof(ce), NULL);
    216. 

  216. 		} else {
    217. 

  217. 			zend_hash_del(doc_props->classmap, basece->name, basece->name_length + 1);
    218. 

  218. 		}
    219. 

  219. 	}
    220. 

  220. 	return SUCCESS;
    221. 

  221. }
    222. 

  222. 

  223. zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece TSRMLS_DC)
    224. 

  224. {
    225. 

  225. 	dom_doc_propsptr doc_props;
    226. 

  226. 	zend_class_entry **ce = NULL;
    227. 

  227. 	
    228. 

  228. 	if (document) {
    229. 

  229. 		doc_props = dom_get_doc_props(document);
    230. 

  230. 		if (doc_props->classmap) {
    231. 

  231. 			if (zend_hash_find(doc_props->classmap, basece->name, basece->name_length + 1,  (void**) &ce) == SUCCESS) {
    232. 

  232. 				return *ce;
    233. 

  233. 			}
    234. 

  234. 		}
    235. 

  235. 	}
    236. 

  236. 

  237. 	return basece;
    238. 

  238. }
    239. 

  239. /* }}} */
    240. 

  240. 

  241. /* {{{ dom_get_strict_error() */
    242. 

  242. int dom_get_strict_error(php_libxml_ref_obj *document) {
    243. 

  243. 	int stricterror;
    244. 

  244. 	dom_doc_propsptr doc_props;
    245. 

  245. 

  246. 	doc_props = dom_get_doc_props(document);
    247. 

  247. 	stricterror = doc_props->stricterror;
    248. 

  248. 	if (document == NULL) {
    249. 

  249. 		efree(doc_props);
    250. 

  250. 	}
    251. 

  251. 

  252. 	return stricterror;
    253. 

  253. }
    254. 

  254. /* }}} */
    255. 

  255. 

  256. /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
    257. 

  257. PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
    258. 

  258. {
    259. 

  259. 	if (obj && obj->ptr != NULL) {
    260. 

  260. 		return ((php_libxml_node_ptr *)obj->ptr)->node;
    261. 

  261. 	} else {
    262. 

  262. 		return NULL;
    263. 

  263. 	}
    264. 

  264. }
    265. 

  265. /* }}} end dom_object_get_node */
    266. 

  266. 

  267. /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
    268. 

  268. PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
    269. 

  269. {
    270. 

  270. 	if (obj && obj->_private != NULL) {
    271. 

  271. 		return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
    272. 

  272. 	} else {
    273. 

  273. 		return NULL;
    274. 

  274. 	}
    275. 

  275. }
    276. 

  276. /* }}} end php_dom_object_get_data */
    277. 

  277. 

  278. /* {{{ dom_read_na */
    279. 

  279. static int dom_read_na(dom_object *obj, zval **retval TSRMLS_DC)
    280. 

  280. {
    281. 

  281. 	*retval = NULL;
    282. 

  282. 	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
    283. 

  283. 	return FAILURE;
    284. 

  284. }
    285. 

  285. /* }}} */
    286. 

  286. 

  287. /* {{{ dom_write_na */
    288. 

  288. static int dom_write_na(dom_object *obj, zval *newval TSRMLS_DC)
    289. 

  289. {
    290. 

  290. 	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot write property");
    291. 

  291. 	return FAILURE;
    292. 

  292. }
    293. 

  293. /* }}} */
    294. 

  294. 

  295. /* {{{ dom_register_prop_handler */
    296. 

  296. static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_read_t read_func, dom_write_t write_func TSRMLS_DC)
    297. 

  297. {
    298. 

  298. 	dom_prop_handler hnd;
    299. 

  299. 	
    300. 

  300. 	hnd.read_func = read_func ? read_func : dom_read_na;
    301. 

  301. 	hnd.write_func = write_func ? write_func : dom_write_na;
    302. 

  302. 	zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(dom_prop_handler), NULL);
    303. 

  303. }
    304. 

  304. /* }}} */
    305. 

  305. 

  306. static zval **dom_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC) /* {{{ */
    307. 

  307. {
    308. 

  308. 	dom_object *obj;
    309. 

  309. 	zval tmp_member;
    310. 

  310. 	zval **retval = NULL;
    311. 

  311. 	dom_prop_handler *hnd;
    312. 

  312. 	zend_object_handlers *std_hnd;
    313. 

  313. 	int ret = FAILURE;
    314. 

  314. 

  315.  	if (member->type != IS_STRING) {
    316. 

  316. 		tmp_member = *member;
    317. 

  317. 		zval_copy_ctor(&tmp_member);
    318. 

  318. 		convert_to_string(&tmp_member);
    319. 

  319. 		member = &tmp_member;
    320. 

  320. 	}
    321. 

  321. 

  322. 	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
    323. 

  323. 

  324. 	if (obj->prop_handler != NULL) {
    325. 

  325. 		ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
    326. 

  326. 	}
    327. 

  327. 	if (ret == FAILURE) {
    328. 

  328. 		std_hnd = zend_get_std_object_handlers();
    329. 

  329. 		retval = std_hnd->get_property_ptr_ptr(object, member TSRMLS_CC);
    330. 

  330. 	}
    331. 

  331. 

  332. 	if (member == &tmp_member) {
    333. 

  333. 		zval_dtor(member);
    334. 

  334. 	}
    335. 

  335. 	return retval;
    336. 

  336. }
    337. 

  337. /* }}} */
    338. 

  338. 

  339. /* {{{ dom_read_property */
    340. 

  340. zval *dom_read_property(zval *object, zval *member, int type TSRMLS_DC)
    341. 

  341. {
    342. 

  342. 	dom_object *obj;
    343. 

  343. 	zval tmp_member;
    344. 

  344. 	zval *retval;
    345. 

  345. 	dom_prop_handler *hnd;
    346. 

  346. 	zend_object_handlers *std_hnd;
    347. 

  347. 	int ret;
    348. 

  348. 

  349.  	if (member->type != IS_STRING) {
    350. 

  350. 		tmp_member = *member;
    351. 

  351. 		zval_copy_ctor(&tmp_member);
    352. 

  352. 		convert_to_string(&tmp_member);
    353. 

  353. 		member = &tmp_member;
    354. 

  354. 	}
    355. 

  355. 

  356. 	ret = FAILURE;
    357. 

  357. 	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
    358. 

  358. 

  359. 	if (obj->prop_handler != NULL) {
    360. 

  360. 		ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
    361. 

  361. 	} else if (instanceof_function(obj->std.ce, dom_node_class_entry TSRMLS_CC)) {
    362. 

  362. 		php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", obj->std.ce->name);
    363. 

  363. 	}
    364. 

  364. 	if (ret == SUCCESS) {
    365. 

  365. 		ret = hnd->read_func(obj, &retval TSRMLS_CC);
    366. 

  366. 		if (ret == SUCCESS) {
    367. 

  367. 			/* ensure we're creating a temporary variable */
    368. 

  368. 			Z_SET_REFCOUNT_P(retval, 0);
    369. 

  369. 			Z_UNSET_ISREF_P(retval);
    370. 

  370. 		} else {
    371. 

  371. 			retval = EG(uninitialized_zval_ptr);
    372. 

  372. 		}
    373. 

  373. 	} else {
    374. 

  374. 		std_hnd = zend_get_std_object_handlers();
    375. 

  375. 		retval = std_hnd->read_property(object, member, type TSRMLS_CC);
    376. 

  376. 	}
    377. 

  377. 

  378. 	if (member == &tmp_member) {
    379. 

  379. 		zval_dtor(member);
    380. 

  380. 	}
    381. 

  381. 	return retval;
    382. 

  382. }
    383. 

  383. /* }}} */
    384. 

  384. 

  385. /* {{{ dom_write_property */
    386. 

  386. void dom_write_property(zval *object, zval *member, zval *value TSRMLS_DC)
    387. 

  387. {
    388. 

  388. 	dom_object *obj;
    389. 

  389. 	zval tmp_member;
    390. 

  390. 	dom_prop_handler *hnd;
    391. 

  391. 	zend_object_handlers *std_hnd;
    392. 

  392. 	int ret;
    393. 

  393. 

  394.  	if (member->type != IS_STRING) {
    395. 

  395. 		tmp_member = *member;
    396. 

  396. 		zval_copy_ctor(&tmp_member);
    397. 

  397. 		convert_to_string(&tmp_member);
    398. 

  398. 		member = &tmp_member;
    399. 

  399. 	}
    400. 

  400. 

  401. 	ret = FAILURE;
    402. 

  402. 	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
    403. 

  403. 

  404. 	if (obj->prop_handler != NULL) {
    405. 

  405. 		ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
    406. 

  406. 	}
    407. 

  407. 	if (ret == SUCCESS) {
    408. 

  408. 		hnd->write_func(obj, value TSRMLS_CC);
    409. 

  409. 	} else {
    410. 

  410. 		std_hnd = zend_get_std_object_handlers();
    411. 

  411. 		std_hnd->write_property(object, member, value TSRMLS_CC);
    412. 

  412. 	}
    413. 

  413. 

  414. 	if (member == &tmp_member) {
    415. 

  415. 		zval_dtor(member);
    416. 

  416. 	}
    417. 

  417. }
    418. 

  418. /* }}} */
    419. 

  419. 

  420. /* {{{ dom_property_exists */
    421. 

  421. static int dom_property_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
    422. 

  422. {
    423. 

  423. 	dom_object *obj;
    424. 

  424. 	zval tmp_member;
    425. 

  425. 	dom_prop_handler *hnd;
    426. 

  426. 	zend_object_handlers *std_hnd;
    427. 

  427. 	int ret, retval=0;
    428. 

  428. 

  429.  	if (member->type != IS_STRING) {
    430. 

  430. 		tmp_member = *member;
    431. 

  431. 		zval_copy_ctor(&tmp_member);
    432. 

  432. 		convert_to_string(&tmp_member);
    433. 

  433. 		member = &tmp_member;
    434. 

  434. 	}
    435. 

  435. 

  436. 	ret = FAILURE;
    437. 

  437. 	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
    438. 

  438. 

  439. 	if (obj->prop_handler != NULL) {
    440. 

  440. 		ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
    441. 

  441. 	}
    442. 

  442. 	if (ret == SUCCESS) {
    443. 

  443. 		zval *tmp;
    444. 

  444. 

  445. 		if (check_empty == 2) {
    446. 

  446. 			retval = 1;
    447. 

  447. 		} else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
    448. 

  448. 			Z_SET_REFCOUNT_P(tmp, 1);
    449. 

  449. 			Z_UNSET_ISREF_P(tmp);
    450. 

  450. 			if (check_empty == 1) {
    451. 

  451. 				retval = zend_is_true(tmp);
    452. 

  452. 			} else if (check_empty == 0) {
    453. 

  453. 				retval = (Z_TYPE_P(tmp) != IS_NULL);
    454. 

  454. 			}
    455. 

  455. 			zval_ptr_dtor(&tmp);
    456. 

  456. 		}
    457. 

  457. 	} else {
    458. 

  458. 		std_hnd = zend_get_std_object_handlers();
    459. 

  459. 		retval = std_hnd->has_property(object, member, check_empty TSRMLS_CC);
    460. 

  460. 	}
    461. 

  461. 

  462. 	if (member == &tmp_member) {
    463. 

  463. 		zval_dtor(member);
    464. 

  464. 	}
    465. 

  465. 	return retval;
    466. 

  466. }
    467. 

  467. /* }}} */
    468. 

  468. 

  469. void *php_dom_export_node(zval *object TSRMLS_DC) /* {{{ */
    470. 

  470. {
    471. 

  471. 	php_libxml_node_object *intern;
    472. 

  472. 	xmlNodePtr nodep = NULL;
    473. 

  473. 

  474. 	intern = (php_libxml_node_object *)zend_object_store_get_object(object TSRMLS_CC);
    475. 

  475. 	if (intern && intern->node) {
    476. 

  476.   		nodep = intern->node->node;
    477. 

  477. 	}
    478. 

  478. 

  479. 	return nodep;	
    480. 

  480. }
    481. 

  481. /* }}} */
    482. 

  482. 

  483. /* {{{ proto somNode dom_import_simplexml(sxeobject node)
    484. 

  484.    Get a simplexml_element object from dom to allow for processing */
    485. 

  485. PHP_FUNCTION(dom_import_simplexml)
    486. 

  486. {
    487. 

  487. 	zval *rv = NULL;
    488. 

  488. 	zval *node;
    489. 

  489. 	xmlNodePtr nodep = NULL;
    490. 

  490. 	php_libxml_node_object *nodeobj;
    491. 

  491. 	int ret;
    492. 

  492. 

  493. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &node) == FAILURE) {
    494. 

  494. 		return;
    495. 

  495. 	}
    496. 

  496. 

  497. 	nodeobj = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
    498. 

  498. 	nodep = php_libxml_import_node(node TSRMLS_CC);
    499. 

  499. 

  500. 	if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
    501. 

  501. 		DOM_RET_OBJ(rv, (xmlNodePtr) nodep, &ret, (dom_object *)nodeobj);
    502. 

  502. 	} else {
    503. 

  503. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
    504. 

  504. 		RETURN_NULL();
    505. 

  505. 	}
    506. 

  506. }
    507. 

  507. /* }}} */
    508. 

  508. 

  509. zend_object_value dom_objects_store_clone_obj(zval *zobject TSRMLS_DC) /* {{{ */
    510. 

  510. {
    511. 

  511. 	zend_object_value retval;
    512. 

  512. 	void *new_object;
    513. 

  513. 	dom_object *intern;
    514. 

  514. 	dom_object *old_object;
    515. 

  515. 	struct _store_object *obj;
    516. 

  516. 	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
    517. 

  517. 

  518. 	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
    519. 

  519. 	
    520. 

  520. 	if (obj->clone == NULL) {
    521. 

  521. 		php_error(E_ERROR, "Trying to clone an uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
    522. 

  522. 	}		
    523. 

  523. 

  524. 	obj->clone(obj->object, &new_object TSRMLS_CC);
    525. 

  525. 

  526. 	retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
    527. 

  527. 	intern = (dom_object *) new_object;
    528. 

  528. 	intern->handle = retval.handle;
    529. 

  529. 	retval.handlers = Z_OBJ_HT_P(zobject);
    530. 

  530. 	
    531. 

  531. 	old_object = (dom_object *) obj->object;
    532. 

  532. 	zend_objects_clone_members(&intern->std, retval, &old_object->std, intern->handle TSRMLS_CC);
    533. 

  533. 

  534. 	return retval;
    535. 

  535. }
    536. 

  536. /* }}} */
    537. 

  537. 

  538. /* {{{ arginfo */
    539. 

  539. ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_import_simplexml, 0, 0, 1)
    540. 

  540. 	ZEND_ARG_INFO(0, node)
    541. 

  541. ZEND_END_ARG_INFO()
    542. 

  542. /* }}} */
    543. 

  543. 

  544. static const zend_function_entry dom_functions[] = {
    545. 

  545. 	PHP_FE(dom_import_simplexml, arginfo_dom_import_simplexml)
    546. 

  546. 	{NULL, NULL, NULL}
    547. 

  547. };
    548. 

  548. 

  549. static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
    550. 

  550. 	return &dom_object_handlers;
    551. 

  551. }
    552. 

  552. 

  553. static const zend_module_dep dom_deps[] = {
    554. 

  554. 	ZEND_MOD_REQUIRED("libxml")
    555. 

  555. 	ZEND_MOD_CONFLICTS("domxml")
    556. 

  556. 	{NULL, NULL, NULL}
    557. 

  557. };
    558. 

  558. 

  559. zend_module_entry dom_module_entry = { /* {{{ */
    560. 

  560. 	STANDARD_MODULE_HEADER_EX, NULL,
    561. 

  561. 	dom_deps,
    562. 

  562. 	"dom",
    563. 

  563. 	dom_functions,
    564. 

  564. 	PHP_MINIT(dom),
    565. 

  565. 	PHP_MSHUTDOWN(dom),
    566. 

  566. 	NULL,
    567. 

  567. 	NULL,
    568. 

  568. 	PHP_MINFO(dom),
    569. 

  569. 	DOM_API_VERSION, /* Extension versionnumber */
    570. 

  570. 	STANDARD_MODULE_PROPERTIES
    571. 

  571. };
    572. 

  572. /* }}} */
    573. 

  573. 

  574. #ifdef COMPILE_DL_DOM
    575. 

  575. ZEND_GET_MODULE(dom)
    576. 

  576. #endif
    577. 

  577. 

  578. /* {{{ PHP_MINIT_FUNCTION(dom) */
    579. 

  579. PHP_MINIT_FUNCTION(dom)
    580. 

  580. {
    581. 

  581. 	zend_class_entry ce;
    582. 

  582. 

  583. 	memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
    584. 

  584. 	dom_object_handlers.read_property = dom_read_property;
    585. 

  585. 	dom_object_handlers.write_property = dom_write_property;
    586. 

  586. 	dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
    587. 

  587. 	dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
    588. 

  588. 	dom_object_handlers.has_property = dom_property_exists;
    589. 

  589. 

  590. 	zend_hash_init(&classes, 0, NULL, NULL, 1);
    591. 

  591. 

  592. 	INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
    593. 

  593. 	dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
    594. 

  594. 	dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
    595. 

  595. 	zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
    596. 

  596. 

  597. 	REGISTER_DOM_CLASS(ce, "DOMStringList", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
    598. 

  598. 	
    599. 

  599. 	zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, NULL, 1);
    600. 

  600. 	dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL TSRMLS_CC);
    601. 

  601. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domstringlist_prop_handlers, sizeof(dom_domstringlist_prop_handlers), NULL);
    602. 

  602. 

  603. 	REGISTER_DOM_CLASS(ce, "DOMNameList", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
    604. 

  604. 	
    605. 

  605. 	zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, NULL, 1);
    606. 

  606. 	dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL TSRMLS_CC);
    607. 

  607. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namelist_prop_handlers, sizeof(dom_namelist_prop_handlers), NULL);
    608. 

  608. 

  609. 	REGISTER_DOM_CLASS(ce, "DOMImplementationList", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
    610. 

  610. 	
    611. 

  611. 	zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, NULL, 1);
    612. 

  612. 	dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL TSRMLS_CC);
    613. 

  613. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domimplementationlist_prop_handlers, sizeof(dom_domimplementationlist_prop_handlers), NULL);
    614. 

  614. 

  615. 	REGISTER_DOM_CLASS(ce, "DOMImplementationSource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
    616. 

  616. 	REGISTER_DOM_CLASS(ce, "DOMImplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
    617. 

  617. 

  618. 	REGISTER_DOM_CLASS(ce, "DOMNode", NULL, php_dom_node_class_functions, dom_node_class_entry);
    619. 

  619. 	
    620. 

  620. 	zend_hash_init(&dom_node_prop_handlers, 0, NULL, NULL, 1);
    621. 

  621. 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
    622. 

  622. 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
    623. 

  623. 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
    624. 

  624. 	dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
    625. 

  625. 	dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", dom_node_child_nodes_read, NULL TSRMLS_CC);
    626. 

  626. 	dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", dom_node_first_child_read, NULL TSRMLS_CC);
    627. 

  627. 	dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", dom_node_last_child_read, NULL TSRMLS_CC);
    628. 

  628. 	dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", dom_node_previous_sibling_read, NULL TSRMLS_CC);
    629. 

  629. 	dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", dom_node_next_sibling_read, NULL TSRMLS_CC);
    630. 

  630. 	dom_register_prop_handler(&dom_node_prop_handlers, "attributes", dom_node_attributes_read, NULL TSRMLS_CC);
    631. 

  631. 	dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
    632. 

  632. 	dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
    633. 

  633. 	dom_register_prop_handler(&dom_node_prop_handlers, "prefix", dom_node_prefix_read, dom_node_prefix_write TSRMLS_CC);
    634. 

  634. 	dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
    635. 

  635. 	dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL TSRMLS_CC);
    636. 

  636. 	dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write TSRMLS_CC);
    637. 

  637. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
    638. 

  638. 

  639. 	REGISTER_DOM_CLASS(ce, "DOMNameSpaceNode", NULL, NULL, dom_namespace_node_class_entry);
    640. 

  640. 

  641. 	zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, NULL, 1);
    642. 

  642. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
    643. 

  643. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL TSRMLS_CC);
    644. 

  644. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
    645. 

  645. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", dom_node_prefix_read, NULL TSRMLS_CC);
    646. 

  646. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
    647. 

  647. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
    648. 

  648. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
    649. 

  649. 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
    650. 

  650. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namespace_node_prop_handlers, sizeof(dom_namespace_node_prop_handlers), NULL);
    651. 

  651. 

  652. 	REGISTER_DOM_CLASS(ce, "DOMDocumentFragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
    653. 

  653. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
    654. 

  654. 	
    655. 

  655. 	REGISTER_DOM_CLASS(ce, "DOMDocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
    656. 

  656. 	zend_hash_init(&dom_document_prop_handlers, 0, NULL, NULL, 1);
    657. 

  657. 	dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL TSRMLS_CC);
    658. 

  658. 	dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL TSRMLS_CC);
    659. 

  659. 	dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL TSRMLS_CC);
    660. 

  660. 	dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
    661. 

  661. 	dom_register_prop_handler(&dom_document_prop_handlers, "encoding", dom_document_encoding_read, dom_document_encoding_write TSRMLS_CC);
    662. 

  662. 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
    663. 

  663. 	dom_register_prop_handler(&dom_document_prop_handlers, "standalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
    664. 

  664. 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
    665. 

  665. 	dom_register_prop_handler(&dom_document_prop_handlers, "version", dom_document_version_read, dom_document_version_write TSRMLS_CC);
    666. 

  666. 	dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", dom_document_version_read, dom_document_version_write TSRMLS_CC);
    667. 

  667. 	dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", dom_document_strict_error_checking_read, dom_document_strict_error_checking_write TSRMLS_CC);
    668. 

  668. 	dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", dom_document_document_uri_read, dom_document_document_uri_write TSRMLS_CC);
    669. 

  669. 	dom_register_prop_handler(&dom_document_prop_handlers, "config", dom_document_config_read, NULL TSRMLS_CC);
    670. 

  670. 	dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", dom_document_format_output_read, dom_document_format_output_write TSRMLS_CC);
    671. 

  671. 	dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", dom_document_validate_on_parse_read, dom_document_validate_on_parse_write TSRMLS_CC);
    672. 

  672. 	dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", dom_document_resolve_externals_read, dom_document_resolve_externals_write TSRMLS_CC);
    673. 

  673. 	dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write TSRMLS_CC);
    674. 

  674. 	dom_register_prop_handler(&dom_document_prop_handlers, "recover", dom_document_recover_read, dom_document_recover_write TSRMLS_CC);
    675. 

  675. 	dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", dom_document_substitue_entities_read, dom_document_substitue_entities_write TSRMLS_CC);
    676. 

  676. 

  677. 	zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    678. 

  678. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_document_prop_handlers, sizeof(dom_document_prop_handlers), NULL);
    679. 

  679. 

  680. 	INIT_CLASS_ENTRY(ce, "DOMNodeList", php_dom_nodelist_class_functions);
    681. 

  681. 	ce.create_object = dom_nnodemap_objects_new;
    682. 

  682. 	dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
    683. 

  683. 	dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
    684. 

  684. 	zend_class_implements(dom_nodelist_class_entry TSRMLS_CC, 1, zend_ce_traversable);
    685. 

  685. 

  686. 	zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, 1);
    687. 

  687. 	dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL TSRMLS_CC);
    688. 

  688. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_nodelist_prop_handlers, sizeof(dom_nodelist_prop_handlers), NULL);
    689. 

  689. 

  690. 	INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", php_dom_namednodemap_class_functions);
    691. 

  691. 	ce.create_object = dom_nnodemap_objects_new;
    692. 

  692. 	dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
    693. 

  693. 	dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
    694. 

  694. 	zend_class_implements(dom_namednodemap_class_entry TSRMLS_CC, 1, zend_ce_traversable);
    695. 

  695. 

  696. 	zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, 1);
    697. 

  697. 	dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL TSRMLS_CC);
    698. 

  698. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namednodemap_prop_handlers, sizeof(dom_namednodemap_prop_handlers), NULL);
    699. 

  699. 

  700. 	REGISTER_DOM_CLASS(ce, "DOMCharacterData", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
    701. 

  701. 	
    702. 

  702. 	zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, NULL, 1);
    703. 

  703. 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write TSRMLS_CC);
    704. 

  704. 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL TSRMLS_CC);
    705. 

  705. 	zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    706. 

  706. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_characterdata_prop_handlers), NULL);
    707. 

  707. 

  708. 	REGISTER_DOM_CLASS(ce, "DOMAttr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
    709. 

  709. 	
    710. 

  710. 	zend_hash_init(&dom_attr_prop_handlers, 0, NULL, NULL, 1);
    711. 

  711. 	dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL TSRMLS_CC);
    712. 

  712. 	dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL TSRMLS_CC);
    713. 

  713. 	dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write TSRMLS_CC);
    714. 

  714. 	dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL TSRMLS_CC);
    715. 

  715. 	dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL TSRMLS_CC);
    716. 

  716. 	zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    717. 

  717. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_attr_prop_handlers, sizeof(dom_attr_prop_handlers), NULL);
    718. 

  718. 

  719. 	REGISTER_DOM_CLASS(ce, "DOMElement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
    720. 

  720. 	
    721. 

  721. 	zend_hash_init(&dom_element_prop_handlers, 0, NULL, NULL, 1);
    722. 

  722. 	dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL TSRMLS_CC);
    723. 

  723. 	dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL TSRMLS_CC);
    724. 

  724. 	zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    725. 

  725. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_element_prop_handlers, sizeof(dom_element_prop_handlers), NULL);
    726. 

  726. 

  727. 	REGISTER_DOM_CLASS(ce, "DOMText", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
    728. 

  728. 	
    729. 

  729. 	zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, 1);
    730. 

  730. 	dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL TSRMLS_CC);
    731. 

  731. 	zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    732. 

  732. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_text_prop_handlers), NULL);
    733. 

  733. 

  734. 	REGISTER_DOM_CLASS(ce, "DOMComment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
    735. 

  735. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
    736. 

  736. 

  737. 	REGISTER_DOM_CLASS(ce, "DOMTypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
    738. 

  738. 	
    739. 

  739. 	zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, NULL, 1);
    740. 

  740. 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL TSRMLS_CC);
    741. 

  741. 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL TSRMLS_CC);
    742. 

  742. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_typeinfo_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
    743. 

  743. 

  744. 	REGISTER_DOM_CLASS(ce, "DOMUserDataHandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
    745. 

  745. 	REGISTER_DOM_CLASS(ce, "DOMDomError", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
    746. 

  746. 	
    747. 

  747. 	zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, NULL, 1);
    748. 

  748. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL TSRMLS_CC);
    749. 

  749. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL TSRMLS_CC);
    750. 

  750. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL TSRMLS_CC);
    751. 

  751. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL TSRMLS_CC);
    752. 

  752. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL TSRMLS_CC);
    753. 

  753. 	dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL TSRMLS_CC);
    754. 

  754. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domerror_prop_handlers, sizeof(dom_domerror_prop_handlers), NULL);
    755. 

  755. 

  756. 	REGISTER_DOM_CLASS(ce, "DOMErrorHandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
    757. 

  757. 	REGISTER_DOM_CLASS(ce, "DOMLocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
    758. 

  758. 	
    759. 

  759. 	zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, NULL, 1);
    760. 

  760. 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL TSRMLS_CC);
    761. 

  761. 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL TSRMLS_CC);
    762. 

  762. 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL TSRMLS_CC);
    763. 

  763. 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL TSRMLS_CC);
    764. 

  764. 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL TSRMLS_CC);
    765. 

  765. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domlocator_prop_handlers, sizeof(dom_domlocator_prop_handlers), NULL);
    766. 

  766. 

  767. 	REGISTER_DOM_CLASS(ce, "DOMConfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
    768. 

  768. 	REGISTER_DOM_CLASS(ce, "DOMCdataSection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
    769. 

  769. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
    770. 

  770. 

  771. 	REGISTER_DOM_CLASS(ce, "DOMDocumentType", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
    772. 

  772. 	
    773. 

  773. 	zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, NULL, 1);
    774. 

  774. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL TSRMLS_CC);
    775. 

  775. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL TSRMLS_CC);
    776. 

  776. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL TSRMLS_CC);
    777. 

  777. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL TSRMLS_CC);
    778. 

  778. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL TSRMLS_CC);
    779. 

  779. 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL TSRMLS_CC);
    780. 

  780. 	zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    781. 

  781. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_documenttype_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
    782. 

  782. 

  783. 	REGISTER_DOM_CLASS(ce, "DOMNotation", dom_node_class_entry, php_dom_notation_class_functions, dom_notation_class_entry);
    784. 

  784. 	
    785. 

  785. 	zend_hash_init(&dom_notation_prop_handlers, 0, NULL, NULL, 1);
    786. 

  786. 	dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL TSRMLS_CC);
    787. 

  787. 	dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL TSRMLS_CC);
    788. 

  788. 	zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    789. 

  789. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_notation_prop_handlers, sizeof(dom_notation_prop_handlers), NULL);
    790. 

  790. 

  791. 	REGISTER_DOM_CLASS(ce, "DOMEntity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
    792. 

  792. 	
    793. 

  793. 	zend_hash_init(&dom_entity_prop_handlers, 0, NULL, NULL, 1);
    794. 

  794. 	dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL TSRMLS_CC);
    795. 

  795. 	dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL TSRMLS_CC);
    796. 

  796. 	dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL TSRMLS_CC);
    797. 

  797. 	dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write TSRMLS_CC);
    798. 

  798. 	dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write TSRMLS_CC);
    799. 

  799. 	dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write TSRMLS_CC);
    800. 

  800. 	zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    801. 

  801. 

  802. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_entity_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
    803. 

  803. 

  804. 	REGISTER_DOM_CLASS(ce, "DOMEntityReference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
    805. 

  805. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
    806. 

  806. 

  807. 	REGISTER_DOM_CLASS(ce, "DOMProcessingInstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
    808. 

  808. 	
    809. 

  809. 	zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, NULL, 1);
    810. 

  810. 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL TSRMLS_CC);
    811. 

  811. 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write TSRMLS_CC);
    812. 

  812. 	zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
    813. 

  813. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_processinginstruction_prop_handlers, sizeof(dom_processinginstruction_prop_handlers), NULL);
    814. 

  814. 

  815. 	REGISTER_DOM_CLASS(ce, "DOMStringExtend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
    816. 

  816. 

  817. #if defined(LIBXML_XPATH_ENABLED)
    818. 

  818. 	INIT_CLASS_ENTRY(ce, "DOMXPath", php_dom_xpath_class_functions);
    819. 

  819. 	ce.create_object = dom_xpath_objects_new;
    820. 

  820. 	dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
    821. 

  821. 

  822. 	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, 1);
    823. 

  823. 	dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL TSRMLS_CC);
    824. 

  824. 	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_xpath_prop_handlers, sizeof(dom_xpath_prop_handlers), NULL);
    825. 

  825. #endif
    826. 

  826. 

  827. 	REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE",			XML_ELEMENT_NODE,			CONST_CS | CONST_PERSISTENT);
    828. 

  828. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NODE",		XML_ATTRIBUTE_NODE,			CONST_CS | CONST_PERSISTENT);
    829. 

  829. 	REGISTER_LONG_CONSTANT("XML_TEXT_NODE",				XML_TEXT_NODE,				CONST_CS | CONST_PERSISTENT);
    830. 

  830. 	REGISTER_LONG_CONSTANT("XML_CDATA_SECTION_NODE",	XML_CDATA_SECTION_NODE,		CONST_CS | CONST_PERSISTENT);
    831. 

  831. 	REGISTER_LONG_CONSTANT("XML_ENTITY_REF_NODE",		XML_ENTITY_REF_NODE,		CONST_CS | CONST_PERSISTENT);
    832. 

  832. 	REGISTER_LONG_CONSTANT("XML_ENTITY_NODE",			XML_ENTITY_NODE,			CONST_CS | CONST_PERSISTENT);
    833. 

  833. 	REGISTER_LONG_CONSTANT("XML_PI_NODE",				XML_PI_NODE,				CONST_CS | CONST_PERSISTENT);
    834. 

  834. 	REGISTER_LONG_CONSTANT("XML_COMMENT_NODE",			XML_COMMENT_NODE,			CONST_CS | CONST_PERSISTENT);
    835. 

  835. 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_NODE",			XML_DOCUMENT_NODE,			CONST_CS | CONST_PERSISTENT);
    836. 

  836. 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_TYPE_NODE",	XML_DOCUMENT_TYPE_NODE,		CONST_CS | CONST_PERSISTENT);
    837. 

  837. 	REGISTER_LONG_CONSTANT("XML_DOCUMENT_FRAG_NODE",	XML_DOCUMENT_FRAG_NODE,		CONST_CS | CONST_PERSISTENT);
    838. 

  838. 	REGISTER_LONG_CONSTANT("XML_NOTATION_NODE",			XML_NOTATION_NODE,			CONST_CS | CONST_PERSISTENT);
    839. 

  839. 	REGISTER_LONG_CONSTANT("XML_HTML_DOCUMENT_NODE",	XML_HTML_DOCUMENT_NODE,		CONST_CS | CONST_PERSISTENT);
    840. 

  840. 	REGISTER_LONG_CONSTANT("XML_DTD_NODE",				XML_DTD_NODE,				CONST_CS | CONST_PERSISTENT);
    841. 

  841. 	REGISTER_LONG_CONSTANT("XML_ELEMENT_DECL_NODE", 	XML_ELEMENT_DECL,			CONST_CS | CONST_PERSISTENT);
    842. 

  842. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_DECL_NODE",	XML_ATTRIBUTE_DECL,			CONST_CS | CONST_PERSISTENT);
    843. 

  843. 	REGISTER_LONG_CONSTANT("XML_ENTITY_DECL_NODE",		XML_ENTITY_DECL,			CONST_CS | CONST_PERSISTENT);
    844. 

  844. 	REGISTER_LONG_CONSTANT("XML_NAMESPACE_DECL_NODE",	XML_NAMESPACE_DECL,			CONST_CS | CONST_PERSISTENT);
    845. 

  845. #ifdef XML_GLOBAL_NAMESPACE
    846. 

  846. 	REGISTER_LONG_CONSTANT("XML_GLOBAL_NAMESPACE",		XML_GLOBAL_NAMESPACE,		CONST_CS | CONST_PERSISTENT);
    847. 

  847. #endif
    848. 

  848. 	REGISTER_LONG_CONSTANT("XML_LOCAL_NAMESPACE",		XML_LOCAL_NAMESPACE,		CONST_CS | CONST_PERSISTENT);
    849. 

  849. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_CDATA",		XML_ATTRIBUTE_CDATA,		CONST_CS | CONST_PERSISTENT);
    850. 

  850. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ID",			XML_ATTRIBUTE_ID,			CONST_CS | CONST_PERSISTENT);
    851. 

  851. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREF",		XML_ATTRIBUTE_IDREF,		CONST_CS | CONST_PERSISTENT);
    852. 

  852. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREFS",		XML_ATTRIBUTE_IDREFS,		CONST_CS | CONST_PERSISTENT);
    853. 

  853. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENTITY",		XML_ATTRIBUTE_ENTITIES,		CONST_CS | CONST_PERSISTENT);
    854. 

  854. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKEN",		XML_ATTRIBUTE_NMTOKEN,		CONST_CS | CONST_PERSISTENT);
    855. 

  855. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKENS",	XML_ATTRIBUTE_NMTOKENS,		CONST_CS | CONST_PERSISTENT);
    856. 

  856. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENUMERATION",	XML_ATTRIBUTE_ENUMERATION,	CONST_CS | CONST_PERSISTENT);
    857. 

  857. 	REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NOTATION",	XML_ATTRIBUTE_NOTATION,		CONST_CS | CONST_PERSISTENT);
    858. 

  858. 

  859. 	/* DOMException Codes */
    860. 

  860. 	REGISTER_LONG_CONSTANT("DOM_PHP_ERR",				PHP_ERR,				CONST_CS | CONST_PERSISTENT);
    861. 

  861. 	REGISTER_LONG_CONSTANT("DOM_INDEX_SIZE_ERR",		INDEX_SIZE_ERR,			CONST_CS | CONST_PERSISTENT);
    862. 

  862. 	REGISTER_LONG_CONSTANT("DOMSTRING_SIZE_ERR",		DOMSTRING_SIZE_ERR,		CONST_CS | CONST_PERSISTENT);
    863. 

  863. 	REGISTER_LONG_CONSTANT("DOM_HIERARCHY_REQUEST_ERR",	HIERARCHY_REQUEST_ERR,	CONST_CS | CONST_PERSISTENT);
    864. 

  864. 	REGISTER_LONG_CONSTANT("DOM_WRONG_DOCUMENT_ERR",	WRONG_DOCUMENT_ERR,		CONST_CS | CONST_PERSISTENT);
    865. 

  865. 	REGISTER_LONG_CONSTANT("DOM_INVALID_CHARACTER_ERR",	INVALID_CHARACTER_ERR,	CONST_CS | CONST_PERSISTENT);
    866. 

  866. 	REGISTER_LONG_CONSTANT("DOM_NO_DATA_ALLOWED_ERR",	NO_DATA_ALLOWED_ERR,	CONST_CS | CONST_PERSISTENT);
    867. 

  867. 	REGISTER_LONG_CONSTANT("DOM_NO_MODIFICATION_ALLOWED_ERR", NO_MODIFICATION_ALLOWED_ERR, CONST_CS | CONST_PERSISTENT);
    868. 

  868. 	REGISTER_LONG_CONSTANT("DOM_NOT_FOUND_ERR",			NOT_FOUND_ERR,			CONST_CS | CONST_PERSISTENT);
    869. 

  869. 	REGISTER_LONG_CONSTANT("DOM_NOT_SUPPORTED_ERR",		NOT_SUPPORTED_ERR,		CONST_CS | CONST_PERSISTENT);
    870. 

  870. 	REGISTER_LONG_CONSTANT("DOM_INUSE_ATTRIBUTE_ERR",	INUSE_ATTRIBUTE_ERR,	CONST_CS | CONST_PERSISTENT);
    871. 

  871. 	REGISTER_LONG_CONSTANT("DOM_INVALID_STATE_ERR",		INVALID_STATE_ERR,		CONST_CS | CONST_PERSISTENT);
    872. 

  872. 	REGISTER_LONG_CONSTANT("DOM_SYNTAX_ERR",			SYNTAX_ERR,				CONST_CS | CONST_PERSISTENT);
    873. 

  873. 	REGISTER_LONG_CONSTANT("DOM_INVALID_MODIFICATION_ERR",	INVALID_MODIFICATION_ERR, CONST_CS | CONST_PERSISTENT);
    874. 

  874. 	REGISTER_LONG_CONSTANT("DOM_NAMESPACE_ERR",			NAMESPACE_ERR,			CONST_CS | CONST_PERSISTENT);
    875. 

  875. 	REGISTER_LONG_CONSTANT("DOM_INVALID_ACCESS_ERR",	INVALID_ACCESS_ERR,		CONST_CS | CONST_PERSISTENT);
    876. 

  876. 	REGISTER_LONG_CONSTANT("DOM_VALIDATION_ERR",		VALIDATION_ERR,			CONST_CS | CONST_PERSISTENT);
    877. 

  877. 

  878. 	php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
    879. 

  879. 

  880. 	return SUCCESS;
    881. 

  881. }
    882. 

  882. /* }}} */
    883. 

  883. 

  884. /* {{{ */
    885. 

  885. PHP_MINFO_FUNCTION(dom)
    886. 

  886. {
    887. 

  887. 	php_info_print_table_start();
    888. 

  888. 	php_info_print_table_row(2, "DOM/XML", "enabled");
    889. 

  889. 	php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
    890. 

  890. 	php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
    891. 

  891. #if defined(LIBXML_HTML_ENABLED)
    892. 

  892. 	php_info_print_table_row(2, "HTML Support", "enabled");
    893. 

  893. #endif
    894. 

  894. #if defined(LIBXML_XPATH_ENABLED)
    895. 

  895. 	php_info_print_table_row(2, "XPath Support", "enabled");
    896. 

  896. #endif
    897. 

  897. #if defined(LIBXML_XPTR_ENABLED)
    898. 

  898. 	php_info_print_table_row(2, "XPointer Support", "enabled");
    899. 

  899. #endif
    900. 

  900. #ifdef LIBXML_SCHEMAS_ENABLED
    901. 

  901. 	php_info_print_table_row(2, "Schema Support", "enabled");
    902. 

  902. 	php_info_print_table_row(2, "RelaxNG Support", "enabled");
    903. 

  903. #endif
    904. 

  904. 	php_info_print_table_end();
    905. 

  905. }
    906. 

  906. /* }}} */
    907. 

  907. 

  908. PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
    909. 

  909. {
    910. 

  910. 	zend_hash_destroy(&dom_domstringlist_prop_handlers);
    911. 

  911. 	zend_hash_destroy(&dom_namelist_prop_handlers);
    912. 

  912. 	zend_hash_destroy(&dom_domimplementationlist_prop_handlers);
    913. 

  913. 	zend_hash_destroy(&dom_document_prop_handlers);
    914. 

  914. 	zend_hash_destroy(&dom_node_prop_handlers);
    915. 

  915. 	zend_hash_destroy(&dom_namespace_node_prop_handlers);
    916. 

  916. 	zend_hash_destroy(&dom_nodelist_prop_handlers);
    917. 

  917. 	zend_hash_destroy(&dom_namednodemap_prop_handlers);
    918. 

  918. 	zend_hash_destroy(&dom_characterdata_prop_handlers);
    919. 

  919. 	zend_hash_destroy(&dom_attr_prop_handlers);
    920. 

  920. 	zend_hash_destroy(&dom_element_prop_handlers);
    921. 

  921. 	zend_hash_destroy(&dom_text_prop_handlers);
    922. 

  922. 	zend_hash_destroy(&dom_typeinfo_prop_handlers);
    923. 

  923. 	zend_hash_destroy(&dom_domerror_prop_handlers);
    924. 

  924. 	zend_hash_destroy(&dom_domlocator_prop_handlers);
    925. 

  925. 	zend_hash_destroy(&dom_documenttype_prop_handlers);
    926. 

  926. 	zend_hash_destroy(&dom_notation_prop_handlers);
    927. 

  927. 	zend_hash_destroy(&dom_entity_prop_handlers);
    928. 

  928. 	zend_hash_destroy(&dom_processinginstruction_prop_handlers);
    929. 

  929. #if defined(LIBXML_XPATH_ENABLED)
    930. 

  930. 	zend_hash_destroy(&dom_xpath_prop_handlers);
    931. 

  931. #endif
    932. 

  932. 	zend_hash_destroy(&classes);
    933. 

  933. 	
    934. 

  934. /*	If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
    935. 

  935. 	uncomment the following line, this will tell you the amount of not freed memory
    936. 

  936. 	and the total used memory into apaches error_log  */
    937. 

  937. /*  xmlMemoryDump();*/
    938. 

  938. 

  939. 	return SUCCESS;
    940. 

  940. }
    941. 

  941. /* }}} */
    942. 

  942. 

  943. /* {{{ node_list_unlink */
    944. 

  944. void node_list_unlink(xmlNodePtr node TSRMLS_DC)
    945. 

  945. {
    946. 

  946. 	dom_object *wrapper;
    947. 

  947. 

  948. 	while (node != NULL) {
    949. 

  949. 

  950. 		wrapper = php_dom_object_get_data(node);
    951. 

  951. 

  952. 		if (wrapper != NULL ) {
    953. 

  953. 			xmlUnlinkNode(node);
    954. 

  954. 		} else {
    955. 

  955. 			if (node->type == XML_ENTITY_REF_NODE)
    956. 

  956. 				break;
    957. 

  957. 			node_list_unlink(node->children TSRMLS_CC);
    958. 

  958. 

  959. 			switch (node->type) {
    960. 

  960. 				case XML_ATTRIBUTE_DECL:
    961. 

  961. 				case XML_DTD_NODE:
    962. 

  962. 				case XML_DOCUMENT_TYPE_NODE:
    963. 

  963. 				case XML_ENTITY_DECL:
    964. 

  964. 				case XML_ATTRIBUTE_NODE:
    965. 

  965. 				case XML_TEXT_NODE:
    966. 

  966. 					break;
    967. 

  967. 				default:
    968. 

  968. 					node_list_unlink((xmlNodePtr) node->properties TSRMLS_CC);
    969. 

  969. 			}
    970. 

  970. 

  971. 		}
    972. 

  972. 

  973. 		node = node->next;
    974. 

  974. 	}
    975. 

  975. }
    976. 

  976. /* }}} end node_list_unlink */
    977. 

  977. 

  978. #if defined(LIBXML_XPATH_ENABLED)
    979. 

  979. /* {{{ dom_xpath_objects_free_storage */
    980. 

  980. void dom_xpath_objects_free_storage(void *object TSRMLS_DC)
    981. 

  981. {
    982. 

  982. 	dom_xpath_object *intern = (dom_xpath_object *)object;
    983. 

  983. 

  984. 	zend_object_std_dtor(&intern->std TSRMLS_CC);
    985. 

  985. 

  986. 	if (intern->ptr != NULL) {
    987. 

  987. 		xmlXPathFreeContext((xmlXPathContextPtr) intern->ptr);
    988. 

  988. 		php_libxml_decrement_doc_ref((php_libxml_node_object *) intern TSRMLS_CC);
    989. 

  989. 		intern->ptr = NULL;
    990. 

  990. 	}
    991. 

  991. 

  992. 	if (intern->registered_phpfunctions) {
    993. 

  993. 		zend_hash_destroy(intern->registered_phpfunctions);
    994. 

  994. 		FREE_HASHTABLE(intern->registered_phpfunctions);
    995. 

  995. 	}
    996. 

  996. 	
    997. 

  997. 	if (intern->node_list) {
    998. 

  998. 		zend_hash_destroy(intern->node_list);
    999. 

  999. 		FREE_HASHTABLE(intern->node_list);
    1000. 

  1000. 	}
    1001. 

  1001. 

  1002. 	efree(object);
    1003. 

  1003. }
    1004. 

  1004. /* }}} */
    1005. 

  1005. #endif
    1006. 

  1006. 

  1007. /* {{{ dom_objects_free_storage */
    1008. 

  1008. void dom_objects_free_storage(void *object TSRMLS_DC)
    1009. 

  1009. {
    1010. 

  1010. 	dom_object *intern = (dom_object *)object;
    1011. 

  1011. 	int retcount;
    1012. 

  1012. 

  1013. 	zend_object_std_dtor(&intern->std TSRMLS_CC);
    1014. 

  1014. 

  1015. 	if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
    1016. 

  1016. 		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) {
    1017. 

  1017. 			php_libxml_node_decrement_resource((php_libxml_node_object *) intern TSRMLS_CC);
    1018. 

  1018. 		} else {
    1019. 

  1019. 			php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
    1020. 

  1020. 			retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    1021. 

  1021. 		}
    1022. 

  1022. 		intern->ptr = NULL;
    1023. 

  1023. 	}
    1024. 

  1024. 

  1025. 	efree(object);
    1026. 

  1026. }
    1027. 

  1027. /* }}} */
    1028. 

  1028. 

  1029. void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns TSRMLS_DC) /* {{{ */
    1030. 

  1030. {
    1031. 

  1031. 	dom_nnodemap_object *mapptr;
    1032. 

  1032. 	zval *baseobj = NULL;
    1033. 

  1033. 

  1034. 	mapptr = (dom_nnodemap_object *)intern->ptr;
    1035. 

  1035. 	if (basenode) {
    1036. 

  1036. 		MAKE_STD_ZVAL(baseobj);
    1037. 

  1037. 		baseobj->type = IS_OBJECT;
    1038. 

  1038. 		Z_SET_ISREF_P(baseobj);
    1039. 

  1039. 		baseobj->value.obj.handle = basenode->handle;
    1040. 

  1040. 		baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
    1041. 

  1041. 		zval_copy_ctor(baseobj);
    1042. 

  1042. 	}
    1043. 

  1043. 	mapptr->baseobjptr = baseobj;
    1044. 

  1044. 	mapptr->baseobj = basenode;
    1045. 

  1045. 	mapptr->nodetype = ntype;
    1046. 

  1046. 	mapptr->ht = ht;
    1047. 

  1047. 	mapptr->local = local;
    1048. 

  1048. 	mapptr->ns = ns;
    1049. 

  1049. 

  1050. }
    1051. 

  1051. /* }}} */
    1052. 

  1052. 

  1053. static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy TSRMLS_DC) /* {{{ */
    1054. 

  1054. {
    1055. 

  1055. 	zend_class_entry *base_class;
    1056. 

  1056. 	zval *tmp;
    1057. 

  1057. 	dom_object *intern;
    1058. 

  1058. 

  1059. 	if (instanceof_function(class_type, dom_xpath_class_entry TSRMLS_CC)) {
    1060. 

  1060. 		intern = emalloc(sizeof(dom_xpath_object));
    1061. 

  1061. 		memset(intern, 0, sizeof(dom_xpath_object));
    1062. 

  1062. 	} else {
    1063. 

  1063. 		intern = emalloc(sizeof(dom_object));
    1064. 

  1064. 	}
    1065. 

  1065. 	intern->ptr = NULL;
    1066. 

  1066. 	intern->prop_handler = NULL;
    1067. 

  1067. 	intern->document = NULL;
    1068. 

  1068. 

  1069. 	base_class = class_type;
    1070. 

  1070. 	while(base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
    1071. 

  1071. 		base_class = base_class->parent;
    1072. 

  1072. 	}
    1073. 

  1073. 

  1074. 	zend_hash_find(&classes, base_class->name, base_class->name_length + 1, (void **) &intern->prop_handler);
    1075. 

  1075. 

  1076. 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
    1077. 

  1077. 	if (hash_copy) {
    1078. 

  1078. 		zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
    1079. 

  1079. 	}
    1080. 

  1080. 

  1081. 	return intern;
    1082. 

  1082. }
    1083. 

  1083. /* }}} */
    1084. 

  1084. 

  1085. /* {{{ dom_objects_clone */
    1086. 

  1086. void dom_objects_clone(void *object, void **object_clone TSRMLS_DC)
    1087. 

  1087. {
    1088. 

  1088. 	dom_object *intern = (dom_object *) object;
    1089. 

  1089. 	dom_object *clone;
    1090. 

  1090. 	xmlNodePtr node;
    1091. 

  1091. 	xmlNodePtr cloned_node;
    1092. 

  1092. 

  1093. 	clone = dom_objects_set_class(intern->std.ce, 0 TSRMLS_CC);
    1094. 

  1094. 

  1095. 	if (instanceof_function(intern->std.ce, dom_node_class_entry TSRMLS_CC)) {
    1096. 

  1096. 		node = (xmlNodePtr)dom_object_get_node((dom_object *) object);
    1097. 

  1097. 		if (node != NULL) {
    1098. 

  1098. 			cloned_node = xmlDocCopyNode(node, node->doc, 1);
    1099. 

  1099. 			if (cloned_node != NULL) {
    1100. 

  1100. 				/* If we cloned a document then we must create new doc proxy */
    1101. 

  1101. 				if (cloned_node->doc == node->doc) {
    1102. 

  1102. 					clone->document = intern->document;
    1103. 

  1103. 				}
    1104. 

  1104. 				php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc TSRMLS_CC);
    1105. 

  1105. 				php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone TSRMLS_CC);
    1106. 

  1106. 				if (intern->document != clone->document) {
    1107. 

  1107. 					dom_copy_doc_props(intern->document, clone->document);
    1108. 

  1108. 				}
    1109. 

  1109. 			}
    1110. 

  1110. 

  1111. 		}
    1112. 

  1112. 	}
    1113. 

  1113. 

  1114. 	*object_clone = (void *) clone;
    1115. 

  1115. }
    1116. 

  1116. /* }}} */
    1117. 

  1117. 

  1118. /* {{{ dom_objects_new */
    1119. 

  1119. zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
    1120. 

  1120. {
    1121. 

  1121. 	zend_object_value retval;
    1122. 

  1122. 	dom_object *intern;
    1123. 

  1123. 	
    1124. 

  1124. 	intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
    1125. 

  1125. 

  1126. 	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);
    1127. 

  1127. 	intern->handle = retval.handle;
    1128. 

  1128. 	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
    1129. 

  1129. 

  1130. 	return retval;
    1131. 

  1131. }
    1132. 

  1132. /* }}} */
    1133. 

  1133. 

  1134. #if defined(LIBXML_XPATH_ENABLED)
    1135. 

  1135. /* {{{ zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC) */
    1136. 

  1136. zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
    1137. 

  1137. {
    1138. 

  1138. 	zend_object_value retval;
    1139. 

  1139. 	dom_xpath_object *intern;
    1140. 

  1140. 

  1141. 	intern = (dom_xpath_object *)dom_objects_set_class(class_type, 1 TSRMLS_CC);
    1142. 

  1142. 	intern->registerPhpFunctions = 0;
    1143. 

  1143. 	intern->registered_phpfunctions = NULL;
    1144. 

  1144. 	intern->node_list = NULL;
    1145. 

  1145. 

  1146. 	ALLOC_HASHTABLE(intern->registered_phpfunctions);
    1147. 

  1147. 	zend_hash_init(intern->registered_phpfunctions, 0, NULL, ZVAL_PTR_DTOR, 0);
    1148. 

  1148. 

  1149. 	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);
    1150. 

  1150. 	intern->handle = retval.handle;
    1151. 

  1151. 	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
    1152. 

  1152. 

  1153. 	return retval;
    1154. 

  1154. }
    1155. 

  1155. /* }}} */
    1156. 

  1156. #endif
    1157. 

  1157. 

  1158. static void dom_nnodemap_object_dtor(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
    1159. 

  1159. {
    1160. 

  1160. 	zval *baseobj;
    1161. 

  1161. 	dom_object *intern;
    1162. 

  1162. 	dom_nnodemap_object *objmap;
    1163. 

  1163. 

  1164. 	intern = (dom_object *)object;
    1165. 

  1165. 	objmap = (dom_nnodemap_object *)intern->ptr;
    1166. 

  1166. 

  1167. 	if (objmap) {
    1168. 

  1168. 		if (objmap->local) {
    1169. 

  1169. 			xmlFree(objmap->local);
    1170. 

  1170. 		}
    1171. 

  1171. 		if (objmap->ns) {
    1172. 

  1172. 			xmlFree(objmap->ns);
    1173. 

  1173. 		}
    1174. 

  1174. 		if (objmap->baseobjptr) {
    1175. 

  1175. 			baseobj = objmap->baseobjptr;
    1176. 

  1176. 			zval_ptr_dtor((zval **)&baseobj);
    1177. 

  1177. 		}
    1178. 

  1178. 		efree(objmap);
    1179. 

  1179. 		intern->ptr = NULL;
    1180. 

  1180. 	}
    1181. 

  1181. 

  1182. 

  1183. }
    1184. 

  1184. /* }}} */
    1185. 

  1185. 

  1186. void dom_nnodemap_objects_free_storage(void *object TSRMLS_DC) /* {{{ */
    1187. 

  1187. {
    1188. 

  1188. 	dom_object *intern = (dom_object *)object;
    1189. 

  1189. 

  1190. 	php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
    1191. 

  1191. 

  1192. 	zend_object_std_dtor(&intern->std TSRMLS_CC);
    1193. 

  1193. 

  1194. 	efree(object);
    1195. 

  1195. }
    1196. 

  1196. /* }}} */
    1197. 

  1197. 

  1198. zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
    1199. 

  1199. {
    1200. 

  1200. 	zend_object_value retval;
    1201. 

  1201. 	dom_object *intern;
    1202. 

  1202. 	dom_nnodemap_object *objmap;
    1203. 

  1203. 	
    1204. 

  1204. 	intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
    1205. 

  1205. 	intern->ptr = emalloc(sizeof(dom_nnodemap_object));
    1206. 

  1206. 	objmap = (dom_nnodemap_object *)intern->ptr;
    1207. 

  1207. 	objmap->baseobj = NULL;
    1208. 

  1208. 	objmap->baseobjptr = NULL;
    1209. 

  1209. 	objmap->nodetype = 0;
    1210. 

  1210. 	objmap->ht = NULL;
    1211. 

  1211. 	objmap->local = NULL;
    1212. 

  1212. 	objmap->ns = NULL;
    1213. 

  1213. 

  1214. 	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);
    1215. 

  1215. 	intern->handle = retval.handle;
    1216. 

  1216. 	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
    1217. 

  1217. 

  1218. 	return retval;
    1219. 

  1219. }
    1220. 

  1220. /* }}} */
    1221. 

  1221. 

  1222. void php_dom_create_interator(zval *return_value, int ce_type TSRMLS_DC) /* {{{ */
    1223. 

  1223. {
    1224. 

  1224. 	zend_class_entry *ce;
    1225. 

  1225. 

  1226. 	if (ce_type == DOM_NAMEDNODEMAP) {
    1227. 

  1227. 		ce = dom_namednodemap_class_entry;
    1228. 

  1228. 	} else {
    1229. 

  1229. 		ce = dom_nodelist_class_entry;
    1230. 

  1230. 	}
    1231. 

  1231. 

  1232. 	object_init_ex(return_value, ce);
    1233. 

  1233. }
    1234. 

  1234. /* }}} */
    1235. 

  1235. 

  1236. /* {{{ php_dom_create_object */
    1237. 

  1237. PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *wrapper_in, zval *return_value, dom_object *domobj TSRMLS_DC)
    1238. 

  1238. {
    1239. 

  1239. 	zval *wrapper;
    1240. 

  1240. 	zend_class_entry *ce;
    1241. 

  1241. 	dom_object *intern;
    1242. 

  1242. 

  1243. 	*found = 0;
    1244. 

  1244. 

  1245. 	if (!obj) {
    1246. 

  1246. 		ALLOC_ZVAL(wrapper);
    1247. 

  1247. 		ZVAL_NULL(wrapper);
    1248. 

  1248. 		return wrapper;
    1249. 

  1249. 	}
    1250. 

  1250. 

  1251. 	if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
    1252. 

  1252. 		return_value->type = IS_OBJECT;
    1253. 

  1253. 		Z_SET_ISREF_P(return_value);
    1254. 

  1254. 		return_value->value.obj.handle = intern->handle;
    1255. 

  1255. 		return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
    1256. 

  1256. 		zval_copy_ctor(return_value);
    1257. 

  1257. 		*found = 1;
    1258. 

  1258. 		return return_value;
    1259. 

  1259. 	}
    1260. 

  1260. 

  1261. 	wrapper = return_value;
    1262. 

  1262. 

  1263. 	switch (obj->type) {
    1264. 

  1264. 		case XML_DOCUMENT_NODE:
    1265. 

  1265. 		case XML_HTML_DOCUMENT_NODE:
    1266. 

  1266. 		{
    1267. 

  1267. 			ce = dom_document_class_entry;
    1268. 

  1268. 			break;
    1269. 

  1269. 		}
    1270. 

  1270. 		case XML_DTD_NODE:
    1271. 

  1271. 		case XML_DOCUMENT_TYPE_NODE:
    1272. 

  1272. 		{
    1273. 

  1273. 			ce = dom_documenttype_class_entry;
    1274. 

  1274. 			break;
    1275. 

  1275. 		}
    1276. 

  1276. 		case XML_ELEMENT_NODE:
    1277. 

  1277. 		{
    1278. 

  1278. 			ce = dom_element_class_entry;
    1279. 

  1279. 			break;
    1280. 

  1280. 		}
    1281. 

  1281. 		case XML_ATTRIBUTE_NODE:
    1282. 

  1282. 		{
    1283. 

  1283. 			ce = dom_attr_class_entry;
    1284. 

  1284. 			break;
    1285. 

  1285. 		}
    1286. 

  1286. 		case XML_TEXT_NODE:
    1287. 

  1287. 		{
    1288. 

  1288. 			ce = dom_text_class_entry;
    1289. 

  1289. 			break;
    1290. 

  1290. 		}
    1291. 

  1291. 		case XML_COMMENT_NODE:
    1292. 

  1292. 		{
    1293. 

  1293. 			ce = dom_comment_class_entry;
    1294. 

  1294. 			break;
    1295. 

  1295. 		}
    1296. 

  1296. 		case XML_PI_NODE:
    1297. 

  1297. 		{
    1298. 

  1298. 			ce = dom_processinginstruction_class_entry;
    1299. 

  1299. 			break;
    1300. 

  1300. 		}
    1301. 

  1301. 		case XML_ENTITY_REF_NODE:
    1302. 

  1302. 		{
    1303. 

  1303. 			ce = dom_entityreference_class_entry;
    1304. 

  1304. 			break;
    1305. 

  1305. 		}
    1306. 

  1306. 		case XML_ENTITY_DECL:
    1307. 

  1307. 		case XML_ELEMENT_DECL:
    1308. 

  1308. 		{
    1309. 

  1309. 			ce = dom_entity_class_entry;
    1310. 

  1310. 			break;
    1311. 

  1311. 		}
    1312. 

  1312. 		case XML_CDATA_SECTION_NODE:
    1313. 

  1313. 		{
    1314. 

  1314. 			ce = dom_cdatasection_class_entry;
    1315. 

  1315. 			break;
    1316. 

  1316. 		}
    1317. 

  1317. 		case XML_DOCUMENT_FRAG_NODE:
    1318. 

  1318. 		{
    1319. 

  1319. 			ce = dom_documentfragment_class_entry;
    1320. 

  1320. 			break;
    1321. 

  1321. 		}
    1322. 

  1322. 		case XML_NOTATION_NODE:
    1323. 

  1323. 		{
    1324. 

  1324. 			ce = dom_notation_class_entry;
    1325. 

  1325. 			break;
    1326. 

  1326. 		}
    1327. 

  1327. 		case XML_NAMESPACE_DECL:
    1328. 

  1328. 		{
    1329. 

  1329. 			ce = dom_namespace_node_class_entry;
    1330. 

  1330. 			break;
    1331. 

  1331. 		}
    1332. 

  1332. 		default:
    1333. 

  1333. 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d", Z_TYPE_P(obj));
    1334. 

  1334. 			ZVAL_NULL(wrapper);
    1335. 

  1335. 			return wrapper;
    1336. 

  1336. 	}
    1337. 

  1337. 

  1338. 	if (domobj && domobj->document) {
    1339. 

  1339. 		ce = dom_get_doc_classmap(domobj->document, ce TSRMLS_CC);
    1340. 

  1340. 	}
    1341. 

  1341. 	object_init_ex(wrapper, ce);
    1342. 

  1342. 

  1343. 	intern = (dom_object *)zend_objects_get_address(wrapper TSRMLS_CC);
    1344. 

  1344. 	if (obj->doc != NULL) {
    1345. 

  1345. 		if (domobj != NULL) {
    1346. 

  1346. 			intern->document = domobj->document;
    1347. 

  1347. 		}
    1348. 

  1348. 		php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc TSRMLS_CC);
    1349. 

  1349. 	}
    1350. 

  1350. 

  1351. 	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern TSRMLS_CC);
    1352. 

  1352. 	return (wrapper);
    1353. 

  1353. }
    1354. 

  1354. /* }}} end php_domobject_new */
    1355. 

  1355. 

  1356. void php_dom_create_implementation(zval **retval  TSRMLS_DC) {
    1357. 

  1357. 	object_init_ex(*retval, dom_domimplementation_class_entry);
    1358. 

  1358. }
    1359. 

  1359. 

  1360. /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
    1361. 

  1361. int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) 
    1362. 

  1362. {
    1363. 

  1363. 	xmlNodePtr nodep;
    1364. 

  1364. 

  1365.     if (parent == NULL || child == NULL || child->doc != parent->doc) {
    1366. 

  1366.         return SUCCESS;
    1367. 

  1367.     }
    1368. 

  1368. 

  1369. 	nodep = parent;
    1370. 

  1370. 

  1371. 	while (nodep) {
    1372. 

  1372. 		if (nodep == child) {
    1373. 

  1373. 			return FAILURE;
    1374. 

  1374. 		}
    1375. 

  1375. 		nodep = nodep->parent;
    1376. 

  1376. 	}
    1377. 

  1377. 

  1378.     return SUCCESS;
    1379. 

  1379. }
    1380. 

  1380. /* }}} end dom_hierarchy */
    1381. 

  1381. 

  1382. /* {{{ dom_has_feature(char *feature, char *version) */
    1383. 

  1383. int dom_has_feature(char *feature, char *version)
    1384. 

  1384. {
    1385. 

  1385. 	int retval = 0;
    1386. 

  1386. 

  1387. 	if (!(strcmp (version, "1.0") && strcmp (version,"2.0") && strcmp(version, ""))) {
    1388. 

  1388. 		if ((!strcasecmp(feature, "Core") && !strcmp (version, "1.0")) || !strcasecmp(feature, "XML"))
    1389. 

  1389. 			retval = 1;
    1390. 

  1390. 	}
    1391. 

  1391. 

  1392. 	return retval;
    1393. 

  1393. }
    1394. 

  1394. /* }}} end dom_has_feature */
    1395. 

  1395. 

  1396. xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index) /* {{{ */
    1397. 

  1397. {
    1398. 

  1398. 	xmlNodePtr ret = NULL;
    1399. 

  1399. 

  1400. 	while (nodep != NULL && (*cur <= index || index == -1)) {
    1401. 

  1401. 		if (nodep->type == XML_ELEMENT_NODE) {
    1402. 

  1402. 			if (xmlStrEqual(nodep->name, (xmlChar *)local) || xmlStrEqual((xmlChar *)"*", (xmlChar *)local)) {
    1403. 

  1403. 				if (ns == NULL || (nodep->ns != NULL && (xmlStrEqual(nodep->ns->href, (xmlChar *)ns) || xmlStrEqual((xmlChar *)"*", (xmlChar *)ns)))) {
    1404. 

  1404. 					if (*cur == index) {
    1405. 

  1405. 						ret = nodep;
    1406. 

  1406. 						break;
    1407. 

  1407. 					}
    1408. 

  1408. 					(*cur)++;
    1409. 

  1409. 				}
    1410. 

  1410. 			}
    1411. 

  1411. 			ret = dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, cur, index);
    1412. 

  1412. 			if (ret != NULL) {
    1413. 

  1413. 				break;
    1414. 

  1414. 			}
    1415. 

  1415. 		}
    1416. 

  1416. 		nodep = nodep->next;
    1417. 

  1417. 	}
    1418. 

  1418. 	return ret;
    1419. 

  1419. }
    1420. 

  1420. /* }}} */
    1421. 

  1421. /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
    1422. 

  1422. 

  1423. /* {{{ void dom_normalize (xmlNodePtr nodep TSRMLS_DC) */
    1424. 

  1424. void dom_normalize (xmlNodePtr nodep TSRMLS_DC)
    1425. 

  1425. {
    1426. 

  1426. 	xmlNodePtr child, nextp, newnextp;
    1427. 

  1427. 	xmlAttrPtr attr;
    1428. 

  1428. 	xmlChar	*strContent; 
    1429. 

  1429. 

  1430. 	child = nodep->children;
    1431. 

  1431. 	while(child != NULL) {
    1432. 

  1432. 		switch (child->type) {
    1433. 

  1433. 			case XML_TEXT_NODE:
    1434. 

  1434. 				nextp = child->next;
    1435. 

  1435. 				while (nextp != NULL) {
    1436. 

  1436. 					if (nextp->type == XML_TEXT_NODE) {
    1437. 

  1437. 						newnextp = nextp->next;
    1438. 

  1438. 						strContent = xmlNodeGetContent(nextp);
    1439. 

  1439. 						xmlNodeAddContent(child, strContent);
    1440. 

  1440. 						xmlFree(strContent);
    1441. 

  1441. 						xmlUnlinkNode(nextp);
    1442. 

  1442. 						php_libxml_node_free_resource(nextp TSRMLS_CC);
    1443. 

  1443. 						nextp = newnextp;
    1444. 

  1444. 					} else {
    1445. 

  1445. 						break;
    1446. 

  1446. 					}
    1447. 

  1447. 				}
    1448. 

  1448. 				break;
    1449. 

  1449. 			case XML_ELEMENT_NODE:
    1450. 

  1450. 				dom_normalize (child TSRMLS_CC);
    1451. 

  1451. 				attr = child->properties;
    1452. 

  1452. 				while (attr != NULL) {
    1453. 

  1453. 					dom_normalize((xmlNodePtr) attr TSRMLS_CC);
    1454. 

  1454. 					attr = attr->next;
    1455. 

  1455. 				}
    1456. 

  1456. 				break;
    1457. 

  1457. 			case XML_ATTRIBUTE_NODE:
    1458. 

  1458. 				dom_normalize (child TSRMLS_CC);
    1459. 

  1459. 				break;
    1460. 

  1460. 			default:
    1461. 

  1461. 				break;
    1462. 

  1462. 		}
    1463. 

  1463. 		child = child->next;
    1464. 

  1464. 	}
    1465. 

  1465. }
    1466. 

  1466. /* }}} end dom_normalize */
    1467. 

  1467. 

  1468. 

  1469. /* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
    1470. 

  1470. void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
    1471. 

  1471. 	xmlNs *cur;
    1472. 

  1472. 

  1473. 	if (doc == NULL)
    1474. 

  1474. 		return;
    1475. 

  1475. 

  1476. 	if (doc->oldNs == NULL) {
    1477. 

  1477. 		doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
    1478. 

  1478. 		if (doc->oldNs == NULL) {
    1479. 

  1479. 			return;
    1480. 

  1480. 		}
    1481. 

  1481. 		memset(doc->oldNs, 0, sizeof(xmlNs));
    1482. 

  1482. 		doc->oldNs->type = XML_LOCAL_NAMESPACE;
    1483. 

  1483. 		doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE); 
    1484. 

  1484. 		doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml"); 
    1485. 

  1485. 	}
    1486. 

  1486. 

  1487. 	cur = doc->oldNs;
    1488. 

  1488. 	while (cur->next != NULL) {
    1489. 

  1489. 		cur = cur->next;
    1490. 

  1490. 	}
    1491. 

  1491. 	cur->next = ns;
    1492. 

  1492. }
    1493. 

  1493. /* }}} end dom_set_old_ns */
    1494. 

  1494. 

  1495. /*
    1496. 

  1496. http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
    1497. 

    1498. 

  1498. NAMESPACE_ERR: Raised if
    1499. 

    1500. 

  1500. 1. the qualifiedName is a malformed qualified name
    1501. 

  1501. 2. the qualifiedName has a prefix and the  namespaceURI is null
    1502. 

  1502. */
    1503. 

  1503. 

  1504. /* {{{ int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) */
    1505. 

  1505. int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
    1506. 

  1506. 	if (name_len == 0) {
    1507. 

  1507. 		return NAMESPACE_ERR;
    1508. 

  1508. 	}
    1509. 

  1509. 	
    1510. 

  1510. 	*localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
    1511. 

  1511. 	if (*localname == NULL) {
    1512. 

  1512. 		*localname = (char *)xmlStrdup((xmlChar *)qname);
    1513. 

  1513. 		if (*prefix == NULL && uri_len == 0) {
    1514. 

  1514. 			return 0;
    1515. 

  1515. 		}
    1516. 

  1516. 	}
    1517. 

  1517. 

  1518. 	/* 1 */
    1519. 

  1519. 	if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
    1520. 

  1520. 		return NAMESPACE_ERR;
    1521. 

  1521. 	}
    1522. 

  1522. 

  1523. 	/* 2 */
    1524. 

  1524. 	if (*prefix != NULL && uri_len == 0) {
    1525. 

  1525. 		return NAMESPACE_ERR;
    1526. 

  1526. 	}
    1527. 

  1527. 

  1528. 	return 0;
    1529. 

  1529. }
    1530. 

  1530. /* }}} */
    1531. 

  1531. 

  1532. /*
    1533. 

  1533. http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
    1534. 

    1535. 

  1535. NAMESPACE_ERR: Raised if
    1536. 

    1537. 

  1537. 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
    1538. 

  1538. 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from  "http://www.w3.org/2000/xmlns/"
    1539. 

  1539. 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the	qualifiedName nor its prefix is "xmlns".
    1540. 

  1540. */
    1541. 

  1541. 

  1542. /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
    1543. 

  1543. xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
    1544. 

  1544. 	xmlNsPtr nsptr = NULL;
    1545. 

  1545. 

  1546. 	*errorcode = 0;
    1547. 

  1547. 

  1548. 	if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
    1549. 

  1549. 		   (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
    1550. 

  1550. 		   (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
    1551. 

  1551. 		nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
    1552. 

  1552. 	}
    1553. 

  1553. 

  1554. 	if (nsptr == NULL) {
    1555. 

  1555. 		*errorcode = NAMESPACE_ERR;
    1556. 

  1556. 	}
    1557. 

  1557. 

  1558. 	return nsptr;
    1559. 

  1559. 

  1560. }
    1561. 

  1561. /* }}} end dom_get_ns */
    1562. 

  1562. 

  1563. /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
    1564. 

  1564. xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
    1565. 

  1565. 	xmlNsPtr cur;
    1566. 

  1566. 	xmlNs *ret = NULL;
    1567. 

  1567. 	if (node == NULL)
    1568. 

  1568. 		return NULL;
    1569. 

  1569. 

  1570. 	if (localName == NULL || xmlStrEqual(localName, (xmlChar *)"")) {
    1571. 

  1571. 		cur = node->nsDef;
    1572. 

  1572. 		while (cur != NULL) {
    1573. 

  1573. 			if (cur->prefix == NULL  && cur->href != NULL) {
    1574. 

  1574. 				ret = cur;
    1575. 

  1575. 				break;
    1576. 

  1576. 			}
    1577. 

  1577. 			cur = cur->next;
    1578. 

  1578. 		}
    1579. 

  1579. 	} else {
    1580. 

  1580. 		cur = node->nsDef;
    1581. 

  1581. 		while (cur != NULL) {
    1582. 

  1582. 			if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
    1583. 

  1583. 				ret = cur;
    1584. 

  1584. 				break;
    1585. 

  1585. 			}
    1586. 

  1586. 			cur = cur->next;
    1587. 

  1587. 		}
    1588. 

  1588. 	}
    1589. 

  1589. 	return ret;
    1590. 

  1590. }
    1591. 

  1591. /* }}} end dom_get_nsdecl */
    1592. 

  1592. 

  1593. #endif /* HAVE_DOM */
    1594. 

  1594. 

  1595. /*
    1596. 

  1596.  * Local variables:
    1597. 

  1597.  * tab-width: 4
    1598. 

  1598.  * c-basic-offset: 4
    1599. 

  1599.  * End:
    1600. 

  1600.  * vim600: noet sw=4 ts=4 fdm=marker
    1601. 

  1601.  * vim<600: noet sw=4 ts=4
    1602. 

  1602.  */
    1603. 

  1603.