diff options
Diffstat (limited to 'ext/xmlreader/php_xmlreader.c')
| -rw-r--r-- | ext/xmlreader/php_xmlreader.c | 879 |
1 files changed, 879 insertions, 0 deletions
diff --git a/ext/xmlreader/php_xmlreader.c b/ext/xmlreader/php_xmlreader.c new file mode 100644 index 0000000000..351da498d5 --- /dev/null +++ b/ext/xmlreader/php_xmlreader.c @@ -0,0 +1,879 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2004 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.0 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_0.txt. | + | 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. | + +----------------------------------------------------------------------+ + | Author: Rob Richards <rrichards@php.net> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php.h" +#include "php_ini.h" +#include "ext/standard/info.h" +#include "php_xmlreader.h" +#include <libxml/uri.h> + +zend_class_entry *xmlreader_class_entry; + +static zend_object_handlers xmlreader_object_handlers; + +static HashTable xmlreader_prop_handlers; + +typedef int (*xmlreader_read_int_t)(xmlTextReaderPtr reader); +typedef unsigned char *(*xmlreader_read_char_t)(xmlTextReaderPtr reader); +typedef int (*xmlreader_write_t)(xmlreader_object *obj, zval *newval TSRMLS_DC); + +typedef unsigned char *(*xmlreader_read_one_char_t)(xmlTextReaderPtr reader, const unsigned char *); + +typedef struct _xmlreader_prop_handler { + xmlreader_read_int_t read_int_func; + xmlreader_read_char_t read_char_func; + xmlreader_write_t write_func; + int type; +} xmlreader_prop_handler; + +static void xmlreader_register_prop_handler(HashTable *prop_handler, char *name, xmlreader_read_int_t read_int_func, xmlreader_read_char_t read_char_func, int rettype TSRMLS_DC) +{ + xmlreader_prop_handler hnd; + + hnd.read_char_func = read_char_func; + hnd.read_int_func = read_int_func; + hnd.type = rettype; + zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(xmlreader_prop_handler), NULL); +} + +static int xmlreader_property_reader(xmlreader_object *obj, xmlreader_prop_handler *hnd, zval **retval TSRMLS_DC) +{ + char *retchar = NULL; + int retint = 0; + + if (obj->ptr != NULL) { + if (hnd->read_char_func) { + retchar = hnd->read_char_func(obj->ptr); + } else { + if (hnd->read_int_func) { + retint = hnd->read_int_func(obj->ptr); + if (retint == -1) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal libxml error returned"); + return FAILURE; + } + } + } + } + + ALLOC_ZVAL(*retval); + + switch (hnd->type) { + case IS_STRING: + if (retchar) { + ZVAL_STRING(*retval, retchar, 1); + xmlFree(retchar); + } else { + ZVAL_EMPTY_STRING(*retval); + } + break; + case IS_BOOL: + ZVAL_BOOL(*retval, retint); + break; + case IS_LONG: + ZVAL_LONG(*retval, retint); + break; + default: + ZVAL_NULL(*retval); + } + + return SUCCESS; +} + +/* {{{ xmlreader_read_property */ +zval *xmlreader_read_property(zval *object, zval *member, int type TSRMLS_DC) +{ + xmlreader_object *obj; + zval tmp_member; + zval *retval; + xmlreader_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 = (xmlreader_object *)zend_objects_get_address(object TSRMLS_CC); + + 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 = xmlreader_property_reader(obj, hnd, &retval TSRMLS_CC); + if (ret == SUCCESS) { + /* ensure we're creating a temporary variable */ + retval->refcount = 0; + } else { + retval = EG(uninitialized_zval_ptr); + } + } else { + std_hnd = zend_get_std_object_handlers(); + retval = std_hnd->read_property(object, member, type TSRMLS_CC); + } + + if (member == &tmp_member) { + zval_dtor(member); + } + return retval; +} +/* }}} */ + +/* {{{ xmlreader_write_property */ +void xmlreader_write_property(zval *object, zval *member, zval *value TSRMLS_DC) +{ + xmlreader_object *obj; + zval tmp_member; + xmlreader_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 = (xmlreader_object *)zend_objects_get_address(object TSRMLS_CC); + + 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) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot write to read-only property"); + } else { + std_hnd = zend_get_std_object_handlers(); + std_hnd->write_property(object, member, value TSRMLS_CC); + } + + if (member == &tmp_member) { + zval_dtor(member); + } +} +/* }}} */ + +/* {{{ xmlreader_module_entry + */ +zend_module_entry xmlreader_module_entry = { + STANDARD_MODULE_HEADER, + "xmlreader", + NULL, + PHP_MINIT(xmlreader), + PHP_MSHUTDOWN(xmlreader), + NULL, + NULL, + PHP_MINFO(xmlreader), + "0.1", /* Replace with version number for your extension */ + STANDARD_MODULE_PROPERTIES +}; +/* }}} */ + +#ifdef COMPILE_DL_XMLREADER +ZEND_GET_MODULE(xmlreader) +#endif + +/* {{{ xmlreader_objects_clone */ +void xmlreader_objects_clone(void *object, void **object_clone TSRMLS_DC) +{ + /* TODO */ +} +/* }}} */ + +static void xmlreader_free_resources(xmlreader_object *intern) { + if (intern) { + if (intern->input) { + xmlFreeParserInputBuffer(intern->input); + intern->input = NULL; + } + + if (intern->ptr) { + xmlFreeTextReader(intern->ptr); + intern->ptr = NULL; + } + } +} + +/* {{{ xmlreader_objects_free_storage */ +void xmlreader_objects_free_storage(void *object TSRMLS_DC) +{ + xmlreader_object *intern = (xmlreader_object *)object; + + zend_hash_destroy(intern->std.properties); + FREE_HASHTABLE(intern->std.properties); + + xmlreader_free_resources(intern); + + efree(object); +} +/* }}} */ + +/* {{{ xmlreader_objects_new */ +zend_object_value xmlreader_objects_new(zend_class_entry *class_type TSRMLS_DC) +{ + zend_object_value retval; + xmlreader_object *intern; + zval *tmp; + + intern = emalloc(sizeof(xmlreader_object)); + intern->std.ce = class_type; + intern->std.in_get = 0; + intern->std.in_set = 0; + intern->ptr = NULL; + intern->input = NULL; + intern->prop_handler = &xmlreader_prop_handlers; + + 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 *)); + retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) xmlreader_objects_free_storage, xmlreader_objects_clone TSRMLS_CC); + intern->handle = retval.handle; + retval.handlers = &xmlreader_object_handlers; + return retval; +} +/* }}} */ + +static void php_xmlreader_string_arg(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_one_char_t internal_function) { + zval *id; + int name_len = 0; + char *retchar = NULL; + xmlreader_object *intern; + char *name; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) { + return; + } + + if (!name_len) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument cannot be an empty string"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retchar = internal_function(intern->ptr, name); + } + if (retchar) { + RETVAL_STRING(retchar, 1); + xmlFree(retchar); + return; + } else { + RETVAL_EMPTY_STRING(); + } +} + +static void php_xmlreader_no_arg(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_int_t internal_function) { + zval *id; + int retval; + xmlreader_object *intern; + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = internal_function(intern->ptr); + if (retval == 1) { + RETURN_TRUE; + } + } + + RETURN_FALSE; +} + +/* This function not yet needed until some additional functions are implemented in libxml +static void php_xmlreader_no_arg_string(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_char_t internal_function) { + zval *id; + char *retchar = NULL; + xmlreader_object *intern; + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retchar = xmlTextReaderReadString(intern->ptr); + } + if (retchar) { + RETVAL_STRING(retchar, 1); + xmlFree(retchar); + return; + } else { + RETVAL_EMPTY_STRING(); + } +} +*/ + +/* {{{ proto boolean close() +Closes xmlreader - current frees resources until xmlTextReaderClose is fixed in libxml */ +PHP_METHOD(xmlreader, close) +{ + zval *id; + xmlreader_object *intern; + + id = getThis(); + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + /* libxml is segfaulting in versions up to 2.6.8 using xmlTextReaderClose so for + now we will free the whole reader when close is called as it would get rebuilt on + a new load anyways */ + xmlreader_free_resources(intern); + + RETURN_TRUE; +} + +/* {{{ proto string getAttribute(string name) +Get value of an attribute from current element */ +PHP_METHOD(xmlreader, getAttribute) +{ + php_xmlreader_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderGetAttribute); +} +/* }}} */ + +/* {{{ proto string getAttributeNo(int index) +Get value of an attribute at index from current element */ +PHP_METHOD(xmlreader, getAttributeNo) +{ + zval *id; + int attr_pos; + char *retchar = NULL; + xmlreader_object *intern; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr_pos) == FAILURE) { + return; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retchar = xmlTextReaderGetAttributeNo(intern->ptr,attr_pos); + } + if (retchar) { + RETVAL_STRING(retchar, 1); + xmlFree(retchar); + return; + } else { + RETURN_EMPTY_STRING(); + } +} +/* }}} */ + +/* {{{ proto string getAttributeNs(string name, string namespaceURI) +Get value of a attribute via name and namespace from current element */ +PHP_METHOD(xmlreader, getAttributeNs) +{ + zval *id; + int name_len = 0, ns_uri_len = 0; + xmlreader_object *intern; + char *name, *ns_uri, *retchar = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &ns_uri, &ns_uri_len) == FAILURE) { + return; + } + + if (name_len == 0 || ns_uri_len == 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute Name and Namespace URI cannot be empty"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retchar = xmlTextReaderGetAttributeNs(intern->ptr, name, ns_uri); + } + if (retchar) { + RETVAL_STRING(retchar, 1); + xmlFree(retchar); + return; + } else { + RETURN_EMPTY_STRING(); + } +} +/* }}} */ + +/* {{{ proto boolean getParserProperty(int property) +Indicates wether given property (one of the parser option constants) is set or not on parser */ +PHP_METHOD(xmlreader, getParserProperty) +{ + zval *id; + int property, retval = -1; + xmlreader_object *intern; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &property) == FAILURE) { + return; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = xmlTextReaderGetParserProp(intern->ptr,property); + } + if (retval == -1) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parser property"); + RETURN_FALSE; + } + + RETURN_BOOL(retval); +} +/* }}} */ + +/* {{{ proto boolean isValid() +Returns boolean indicating if parsed document is valid or not. +Must set XMLREADER_LOADDTD or XMLREADER_VALIDATE parser option prior to the first call to read +or this method will always return FALSE */ +PHP_METHOD(xmlreader, isValid) +{ + php_xmlreader_no_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderIsValid); +} +/* }}} */ + +/* {{{ proto string lookupNamespace(string prefix) +Return namespaceURI for associated prefix on current node */ +PHP_METHOD(xmlreader, lookupNamespace) +{ + php_xmlreader_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderLookupNamespace); +} +/* }}} */ + +/* {{{ proto boolean moveToAttribute(string name) +Positions reader at specified attribute - Returns TRUE on success and FALSE on failure */ +PHP_METHOD(xmlreader, moveToAttribute) +{ + zval *id; + int name_len = 0, retval; + xmlreader_object *intern; + char *name; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) { + return; + } + + if (name_len == 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute Name is required"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = xmlTextReaderMoveToAttribute(intern->ptr, name); + if (retval == 1) { + RETURN_TRUE; + } + } + + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto boolean moveToAttributeNo(int index) +Positions reader at attribute at spcecified index. +Returns TRUE on success and FALSE on failure */ +PHP_METHOD(xmlreader, moveToAttributeNo) +{ + zval *id; + int attr_pos, retval; + xmlreader_object *intern; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr_pos) == FAILURE) { + return; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = xmlTextReaderMoveToAttributeNo(intern->ptr, attr_pos); + if (retval == 1) { + RETURN_TRUE; + } + } + + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto boolean moveToAttributeNs(string name, string namespaceURI) +Positions reader at attribute spcified by name and namespaceURI. +Returns TRUE on success and FALSE on failure */ +PHP_METHOD(xmlreader, moveToAttributeNs) +{ + zval *id; + int name_len=0, ns_uri_len=0, retval; + xmlreader_object *intern; + char *name, *ns_uri; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &name, &name_len, &ns_uri, &ns_uri_len) == FAILURE) { + return; + } + + if (name_len == 0 || ns_uri_len == 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attribute Name and Namespace URI cannot be empty"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = xmlTextReaderMoveToAttributeNs(intern->ptr, name, ns_uri); + if (retval == 1) { + RETURN_TRUE; + } + } + + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto boolean moveToElement() +Moves the position of the current instance to the node that contains the current Attribute node. */ +PHP_METHOD(xmlreader, moveToElement) +{ + php_xmlreader_no_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderMoveToElement); +} +/* }}} */ + +/* {{{ proto boolean moveToFirstAttribute() +Moves the position of the current instance to the first attribute associated with the current node. */ +PHP_METHOD(xmlreader, moveToFirstAttribute) +{ + php_xmlreader_no_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderMoveToFirstAttribute); +} +/* }}} */ + +/* {{{ proto boolean moveToNextAttribute() +Moves the position of the current instance to the next attribute associated with the current node. */ +PHP_METHOD(xmlreader, moveToNextAttribute) +{ + php_xmlreader_no_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderMoveToNextAttribute); +} +/* }}} */ + +/* {{{ proto boolean read() +Moves the position of the current instance to the next node in the stream. */ +PHP_METHOD(xmlreader, read) +{ + zval *id; + int retval; + xmlreader_object *intern; + + id = getThis(); + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern != NULL && intern->ptr != NULL) { + retval = xmlTextReaderRead(intern->ptr); + if (retval == -1) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "An Error Occured while reading"); + RETURN_FALSE; + } else { + RETURN_BOOL(retval); + } + } + + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Load Data before trying to read"); + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto boolean open(string URI) +Sets the URI that the the XMLReader will parse. */ +PHP_METHOD(xmlreader, open) +{ + zval *id; + int source_len = 0; + xmlreader_object *intern; + char *source; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &source, &source_len) == FAILURE) { + return; + } + + if (!source_len) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + + xmlreader_free_resources(intern); + + intern->ptr = xmlNewTextReaderFilename(source); + + if (intern->ptr == NULL) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open source data"); + RETURN_FALSE; + } + + RETURN_TRUE; + +} +/* }}} */ + +/* Not Yet Implemented in libxml - functions exist just not coded +PHP_METHOD(xmlreader, readInnerXml) +{ + php_xmlreader_no_arg_string(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderReadInnerXml); +} + +PHP_METHOD(xmlreader, readOuterXml) +{ + php_xmlreader_no_arg_string(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderReadInnerXml); +} + +PHP_METHOD(xmlreader, readString) +{ + php_xmlreader_no_arg_string(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextReaderReadString); +} + +PHP_METHOD(xmlreader, resetState) +{ + +} +*/ + +/* {{{ proto boolean setParserProperty(int property, boolean value) +Sets parser property (one of the parser option constants). +Properties must be set after open() or XML() and before the first read() is called */ +PHP_METHOD(xmlreader, setParserProperty) +{ + zval *id; + int property, value, retval = -1; + xmlreader_object *intern; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lb", &property, &value) == FAILURE) { + return; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + if (intern && intern->ptr) { + retval = xmlTextReaderSetParserProp(intern->ptr,property, value); + } + if (retval == -1) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parser property"); + RETURN_FALSE; + } + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto boolean XML(string source) +Sets the string that the the XMLReader will parse. */ +PHP_METHOD(xmlreader, XML) +{ + zval *id; + int source_len = 0; + xmlreader_object *intern; + char *source, *uri = NULL; + int resolved_path_len; + char *directory=NULL, resolved_path[MAXPATHLEN]; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &source, &source_len) == FAILURE) { + return; + } + + if (!source_len) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string supplied as input"); + RETURN_FALSE; + } + + id = getThis(); + + intern = (xmlreader_object *)zend_object_store_get_object(id TSRMLS_CC); + + xmlreader_free_resources(intern); + + intern->input = xmlParserInputBufferCreateMem(source, source_len, XML_CHAR_ENCODING_NONE); + + if (intern->input != NULL) { +/* Get the URI of the current script so that we can set the base directory in libxml */ +#if HAVE_GETCWD + directory = VCWD_GETCWD(resolved_path, MAXPATHLEN); +#elif HAVE_GETWD + directory = VCWD_GETWD(resolved_path); +#endif + if (directory) { + resolved_path_len = strlen(resolved_path); + if (resolved_path[resolved_path_len - 1] != DEFAULT_SLASH) { + resolved_path[resolved_path_len] = DEFAULT_SLASH; + resolved_path[++resolved_path_len] = '\0'; + } + uri = (char *) xmlCanonicPath((const xmlChar *) resolved_path); + } + intern->ptr = xmlNewTextReader(intern->input, uri); + if (uri) { + xmlFree(uri); + } + if (intern->ptr != NULL) { + RETURN_TRUE; + } + } + + xmlreader_free_resources(intern); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to load source data"); + RETURN_FALSE; +} +/* }}} */ + +static zend_function_entry xmlreader_functions[] = { + PHP_ME(xmlreader, close, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, getAttribute, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, getAttributeNo, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, getAttributeNs, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, getParserProperty, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, isValid, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, lookupNamespace, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToAttributeNo, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToAttribute, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToAttributeNs, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToElement, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToFirstAttribute, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, moveToNextAttribute, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, open, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, read, NULL, ZEND_ACC_PUBLIC) +/* Not Yet Implemented though defined in libxml as of 2.6.9dev + PHP_ME(xmlreader, readInnerXml, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, readOuterXml, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, readString, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, resetState, NULL, ZEND_ACC_PUBLIC) +*/ + PHP_ME(xmlreader, setParserProperty, NULL, ZEND_ACC_PUBLIC) + PHP_ME(xmlreader, XML, NULL, ZEND_ACC_PUBLIC) + {NULL, NULL, NULL} +}; + +/* {{{ PHP_MINIT_FUNCTION + */ +PHP_MINIT_FUNCTION(xmlreader) +{ + + zend_class_entry ce; + + memcpy(&xmlreader_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + xmlreader_object_handlers.read_property = xmlreader_read_property; + xmlreader_object_handlers.write_property = xmlreader_write_property; + xmlreader_object_handlers.get_property_ptr_ptr = NULL; + + INIT_CLASS_ENTRY(ce, "XMLReader", xmlreader_functions); + ce.create_object = xmlreader_objects_new; + xmlreader_class_entry = zend_register_internal_class(&ce TSRMLS_CC); + + zend_hash_init(&xmlreader_prop_handlers, 0, NULL, NULL, 1); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "attributeCount", xmlTextReaderAttributeCount, NULL, IS_LONG TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "baseURI", NULL, xmlTextReaderBaseUri, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "depth", xmlTextReaderDepth, NULL, IS_LONG TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "hasAttributes", xmlTextReaderHasAttributes, NULL, IS_BOOL TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "hasValue", xmlTextReaderHasValue, NULL, IS_BOOL TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "isDefault", xmlTextReaderIsDefault, NULL, IS_BOOL TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "isEmptyElement", xmlTextReaderIsEmptyElement, NULL, IS_BOOL TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "localName", NULL, xmlTextReaderLocalName, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "name", NULL, xmlTextReaderName, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "namespaceURI", NULL, xmlTextReaderNamespaceUri, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "nodeType", xmlTextReaderNodeType, NULL, IS_LONG TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "prefix", NULL, xmlTextReaderPrefix, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "value", NULL, xmlTextReaderValue, IS_STRING TSRMLS_CC); + xmlreader_register_prop_handler(&xmlreader_prop_handlers, "xmlLang", NULL, xmlTextReaderXmlLang, IS_STRING TSRMLS_CC); + + /* Constants for NodeType - cannot define common types to share with dom as there are differences in these types */ + REGISTER_LONG_CONSTANT("XMLREADER_NONE", XML_READER_TYPE_NONE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_ELEMENT", XML_READER_TYPE_ELEMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_ATTRIBUTE", XML_READER_TYPE_ATTRIBUTE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_TEXT", XML_READER_TYPE_TEXT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_CDATA", XML_READER_TYPE_CDATA, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_ENTITY_REF", XML_READER_TYPE_ENTITY_REFERENCE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_ENTITY", XML_READER_TYPE_ENTITY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_PI", XML_READER_TYPE_PROCESSING_INSTRUCTION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_COMMENT", XML_READER_TYPE_COMMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_DOC", XML_READER_TYPE_DOCUMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_DOC_TYPE", XML_READER_TYPE_DOCUMENT_TYPE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_DOC_FRAGMENT", XML_READER_TYPE_DOCUMENT_FRAGMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_NOTATION", XML_READER_TYPE_NOTATION, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_WHITESPACE", XML_READER_TYPE_WHITESPACE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_SIGNIFICANT_WHITESPACE", XML_READER_TYPE_SIGNIFICANT_WHITESPACE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_END_ELEMENT", XML_READER_TYPE_END_ELEMENT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_END_ENTITY", XML_READER_TYPE_END_ENTITY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_XML_DECLARATION", XML_READER_TYPE_XML_DECLARATION, CONST_CS | CONST_PERSISTENT); + + /* Constants for Parser options */ + REGISTER_LONG_CONSTANT("XMLREADER_LOADDTD", XML_PARSER_LOADDTD, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_DEFAULTATTRS", XML_PARSER_DEFAULTATTRS, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_VALIDATE", XML_PARSER_VALIDATE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_SUBST_ENTITIES", XML_PARSER_SUBST_ENTITIES, CONST_CS | CONST_PERSISTENT); + + /* Constants for Errors when loading - not yet used until we implement custom error handling + REGISTER_LONG_CONSTANT("XMLREADER_VALIDITY_WARNING", XML_PARSER_SEVERITY_VALIDITY_WARNING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_VALIDITY_ERROR", XML_PARSER_SEVERITY_VALIDITY_ERROR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_WARNING", XML_PARSER_SEVERITY_WARNING, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("XMLREADER_ERROR", XML_PARSER_SEVERITY_ERROR, CONST_CS | CONST_PERSISTENT); + */ + + return SUCCESS; +} +/* }}} */ + + +/* {{{ PHP_MSHUTDOWN_FUNCTION + */ +PHP_MSHUTDOWN_FUNCTION(xmlreader) +{ + zend_hash_destroy(&xmlreader_prop_handlers); + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MINFO_FUNCTION + */ +PHP_MINFO_FUNCTION(xmlreader) +{ + php_info_print_table_start(); + { + php_info_print_table_row(2, "XMLReader", "enabled"); + } + php_info_print_table_end(); + + /* Remove comments if you have entries in php.ini + DISPLAY_INI_ENTRIES(); + */ +} +/* }}} */ + +/* + * 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 + */ |