1999-04-22 10:48:28 +08:00
|
|
|
|
/*
|
|
|
|
|
+----------------------------------------------------------------------+
|
1999-07-16 21:13:16 +08:00
|
|
|
|
| PHP version 4.0 |
|
1999-04-22 10:48:28 +08:00
|
|
|
|
+----------------------------------------------------------------------+
|
2000-01-01 09:32:05 +08:00
|
|
|
|
| Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
|
1999-04-22 10:48:28 +08:00
|
|
|
|
+----------------------------------------------------------------------+
|
2000-05-18 23:34:45 +08:00
|
|
|
|
| This source file is subject to version 2.02 of the PHP license, |
|
1999-07-16 21:13:16 +08:00
|
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
|
|
|
| available at through the world-wide-web at |
|
2000-05-18 23:34:45 +08:00
|
|
|
|
| http://www.php.net/license/2_02.txt. |
|
1999-07-16 21:13:16 +08: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. |
|
1999-04-22 10:48:28 +08:00
|
|
|
|
+----------------------------------------------------------------------+
|
1999-05-21 18:06:25 +08:00
|
|
|
|
| Authors: Stig S<EFBFBD>ther Bakken <ssb@fast.no> |
|
2000-10-29 17:14:55 +08:00
|
|
|
|
| Thies C. Arntzen <thies@thieso.net> |
|
1999-04-22 10:48:28 +08:00
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* $Id$ */
|
|
|
|
|
#define IS_EXT_MODULE
|
1999-07-22 05:56:25 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
#include "php.h"
|
2000-02-11 02:03:55 +08:00
|
|
|
|
#define PHP_XML_INTERNAL
|
1999-12-05 03:19:57 +08:00
|
|
|
|
#include "php_xml.h"
|
1999-04-22 10:48:28 +08:00
|
|
|
|
#include "zend_variables.h"
|
1999-12-05 03:19:57 +08:00
|
|
|
|
#include "ext/standard/php_string.h"
|
2000-04-06 05:43:03 +08:00
|
|
|
|
#include "ext/standard/info.h"
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
#if HAVE_LIBEXPAT
|
|
|
|
|
|
2000-06-16 07:45:05 +08:00
|
|
|
|
#ifndef PHP_WIN32
|
1999-04-22 10:48:28 +08:00
|
|
|
|
# include "build-defs.h"
|
|
|
|
|
# endif
|
|
|
|
|
# include "ext/standard/head.h"
|
|
|
|
|
|
|
|
|
|
/* Short-term TODO list:
|
|
|
|
|
* - Implement XML_ExternalEntityParserCreate()
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Long-term TODO list:
|
|
|
|
|
* - Fix the expat library so you can install your own memory manager
|
|
|
|
|
* functions
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Known bugs:
|
|
|
|
|
* - Weird things happen with <![CDATA[]]> sections.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
#ifdef ZTS
|
|
|
|
|
int xml_globals_id;
|
|
|
|
|
#else
|
|
|
|
|
PHP_XML_API php_xml_globals xml_globals;
|
|
|
|
|
#endif
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
/* {{{ dynamically loadable module stuff */
|
|
|
|
|
|
2000-05-23 17:33:51 +08:00
|
|
|
|
#ifdef COMPILE_DL_XML
|
2000-05-02 08:30:36 +08:00
|
|
|
|
ZEND_GET_MODULE(xml)
|
1999-12-04 22:45:38 +08:00
|
|
|
|
#endif /* COMPILE_DL_XML */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ function prototypes */
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_MINIT_FUNCTION(xml);
|
|
|
|
|
PHP_RINIT_FUNCTION(xml);
|
|
|
|
|
PHP_MSHUTDOWN_FUNCTION(xml);
|
|
|
|
|
PHP_RSHUTDOWN_FUNCTION(xml);
|
|
|
|
|
PHP_MINFO_FUNCTION(xml);
|
1999-07-02 23:31:02 +08:00
|
|
|
|
|
2000-10-21 02:25:16 +08:00
|
|
|
|
static void xml_parser_dtor(zend_rsrc_list_entry *rsrc);
|
2000-08-23 03:32:07 +08:00
|
|
|
|
static void xml_set_handler(zval **, zval **);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
inline static unsigned short xml_encode_iso_8859_1(unsigned char);
|
|
|
|
|
inline static char xml_decode_iso_8859_1(unsigned short);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
inline static unsigned short xml_encode_us_ascii(unsigned char);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
inline static char xml_decode_us_ascii(unsigned short);
|
|
|
|
|
static XML_Char *xml_utf8_encode(const char *, int, int *, const XML_Char *);
|
2000-08-23 03:32:07 +08:00
|
|
|
|
static zval *xml_call_handler(xml_parser *, zval *, int, zval **);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
static zval *_xml_xmlchar_zval(const XML_Char *, int, const XML_Char *);
|
|
|
|
|
static int _xml_xmlcharlen(const XML_Char *);
|
|
|
|
|
static void _xml_add_to_info(xml_parser *parser,char *name);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_startElementHandler(void *, const char *, const char **);
|
|
|
|
|
void _xml_endElementHandler(void *, const char *);
|
|
|
|
|
void _xml_characterDataHandler(void *, const XML_Char *, int);
|
|
|
|
|
void _xml_processingInstructionHandler(void *, const XML_Char *, const XML_Char *);
|
|
|
|
|
void _xml_defaultHandler(void *, const XML_Char *, int);
|
|
|
|
|
void _xml_unparsedEntityDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
|
|
|
|
|
void _xml_notationDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
|
|
|
|
|
int _xml_externalEntityRefHandler(XML_Parser, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ extension definition structures */
|
|
|
|
|
|
2000-08-20 23:59:54 +08:00
|
|
|
|
static unsigned char third_and_fourth_args_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_FORCE, BYREF_FORCE };
|
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
function_entry xml_functions[] = {
|
|
|
|
|
PHP_FE(xml_parser_create, NULL)
|
2000-08-20 23:59:54 +08:00
|
|
|
|
PHP_FE(xml_set_object, second_arg_force_ref)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FE(xml_set_element_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_character_data_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_processing_instruction_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_default_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_unparsed_entity_decl_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_notation_decl_handler, NULL)
|
|
|
|
|
PHP_FE(xml_set_external_entity_ref_handler, NULL)
|
|
|
|
|
PHP_FE(xml_parse, NULL)
|
2000-08-20 23:59:54 +08:00
|
|
|
|
PHP_FE(xml_parse_into_struct, third_and_fourth_args_force_ref)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FE(xml_get_error_code, NULL)
|
|
|
|
|
PHP_FE(xml_error_string, NULL)
|
|
|
|
|
PHP_FE(xml_get_current_line_number, NULL)
|
|
|
|
|
PHP_FE(xml_get_current_column_number, NULL)
|
|
|
|
|
PHP_FE(xml_get_current_byte_index, NULL)
|
|
|
|
|
PHP_FE(xml_parser_free, NULL)
|
|
|
|
|
PHP_FE(xml_parser_set_option, NULL)
|
|
|
|
|
PHP_FE(xml_parser_get_option, NULL)
|
|
|
|
|
PHP_FE(utf8_encode, NULL)
|
|
|
|
|
PHP_FE(utf8_decode, NULL)
|
|
|
|
|
{NULL, NULL, NULL}
|
|
|
|
|
};
|
|
|
|
|
|
1999-12-18 04:55:31 +08:00
|
|
|
|
zend_module_entry xml_module_entry = {
|
2000-03-07 02:44:01 +08:00
|
|
|
|
"xml", /* extension name */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_functions, /* extension function list */
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_MINIT(xml), /* extension-wide startup function */
|
|
|
|
|
PHP_MSHUTDOWN(xml), /* extension-wide shutdown function */
|
|
|
|
|
PHP_RINIT(xml), /* per-request startup function */
|
|
|
|
|
PHP_RSHUTDOWN(xml), /* per-request shutdown function */
|
|
|
|
|
PHP_MINFO(xml), /* information function */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
STANDARD_MODULE_PROPERTIES
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* All the encoding functions are set to NULL right now, since all
|
|
|
|
|
* the encoding is currently done internally by expat/xmltok.
|
|
|
|
|
*/
|
|
|
|
|
xml_encoding xml_encodings[] = {
|
|
|
|
|
{ "ISO-8859-1", xml_decode_iso_8859_1, xml_encode_iso_8859_1 },
|
|
|
|
|
{ "US-ASCII", xml_decode_us_ascii, xml_encode_us_ascii },
|
|
|
|
|
{ "UTF-8", NULL, NULL },
|
|
|
|
|
{ NULL, NULL, NULL }
|
|
|
|
|
};
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
/* True globals, no need for thread safety */
|
|
|
|
|
static int le_xml_parser;
|
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ startup, shutdown and info functions */
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
#ifdef ZTS
|
|
|
|
|
static void php_xml_init_globals(php_xml_globals *xml_globals)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
1999-09-20 20:51:20 +08:00
|
|
|
|
XML(default_encoding) = "ISO-8859-1";
|
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-08-18 23:40:54 +08:00
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_MINIT_FUNCTION(xml)
|
|
|
|
|
{
|
2000-10-26 01:44:02 +08:00
|
|
|
|
le_xml_parser = zend_register_list_destructors_ex(xml_parser_dtor, NULL, "xml", module_number);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
#ifdef ZTS
|
1999-12-23 20:52:12 +08:00
|
|
|
|
xml_globals_id = ts_allocate_id(sizeof(php_xml_globals), (ts_allocate_ctor) php_xml_init_globals, NULL);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
#else
|
|
|
|
|
XML(default_encoding) = "ISO-8859-1";
|
|
|
|
|
#endif
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_NONE", XML_ERROR_NONE, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_NO_MEMORY", XML_ERROR_NO_MEMORY, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_SYNTAX", XML_ERROR_SYNTAX, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_NO_ELEMENTS", XML_ERROR_NO_ELEMENTS, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_INVALID_TOKEN", XML_ERROR_INVALID_TOKEN, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_TOKEN", XML_ERROR_UNCLOSED_TOKEN, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_PARTIAL_CHAR", XML_ERROR_PARTIAL_CHAR, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_TAG_MISMATCH", XML_ERROR_TAG_MISMATCH, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_DUPLICATE_ATTRIBUTE", XML_ERROR_DUPLICATE_ATTRIBUTE, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_JUNK_AFTER_DOC_ELEMENT", XML_ERROR_JUNK_AFTER_DOC_ELEMENT, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_PARAM_ENTITY_REF", XML_ERROR_PARAM_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_UNDEFINED_ENTITY", XML_ERROR_UNDEFINED_ENTITY, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_RECURSIVE_ENTITY_REF", XML_ERROR_RECURSIVE_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_ASYNC_ENTITY", XML_ERROR_ASYNC_ENTITY, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_BAD_CHAR_REF", XML_ERROR_BAD_CHAR_REF, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_BINARY_ENTITY_REF", XML_ERROR_BINARY_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF", XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_MISPLACED_XML_PI", XML_ERROR_MISPLACED_XML_PI, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_UNKNOWN_ENCODING", XML_ERROR_UNKNOWN_ENCODING, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_INCORRECT_ENCODING", XML_ERROR_INCORRECT_ENCODING, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_CDATA_SECTION", XML_ERROR_UNCLOSED_CDATA_SECTION, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_ERROR_EXTERNAL_ENTITY_HANDLING", XML_ERROR_EXTERNAL_ENTITY_HANDLING, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
|
1999-12-18 11:20:53 +08:00
|
|
|
|
REGISTER_LONG_CONSTANT("XML_OPTION_CASE_FOLDING", PHP_XML_OPTION_CASE_FOLDING, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_OPTION_TARGET_ENCODING", PHP_XML_OPTION_TARGET_ENCODING, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_TAGSTART", PHP_XML_OPTION_SKIP_TAGSTART, CONST_CS|CONST_PERSISTENT);
|
|
|
|
|
REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_WHITE", PHP_XML_OPTION_SKIP_WHITE, CONST_CS|CONST_PERSISTENT);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
return SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_RINIT_FUNCTION(xml)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
return SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_MSHUTDOWN_FUNCTION(xml)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
return SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_RSHUTDOWN_FUNCTION(xml)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
return SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
PHP_MINFO_FUNCTION(xml)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
2000-04-06 05:43:03 +08:00
|
|
|
|
|
|
|
|
|
php_info_print_table_start();
|
|
|
|
|
php_info_print_table_row(2, "XML Support", "active");
|
|
|
|
|
php_info_print_table_end();
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ extension-internal functions */
|
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
static zval *_xml_resource_zval(long value)
|
|
|
|
|
{
|
|
|
|
|
zval *ret;
|
|
|
|
|
MAKE_STD_ZVAL(ret);
|
|
|
|
|
|
|
|
|
|
ret->type = IS_RESOURCE;
|
|
|
|
|
ret->value.lval = value;
|
|
|
|
|
|
1999-10-07 20:27:40 +08:00
|
|
|
|
zend_list_addref(value);
|
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static zval *_xml_string_zval(const char *str)
|
|
|
|
|
{
|
|
|
|
|
zval *ret;
|
|
|
|
|
int len = strlen(str);
|
|
|
|
|
MAKE_STD_ZVAL(ret);
|
|
|
|
|
|
|
|
|
|
ret->type = IS_STRING;
|
|
|
|
|
ret->value.str.len = len;
|
|
|
|
|
ret->value.str.val = estrndup(str, len);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static zval *_xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding)
|
|
|
|
|
{
|
|
|
|
|
zval *ret;
|
|
|
|
|
MAKE_STD_ZVAL(ret);
|
|
|
|
|
|
|
|
|
|
if (s == NULL) {
|
|
|
|
|
var_reset(ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
if (len == 0) {
|
|
|
|
|
len = _xml_xmlcharlen(s);
|
|
|
|
|
}
|
|
|
|
|
ret->type = IS_STRING;
|
|
|
|
|
ret->value.str.val = xml_utf8_decode(s, len, &ret->value.str.len, encoding);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-12-06 00:43:42 +08:00
|
|
|
|
/* {{{ xml_parser_dtor() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
static void
|
2000-10-21 02:25:16 +08:00
|
|
|
|
xml_parser_dtor(zend_rsrc_list_entry *rsrc)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
2000-10-21 02:25:16 +08:00
|
|
|
|
xml_parser *parser = (xml_parser *)rsrc->ptr;
|
1999-12-06 00:43:42 +08:00
|
|
|
|
|
|
|
|
|
if (parser->object) {
|
|
|
|
|
zval_del_ref(&parser->object);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (parser->parser) {
|
|
|
|
|
XML_ParserFree(parser->parser);
|
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser->ltags) {
|
1999-10-20 22:02:32 +08:00
|
|
|
|
int inx;
|
|
|
|
|
for (inx = 0; inx < parser->level; inx++)
|
|
|
|
|
efree(parser->ltags[ inx ]);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
efree(parser->ltags);
|
|
|
|
|
}
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (parser->startElementHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->startElementHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->endElementHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->endElementHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->characterDataHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->characterDataHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->processingInstructionHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->processingInstructionHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->defaultHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->defaultHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->unparsedEntityDeclHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->unparsedEntityDeclHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->notationDeclHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->notationDeclHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->externalEntityRefHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->externalEntityRefHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->unknownEncodingHandler) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval_del_ref(&parser->unknownEncodingHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
if (parser->baseURI) {
|
|
|
|
|
efree(parser->baseURI);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
efree(parser);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_set_handler() */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-08-23 03:32:07 +08:00
|
|
|
|
xml_set_handler(zval **handler, zval **data)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
2000-08-23 03:32:07 +08:00
|
|
|
|
/* IS_ARRAY might indicate that we're using array($obj, 'method') syntax */
|
|
|
|
|
if (Z_TYPE_PP(data) != IS_ARRAY) {
|
|
|
|
|
convert_to_string_ex(data);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
2000-08-23 03:32:07 +08:00
|
|
|
|
|
|
|
|
|
zval_add_ref(data);
|
|
|
|
|
*handler = *data;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_call_handler() */
|
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
static zval *
|
2000-08-23 03:32:07 +08:00
|
|
|
|
xml_call_handler(xml_parser *parser, zval *handler, int argc, zval **argv)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
1999-05-27 09:34:18 +08:00
|
|
|
|
ELS_FETCH();
|
|
|
|
|
|
2000-08-23 03:32:07 +08:00
|
|
|
|
if (parser && handler) {
|
|
|
|
|
zval *retval;
|
1999-09-25 02:02:58 +08:00
|
|
|
|
int i;
|
|
|
|
|
int result;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
MAKE_STD_ZVAL(retval);
|
|
|
|
|
retval->type = IS_BOOL;
|
1999-10-07 20:27:40 +08:00
|
|
|
|
retval->value.lval = 0;
|
1999-09-25 02:02:58 +08:00
|
|
|
|
|
2000-12-24 05:46:44 +08:00
|
|
|
|
if (parser->object)
|
|
|
|
|
result = call_user_function(EG(function_table), &parser->object, handler, retval, argc, argv);
|
|
|
|
|
else
|
|
|
|
|
result = call_user_function(EG(function_table), NULL, handler, retval, argc, argv);
|
1999-09-25 02:02:58 +08:00
|
|
|
|
|
|
|
|
|
if (result == FAILURE) {
|
2000-08-23 03:32:07 +08:00
|
|
|
|
zval **method;
|
|
|
|
|
zval **obj;
|
|
|
|
|
|
|
|
|
|
if (Z_TYPE_P(handler) == IS_STRING) {
|
|
|
|
|
php_error(E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(handler));
|
|
|
|
|
} else if (zend_hash_index_find(handler->value.ht, 0, (void **) &obj) == SUCCESS &&
|
|
|
|
|
zend_hash_index_find(handler->value.ht, 1, (void **) &method) == SUCCESS &&
|
|
|
|
|
Z_TYPE_PP(obj) == IS_OBJECT &&
|
|
|
|
|
Z_TYPE_PP(method) == IS_STRING) {
|
|
|
|
|
php_error(E_WARNING, "Unable to call handler %s::%s()", (*obj)->value.obj.ce->name, Z_STRVAL_PP(method));
|
|
|
|
|
} else
|
|
|
|
|
php_error(E_WARNING, "Unable to call handler");
|
1999-09-25 02:02:58 +08:00
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
1999-10-07 20:27:40 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
for (i = 0; i < argc; i++) {
|
1999-10-07 20:27:40 +08:00
|
|
|
|
zval_del_ref(&(argv[i]));
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-10-07 20:27:40 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
if (result == FAILURE) {
|
|
|
|
|
return NULL;
|
|
|
|
|
} else {
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_encode_iso_8859_1() */
|
|
|
|
|
|
|
|
|
|
inline static unsigned short
|
|
|
|
|
xml_encode_iso_8859_1(unsigned char c)
|
|
|
|
|
{
|
|
|
|
|
return (unsigned short)c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_decode_iso_8859_1() */
|
|
|
|
|
|
|
|
|
|
inline static char
|
|
|
|
|
xml_decode_iso_8859_1(unsigned short c)
|
|
|
|
|
{
|
|
|
|
|
return (char)(c > 0xff ? '?' : c);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_encode_us_ascii() */
|
|
|
|
|
|
|
|
|
|
inline static unsigned short
|
1999-05-21 18:06:25 +08:00
|
|
|
|
xml_encode_us_ascii(unsigned char c)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
return (unsigned short)c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_decode_us_ascii() */
|
|
|
|
|
|
|
|
|
|
inline static char
|
|
|
|
|
xml_decode_us_ascii(unsigned short c)
|
|
|
|
|
{
|
|
|
|
|
return (char)(c > 0x7f ? '?' : c);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_get_encoding() */
|
|
|
|
|
|
|
|
|
|
static xml_encoding *
|
|
|
|
|
xml_get_encoding(const XML_Char *name)
|
|
|
|
|
{
|
|
|
|
|
xml_encoding *enc = &xml_encodings[0];
|
|
|
|
|
|
|
|
|
|
while (enc && enc->name) {
|
|
|
|
|
if (strcasecmp(name, enc->name) == 0) {
|
|
|
|
|
return enc;
|
|
|
|
|
}
|
|
|
|
|
enc++;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_utf8_encode */
|
|
|
|
|
static XML_Char *
|
|
|
|
|
xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char *encoding)
|
|
|
|
|
{
|
|
|
|
|
int pos = len;
|
|
|
|
|
char *newbuf;
|
|
|
|
|
unsigned short c;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
unsigned short (*encoder)(unsigned char) = NULL;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_encoding *enc = xml_get_encoding(encoding);
|
|
|
|
|
|
|
|
|
|
*newlen = 0;
|
|
|
|
|
if (enc) {
|
|
|
|
|
encoder = enc->encoding_function;
|
|
|
|
|
} else {
|
|
|
|
|
/* If the target encoding was unknown, fail */
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
if (encoder == NULL) {
|
|
|
|
|
/* If no encoder function was specified, return the data as-is.
|
|
|
|
|
*/
|
|
|
|
|
newbuf = emalloc(len);
|
|
|
|
|
memcpy(newbuf, s, len);
|
|
|
|
|
*newlen = len;
|
|
|
|
|
return newbuf;
|
|
|
|
|
}
|
|
|
|
|
/* This is the theoretical max (will never get beyond len * 2 as long
|
|
|
|
|
* as we are converting from single-byte characters, though) */
|
|
|
|
|
newbuf = emalloc(len * 4);
|
|
|
|
|
while (pos > 0) {
|
|
|
|
|
c = encoder ? encoder((unsigned char)(*s)) : (unsigned short)(*s);
|
|
|
|
|
if (c < 0x80) {
|
2000-02-03 02:42:04 +08:00
|
|
|
|
newbuf[(*newlen)++] = (char) c;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
} else if (c < 0x800) {
|
|
|
|
|
newbuf[(*newlen)++] = (0xc0 | (c >> 6));
|
|
|
|
|
newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
|
|
|
|
|
} else if (c < 0x10000) {
|
|
|
|
|
newbuf[(*newlen)++] = (0xe0 | (c >> 12));
|
|
|
|
|
newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
|
|
|
|
|
newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
|
|
|
|
|
} else if (c < 0x200000) {
|
|
|
|
|
newbuf[(*newlen)++] = (0xf0 | (c >> 18));
|
|
|
|
|
newbuf[(*newlen)++] = (0xe0 | ((c >> 12) & 0x3f));
|
|
|
|
|
newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
|
|
|
|
|
newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
|
|
|
|
|
}
|
|
|
|
|
pos--;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
if (*newlen < len * 4) {
|
|
|
|
|
newbuf = erealloc(newbuf, *newlen);
|
|
|
|
|
}
|
|
|
|
|
return newbuf;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
/* {{{ xml_utf8_decode */
|
2000-04-04 23:42:05 +08:00
|
|
|
|
PHPAPI char *
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_utf8_decode(const XML_Char *s, int len, int *newlen, const XML_Char *encoding)
|
|
|
|
|
{
|
|
|
|
|
int pos = len;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
char *newbuf = emalloc(len + 1);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
unsigned short c;
|
|
|
|
|
char (*decoder)(unsigned short) = NULL;
|
|
|
|
|
xml_encoding *enc = xml_get_encoding(encoding);
|
|
|
|
|
|
|
|
|
|
*newlen = 0;
|
|
|
|
|
if (enc) {
|
|
|
|
|
decoder = enc->decoding_function;
|
|
|
|
|
}
|
|
|
|
|
if (decoder == NULL) {
|
|
|
|
|
/* If the target encoding was unknown, or no decoder function
|
|
|
|
|
* was specified, return the UTF-8-encoded data as-is.
|
|
|
|
|
*/
|
|
|
|
|
memcpy(newbuf, s, len);
|
|
|
|
|
*newlen = len;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
newbuf[*newlen] = '\0';
|
1999-04-22 10:48:28 +08:00
|
|
|
|
return newbuf;
|
|
|
|
|
}
|
|
|
|
|
while (pos > 0) {
|
|
|
|
|
c = (unsigned char)(*s);
|
|
|
|
|
if (c >= 0xf0) { /* four bytes encoded, 21 bits */
|
|
|
|
|
c = ((s[0]&7)<<18) | ((s[1]&63)<<12) | ((s[2]&63)<<6) | (s[3]&63);
|
|
|
|
|
s += 4;
|
|
|
|
|
pos -= 4;
|
|
|
|
|
} else if (c >= 0xe0) { /* three bytes encoded, 16 bits */
|
|
|
|
|
c = ((s[0]&63)<<12) | ((s[1]&63)<<6) | (s[2]&63);
|
|
|
|
|
s += 3;
|
|
|
|
|
pos -= 3;
|
|
|
|
|
} else if (c >= 0xc0) { /* two bytes encoded, 11 bits */
|
|
|
|
|
c = ((s[0]&63)<<6) | (s[1]&63);
|
|
|
|
|
s += 2;
|
|
|
|
|
pos -= 2;
|
|
|
|
|
} else {
|
|
|
|
|
s++;
|
|
|
|
|
pos--;
|
|
|
|
|
}
|
|
|
|
|
newbuf[*newlen] = decoder ? decoder(c) : c;
|
|
|
|
|
++*newlen;
|
|
|
|
|
}
|
|
|
|
|
if (*newlen < len) {
|
1999-05-21 18:06:25 +08:00
|
|
|
|
newbuf = erealloc(newbuf, *newlen + 1);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
newbuf[*newlen] = '\0';
|
1999-04-22 10:48:28 +08:00
|
|
|
|
return newbuf;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_xmlcharlen() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
static int _xml_xmlcharlen(const XML_Char *s)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
|
|
while (*s) {
|
|
|
|
|
len++;
|
|
|
|
|
s++;
|
|
|
|
|
}
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_zval_strdup() */
|
1999-07-21 22:43:12 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
PHPAPI char *_xml_zval_strdup(zval *val)
|
1999-07-21 22:43:12 +08:00
|
|
|
|
{
|
|
|
|
|
if (val->type == IS_STRING) {
|
|
|
|
|
char *buf = emalloc(val->value.str.len + 1);
|
|
|
|
|
memcpy(buf, val->value.str.val, val->value.str.len);
|
|
|
|
|
buf[val->value.str.len] = '\0';
|
|
|
|
|
return buf;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_add_to_info */
|
|
|
|
|
static void _xml_add_to_info(xml_parser *parser,char *name)
|
1999-05-21 18:06:25 +08:00
|
|
|
|
{
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **element, *values;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if (! parser->info) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-03 03:17:14 +08:00
|
|
|
|
if (zend_hash_find(parser->info->value.ht,name,strlen(name) + 1,(void **) &element) == FAILURE) {
|
1999-10-01 21:44:07 +08:00
|
|
|
|
MAKE_STD_ZVAL(values);
|
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
if (array_init(values) == FAILURE) {
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_ERROR, "Unable to initialize array");
|
1999-05-21 18:06:25 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zend_hash_update(parser->info->value.ht, name, strlen(name)+1, (void *) &values, sizeof(zval*), (void **) &element);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_next_index_long(*element,parser->curtag);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
parser->curtag++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_startElementHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_startElementHandler(void *userData, const char *name,
|
1999-04-22 10:48:28 +08:00
|
|
|
|
const char **attributes)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
const char **attrs = attributes;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[3];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
parser->level++;
|
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (parser->case_folding) {
|
1999-12-10 07:45:30 +08:00
|
|
|
|
name = php_strtoupper(estrdup(name), strlen(name));
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if (parser->startElementHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
|
|
|
|
args[1] = _xml_string_zval(name);
|
1999-08-08 19:37:50 +08:00
|
|
|
|
MAKE_STD_ZVAL(args[2]);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
array_init(args[2]);
|
|
|
|
|
while (attributes && *attributes) {
|
|
|
|
|
char *key = (char *)attributes[0];
|
|
|
|
|
char *value = (char *)attributes[1];
|
|
|
|
|
char *decoded_value;
|
|
|
|
|
int decoded_len;
|
|
|
|
|
if (parser->case_folding) {
|
1999-12-10 22:27:19 +08:00
|
|
|
|
key = php_strtoupper(estrdup(key), strlen(key));
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
decoded_value = xml_utf8_decode(value, strlen(value),
|
|
|
|
|
&decoded_len,
|
|
|
|
|
parser->target_encoding);
|
|
|
|
|
|
1999-07-04 21:30:13 +08:00
|
|
|
|
add_assoc_stringl(args[2], key, decoded_value, decoded_len, 0);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser->case_folding) {
|
|
|
|
|
efree(key);
|
|
|
|
|
}
|
|
|
|
|
attributes += 2;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if ((retval = xml_call_handler(parser, parser->startElementHandler, 3, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
efree(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parser->data) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *tag, *atr;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
int atcnt = 0;
|
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
MAKE_STD_ZVAL(tag);
|
|
|
|
|
MAKE_STD_ZVAL(atr);
|
1999-07-02 23:45:52 +08:00
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
array_init(tag);
|
|
|
|
|
array_init(atr);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
_xml_add_to_info(parser,((char *) name) + parser->toffset);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_assoc_string(tag,"tag",((char *) name) + parser->toffset,1); /* cast to avoid gcc-warning */
|
|
|
|
|
add_assoc_string(tag,"type","open",1);
|
|
|
|
|
add_assoc_long(tag,"level",parser->level);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
parser->ltags[parser->level-1] = estrdup(name);
|
|
|
|
|
parser->lastwasopen = 1;
|
|
|
|
|
|
|
|
|
|
attributes = attrs;
|
|
|
|
|
while (attributes && *attributes) {
|
|
|
|
|
char *key = (char *)attributes[0];
|
|
|
|
|
char *value = (char *)attributes[1];
|
|
|
|
|
char *decoded_value;
|
|
|
|
|
int decoded_len;
|
|
|
|
|
if (parser->case_folding) {
|
1999-12-10 22:27:19 +08:00
|
|
|
|
key = php_strtoupper(estrdup(key), strlen(key));
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
decoded_value = xml_utf8_decode(value, strlen(value),
|
|
|
|
|
&decoded_len,
|
|
|
|
|
parser->target_encoding);
|
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_assoc_stringl(atr,key,decoded_value,decoded_len,0);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
atcnt++;
|
|
|
|
|
if (parser->case_folding) {
|
|
|
|
|
efree(key);
|
|
|
|
|
}
|
|
|
|
|
attributes += 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (atcnt) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zend_hash_add(tag->value.ht,"attributes",sizeof("attributes"),&atr,sizeof(zval*),NULL);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
} else {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(atr);
|
1999-07-02 23:31:02 +08:00
|
|
|
|
efree(atr);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zend_hash_next_index_insert(parser->data->value.ht,&tag,sizeof(zval*),(void *) &parser->ctag);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (parser->case_folding) {
|
|
|
|
|
efree((char *)name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_endElementHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_endElementHandler(void *userData, const char *name)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[2];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
if (parser->case_folding) {
|
1999-12-10 22:27:19 +08:00
|
|
|
|
name = php_strtoupper(estrdup(name), strlen(name));
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if (parser->endElementHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
|
|
|
|
args[1] = _xml_string_zval(name);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if ((retval = xml_call_handler(parser, parser->endElementHandler, 2, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parser->data) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *tag;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
if (parser->lastwasopen) {
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_assoc_string(*(parser->ctag),"type","complete",1);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
} else {
|
1999-10-01 21:44:07 +08:00
|
|
|
|
MAKE_STD_ZVAL(tag);
|
1999-07-02 23:31:02 +08:00
|
|
|
|
|
|
|
|
|
array_init(tag);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
_xml_add_to_info(parser,((char *) name) + parser->toffset);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_assoc_string(tag,"tag",((char *) name) + parser->toffset,1); /* cast to avoid gcc-warning */
|
|
|
|
|
add_assoc_string(tag,"type","close",1);
|
|
|
|
|
add_assoc_long(tag,"level",parser->level);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zend_hash_next_index_insert(parser->data->value.ht,&tag,sizeof(zval*),NULL);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parser->lastwasopen = 0;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (parser->case_folding) {
|
|
|
|
|
efree((char *)name);
|
|
|
|
|
}
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser->ltags) {
|
|
|
|
|
efree(parser->ltags[parser->level-1]);
|
|
|
|
|
}
|
|
|
|
|
parser->level--;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_characterDataHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[2];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (parser->characterDataHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->characterDataHandler, 2, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (parser->data) {
|
|
|
|
|
int i;
|
|
|
|
|
int doprint = 0;
|
|
|
|
|
|
|
|
|
|
char *decoded_value;
|
|
|
|
|
int decoded_len;
|
|
|
|
|
|
|
|
|
|
decoded_value = xml_utf8_decode(s,len,&decoded_len,parser->target_encoding);
|
|
|
|
|
for (i = 0; i < decoded_len; i++) {
|
|
|
|
|
switch (decoded_value[i]) {
|
|
|
|
|
case ' ':
|
|
|
|
|
case '\t':
|
|
|
|
|
case '\n':
|
|
|
|
|
continue;
|
|
|
|
|
default:
|
|
|
|
|
doprint = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (doprint) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (doprint || (! parser->skipwhite)) {
|
|
|
|
|
if (parser->lastwasopen) {
|
1999-10-20 22:58:03 +08:00
|
|
|
|
zval **myval;
|
|
|
|
|
|
|
|
|
|
/* check if the current tag already has a value - if yes append to that! */
|
|
|
|
|
if (zend_hash_find((*parser->ctag)->value.ht,"value",sizeof("value"),(void **) &myval) == SUCCESS) {
|
|
|
|
|
int newlen = (*myval)->value.str.len + decoded_len;
|
1999-11-19 22:11:15 +08:00
|
|
|
|
(*myval)->value.str.val = erealloc((*myval)->value.str.val,newlen+1);
|
1999-10-20 22:58:03 +08:00
|
|
|
|
strcpy((*myval)->value.str.val + (*myval)->value.str.len,decoded_value);
|
|
|
|
|
(*myval)->value.str.len += decoded_len;
|
|
|
|
|
efree(decoded_value);
|
|
|
|
|
} else {
|
|
|
|
|
add_assoc_string(*(parser->ctag),"value",decoded_value,0);
|
|
|
|
|
}
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
} else {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *tag;
|
1999-07-02 23:31:02 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
MAKE_STD_ZVAL(tag);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
array_init(tag);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
_xml_add_to_info(parser,parser->ltags[parser->level-1] + parser->toffset);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-07-02 23:31:02 +08:00
|
|
|
|
add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset,1);
|
|
|
|
|
add_assoc_string(tag,"value",decoded_value,0);
|
|
|
|
|
add_assoc_string(tag,"type","cdata",1);
|
|
|
|
|
add_assoc_long(tag,"level",parser->level);
|
1999-10-20 22:58:03 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zend_hash_next_index_insert(parser->data->value.ht,&tag,sizeof(zval*),NULL);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
efree(decoded_value);
|
|
|
|
|
}
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_processingInstructionHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_processingInstructionHandler(void *userData,
|
1999-04-22 10:48:28 +08:00
|
|
|
|
const XML_Char *target,
|
|
|
|
|
const XML_Char *data)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
|
|
|
|
if (parser && parser->processingInstructionHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[3];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(target, 0, parser->target_encoding);
|
|
|
|
|
args[2] = _xml_xmlchar_zval(data, 0, parser->target_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->processingInstructionHandler, 3, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_defaultHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_defaultHandler(void *userData, const XML_Char *s, int len)
|
1999-04-22 10:48:28 +08:00
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
|
|
|
|
if (parser && parser->defaultHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[2];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->defaultHandler, 2, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_unparsedEntityDeclHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
void _xml_unparsedEntityDeclHandler(void *userData,
|
1999-04-22 10:48:28 +08:00
|
|
|
|
const XML_Char *entityName,
|
|
|
|
|
const XML_Char *base,
|
|
|
|
|
const XML_Char *systemId,
|
|
|
|
|
const XML_Char *publicId,
|
|
|
|
|
const XML_Char *notationName)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
|
|
|
|
if (parser && parser->unparsedEntityDeclHandler) {
|
1999-12-15 02:37:14 +08:00
|
|
|
|
zval *retval, *args[6];
|
1999-09-26 00:42:31 +08:00
|
|
|
|
|
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(entityName, 0, parser->target_encoding);
|
|
|
|
|
args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
|
|
|
|
|
args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
|
|
|
|
|
args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
|
|
|
|
|
args[5] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->unparsedEntityDeclHandler, 6, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_notationDeclHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
void
|
1999-10-01 21:44:07 +08:00
|
|
|
|
_xml_notationDeclHandler(void *userData,
|
1999-04-22 10:48:28 +08:00
|
|
|
|
const XML_Char *notationName,
|
|
|
|
|
const XML_Char *base,
|
|
|
|
|
const XML_Char *systemId,
|
|
|
|
|
const XML_Char *publicId)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = (xml_parser *)userData;
|
|
|
|
|
|
|
|
|
|
if (parser && parser->notationDeclHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[5];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
|
|
|
|
|
args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
|
|
|
|
|
args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
|
|
|
|
|
args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->notationDeclHandler, 5, args))) {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
zval_dtor(retval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
efree(retval);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
1999-10-01 21:44:07 +08:00
|
|
|
|
/* {{{ _xml_externalEntityRefHandler() */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
|
|
|
|
int
|
1999-10-01 21:44:07 +08:00
|
|
|
|
_xml_externalEntityRefHandler(XML_Parser parserPtr,
|
1999-04-22 10:48:28 +08:00
|
|
|
|
const XML_Char *openEntityNames,
|
|
|
|
|
const XML_Char *base,
|
|
|
|
|
const XML_Char *systemId,
|
|
|
|
|
const XML_Char *publicId)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser = XML_GetUserData(parserPtr);
|
|
|
|
|
int ret = 0; /* abort if no handler is set (should be configurable?) */
|
|
|
|
|
|
|
|
|
|
if (parser && parser->externalEntityRefHandler) {
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval *retval, *args[5];
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-26 00:42:31 +08:00
|
|
|
|
args[0] = _xml_resource_zval(parser->index);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
args[1] = _xml_xmlchar_zval(openEntityNames, 0, parser->target_encoding);
|
|
|
|
|
args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
|
|
|
|
|
args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
|
|
|
|
|
args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if ((retval = xml_call_handler(parser, parser->externalEntityRefHandler, 5, args))) {
|
|
|
|
|
convert_to_long(retval);
|
|
|
|
|
ret = retval->value.lval;
|
|
|
|
|
efree(retval);
|
|
|
|
|
} else {
|
|
|
|
|
ret = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/************************* EXTENSION FUNCTIONS *************************/
|
|
|
|
|
|
2000-02-24 22:43:53 +08:00
|
|
|
|
/* {{{ proto int xml_parser_create(void)
|
1999-05-21 18:06:25 +08:00
|
|
|
|
Create an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_parser_create)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-24 22:18:33 +08:00
|
|
|
|
int argc;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **encodingArg;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
XML_Char *encoding;
|
|
|
|
|
char thisfunc[] = "xml_parser_create";
|
1999-09-20 20:51:20 +08:00
|
|
|
|
XMLLS_FETCH();
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
argc = ZEND_NUM_ARGS();
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-12-19 06:40:35 +08:00
|
|
|
|
if (argc > 1 || zend_get_parameters_ex(argc, &encodingArg) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (argc == 1) {
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_string_ex(encodingArg);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
/* The supported encoding types are hardcoded here because
|
|
|
|
|
* we are limited to the encodings supported by expat/xmltok.
|
|
|
|
|
*/
|
1999-09-25 02:02:58 +08:00
|
|
|
|
if (strncasecmp((*encodingArg)->value.str.val, "ISO-8859-1",
|
|
|
|
|
(*encodingArg)->value.str.len) == 0) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
encoding = "ISO-8859-1";
|
1999-09-25 02:02:58 +08:00
|
|
|
|
} else if (strncasecmp((*encodingArg)->value.str.val, "UTF-8",
|
|
|
|
|
(*encodingArg)->value.str.len) == 0) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
encoding = "UTF-8";
|
1999-09-25 02:02:58 +08:00
|
|
|
|
} else if (strncasecmp((*encodingArg)->value.str.val, "US-ASCII",
|
|
|
|
|
(*encodingArg)->value.str.len) == 0) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
encoding = "US-ASCII";
|
|
|
|
|
} else { /* UTF-16 not supported */
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "%s: unsupported source encoding \"%s\"",
|
1999-09-25 02:02:58 +08:00
|
|
|
|
thisfunc, (*encodingArg)->value.str.val);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
1999-09-20 20:51:20 +08:00
|
|
|
|
encoding = XML(default_encoding);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parser = ecalloc(sizeof(xml_parser), 1);
|
|
|
|
|
parser->parser = XML_ParserCreate(encoding);
|
|
|
|
|
parser->target_encoding = encoding;
|
|
|
|
|
parser->case_folding = 1;
|
1999-12-06 00:43:42 +08:00
|
|
|
|
parser->object = NULL;
|
1999-09-20 20:51:20 +08:00
|
|
|
|
XML_SetUserData(parser->parser, parser);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-09-20 20:51:20 +08:00
|
|
|
|
ZEND_REGISTER_RESOURCE(return_value,parser,le_xml_parser);
|
|
|
|
|
parser->index = return_value->value.lval;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-12-06 00:59:15 +08:00
|
|
|
|
/* {{{ proto int xml_set_object(int pind, object &obj)
|
1999-12-06 00:43:42 +08:00
|
|
|
|
Set up object which should be used for callbacks */
|
|
|
|
|
PHP_FUNCTION(xml_set_object)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
|
|
|
|
zval **pind, **mythis;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 ||
|
1999-12-19 06:40:35 +08:00
|
|
|
|
zend_get_parameters_ex(2, &pind, &mythis) == FAILURE) {
|
1999-12-06 00:43:42 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((*mythis)->type != IS_OBJECT) {
|
|
|
|
|
php_error(E_WARNING,"arg 2 has wrong type");
|
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (! ParameterPassedByReference(ht,2)) {
|
|
|
|
|
php_error(E_WARNING,"arg 2 not passed by reference");
|
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *,pind, -1, "XML Parser", le_xml_parser);
|
|
|
|
|
|
|
|
|
|
if (parser->object) {
|
|
|
|
|
zval_del_ref(&parser->object);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parser->object = *mythis;
|
|
|
|
|
zval_add_ref(&parser->object);
|
|
|
|
|
|
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_element_handler(int pind, string shdl, string ehdl)
|
|
|
|
|
Set up start and end element handlers */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_element_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **shdl, **ehdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 3 ||
|
1999-12-19 06:40:35 +08:00
|
|
|
|
zend_get_parameters_ex(3, &pind, &shdl, &ehdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *,pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->startElementHandler, shdl);
|
|
|
|
|
xml_set_handler(&parser->endElementHandler, ehdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_character_data_handler(int pind, string hdl)
|
|
|
|
|
Set up character data handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_character_data_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->characterDataHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_processing_instruction_handler(int pind, string hdl)
|
|
|
|
|
Set up processing instruction (PI) handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_processing_instruction_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->processingInstructionHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetProcessingInstructionHandler(parser->parser, _xml_processingInstructionHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_default_handler(int pind, string hdl)
|
|
|
|
|
Set up default handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_default_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->defaultHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_unparsed_entity_decl_handler(int pind, string hdl)
|
|
|
|
|
Set up unparsed entity declaration handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->unparsedEntityDeclHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetUnparsedEntityDeclHandler(parser->parser, _xml_unparsedEntityDeclHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_notation_decl_handler(int pind, string hdl)
|
|
|
|
|
Set up notation declaration handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_notation_decl_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->notationDeclHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetNotationDeclHandler(parser->parser, _xml_notationDeclHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_set_external_entity_ref_handler(int pind, string hdl)
|
|
|
|
|
Set up external entity reference handler */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_set_external_entity_ref_handler)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **hdl;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &hdl) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
xml_set_handler(&parser->externalEntityRefHandler, hdl);
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetExternalEntityRefHandler(parser->parser, _xml_externalEntityRefHandler);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
2000-02-24 22:43:53 +08:00
|
|
|
|
/* {{{ proto int xml_parse(int pind, string data [, int isFinal])
|
1999-05-21 18:06:25 +08:00
|
|
|
|
Start parsing an XML document */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_parse)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **data, **final;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
int argc, isFinal, ret;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
argc = ZEND_NUM_ARGS();
|
1999-12-19 06:40:35 +08:00
|
|
|
|
if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &pind, &data, &final) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_string_ex(data);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (argc == 3) {
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(final);
|
|
|
|
|
isFinal = (*final)->value.lval;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
} else {
|
|
|
|
|
isFinal = 0;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ret = XML_Parse(parser->parser, (*data)->value.str.val, (*data)->value.str.len, isFinal);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_LONG(ret);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
2000-02-24 22:43:53 +08:00
|
|
|
|
/* {{{ proto int xml_parse_into_struct(int pind, string data, array &struct, array &index)
|
1999-05-21 18:06:25 +08:00
|
|
|
|
Parsing a XML document */
|
|
|
|
|
|
|
|
|
|
PHP_FUNCTION(xml_parse_into_struct)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **data, **xdata, **info = 0;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
int argc, ret;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
argc = ZEND_NUM_ARGS();
|
1999-12-19 06:40:35 +08:00
|
|
|
|
if (zend_get_parameters_ex(4, &pind, &data, &xdata,&info) == SUCCESS) {
|
1999-05-21 18:06:25 +08:00
|
|
|
|
if (!ParameterPassedByReference(ht, 4)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "Array to be filled with values must be passed by reference.");
|
1999-05-21 18:06:25 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval_dtor(*info);
|
1999-09-25 02:02:58 +08:00
|
|
|
|
array_init(*info);
|
1999-12-19 06:40:35 +08:00
|
|
|
|
} else if (zend_get_parameters_ex(3, &pind, &data, &xdata) == FAILURE) {
|
1999-05-21 18:06:25 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ParameterPassedByReference(ht, 3)) {
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "Array to be filled with values must be passed by reference.");
|
1999-05-21 18:06:25 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_string_ex(data);
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval_dtor(*xdata);
|
1999-09-25 02:02:58 +08:00
|
|
|
|
array_init(*xdata);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
parser->data = *xdata;
|
|
|
|
|
if (info)
|
|
|
|
|
parser->info = *info;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
parser->level = 0;
|
|
|
|
|
parser->ltags = emalloc(XML_MAXLEVEL * sizeof(char *));
|
|
|
|
|
|
1999-10-01 21:44:07 +08:00
|
|
|
|
XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
|
|
|
|
|
XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
|
|
|
|
|
XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ret = XML_Parse(parser->parser, (*data)->value.str.val, (*data)->value.str.len, 1);
|
1999-05-21 18:06:25 +08:00
|
|
|
|
|
|
|
|
|
RETVAL_LONG(ret);
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_get_error_code(int pind)
|
|
|
|
|
Get XML parser error code */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_get_error_code)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pind) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_LONG((long)XML_GetErrorCode(parser->parser));
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto string xml_error_string(int code)
|
|
|
|
|
Get XML parser error string */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_error_string)
|
|
|
|
|
{
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **code;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
char *str;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &code) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(code);
|
|
|
|
|
str = (char *)XML_ErrorString((int)(*code)->value.lval);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (str) {
|
|
|
|
|
RETVAL_STRING(str, 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_get_current_line_number(int pind)
|
|
|
|
|
Get current line number for an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_get_current_line_number)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pind) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_LONG(XML_GetCurrentLineNumber(parser->parser));
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_get_current_column_number(int pind)
|
2000-02-24 22:43:53 +08:00
|
|
|
|
Get current column number for an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_get_current_column_number)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pind) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_LONG(XML_GetCurrentColumnNumber(parser->parser));
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_get_current_byte_index(int pind)
|
|
|
|
|
Get current byte index for an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_get_current_byte_index)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pind) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_LONG(XML_GetCurrentByteIndex(parser->parser));
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_parser_free(int pind)
|
|
|
|
|
Free an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_parser_free)
|
|
|
|
|
{
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind;
|
1999-09-20 20:51:20 +08:00
|
|
|
|
xml_parser *parser;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &pind) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-12-18 03:51:39 +08:00
|
|
|
|
if (zend_list_delete(parser->index) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_parser_set_option(int pind, int option, mixed value)
|
|
|
|
|
Set options in an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_parser_set_option)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **opt, **val;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
char thisfunc[] = "xml_parser_set_option";
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &pind, &opt, &val) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(opt);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
switch ((*opt)->value.lval) {
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_CASE_FOLDING:
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(val);
|
|
|
|
|
parser->case_folding = (*val)->value.lval;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
break;
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_SKIP_TAGSTART:
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(val);
|
|
|
|
|
parser->toffset = (*val)->value.lval;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
break;
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_SKIP_WHITE:
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(val);
|
|
|
|
|
parser->skipwhite = (*val)->value.lval;
|
1999-05-21 18:06:25 +08:00
|
|
|
|
break;
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_TARGET_ENCODING: {
|
1999-09-25 02:02:58 +08:00
|
|
|
|
xml_encoding *enc;
|
|
|
|
|
convert_to_string_ex(val);
|
|
|
|
|
enc = xml_get_encoding((*val)->value.str.val);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (enc == NULL) {
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "%s: unsupported target encoding \"%s\"",
|
1999-09-25 02:02:58 +08:00
|
|
|
|
thisfunc, (*val)->value.str.val);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
parser->target_encoding = enc->name;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "%s: unknown option", thisfunc);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
RETVAL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto int xml_parser_get_option(int pind, int option)
|
|
|
|
|
Get options from an XML parser */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(xml_parser_get_option)
|
|
|
|
|
{
|
|
|
|
|
xml_parser *parser;
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **pind, **opt;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
char thisfunc[] = "xml_parser_get_option";
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &pind, &opt) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_long_ex(opt);
|
1999-09-20 20:51:20 +08:00
|
|
|
|
|
1999-09-25 02:02:58 +08:00
|
|
|
|
switch ((*opt)->value.lval) {
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_CASE_FOLDING:
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_LONG(parser->case_folding);
|
|
|
|
|
break;
|
1999-12-18 11:20:53 +08:00
|
|
|
|
case PHP_XML_OPTION_TARGET_ENCODING:
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_STRING(parser->target_encoding, 1);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
1999-08-03 03:17:14 +08:00
|
|
|
|
php_error(E_WARNING, "%s: unknown option", thisfunc);
|
1999-04-22 10:48:28 +08:00
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
RETVAL_FALSE;
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto string utf8_encode(string data)
|
|
|
|
|
Encodes an ISO-8859-1 string to UTF-8 */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(utf8_encode)
|
|
|
|
|
{
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **arg;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
XML_Char *encoded;
|
|
|
|
|
int len;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_string_ex(arg);
|
|
|
|
|
encoded = xml_utf8_encode((*arg)->value.str.val, (*arg)->value.str.len, &len, "ISO-8859-1");
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (encoded == NULL) {
|
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
RETVAL_STRINGL(encoded, len, 0);
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
1999-05-21 18:06:25 +08:00
|
|
|
|
/* {{{ proto string utf8_decode(string data)
|
|
|
|
|
Converts a UTF-8 encoded string to ISO-8859-1 */
|
1999-04-22 10:48:28 +08:00
|
|
|
|
PHP_FUNCTION(utf8_decode)
|
|
|
|
|
{
|
1999-09-26 00:42:31 +08:00
|
|
|
|
zval **arg;
|
1999-04-22 10:48:28 +08:00
|
|
|
|
XML_Char *decoded;
|
|
|
|
|
int len;
|
|
|
|
|
|
2000-06-06 03:47:54 +08:00
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
|
1999-04-22 10:48:28 +08:00
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
|
}
|
1999-09-25 02:02:58 +08:00
|
|
|
|
convert_to_string_ex(arg);
|
|
|
|
|
decoded = xml_utf8_decode((*arg)->value.str.val, (*arg)->value.str.len, &len, "ISO-8859-1");
|
1999-04-22 10:48:28 +08:00
|
|
|
|
if (decoded == NULL) {
|
|
|
|
|
RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
RETVAL_STRINGL(decoded, len, 0);
|
|
|
|
|
}
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Local variables:
|
|
|
|
|
* tab-width: 4
|
|
|
|
|
* c-basic-offset: 4
|
|
|
|
|
* End:
|
|
|
|
|
*/
|