2003-06-05 17:06:52 +00:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| PHP Version 4 |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Copyright (c) 1997-2003 The PHP Group |
|
|
|
|
+----------------------------------------------------------------------+
|
2003-06-10 20:04:29 +00:00
|
|
|
| This source file is subject to version 3.0 of the PHP license, |
|
2003-06-05 17:06:52 +00:00
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
2003-06-10 20:04:29 +00:00
|
|
|
| available through the world-wide-web at the following url: |
|
|
|
|
| http://www.php.net/license/3_0.txt. |
|
2003-06-05 17:06:52 +00:00
|
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Authors: Christian Stocker <chregu@php.net> |
|
2003-06-09 20:20:55 +00:00
|
|
|
| Rob Richards <rrichards@php.net> |
|
2003-06-05 17:06:52 +00:00
|
|
|
| Marcus Borger <helly@php.net> |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* $Id$ */
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "php.h"
|
2003-08-22 15:04:29 +00:00
|
|
|
#if HAVE_LIBXML && HAVE_DOM
|
2003-06-05 17:06:52 +00:00
|
|
|
#include "ext/standard/php_rand.h"
|
|
|
|
#include "php_dom.h"
|
|
|
|
#include "dom_ce.h"
|
|
|
|
#include "dom_properties.h"
|
|
|
|
|
|
|
|
#include "ext/standard/info.h"
|
|
|
|
#define PHP_XPATH 1
|
|
|
|
#define PHP_XPTR 2
|
|
|
|
|
|
|
|
zend_object_handlers dom_object_handlers;
|
|
|
|
|
|
|
|
static HashTable classes;
|
|
|
|
|
|
|
|
static HashTable dom_domstringlist_prop_handlers;
|
|
|
|
static HashTable dom_namelist_prop_handlers;
|
|
|
|
static HashTable dom_domimplementationlist_prop_handlers;
|
|
|
|
static HashTable dom_document_prop_handlers;
|
|
|
|
static HashTable dom_node_prop_handlers;
|
|
|
|
static HashTable dom_nodelist_prop_handlers;
|
|
|
|
static HashTable dom_namednodemap_prop_handlers;
|
|
|
|
static HashTable dom_characterdata_prop_handlers;
|
|
|
|
static HashTable dom_attr_prop_handlers;
|
|
|
|
static HashTable dom_element_prop_handlers;
|
|
|
|
static HashTable dom_text_prop_handlers;
|
|
|
|
static HashTable dom_typeinfo_prop_handlers;
|
|
|
|
static HashTable dom_domerror_prop_handlers;
|
|
|
|
static HashTable dom_domlocator_prop_handlers;
|
|
|
|
static HashTable dom_documenttype_prop_handlers;
|
|
|
|
static HashTable dom_notation_prop_handlers;
|
|
|
|
static HashTable dom_entity_prop_handlers;
|
|
|
|
static HashTable dom_processinginstruction_prop_handlers;
|
2003-07-24 13:18:40 +00:00
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
static HashTable dom_xpath_prop_handlers;
|
|
|
|
#endif
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
typedef int (*dom_read_t)(dom_object *obj, zval **retval TSRMLS_DC);
|
|
|
|
typedef int (*dom_write_t)(dom_object *obj, zval *newval TSRMLS_DC);
|
|
|
|
|
|
|
|
typedef struct _dom_prop_handler {
|
|
|
|
dom_read_t read_func;
|
|
|
|
dom_write_t write_func;
|
|
|
|
} dom_prop_handler;
|
|
|
|
|
|
|
|
static zend_function_entry dom_functions[] = {
|
|
|
|
{NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2003-07-12 17:29:20 +00:00
|
|
|
/* {{{ int dom_node_is_read_only(xmlNodePtr node) */
|
|
|
|
int dom_node_is_read_only(xmlNodePtr node) {
|
|
|
|
switch (node->type) {
|
|
|
|
case XML_ENTITY_REF_NODE:
|
|
|
|
case XML_ENTITY_NODE:
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
case XML_NOTATION_NODE:
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_ELEMENT_DECL:
|
|
|
|
case XML_ATTRIBUTE_DECL:
|
|
|
|
case XML_ENTITY_DECL:
|
|
|
|
case XML_NAMESPACE_DECL:
|
|
|
|
return SUCCESS;
|
|
|
|
break;
|
|
|
|
default:
|
2003-08-24 10:23:43 +00:00
|
|
|
if (node->doc == NULL) {
|
|
|
|
return SUCCESS;
|
|
|
|
} else {
|
|
|
|
return FAILURE;
|
|
|
|
}
|
2003-07-12 17:29:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_node_is_read_only */
|
|
|
|
|
|
|
|
/* {{{ int dom_node_children_valid(xmlNodePtr node) */
|
|
|
|
int dom_node_children_valid(xmlNodePtr node) {
|
|
|
|
switch (node->type) {
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_PI_NODE:
|
|
|
|
case XML_COMMENT_NODE:
|
|
|
|
case XML_TEXT_NODE:
|
|
|
|
case XML_CDATA_SECTION_NODE:
|
|
|
|
return FAILURE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_node_children_valid */
|
2003-06-09 20:20:55 +00:00
|
|
|
|
2003-08-24 10:23:43 +00:00
|
|
|
int dom_get_strict_error(dom_ref_obj *document) {
|
|
|
|
if (document) {
|
|
|
|
return document->stricterror;
|
|
|
|
} else {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
/* {{{ int increment_document_reference(dom_object *object) */
|
2003-06-09 20:20:55 +00:00
|
|
|
int increment_document_reference(dom_object *object, xmlDocPtr docp TSRMLS_DC) {
|
|
|
|
int ret_refcount = -1;
|
|
|
|
|
|
|
|
if (object->document != NULL) {
|
|
|
|
object->document->refcount++;
|
|
|
|
ret_refcount = object->document->refcount;
|
|
|
|
} else if (docp != NULL) {
|
2003-07-07 19:37:32 +00:00
|
|
|
ret_refcount = 1;
|
2003-06-09 20:20:55 +00:00
|
|
|
object->document = emalloc(sizeof(dom_ref_obj));
|
|
|
|
object->document->ptr = docp;
|
2003-07-07 19:37:32 +00:00
|
|
|
object->document->refcount = ret_refcount;
|
2003-08-24 10:23:43 +00:00
|
|
|
object->document->stricterror = 1;
|
2003-06-09 20:20:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret_refcount;
|
|
|
|
}
|
|
|
|
/* }}} end increment_document_reference */
|
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
/* {{{ int decrement_document_reference(dom_object *object) */
|
2003-06-09 20:20:55 +00:00
|
|
|
int decrement_document_reference(dom_object *object TSRMLS_DC) {
|
|
|
|
int ret_refcount = -1;
|
|
|
|
|
|
|
|
if (object != NULL && object->document != NULL) {
|
|
|
|
object->document->refcount--;
|
|
|
|
ret_refcount = object->document->refcount;
|
|
|
|
if (ret_refcount == 0) {
|
2003-06-12 20:02:05 +00:00
|
|
|
if (object->document->ptr != NULL) {
|
|
|
|
xmlFreeDoc((xmlDoc *) object->document->ptr);
|
|
|
|
object->document->ptr = NULL;
|
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
efree(object->document);
|
|
|
|
}
|
2003-07-07 19:37:32 +00:00
|
|
|
object->document = NULL;
|
2003-06-09 20:20:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret_refcount;
|
|
|
|
}
|
|
|
|
/* }}} end decrement_document_reference */
|
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
/* {{{ int decrement_node_ptr(dom_object *object) */
|
|
|
|
int decrement_node_ptr(dom_object *object TSRMLS_DC) {
|
|
|
|
int ret_refcount = -1;
|
2003-07-24 13:18:40 +00:00
|
|
|
node_ptr *obj_node;
|
2003-07-07 19:37:32 +00:00
|
|
|
|
|
|
|
if (object != NULL && object->ptr != NULL) {
|
2003-07-24 13:18:40 +00:00
|
|
|
obj_node = (node_ptr *) object->ptr;
|
|
|
|
ret_refcount = --obj_node->refcount;
|
2003-07-07 19:37:32 +00:00
|
|
|
if (ret_refcount == 0) {
|
2003-07-24 13:18:40 +00:00
|
|
|
if (obj_node->node != NULL) {
|
|
|
|
obj_node->node->_private = NULL;
|
2003-07-07 19:37:32 +00:00
|
|
|
}
|
|
|
|
efree(object->ptr);
|
|
|
|
}
|
|
|
|
object->ptr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret_refcount;
|
|
|
|
}
|
|
|
|
/* }}} end decrement_node_ptr */
|
|
|
|
|
|
|
|
/* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
|
|
|
|
xmlNodePtr dom_object_get_node(dom_object *obj)
|
|
|
|
{
|
|
|
|
if (obj->ptr != NULL) {
|
2003-07-24 13:18:40 +00:00
|
|
|
return ((node_ptr *)obj->ptr)->node;
|
2003-07-07 19:37:32 +00:00
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_object_get_node */
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
/* {{{ dom_object_set_data */
|
2003-06-09 20:20:55 +00:00
|
|
|
static void dom_object_set_data(xmlNodePtr obj, dom_object *wrapper TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
2003-07-07 19:37:32 +00:00
|
|
|
if (wrapper == NULL) {
|
|
|
|
obj->_private = NULL;
|
|
|
|
} else {
|
|
|
|
obj->_private = wrapper->ptr;
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
/* }}} end dom_object_set_data */
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
/* {{{ dom_object *dom_object_get_data(xmlNodePtr obj) */
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_object *dom_object_get_data(xmlNodePtr obj)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
2003-07-07 19:37:32 +00:00
|
|
|
if (obj->_private != NULL) {
|
|
|
|
return (dom_object *) ((node_ptr *) obj->_private)->_private;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
/* }}} end dom_object_get_data */
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
/* {{{ php_dom_clear_object */
|
2003-06-09 20:20:55 +00:00
|
|
|
static void php_dom_clear_object(dom_object *object TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
2003-06-07 13:30:58 +00:00
|
|
|
if (object->prop_handler) {
|
|
|
|
object->prop_handler = NULL;
|
|
|
|
}
|
2003-07-07 19:37:32 +00:00
|
|
|
decrement_node_ptr(object TSRMLS_CC);
|
2003-06-09 20:20:55 +00:00
|
|
|
decrement_document_reference(object TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-07-07 19:37:32 +00:00
|
|
|
/* }}} end php_dom_clear_object */
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
/* {{{ void php_dom_set_object(dom_object *object, xmlNodePtr obj TSRMLS_DC) */
|
|
|
|
void php_dom_set_object(dom_object *object, xmlNodePtr obj TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
2003-07-24 13:18:40 +00:00
|
|
|
node_ptr *obj_node;
|
|
|
|
|
2003-07-07 19:37:32 +00:00
|
|
|
if (obj->_private == NULL) {
|
|
|
|
object->ptr = emalloc(sizeof(node_ptr));
|
2003-07-24 13:18:40 +00:00
|
|
|
obj_node = (node_ptr *)object->ptr;
|
|
|
|
obj_node->node = obj;
|
|
|
|
obj_node->refcount = 1;
|
|
|
|
obj_node->_private = object;
|
2003-07-07 19:37:32 +00:00
|
|
|
dom_object_set_data(obj, object TSRMLS_CC);
|
|
|
|
} else if (object->ptr == NULL) {
|
2003-07-24 13:18:40 +00:00
|
|
|
(node_ptr *)object->ptr = obj->_private;
|
|
|
|
obj_node = (node_ptr *)object->ptr;
|
|
|
|
obj_node->refcount++;
|
|
|
|
if (obj_node->_private == NULL) {
|
|
|
|
obj_node->_private = object;
|
2003-07-07 19:37:32 +00:00
|
|
|
}
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
/* }}} end php_dom_set_object */
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
/* {{{ dom_unregister_node */
|
|
|
|
void dom_unregister_node(xmlNodePtr nodep TSRMLS_DC)
|
|
|
|
{
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_object *wrapper;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
wrapper = dom_object_get_data(nodep);
|
|
|
|
if (wrapper != NULL ) {
|
|
|
|
php_dom_clear_object(wrapper TSRMLS_CC);
|
|
|
|
}
|
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
/* }}} end dom_unregister_node */
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
/* {{{ dom_read_na */
|
|
|
|
static int dom_read_na(dom_object *obj, zval **retval TSRMLS_DC)
|
|
|
|
{
|
|
|
|
*retval = NULL;
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_write_na */
|
|
|
|
static int dom_write_na(dom_object *obj, zval *newval TSRMLS_DC)
|
|
|
|
{
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot write property");
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_register_prop_handler */
|
|
|
|
static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_read_t read_func, dom_write_t write_func TSRMLS_DC)
|
|
|
|
{
|
|
|
|
dom_prop_handler hnd;
|
|
|
|
|
|
|
|
hnd.read_func = read_func ? read_func : dom_read_na;
|
|
|
|
hnd.write_func = write_func ? write_func : dom_write_na;
|
|
|
|
zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(dom_prop_handler), NULL);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_read_property */
|
2003-07-22 13:50:00 +00:00
|
|
|
zval *dom_read_property(zval *object, zval *member, zend_bool silent TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
|
|
|
dom_object *obj;
|
|
|
|
zval tmp_member;
|
|
|
|
zval *retval;
|
|
|
|
dom_prop_handler *hnd;
|
|
|
|
zend_object_handlers *std_hnd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (member->type != IS_STRING) {
|
|
|
|
tmp_member = *member;
|
|
|
|
zval_copy_ctor(&tmp_member);
|
|
|
|
convert_to_string(&tmp_member);
|
|
|
|
member = &tmp_member;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = FAILURE;
|
|
|
|
obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
|
2003-06-07 13:30:58 +00:00
|
|
|
|
|
|
|
if (obj->prop_handler != NULL) {
|
|
|
|
ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
|
|
|
|
}
|
|
|
|
if (ret == SUCCESS) {
|
|
|
|
ret = hnd->read_func(obj, &retval TSRMLS_CC);
|
2003-06-06 19:04:32 +00:00
|
|
|
if (ret == SUCCESS) {
|
2003-06-07 13:30:58 +00:00
|
|
|
/* ensure we're creating a temporary variable */
|
2003-08-18 23:13:25 +00:00
|
|
|
retval->refcount = 0;
|
2003-06-05 17:06:52 +00:00
|
|
|
} else {
|
2003-06-07 13:30:58 +00:00
|
|
|
retval = EG(uninitialized_zval_ptr);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
2003-06-07 13:30:58 +00:00
|
|
|
std_hnd = zend_get_std_object_handlers();
|
2003-07-22 13:50:00 +00:00
|
|
|
retval = std_hnd->read_property(object, member, silent TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-06-07 13:30:58 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
if (member == &tmp_member) {
|
|
|
|
zval_dtor(member);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_write_property */
|
|
|
|
void dom_write_property(zval *object, zval *member, zval *value TSRMLS_DC)
|
|
|
|
{
|
|
|
|
dom_object *obj;
|
|
|
|
zval tmp_member;
|
|
|
|
dom_prop_handler *hnd;
|
|
|
|
zend_object_handlers *std_hnd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (member->type != IS_STRING) {
|
|
|
|
tmp_member = *member;
|
|
|
|
zval_copy_ctor(&tmp_member);
|
|
|
|
convert_to_string(&tmp_member);
|
|
|
|
member = &tmp_member;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = FAILURE;
|
|
|
|
obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
|
2003-06-07 13:30:58 +00:00
|
|
|
|
|
|
|
if (obj->prop_handler != NULL) {
|
|
|
|
ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
|
|
|
|
}
|
|
|
|
if (ret == SUCCESS) {
|
|
|
|
hnd->write_func(obj, value TSRMLS_CC);
|
2003-08-24 10:23:43 +00:00
|
|
|
if (! PZVAL_IS_REF(value) && value->refcount == 0) {
|
|
|
|
value->refcount++;
|
|
|
|
zval_ptr_dtor(&value);
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
} else {
|
2003-06-07 13:30:58 +00:00
|
|
|
std_hnd = zend_get_std_object_handlers();
|
|
|
|
std_hnd->write_property(object, member, value TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
2003-06-07 13:30:58 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
if (member == &tmp_member) {
|
|
|
|
zval_dtor(member);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
zend_module_entry dom_module_entry = {
|
|
|
|
STANDARD_MODULE_HEADER,
|
|
|
|
"dom",
|
|
|
|
dom_functions,
|
|
|
|
PHP_MINIT(dom),
|
|
|
|
PHP_MSHUTDOWN(dom),
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
PHP_MINFO(dom),
|
|
|
|
DOM_API_VERSION, /* Extension versionnumber */
|
|
|
|
STANDARD_MODULE_PROPERTIES
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef COMPILE_DL_DOM
|
|
|
|
ZEND_GET_MODULE(dom)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* {{{ PHP_MINIT_FUNCTION(dom) */
|
|
|
|
PHP_MINIT_FUNCTION(dom)
|
|
|
|
{
|
|
|
|
zend_class_entry ce;
|
|
|
|
|
|
|
|
memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
|
|
|
|
dom_object_handlers.read_property = dom_read_property;
|
|
|
|
dom_object_handlers.write_property = dom_write_property;
|
|
|
|
|
|
|
|
zend_hash_init(&classes, 0, NULL, NULL, 1);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domexception", NULL, php_dom_domexception_class_functions, dom_domexception_class_entry);
|
|
|
|
REGISTER_DOM_CLASS(ce, "domstringlist", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domstringlist_prop_handlers, sizeof(dom_domstringlist_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domnamelist", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namelist_prop_handlers, sizeof(dom_namelist_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domimplementationlist", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domimplementationlist_prop_handlers, sizeof(dom_domimplementationlist_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domimplementationsource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
|
|
|
|
REGISTER_DOM_CLASS(ce, "domimplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domnode", NULL, php_dom_node_class_functions, dom_node_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_node_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", dom_node_child_nodes_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", dom_node_first_child_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", dom_node_last_child_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", dom_node_previous_sibling_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", dom_node_next_sibling_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "attributes", dom_node_attributes_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "prefix", dom_node_prefix_read, dom_node_prefix_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domdocumentfragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domdocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
|
|
|
|
zend_hash_init(&dom_document_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL TSRMLS_CC);
|
|
|
|
/* actualEncoding currently set as read only alias to encoding
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_actual_encoding_read, dom_document_actual_encoding_write TSRMLS_CC); */
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "encoding", dom_document_encoding_read, dom_document_encoding_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "standalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "version", dom_document_version_read, dom_document_version_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", dom_document_strict_error_checking_read, dom_document_strict_error_checking_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", dom_document_document_uri_read, dom_document_document_uri_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_document_prop_handlers, "config", dom_document_config_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_document_prop_handlers, sizeof(dom_document_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domnodelist", NULL, php_dom_nodelist_class_functions, dom_nodelist_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_nodelist_prop_handlers, sizeof(dom_nodelist_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domnamednodemap", NULL, php_dom_namednodemap_class_functions, dom_namednodemap_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namednodemap_prop_handlers, sizeof(dom_namednodemap_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domcharacterdata", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_characterdata_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domattr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_attr_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_attr_prop_handlers, sizeof(dom_attr_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domelement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_element_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_element_prop_handlers, sizeof(dom_element_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domtext", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, 1);
|
2003-06-07 15:07:42 +00:00
|
|
|
dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_text_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domcomment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domtypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_typeinfo_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domuserdatahandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
|
|
|
|
REGISTER_DOM_CLASS(ce, "domdomerror", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domerror_prop_handlers, sizeof(dom_domerror_prop_handlers), NULL);
|
|
|
|
|
2003-06-07 15:09:24 +00:00
|
|
|
REGISTER_DOM_CLASS(ce, "domerrorhandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
|
|
|
|
REGISTER_DOM_CLASS(ce, "domlocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domlocator_prop_handlers, sizeof(dom_domlocator_prop_handlers), NULL);
|
|
|
|
|
2003-06-07 15:09:24 +00:00
|
|
|
REGISTER_DOM_CLASS(ce, "domconfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
|
2003-06-05 17:06:52 +00:00
|
|
|
REGISTER_DOM_CLASS(ce, "domcdatasection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domdocumenttype", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_documenttype_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
|
|
|
|
|
2003-07-12 17:29:20 +00:00
|
|
|
REGISTER_DOM_CLASS(ce, "domnotation", NULL, php_dom_notation_class_functions, dom_notation_class_entry);
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
zend_hash_init(&dom_notation_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL TSRMLS_CC);
|
2003-07-12 17:29:20 +00:00
|
|
|
/* Notation nodes are special */
|
|
|
|
dom_register_prop_handler(&dom_notation_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_notation_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_notation_prop_handlers, "attributes", dom_node_attributes_read, NULL TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_notation_prop_handlers, sizeof(dom_notation_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domentity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_entity_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_entity_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domentityreference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domprocessinginstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL TSRMLS_CC);
|
|
|
|
dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write TSRMLS_CC);
|
|
|
|
zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_processinginstruction_prop_handlers, sizeof(dom_processinginstruction_prop_handlers), NULL);
|
|
|
|
|
|
|
|
REGISTER_DOM_CLASS(ce, "domstring_extend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
INIT_CLASS_ENTRY(ce, "domxpath", php_dom_xpath_class_functions);
|
|
|
|
ce.create_object = dom_xpath_objects_new;
|
|
|
|
dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
|
|
|
|
|
|
|
|
zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, 1);
|
|
|
|
dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL TSRMLS_CC);
|
|
|
|
zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_xpath_prop_handlers, sizeof(dom_xpath_prop_handlers), NULL);
|
|
|
|
#endif
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE", XML_ELEMENT_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NODE", XML_ATTRIBUTE_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_TEXT_NODE", XML_TEXT_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_CDATA_SECTION_NODE", XML_CDATA_SECTION_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ENTITY_REF_NODE", XML_ENTITY_REF_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ENTITY_NODE", XML_ENTITY_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_PI_NODE", XML_PI_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_COMMENT_NODE", XML_COMMENT_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_DOCUMENT_NODE", XML_DOCUMENT_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_DOCUMENT_TYPE_NODE", XML_DOCUMENT_TYPE_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_DOCUMENT_FRAG_NODE", XML_DOCUMENT_FRAG_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_NOTATION_NODE", XML_NOTATION_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_HTML_DOCUMENT_NODE", XML_HTML_DOCUMENT_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_DTD_NODE", XML_DTD_NODE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ELEMENT_DECL_NODE", XML_ELEMENT_DECL, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_DECL_NODE", XML_ATTRIBUTE_DECL, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ENTITY_DECL_NODE", XML_ENTITY_DECL, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_NAMESPACE_DECL_NODE", XML_NAMESPACE_DECL, CONST_CS | CONST_PERSISTENT);
|
|
|
|
#ifdef XML_GLOBAL_NAMESPACE
|
|
|
|
REGISTER_LONG_CONSTANT("XML_GLOBAL_NAMESPACE", XML_GLOBAL_NAMESPACE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
#endif
|
|
|
|
REGISTER_LONG_CONSTANT("XML_LOCAL_NAMESPACE", XML_LOCAL_NAMESPACE, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_CDATA", XML_ATTRIBUTE_CDATA, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ID", XML_ATTRIBUTE_ID, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREF", XML_ATTRIBUTE_IDREF, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREFS", XML_ATTRIBUTE_IDREFS, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENTITY", XML_ATTRIBUTE_ENTITIES, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKEN", XML_ATTRIBUTE_NMTOKEN, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKENS", XML_ATTRIBUTE_NMTOKENS, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENUMERATION", XML_ATTRIBUTE_ENUMERATION, CONST_CS | CONST_PERSISTENT);
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NOTATION", XML_ATTRIBUTE_NOTATION, CONST_CS | CONST_PERSISTENT);
|
|
|
|
|
2003-06-14 18:15:50 +00:00
|
|
|
xmlInitParser();
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ */
|
|
|
|
PHP_MINFO_FUNCTION(dom)
|
|
|
|
{
|
|
|
|
php_info_print_table_start();
|
|
|
|
php_info_print_table_row(2, "DOM/XML", "enabled");
|
|
|
|
php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
|
2003-06-12 20:02:05 +00:00
|
|
|
php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
|
2003-06-05 17:06:52 +00:00
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
|
|
php_info_print_table_row(2, "HTML Support", "enabled");
|
|
|
|
#endif
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
php_info_print_table_row(2, "XPath Support", "enabled");
|
|
|
|
#endif
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED)
|
|
|
|
php_info_print_table_row(2, "XPointer Support", "enabled");
|
|
|
|
#endif
|
|
|
|
php_info_print_table_end();
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
PHP_MSHUTDOWN_FUNCTION(dom)
|
|
|
|
{
|
2003-06-14 18:15:50 +00:00
|
|
|
xmlCleanupParser();
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
zend_hash_destroy(&dom_domstringlist_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_namelist_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_domimplementationlist_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_document_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_node_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_nodelist_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_namednodemap_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_characterdata_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_attr_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_element_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_text_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_typeinfo_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_domerror_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_domlocator_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_documenttype_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_notation_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_entity_prop_handlers);
|
|
|
|
zend_hash_destroy(&dom_processinginstruction_prop_handlers);
|
2003-07-24 13:18:40 +00:00
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
zend_hash_destroy(&dom_xpath_prop_handlers);
|
|
|
|
#endif
|
2003-06-05 17:06:52 +00:00
|
|
|
zend_hash_destroy(&classes);
|
|
|
|
|
|
|
|
/* If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
|
|
|
|
uncomment the following line, this will tell you the amount of not freed memory
|
|
|
|
and the total used memory into apaches error_log */
|
|
|
|
/* xmlMemoryDump();*/
|
2003-07-27 20:21:36 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* {{{ node_list_unlink */
|
|
|
|
void node_list_unlink(xmlNodePtr node TSRMLS_DC)
|
|
|
|
{
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_object *wrapper;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
while (node != NULL) {
|
|
|
|
|
|
|
|
wrapper = dom_object_get_data(node);
|
|
|
|
|
|
|
|
if (wrapper != NULL ) {
|
|
|
|
xmlUnlinkNode(node);
|
|
|
|
} else {
|
|
|
|
node_list_unlink(node->children TSRMLS_CC);
|
|
|
|
|
|
|
|
switch (node->type) {
|
|
|
|
case XML_ATTRIBUTE_DECL:
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
case XML_ENTITY_DECL:
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
node_list_unlink((xmlNodePtr) node->properties TSRMLS_CC);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
node = node->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end node_list_unlink */
|
|
|
|
|
2003-06-07 13:30:58 +00:00
|
|
|
|
|
|
|
/* {{{ void dom_node_free(xmlNodePtr node) */
|
|
|
|
void dom_node_free(xmlNodePtr node)
|
|
|
|
{
|
|
|
|
if(node) {
|
2003-07-07 19:37:32 +00:00
|
|
|
if (node->_private != NULL) {
|
|
|
|
((node_ptr *) node->_private)->node = NULL;
|
|
|
|
}
|
2003-06-07 13:30:58 +00:00
|
|
|
switch (node->type) {
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
|
|
|
xmlFreeProp((xmlAttrPtr) node);
|
|
|
|
break;
|
|
|
|
case XML_ENTITY_DECL:
|
2003-07-12 17:29:20 +00:00
|
|
|
case XML_ELEMENT_DECL:
|
|
|
|
case XML_ATTRIBUTE_DECL:
|
|
|
|
case XML_NAMESPACE_DECL:
|
|
|
|
/* These can never stand alone */
|
|
|
|
break;
|
|
|
|
case XML_NOTATION_NODE:
|
|
|
|
/* These require special handling */
|
|
|
|
if (node->name != NULL) {
|
|
|
|
xmlFree((char *) node->name);
|
|
|
|
}
|
|
|
|
if (((xmlEntityPtr) node)->ExternalID != NULL) {
|
|
|
|
xmlFree((char *) ((xmlEntityPtr) node)->ExternalID);
|
|
|
|
}
|
|
|
|
if (((xmlEntityPtr) node)->SystemID != NULL) {
|
|
|
|
xmlFree((char *) ((xmlEntityPtr) node)->SystemID);
|
|
|
|
}
|
|
|
|
xmlFree(node);
|
2003-06-07 13:30:58 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
xmlFreeNode(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_node_free */
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
/* {{{ node_free_list */
|
|
|
|
void node_free_list(xmlNodePtr node TSRMLS_DC)
|
|
|
|
{
|
|
|
|
xmlNodePtr curnode;
|
|
|
|
|
|
|
|
if (node != NULL) {
|
2003-06-06 19:04:32 +00:00
|
|
|
curnode = node;
|
2003-06-05 17:06:52 +00:00
|
|
|
while (curnode != NULL) {
|
|
|
|
node = curnode;
|
|
|
|
switch (node->type) {
|
|
|
|
/* Skip property freeing for the following types */
|
2003-07-12 17:29:20 +00:00
|
|
|
case XML_NOTATION_NODE:
|
|
|
|
break;
|
2003-06-07 13:30:58 +00:00
|
|
|
case XML_ENTITY_REF_NODE:
|
|
|
|
node_free_list((xmlNodePtr) node->properties TSRMLS_CC);
|
|
|
|
break;
|
2003-06-05 17:06:52 +00:00
|
|
|
case XML_ATTRIBUTE_DECL:
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
case XML_ENTITY_DECL:
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
2003-06-07 13:30:58 +00:00
|
|
|
node_free_list(node->children TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
break;
|
|
|
|
default:
|
2003-06-07 13:30:58 +00:00
|
|
|
node_free_list(node->children TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
node_free_list((xmlNodePtr) node->properties TSRMLS_CC);
|
|
|
|
}
|
|
|
|
|
2003-06-06 19:04:32 +00:00
|
|
|
curnode = node->next;
|
2003-06-05 17:06:52 +00:00
|
|
|
xmlUnlinkNode(node);
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_unregister_node(node TSRMLS_CC);
|
2003-06-07 13:30:58 +00:00
|
|
|
dom_node_free(node);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end node_free_list */
|
|
|
|
|
|
|
|
/* {{{ node_free_resource */
|
|
|
|
void node_free_resource(xmlNodePtr node TSRMLS_DC)
|
|
|
|
{
|
|
|
|
if (!node) {
|
|
|
|
return;
|
|
|
|
}
|
2003-06-05 18:54:25 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
switch (node->type) {
|
|
|
|
case XML_DOCUMENT_NODE:
|
|
|
|
case XML_HTML_DOCUMENT_NODE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (node->parent == NULL) {
|
|
|
|
node_free_list((xmlNodePtr) node->children TSRMLS_CC);
|
|
|
|
switch (node->type) {
|
|
|
|
/* Skip property freeing for the following types */
|
|
|
|
case XML_ATTRIBUTE_DECL:
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
case XML_ENTITY_DECL:
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
node_free_list((xmlNodePtr) node->properties TSRMLS_CC);
|
|
|
|
}
|
|
|
|
dom_unregister_node(node TSRMLS_CC);
|
2003-07-07 19:37:32 +00:00
|
|
|
dom_node_free(node);
|
2003-06-05 17:06:52 +00:00
|
|
|
} else {
|
2003-06-06 19:04:32 +00:00
|
|
|
dom_unregister_node(node TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_objects_clone */
|
|
|
|
void dom_objects_clone(void *object, void **object_clone TSRMLS_DC)
|
|
|
|
{
|
|
|
|
/* TODO */
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
/* {{{ dom_xpath_objects_dtor */
|
|
|
|
void dom_xpath_objects_dtor(void *object, zend_object_handle handle TSRMLS_DC)
|
|
|
|
{
|
|
|
|
dom_object *intern = (dom_object *)object;
|
|
|
|
|
|
|
|
zend_hash_destroy(intern->std.properties);
|
|
|
|
FREE_HASHTABLE(intern->std.properties);
|
|
|
|
|
|
|
|
if (intern->ptr != NULL) {
|
|
|
|
xmlXPathFreeContext((xmlXPathContextPtr) intern->ptr);
|
|
|
|
decrement_document_reference((dom_object *) intern TSRMLS_CC);
|
|
|
|
intern->ptr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
efree(object);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
#endif
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
/* {{{ dom_objects_dtor */
|
|
|
|
void dom_objects_dtor(void *object, zend_object_handle handle TSRMLS_DC)
|
|
|
|
{
|
|
|
|
dom_object *intern = (dom_object *)object;
|
2003-06-09 20:20:55 +00:00
|
|
|
int retcount;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
zend_hash_destroy(intern->std.properties);
|
|
|
|
FREE_HASHTABLE(intern->std.properties);
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
if (intern->ptr != NULL && ((node_ptr *)intern->ptr)->node != NULL) {
|
|
|
|
if (((xmlNodePtr) ((node_ptr *)intern->ptr)->node)->type != XML_DOCUMENT_NODE && ((xmlNodePtr) ((node_ptr *)intern->ptr)->node)->type != XML_HTML_DOCUMENT_NODE) {
|
2003-07-07 19:37:32 +00:00
|
|
|
node_free_resource(dom_object_get_node(intern) TSRMLS_CC);
|
2003-06-09 20:20:55 +00:00
|
|
|
} else {
|
2003-07-07 19:37:32 +00:00
|
|
|
decrement_node_ptr(intern TSRMLS_CC);
|
2003-06-09 20:20:55 +00:00
|
|
|
retcount = decrement_document_reference(intern TSRMLS_CC);
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
intern->ptr = NULL;
|
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
efree(object);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
/* {{{ dom_objects_set_class */
|
|
|
|
static dom_object* dom_objects_set_class(zend_class_entry *class_type TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
|
|
|
zend_class_entry *base_class;
|
|
|
|
zval *tmp;
|
2003-07-24 13:18:40 +00:00
|
|
|
dom_object *intern;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
intern = emalloc(sizeof(dom_object));
|
|
|
|
intern->std.ce = class_type;
|
|
|
|
intern->std.in_get = 0;
|
|
|
|
intern->std.in_set = 0;
|
|
|
|
intern->ptr = NULL;
|
|
|
|
intern->prop_handler = NULL;
|
2003-06-07 13:30:58 +00:00
|
|
|
intern->document = NULL;
|
2003-07-24 13:18:40 +00:00
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
base_class = class_type;
|
|
|
|
while(base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
|
|
|
|
base_class = base_class->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
zend_hash_find(&classes, base_class->name , base_class->name_length + 1, (void **) &intern->prop_handler);
|
|
|
|
|
|
|
|
ALLOC_HASHTABLE(intern->std.properties);
|
|
|
|
zend_hash_init(intern->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
|
|
|
|
zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
return intern;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ dom_objects_new */
|
|
|
|
zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
|
|
|
|
{
|
|
|
|
zend_object_value retval;
|
|
|
|
dom_object *intern;
|
|
|
|
|
|
|
|
intern = dom_objects_set_class(class_type TSRMLS_CC);
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
retval.handle = zend_objects_store_put(intern, dom_objects_dtor, dom_objects_clone TSRMLS_CC);
|
2003-06-09 20:20:55 +00:00
|
|
|
intern->handle = retval.handle;
|
2003-06-05 17:06:52 +00:00
|
|
|
retval.handlers = &dom_object_handlers;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-07-24 13:18:40 +00:00
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
|
|
/* {{{ zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC) */
|
|
|
|
zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
|
|
|
|
{
|
|
|
|
zend_object_value retval;
|
|
|
|
dom_object *intern;
|
|
|
|
|
|
|
|
intern = dom_objects_set_class(class_type TSRMLS_CC);
|
|
|
|
|
|
|
|
retval.handle = zend_objects_store_put(intern, dom_xpath_objects_dtor, dom_objects_clone TSRMLS_CC);
|
|
|
|
intern->handle = retval.handle;
|
|
|
|
retval.handlers = &dom_object_handlers;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* {{{ php_dom_create_object */
|
2003-06-09 20:20:55 +00:00
|
|
|
zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *wrapper_in, zval *return_value, dom_object *domobj TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
|
|
|
zval *wrapper;
|
|
|
|
zend_class_entry *ce;
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_object *intern;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
*found = 0;
|
|
|
|
|
|
|
|
if (!obj) {
|
2003-06-09 20:20:55 +00:00
|
|
|
ALLOC_ZVAL(wrapper);
|
2003-06-05 17:06:52 +00:00
|
|
|
ZVAL_NULL(wrapper);
|
|
|
|
return wrapper;
|
|
|
|
}
|
|
|
|
|
2003-06-09 20:20:55 +00:00
|
|
|
if ((intern = (dom_object *) dom_object_get_data((void *) obj))) {
|
|
|
|
return_value->type = IS_OBJECT;
|
|
|
|
return_value->is_ref = 1;
|
|
|
|
return_value->value.obj.handle = intern->handle;
|
|
|
|
return_value->value.obj.handlers = &dom_object_handlers;
|
|
|
|
zval_copy_ctor(return_value);
|
|
|
|
*found = 1;
|
|
|
|
return return_value;
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
|
2003-06-09 20:20:55 +00:00
|
|
|
wrapper = return_value;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
|
|
|
switch (obj->type) {
|
|
|
|
case XML_DOCUMENT_NODE:
|
|
|
|
case XML_HTML_DOCUMENT_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_document_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_DTD_NODE:
|
|
|
|
case XML_DOCUMENT_TYPE_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_documenttype_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_ELEMENT_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_element_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_attr_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_TEXT_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_text_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_COMMENT_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_comment_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_PI_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_processinginstruction_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_ENTITY_REF_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_entityreference_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_ENTITY_DECL:
|
|
|
|
case XML_ELEMENT_DECL:
|
|
|
|
{
|
|
|
|
ce = dom_entity_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_CDATA_SECTION_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_cdatasection_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_DOCUMENT_FRAG_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_documentfragment_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XML_NOTATION_NODE:
|
|
|
|
{
|
|
|
|
ce = dom_notation_class_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d\n", Z_TYPE_P(obj));
|
|
|
|
ZVAL_NULL(wrapper);
|
|
|
|
return wrapper;
|
|
|
|
}
|
|
|
|
|
2003-06-09 20:20:55 +00:00
|
|
|
object_init_ex(wrapper, ce);
|
2003-06-12 20:02:05 +00:00
|
|
|
/* Add object properties not needing function calls */
|
|
|
|
if (obj->type == XML_DOCUMENT_NODE || obj->type == XML_HTML_DOCUMENT_NODE) {
|
2003-07-10 11:17:25 +00:00
|
|
|
add_domdocument_properties(wrapper TSRMLS_CC);
|
2003-06-12 20:02:05 +00:00
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
intern = (dom_object *)zend_objects_get_address(wrapper TSRMLS_CC);
|
|
|
|
if (obj->doc != NULL) {
|
|
|
|
if (domobj != NULL) {
|
|
|
|
intern->document = domobj->document;
|
|
|
|
}
|
|
|
|
increment_document_reference(intern, obj->doc TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
|
2003-06-09 20:20:55 +00:00
|
|
|
php_dom_set_object(intern, (void *) obj TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
return (wrapper);
|
|
|
|
}
|
|
|
|
/* }}} end php_domobject_new */
|
|
|
|
|
|
|
|
|
|
|
|
void php_dom_create_implementation(zval **retval TSRMLS_DC) {
|
|
|
|
object_init_ex(*retval, dom_domimplementation_class_entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
|
|
|
|
int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child)
|
|
|
|
{
|
|
|
|
xmlNodePtr nodep;
|
|
|
|
|
|
|
|
if (parent == NULL || child == NULL || child->doc != parent->doc) {
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
nodep = parent;
|
|
|
|
|
|
|
|
while (nodep) {
|
|
|
|
if (nodep == child) {
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
nodep = nodep->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
/* }}} end dom_hierarchy */
|
|
|
|
|
2003-06-12 20:02:05 +00:00
|
|
|
/* {{{ dom_has_feature(char *feature, char *version) */
|
|
|
|
int dom_has_feature(char *feature, char *version)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
if (!(strcmp (version, "1.0") && strcmp (version,"2.0") && strcmp(version, ""))) {
|
|
|
|
if ((!strcasecmp(feature, "Core") && strcmp (version, "1.0")) || !strcasecmp(feature, "XML"))
|
|
|
|
retval = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
/* }}} end dom_has_feature */
|
|
|
|
|
2003-06-05 17:06:52 +00:00
|
|
|
/* {{{ void dom_element_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, zval **retval TSRMLS_DC) */
|
2003-06-09 20:20:55 +00:00
|
|
|
void dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, zval **retval, dom_object *intern TSRMLS_DC)
|
2003-06-05 17:06:52 +00:00
|
|
|
{
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_object *wrapper;
|
2003-06-05 17:06:52 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
while (nodep != NULL) {
|
|
|
|
if (nodep->type == XML_ELEMENT_NODE && xmlStrEqual(nodep->name, local)) {
|
|
|
|
if (ns == NULL || (nodep->ns != NULL && xmlStrEqual(nodep->ns->href, ns))) {
|
|
|
|
zval *child = NULL;
|
|
|
|
wrapper = dom_object_get_data(nodep);
|
|
|
|
if (wrapper == NULL) {
|
|
|
|
MAKE_STD_ZVAL(child);
|
|
|
|
}
|
|
|
|
|
2003-06-09 20:20:55 +00:00
|
|
|
child = php_dom_create_object(nodep, &ret, NULL, child, intern TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
add_next_index_zval(*retval, child);
|
|
|
|
}
|
|
|
|
}
|
2003-06-09 20:20:55 +00:00
|
|
|
dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, retval, intern TSRMLS_CC);
|
2003-06-05 17:06:52 +00:00
|
|
|
nodep = nodep->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_element_get_elements_by_tag_name_ns_raw */
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ void dom_normalize (xmlNodePtr nodep TSRMLS_DC) */
|
|
|
|
void dom_normalize (xmlNodePtr nodep TSRMLS_DC)
|
|
|
|
{
|
2003-08-20 18:58:03 +00:00
|
|
|
xmlNodePtr child, nextp, newnextp;
|
2003-06-05 17:06:52 +00:00
|
|
|
xmlAttrPtr attr;
|
|
|
|
xmlChar *strContent;
|
|
|
|
|
|
|
|
child = nodep->children;
|
|
|
|
while(child != NULL) {
|
|
|
|
switch (child->type) {
|
|
|
|
case XML_TEXT_NODE:
|
|
|
|
nextp = child->next;
|
|
|
|
while (nextp != NULL) {
|
|
|
|
if (nextp->type == XML_TEXT_NODE) {
|
2003-08-20 18:58:03 +00:00
|
|
|
newnextp = nextp->next;
|
2003-06-05 17:06:52 +00:00
|
|
|
strContent = xmlNodeGetContent(nextp);
|
|
|
|
xmlNodeAddContent(child, strContent);
|
|
|
|
xmlFree(strContent);
|
|
|
|
xmlUnlinkNode(nextp);
|
|
|
|
node_free_resource(nextp TSRMLS_CC);
|
2003-08-20 18:58:03 +00:00
|
|
|
nextp = newnextp;
|
|
|
|
} else {
|
|
|
|
break;
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case XML_ELEMENT_NODE:
|
|
|
|
dom_normalize (child TSRMLS_CC);
|
|
|
|
attr = child->properties;
|
|
|
|
while (attr != NULL) {
|
|
|
|
dom_normalize((xmlNodePtr) attr TSRMLS_CC);
|
|
|
|
attr = attr->next;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case XML_ATTRIBUTE_NODE:
|
|
|
|
dom_normalize (child TSRMLS_CC);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
child = child->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} end dom_normalize */
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
|
|
|
|
void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
|
|
|
|
xmlNs *cur;
|
|
|
|
|
|
|
|
if (doc == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (doc->oldNs == NULL) {
|
|
|
|
doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
|
|
|
|
if (doc->oldNs == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memset(doc->oldNs, 0, sizeof(xmlNs));
|
|
|
|
doc->oldNs->type = XML_LOCAL_NAMESPACE;
|
|
|
|
doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE);
|
|
|
|
doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml");
|
|
|
|
}
|
|
|
|
|
|
|
|
cur = doc->oldNs;
|
|
|
|
while (cur->next != NULL) {
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
cur->next = ns;
|
|
|
|
}
|
|
|
|
/* }}} end dom_set_old_ns */
|
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
|
|
|
|
int errorcode = 0;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
if (uri_len > 0 && name_len > 0) {
|
|
|
|
*localname = xmlSplitQName2(qname, (xmlChar **) prefix);
|
|
|
|
if (*localname == NULL) {
|
|
|
|
*localname = xmlStrdup(qname);
|
|
|
|
}
|
|
|
|
if (*localname == NULL || (xmlStrchr(*localname, (xmlChar) ':') != NULL)) {
|
|
|
|
errorcode = NAMESPACE_ERR;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
errorcode = NAMESPACE_ERR;
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
return errorcode;
|
|
|
|
}
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
/* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
|
|
|
|
xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
|
|
|
|
xmlNsPtr nsptr = NULL;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
*errorcode = 0;
|
2003-06-05 17:06:52 +00:00
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
if (! (prefix && !strcmp (prefix, "xml") && strcmp(uri, XML_XML_NAMESPACE))) {
|
|
|
|
nsptr = xmlNewNs(nodep, uri, prefix);
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
|
2003-07-27 17:57:06 +00:00
|
|
|
if (nsptr == NULL) {
|
|
|
|
*errorcode = NAMESPACE_ERR;
|
2003-06-05 17:06:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nsptr;
|
|
|
|
|
|
|
|
}
|
|
|
|
/* }}} end dom_get_ns */
|
|
|
|
|
|
|
|
/* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
|
|
|
|
xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
|
|
|
|
xmlNsPtr cur;
|
|
|
|
xmlNs *ret = NULL;
|
|
|
|
if (node == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (localName == NULL || xmlStrEqual(localName, "")) {
|
|
|
|
cur = node->nsDef;
|
|
|
|
while (cur != NULL) {
|
|
|
|
if (cur->prefix == NULL) {
|
|
|
|
ret = cur;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cur = node->nsDef;
|
|
|
|
while (cur != NULL) {
|
|
|
|
if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
|
|
|
|
ret = cur;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cur = cur->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* }}} end dom_get_nsdecl */
|
|
|
|
|
|
|
|
#endif /* HAVE_DOM */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* tab-width: 4
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* End:
|
|
|
|
* vim600: noet sw=4 ts=4 fdm=marker
|
|
|
|
* vim<600: noet sw=4 ts=4
|
|
|
|
*/
|