Annotation of embedaddon/php/ext/xml/xml.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Stig Sæther Bakken <ssb@php.net> |
16: | Thies C. Arntzen <thies@thieso.net> |
17: | Sterling Hughes <sterling@php.net> |
18: +----------------------------------------------------------------------+
19: */
20:
21: /* $Id: xml.c 321634 2012-01-01 13:15:04Z felipe $ */
22:
23: #define IS_EXT_MODULE
24:
25: #ifdef HAVE_CONFIG_H
26: #include "config.h"
27: #endif
28:
29: #include "php.h"
30:
31: #define PHP_XML_INTERNAL
32: #include "zend_variables.h"
33: #include "ext/standard/php_string.h"
34: #include "ext/standard/info.h"
35:
36: #if HAVE_XML
37:
38: #include "php_xml.h"
39: # include "ext/standard/head.h"
40: #ifdef LIBXML_EXPAT_COMPAT
41: #include "ext/libxml/php_libxml.h"
42: #endif
43:
44: /* Short-term TODO list:
45: * - Implement XML_ExternalEntityParserCreate()
46: * - XML_SetCommentHandler
47: * - XML_SetCdataSectionHandler
48: * - XML_SetParamEntityParsing
49: */
50:
51: /* Long-term TODO list:
52: * - Fix the expat library so you can install your own memory manager
53: * functions
54: */
55:
56: /* Known bugs:
57: * - Weird things happen with <![CDATA[]]> sections.
58: */
59:
60: ZEND_DECLARE_MODULE_GLOBALS(xml)
61:
62: /* {{{ dynamically loadable module stuff */
63: #ifdef COMPILE_DL_XML
64: ZEND_GET_MODULE(xml)
65: #endif /* COMPILE_DL_XML */
66: /* }}} */
67:
68: /* {{{ function prototypes */
69: PHP_MINIT_FUNCTION(xml);
70: PHP_MINFO_FUNCTION(xml);
71: static PHP_GINIT_FUNCTION(xml);
72:
73: static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC);
74: static void xml_set_handler(zval **, zval **);
75: inline static unsigned short xml_encode_iso_8859_1(unsigned char);
76: inline static char xml_decode_iso_8859_1(unsigned short);
77: inline static unsigned short xml_encode_us_ascii(unsigned char);
78: inline static char xml_decode_us_ascii(unsigned short);
79: static zval *xml_call_handler(xml_parser *, zval *, zend_function *, int, zval **);
80: static zval *_xml_xmlchar_zval(const XML_Char *, int, const XML_Char *);
81: static int _xml_xmlcharlen(const XML_Char *);
82: static void _xml_add_to_info(xml_parser *parser,char *name);
83: inline static char *_xml_decode_tag(xml_parser *parser, const char *tag);
84:
85: void _xml_startElementHandler(void *, const XML_Char *, const XML_Char **);
86: void _xml_endElementHandler(void *, const XML_Char *);
87: void _xml_characterDataHandler(void *, const XML_Char *, int);
88: void _xml_processingInstructionHandler(void *, const XML_Char *, const XML_Char *);
89: void _xml_defaultHandler(void *, const XML_Char *, int);
90: void _xml_unparsedEntityDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
91: void _xml_notationDeclHandler(void *, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
92: int _xml_externalEntityRefHandler(XML_Parser, const XML_Char *, const XML_Char *, const XML_Char *, const XML_Char *);
93:
94: void _xml_startNamespaceDeclHandler(void *, const XML_Char *, const XML_Char *);
95: void _xml_endNamespaceDeclHandler(void *, const XML_Char *);
96: /* }}} */
97:
98: /* {{{ extension definition structures */
99: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_create, 0, 0, 0)
100: ZEND_ARG_INFO(0, encoding)
101: ZEND_END_ARG_INFO()
102:
103: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_create_ns, 0, 0, 0)
104: ZEND_ARG_INFO(0, encoding)
105: ZEND_ARG_INFO(0, sep)
106: ZEND_END_ARG_INFO()
107:
108: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_object, 0, 0, 2)
109: ZEND_ARG_INFO(0, parser)
110: ZEND_ARG_INFO(1, obj)
111: ZEND_END_ARG_INFO()
112:
113: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_element_handler, 0, 0, 3)
114: ZEND_ARG_INFO(0, parser)
115: ZEND_ARG_INFO(0, shdl)
116: ZEND_ARG_INFO(0, ehdl)
117: ZEND_END_ARG_INFO()
118:
119: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_character_data_handler, 0, 0, 2)
120: ZEND_ARG_INFO(0, parser)
121: ZEND_ARG_INFO(0, hdl)
122: ZEND_END_ARG_INFO()
123:
124: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_processing_instruction_handler, 0, 0, 2)
125: ZEND_ARG_INFO(0, parser)
126: ZEND_ARG_INFO(0, hdl)
127: ZEND_END_ARG_INFO()
128:
129: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_default_handler, 0, 0, 2)
130: ZEND_ARG_INFO(0, parser)
131: ZEND_ARG_INFO(0, hdl)
132: ZEND_END_ARG_INFO()
133:
134: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_unparsed_entity_decl_handler, 0, 0, 2)
135: ZEND_ARG_INFO(0, parser)
136: ZEND_ARG_INFO(0, hdl)
137: ZEND_END_ARG_INFO()
138:
139: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_notation_decl_handler, 0, 0, 2)
140: ZEND_ARG_INFO(0, parser)
141: ZEND_ARG_INFO(0, hdl)
142: ZEND_END_ARG_INFO()
143:
144: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_external_entity_ref_handler, 0, 0, 2)
145: ZEND_ARG_INFO(0, parser)
146: ZEND_ARG_INFO(0, hdl)
147: ZEND_END_ARG_INFO()
148:
149: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_start_namespace_decl_handler, 0, 0, 2)
150: ZEND_ARG_INFO(0, parser)
151: ZEND_ARG_INFO(0, hdl)
152: ZEND_END_ARG_INFO()
153:
154: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_set_end_namespace_decl_handler, 0, 0, 2)
155: ZEND_ARG_INFO(0, parser)
156: ZEND_ARG_INFO(0, hdl)
157: ZEND_END_ARG_INFO()
158:
159: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parse, 0, 0, 2)
160: ZEND_ARG_INFO(0, parser)
161: ZEND_ARG_INFO(0, data)
162: ZEND_ARG_INFO(0, isfinal)
163: ZEND_END_ARG_INFO()
164:
165: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parse_into_struct, 0, 0, 3)
166: ZEND_ARG_INFO(0, parser)
167: ZEND_ARG_INFO(0, data)
168: ZEND_ARG_INFO(1, values)
169: ZEND_ARG_INFO(1, index)
170: ZEND_END_ARG_INFO()
171:
172: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_error_code, 0, 0, 1)
173: ZEND_ARG_INFO(0, parser)
174: ZEND_END_ARG_INFO()
175:
176: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_error_string, 0, 0, 1)
177: ZEND_ARG_INFO(0, code)
178: ZEND_END_ARG_INFO()
179:
180: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_line_number, 0, 0, 1)
181: ZEND_ARG_INFO(0, parser)
182: ZEND_END_ARG_INFO()
183:
184: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_column_number, 0, 0, 1)
185: ZEND_ARG_INFO(0, parser)
186: ZEND_END_ARG_INFO()
187:
188: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_get_current_byte_index, 0, 0, 1)
189: ZEND_ARG_INFO(0, parser)
190: ZEND_END_ARG_INFO()
191:
192: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_free, 0, 0, 1)
193: ZEND_ARG_INFO(0, parser)
194: ZEND_END_ARG_INFO()
195:
196: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_set_option, 0, 0, 3)
197: ZEND_ARG_INFO(0, parser)
198: ZEND_ARG_INFO(0, option)
199: ZEND_ARG_INFO(0, value)
200: ZEND_END_ARG_INFO()
201:
202: ZEND_BEGIN_ARG_INFO_EX(arginfo_xml_parser_get_option, 0, 0, 2)
203: ZEND_ARG_INFO(0, parser)
204: ZEND_ARG_INFO(0, option)
205: ZEND_END_ARG_INFO()
206:
207: ZEND_BEGIN_ARG_INFO_EX(arginfo_utf8_encode, 0, 0, 1)
208: ZEND_ARG_INFO(0, data)
209: ZEND_END_ARG_INFO()
210:
211: ZEND_BEGIN_ARG_INFO_EX(arginfo_utf8_decode, 0, 0, 1)
212: ZEND_ARG_INFO(0, data)
213: ZEND_END_ARG_INFO()
214:
215: const zend_function_entry xml_functions[] = {
216: PHP_FE(xml_parser_create, arginfo_xml_parser_create)
217: PHP_FE(xml_parser_create_ns, arginfo_xml_parser_create_ns)
218: PHP_FE(xml_set_object, arginfo_xml_set_object)
219: PHP_FE(xml_set_element_handler, arginfo_xml_set_element_handler)
220: PHP_FE(xml_set_character_data_handler, arginfo_xml_set_character_data_handler)
221: PHP_FE(xml_set_processing_instruction_handler, arginfo_xml_set_processing_instruction_handler)
222: PHP_FE(xml_set_default_handler, arginfo_xml_set_default_handler)
223: PHP_FE(xml_set_unparsed_entity_decl_handler,arginfo_xml_set_unparsed_entity_decl_handler)
224: PHP_FE(xml_set_notation_decl_handler, arginfo_xml_set_notation_decl_handler)
225: PHP_FE(xml_set_external_entity_ref_handler, arginfo_xml_set_external_entity_ref_handler)
226: PHP_FE(xml_set_start_namespace_decl_handler,arginfo_xml_set_start_namespace_decl_handler)
227: PHP_FE(xml_set_end_namespace_decl_handler, arginfo_xml_set_end_namespace_decl_handler)
228: PHP_FE(xml_parse, arginfo_xml_parse)
229: PHP_FE(xml_parse_into_struct, arginfo_xml_parse_into_struct)
230: PHP_FE(xml_get_error_code, arginfo_xml_get_error_code)
231: PHP_FE(xml_error_string, arginfo_xml_error_string)
232: PHP_FE(xml_get_current_line_number, arginfo_xml_get_current_line_number)
233: PHP_FE(xml_get_current_column_number, arginfo_xml_get_current_column_number)
234: PHP_FE(xml_get_current_byte_index, arginfo_xml_get_current_byte_index)
235: PHP_FE(xml_parser_free, arginfo_xml_parser_free)
236: PHP_FE(xml_parser_set_option, arginfo_xml_parser_set_option)
237: PHP_FE(xml_parser_get_option, arginfo_xml_parser_get_option)
238: PHP_FE(utf8_encode, arginfo_utf8_encode)
239: PHP_FE(utf8_decode, arginfo_utf8_decode)
240: PHP_FE_END
241: };
242:
243: #ifdef LIBXML_EXPAT_COMPAT
244: static const zend_module_dep xml_deps[] = {
245: ZEND_MOD_REQUIRED("libxml")
246: ZEND_MOD_END
247: };
248: #endif
249:
250: zend_module_entry xml_module_entry = {
251: #ifdef LIBXML_EXPAT_COMPAT
252: STANDARD_MODULE_HEADER_EX, NULL,
253: xml_deps,
254: #else
255: STANDARD_MODULE_HEADER,
256: #endif
257: "xml", /* extension name */
258: xml_functions, /* extension function list */
259: PHP_MINIT(xml), /* extension-wide startup function */
260: NULL, /* extension-wide shutdown function */
261: NULL, /* per-request startup function */
262: NULL, /* per-request shutdown function */
263: PHP_MINFO(xml), /* information function */
264: NO_VERSION_YET,
265: PHP_MODULE_GLOBALS(xml), /* globals descriptor */
266: PHP_GINIT(xml), /* globals ctor */
267: NULL, /* globals dtor */
268: NULL, /* post deactivate */
269: STANDARD_MODULE_PROPERTIES_EX
270: };
271:
272: /* All the encoding functions are set to NULL right now, since all
273: * the encoding is currently done internally by expat/xmltok.
274: */
275: xml_encoding xml_encodings[] = {
276: { "ISO-8859-1", xml_decode_iso_8859_1, xml_encode_iso_8859_1 },
277: { "US-ASCII", xml_decode_us_ascii, xml_encode_us_ascii },
278: { "UTF-8", NULL, NULL },
279: { NULL, NULL, NULL }
280: };
281:
282: static XML_Memory_Handling_Suite php_xml_mem_hdlrs;
283:
284: /* True globals, no need for thread safety */
285: static int le_xml_parser;
286:
287: /* }}} */
288:
289: /* {{{ startup, shutdown and info functions */
290: static PHP_GINIT_FUNCTION(xml)
291: {
292: xml_globals->default_encoding = "UTF-8";
293: }
294:
295: static void *php_xml_malloc_wrapper(size_t sz)
296: {
297: return emalloc(sz);
298: }
299:
300: static void *php_xml_realloc_wrapper(void *ptr, size_t sz)
301: {
302: return erealloc(ptr, sz);
303: }
304:
305: static void php_xml_free_wrapper(void *ptr)
306: {
307: if (ptr != NULL) {
308: efree(ptr);
309: }
310: }
311:
312: PHP_MINIT_FUNCTION(xml)
313: {
314: le_xml_parser = zend_register_list_destructors_ex(xml_parser_dtor, NULL, "xml", module_number);
315:
316: REGISTER_LONG_CONSTANT("XML_ERROR_NONE", XML_ERROR_NONE, CONST_CS|CONST_PERSISTENT);
317: REGISTER_LONG_CONSTANT("XML_ERROR_NO_MEMORY", XML_ERROR_NO_MEMORY, CONST_CS|CONST_PERSISTENT);
318: REGISTER_LONG_CONSTANT("XML_ERROR_SYNTAX", XML_ERROR_SYNTAX, CONST_CS|CONST_PERSISTENT);
319: REGISTER_LONG_CONSTANT("XML_ERROR_NO_ELEMENTS", XML_ERROR_NO_ELEMENTS, CONST_CS|CONST_PERSISTENT);
320: REGISTER_LONG_CONSTANT("XML_ERROR_INVALID_TOKEN", XML_ERROR_INVALID_TOKEN, CONST_CS|CONST_PERSISTENT);
321: REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_TOKEN", XML_ERROR_UNCLOSED_TOKEN, CONST_CS|CONST_PERSISTENT);
322: REGISTER_LONG_CONSTANT("XML_ERROR_PARTIAL_CHAR", XML_ERROR_PARTIAL_CHAR, CONST_CS|CONST_PERSISTENT);
323: REGISTER_LONG_CONSTANT("XML_ERROR_TAG_MISMATCH", XML_ERROR_TAG_MISMATCH, CONST_CS|CONST_PERSISTENT);
324: REGISTER_LONG_CONSTANT("XML_ERROR_DUPLICATE_ATTRIBUTE", XML_ERROR_DUPLICATE_ATTRIBUTE, CONST_CS|CONST_PERSISTENT);
325: REGISTER_LONG_CONSTANT("XML_ERROR_JUNK_AFTER_DOC_ELEMENT", XML_ERROR_JUNK_AFTER_DOC_ELEMENT, CONST_CS|CONST_PERSISTENT);
326: REGISTER_LONG_CONSTANT("XML_ERROR_PARAM_ENTITY_REF", XML_ERROR_PARAM_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
327: REGISTER_LONG_CONSTANT("XML_ERROR_UNDEFINED_ENTITY", XML_ERROR_UNDEFINED_ENTITY, CONST_CS|CONST_PERSISTENT);
328: REGISTER_LONG_CONSTANT("XML_ERROR_RECURSIVE_ENTITY_REF", XML_ERROR_RECURSIVE_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
329: REGISTER_LONG_CONSTANT("XML_ERROR_ASYNC_ENTITY", XML_ERROR_ASYNC_ENTITY, CONST_CS|CONST_PERSISTENT);
330: REGISTER_LONG_CONSTANT("XML_ERROR_BAD_CHAR_REF", XML_ERROR_BAD_CHAR_REF, CONST_CS|CONST_PERSISTENT);
331: REGISTER_LONG_CONSTANT("XML_ERROR_BINARY_ENTITY_REF", XML_ERROR_BINARY_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
332: REGISTER_LONG_CONSTANT("XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF", XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, CONST_CS|CONST_PERSISTENT);
333: REGISTER_LONG_CONSTANT("XML_ERROR_MISPLACED_XML_PI", XML_ERROR_MISPLACED_XML_PI, CONST_CS|CONST_PERSISTENT);
334: REGISTER_LONG_CONSTANT("XML_ERROR_UNKNOWN_ENCODING", XML_ERROR_UNKNOWN_ENCODING, CONST_CS|CONST_PERSISTENT);
335: REGISTER_LONG_CONSTANT("XML_ERROR_INCORRECT_ENCODING", XML_ERROR_INCORRECT_ENCODING, CONST_CS|CONST_PERSISTENT);
336: REGISTER_LONG_CONSTANT("XML_ERROR_UNCLOSED_CDATA_SECTION", XML_ERROR_UNCLOSED_CDATA_SECTION, CONST_CS|CONST_PERSISTENT);
337: REGISTER_LONG_CONSTANT("XML_ERROR_EXTERNAL_ENTITY_HANDLING", XML_ERROR_EXTERNAL_ENTITY_HANDLING, CONST_CS|CONST_PERSISTENT);
338:
339: REGISTER_LONG_CONSTANT("XML_OPTION_CASE_FOLDING", PHP_XML_OPTION_CASE_FOLDING, CONST_CS|CONST_PERSISTENT);
340: REGISTER_LONG_CONSTANT("XML_OPTION_TARGET_ENCODING", PHP_XML_OPTION_TARGET_ENCODING, CONST_CS|CONST_PERSISTENT);
341: REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_TAGSTART", PHP_XML_OPTION_SKIP_TAGSTART, CONST_CS|CONST_PERSISTENT);
342: REGISTER_LONG_CONSTANT("XML_OPTION_SKIP_WHITE", PHP_XML_OPTION_SKIP_WHITE, CONST_CS|CONST_PERSISTENT);
343:
344: /* this object should not be pre-initialised at compile time,
345: as the order of members may vary */
346:
347: php_xml_mem_hdlrs.malloc_fcn = php_xml_malloc_wrapper;
348: php_xml_mem_hdlrs.realloc_fcn = php_xml_realloc_wrapper;
349: php_xml_mem_hdlrs.free_fcn = php_xml_free_wrapper;
350:
351: #ifdef LIBXML_EXPAT_COMPAT
352: REGISTER_STRING_CONSTANT("XML_SAX_IMPL", "libxml", CONST_CS|CONST_PERSISTENT);
353: #else
354: REGISTER_STRING_CONSTANT("XML_SAX_IMPL", "expat", CONST_CS|CONST_PERSISTENT);
355: #endif
356:
357: return SUCCESS;
358: }
359:
360: PHP_MINFO_FUNCTION(xml)
361: {
362: php_info_print_table_start();
363: php_info_print_table_row(2, "XML Support", "active");
364: php_info_print_table_row(2, "XML Namespace Support", "active");
365: #if defined(LIBXML_DOTTED_VERSION) && defined(LIBXML_EXPAT_COMPAT)
366: php_info_print_table_row(2, "libxml2 Version", LIBXML_DOTTED_VERSION);
367: #else
368: php_info_print_table_row(2, "EXPAT Version", XML_ExpatVersion());
369: #endif
370: php_info_print_table_end();
371: }
372: /* }}} */
373:
374: /* {{{ extension-internal functions */
375: static zval *_xml_resource_zval(long value)
376: {
377: zval *ret;
378: TSRMLS_FETCH();
379:
380: MAKE_STD_ZVAL(ret);
381:
382: Z_TYPE_P(ret) = IS_RESOURCE;
383: Z_LVAL_P(ret) = value;
384:
385: zend_list_addref(value);
386:
387: return ret;
388: }
389:
390: static zval *_xml_string_zval(const char *str)
391: {
392: zval *ret;
393: int len = strlen(str);
394: MAKE_STD_ZVAL(ret);
395:
396: Z_TYPE_P(ret) = IS_STRING;
397: Z_STRLEN_P(ret) = len;
398: Z_STRVAL_P(ret) = estrndup(str, len);
399: return ret;
400: }
401:
402: static zval *_xml_xmlchar_zval(const XML_Char *s, int len, const XML_Char *encoding)
403: {
404: zval *ret;
405: MAKE_STD_ZVAL(ret);
406:
407: if (s == NULL) {
408: ZVAL_FALSE(ret);
409: return ret;
410: }
411: if (len == 0) {
412: len = _xml_xmlcharlen(s);
413: }
414: Z_TYPE_P(ret) = IS_STRING;
415: Z_STRVAL_P(ret) = xml_utf8_decode(s, len, &Z_STRLEN_P(ret), encoding);
416: return ret;
417: }
418: /* }}} */
419:
420: /* {{{ xml_parser_dtor() */
421: static void xml_parser_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
422: {
423: xml_parser *parser = (xml_parser *)rsrc->ptr;
424:
425: if (parser->parser) {
426: XML_ParserFree(parser->parser);
427: }
428: if (parser->ltags) {
429: int inx;
430: for (inx = 0; inx < parser->level; inx++)
431: efree(parser->ltags[ inx ]);
432: efree(parser->ltags);
433: }
434: if (parser->startElementHandler) {
435: zval_ptr_dtor(&parser->startElementHandler);
436: }
437: if (parser->endElementHandler) {
438: zval_ptr_dtor(&parser->endElementHandler);
439: }
440: if (parser->characterDataHandler) {
441: zval_ptr_dtor(&parser->characterDataHandler);
442: }
443: if (parser->processingInstructionHandler) {
444: zval_ptr_dtor(&parser->processingInstructionHandler);
445: }
446: if (parser->defaultHandler) {
447: zval_ptr_dtor(&parser->defaultHandler);
448: }
449: if (parser->unparsedEntityDeclHandler) {
450: zval_ptr_dtor(&parser->unparsedEntityDeclHandler);
451: }
452: if (parser->notationDeclHandler) {
453: zval_ptr_dtor(&parser->notationDeclHandler);
454: }
455: if (parser->externalEntityRefHandler) {
456: zval_ptr_dtor(&parser->externalEntityRefHandler);
457: }
458: if (parser->unknownEncodingHandler) {
459: zval_ptr_dtor(&parser->unknownEncodingHandler);
460: }
461: if (parser->startNamespaceDeclHandler) {
462: zval_ptr_dtor(&parser->startNamespaceDeclHandler);
463: }
464: if (parser->endNamespaceDeclHandler) {
465: zval_ptr_dtor(&parser->endNamespaceDeclHandler);
466: }
467: if (parser->baseURI) {
468: efree(parser->baseURI);
469: }
470: if (parser->object) {
471: zval_ptr_dtor(&parser->object);
472: }
473:
474: efree(parser);
475: }
476: /* }}} */
477:
478: /* {{{ xml_set_handler() */
479: static void xml_set_handler(zval **handler, zval **data)
480: {
481: /* If we have already a handler, release it */
482: if (*handler) {
483: zval_ptr_dtor(handler);
484: }
485:
486: /* IS_ARRAY might indicate that we're using array($obj, 'method') syntax */
487: if (Z_TYPE_PP(data) != IS_ARRAY && Z_TYPE_PP(data) != IS_OBJECT) {
488:
489: convert_to_string_ex(data);
490: if (Z_STRLEN_PP(data) == 0) {
491: *handler = NULL;
492: return;
493: }
494: }
495:
496: zval_add_ref(data);
497:
498: *handler = *data;
499: }
500: /* }}} */
501:
502: /* {{{ xml_call_handler() */
503: static zval *xml_call_handler(xml_parser *parser, zval *handler, zend_function *function_ptr, int argc, zval **argv)
504: {
505: int i;
506: TSRMLS_FETCH();
507:
508: if (parser && handler && !EG(exception)) {
509: zval ***args;
510: zval *retval;
511: int result;
512: zend_fcall_info fci;
513:
514: args = safe_emalloc(sizeof(zval **), argc, 0);
515: for (i = 0; i < argc; i++) {
516: args[i] = &argv[i];
517: }
518:
519: fci.size = sizeof(fci);
520: fci.function_table = EG(function_table);
521: fci.function_name = handler;
522: fci.symbol_table = NULL;
523: fci.object_ptr = parser->object;
524: fci.retval_ptr_ptr = &retval;
525: fci.param_count = argc;
526: fci.params = args;
527: fci.no_separation = 0;
528: /*fci.function_handler_cache = &function_ptr;*/
529:
530: result = zend_call_function(&fci, NULL TSRMLS_CC);
531: if (result == FAILURE) {
532: zval **method;
533: zval **obj;
534:
535: if (Z_TYPE_P(handler) == IS_STRING) {
536: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(handler));
537: } else if (zend_hash_index_find(Z_ARRVAL_P(handler), 0, (void **) &obj) == SUCCESS &&
538: zend_hash_index_find(Z_ARRVAL_P(handler), 1, (void **) &method) == SUCCESS &&
539: Z_TYPE_PP(obj) == IS_OBJECT &&
540: Z_TYPE_PP(method) == IS_STRING) {
541: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s::%s()", Z_OBJCE_PP(obj)->name, Z_STRVAL_PP(method));
542: } else
543: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler");
544: }
545:
546: for (i = 0; i < argc; i++) {
547: zval_ptr_dtor(args[i]);
548: }
549: efree(args);
550:
551: if (result == FAILURE) {
552: return NULL;
553: } else {
554: return EG(exception) ? NULL : retval;
555: }
556: } else {
557: for (i = 0; i < argc; i++) {
558: zval_ptr_dtor(&argv[i]);
559: }
560: return NULL;
561: }
562: }
563: /* }}} */
564:
565: /* {{{ xml_encode_iso_8859_1() */
566: inline static unsigned short xml_encode_iso_8859_1(unsigned char c)
567: {
568: return (unsigned short)c;
569: }
570: /* }}} */
571:
572: /* {{{ xml_decode_iso_8859_1() */
573: inline static char xml_decode_iso_8859_1(unsigned short c)
574: {
575: return (char)(c > 0xff ? '?' : c);
576: }
577: /* }}} */
578:
579: /* {{{ xml_encode_us_ascii() */
580: inline static unsigned short xml_encode_us_ascii(unsigned char c)
581: {
582: return (unsigned short)c;
583: }
584: /* }}} */
585:
586: /* {{{ xml_decode_us_ascii() */
587: inline static char xml_decode_us_ascii(unsigned short c)
588: {
589: return (char)(c > 0x7f ? '?' : c);
590: }
591: /* }}} */
592:
593: /* {{{ xml_get_encoding() */
594: static xml_encoding *xml_get_encoding(const XML_Char *name)
595: {
596: xml_encoding *enc = &xml_encodings[0];
597:
598: while (enc && enc->name) {
599: if (strcasecmp(name, enc->name) == 0) {
600: return enc;
601: }
602: enc++;
603: }
604: return NULL;
605: }
606: /* }}} */
607:
608: /* {{{ xml_utf8_encode */
609: PHPAPI char *xml_utf8_encode(const char *s, int len, int *newlen, const XML_Char *encoding)
610: {
611: int pos = len;
612: char *newbuf;
613: unsigned int c;
614: unsigned short (*encoder)(unsigned char) = NULL;
615: xml_encoding *enc = xml_get_encoding(encoding);
616:
617: *newlen = 0;
618: if (enc) {
619: encoder = enc->encoding_function;
620: } else {
621: /* If the target encoding was unknown, fail */
622: return NULL;
623: }
624: if (encoder == NULL) {
625: /* If no encoder function was specified, return the data as-is.
626: */
627: newbuf = emalloc(len + 1);
628: memcpy(newbuf, s, len);
629: *newlen = len;
630: newbuf[*newlen] = '\0';
631: return newbuf;
632: }
633: /* This is the theoretical max (will never get beyond len * 2 as long
634: * as we are converting from single-byte characters, though) */
635: newbuf = safe_emalloc(len, 4, 1);
636: while (pos > 0) {
637: c = encoder ? encoder((unsigned char)(*s)) : (unsigned short)(*s);
638: if (c < 0x80) {
639: newbuf[(*newlen)++] = (char) c;
640: } else if (c < 0x800) {
641: newbuf[(*newlen)++] = (0xc0 | (c >> 6));
642: newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
643: } else if (c < 0x10000) {
644: newbuf[(*newlen)++] = (0xe0 | (c >> 12));
645: newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
646: newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
647: } else if (c < 0x200000) {
648: newbuf[(*newlen)++] = (0xf0 | (c >> 18));
649: newbuf[(*newlen)++] = (0xe0 | ((c >> 12) & 0x3f));
650: newbuf[(*newlen)++] = (0xc0 | ((c >> 6) & 0x3f));
651: newbuf[(*newlen)++] = (0x80 | (c & 0x3f));
652: }
653: pos--;
654: s++;
655: }
656: newbuf[*newlen] = 0;
657: newbuf = erealloc(newbuf, (*newlen)+1);
658: return newbuf;
659: }
660: /* }}} */
661:
662: /* copied from trunk's implementation of get_next_char in ext/standard/html.c */
663: #define MB_FAILURE(pos, advance) do { \
664: *cursor = pos + (advance); \
665: *status = FAILURE; \
666: return 0; \
667: } while (0)
668:
669: #define CHECK_LEN(pos, chars_need) ((str_len - (pos)) >= (chars_need))
670: #define utf8_lead(c) ((c) < 0x80 || ((c) >= 0xC2 && (c) <= 0xF4))
671: #define utf8_trail(c) ((c) >= 0x80 && (c) <= 0xBF)
672:
673: /* {{{ php_next_utf8_char
674: */
675: static inline unsigned int php_next_utf8_char(
676: const unsigned char *str,
677: size_t str_len,
678: size_t *cursor,
679: int *status)
680: {
681: size_t pos = *cursor;
682: unsigned int this_char = 0;
683: unsigned char c;
684:
685: *status = SUCCESS;
686:
687: if (!CHECK_LEN(pos, 1))
688: MB_FAILURE(pos, 1);
689:
690: /* We'll follow strategy 2. from section 3.6.1 of UTR #36:
691: * "In a reported illegal byte sequence, do not include any
692: * non-initial byte that encodes a valid character or is a leading
693: * byte for a valid sequence.» */
694: c = str[pos];
695: if (c < 0x80) {
696: this_char = c;
697: pos++;
698: } else if (c < 0xc2) {
699: MB_FAILURE(pos, 1);
700: } else if (c < 0xe0) {
701: if (!CHECK_LEN(pos, 2))
702: MB_FAILURE(pos, 1);
703:
704: if (!utf8_trail(str[pos + 1])) {
705: MB_FAILURE(pos, utf8_lead(str[pos + 1]) ? 1 : 2);
706: }
707: this_char = ((c & 0x1f) << 6) | (str[pos + 1] & 0x3f);
708: if (this_char < 0x80) { /* non-shortest form */
709: MB_FAILURE(pos, 2);
710: }
711: pos += 2;
712: } else if (c < 0xf0) {
713: size_t avail = str_len - pos;
714:
715: if (avail < 3 ||
716: !utf8_trail(str[pos + 1]) || !utf8_trail(str[pos + 2])) {
717: if (avail < 2 || utf8_lead(str[pos + 1]))
718: MB_FAILURE(pos, 1);
719: else if (avail < 3 || utf8_lead(str[pos + 2]))
720: MB_FAILURE(pos, 2);
721: else
722: MB_FAILURE(pos, 3);
723: }
724:
725: this_char = ((c & 0x0f) << 12) | ((str[pos + 1] & 0x3f) << 6) | (str[pos + 2] & 0x3f);
726: if (this_char < 0x800) { /* non-shortest form */
727: MB_FAILURE(pos, 3);
728: } else if (this_char >= 0xd800 && this_char <= 0xdfff) { /* surrogate */
729: MB_FAILURE(pos, 3);
730: }
731: pos += 3;
732: } else if (c < 0xf5) {
733: size_t avail = str_len - pos;
734:
735: if (avail < 4 ||
736: !utf8_trail(str[pos + 1]) || !utf8_trail(str[pos + 2]) ||
737: !utf8_trail(str[pos + 3])) {
738: if (avail < 2 || utf8_lead(str[pos + 1]))
739: MB_FAILURE(pos, 1);
740: else if (avail < 3 || utf8_lead(str[pos + 2]))
741: MB_FAILURE(pos, 2);
742: else if (avail < 4 || utf8_lead(str[pos + 3]))
743: MB_FAILURE(pos, 3);
744: else
745: MB_FAILURE(pos, 4);
746: }
747:
748: this_char = ((c & 0x07) << 18) | ((str[pos + 1] & 0x3f) << 12) | ((str[pos + 2] & 0x3f) << 6) | (str[pos + 3] & 0x3f);
749: if (this_char < 0x10000 || this_char > 0x10FFFF) { /* non-shortest form or outside range */
750: MB_FAILURE(pos, 4);
751: }
752: pos += 4;
753: } else {
754: MB_FAILURE(pos, 1);
755: }
756:
757: *cursor = pos;
758: return this_char;
759: }
760: /* }}} */
761:
762:
763: /* {{{ xml_utf8_decode */
764: PHPAPI char *xml_utf8_decode(const XML_Char *s, int len, int *newlen, const XML_Char *encoding)
765: {
766: size_t pos = 0;
767: char *newbuf = emalloc(len + 1);
768: unsigned int c;
769: char (*decoder)(unsigned short) = NULL;
770: xml_encoding *enc = xml_get_encoding(encoding);
771:
772: *newlen = 0;
773: if (enc) {
774: decoder = enc->decoding_function;
775: }
776: if (decoder == NULL) {
777: /* If the target encoding was unknown, or no decoder function
778: * was specified, return the UTF-8-encoded data as-is.
779: */
780: memcpy(newbuf, s, len);
781: *newlen = len;
782: newbuf[*newlen] = '\0';
783: return newbuf;
784: }
785:
786: while (pos < (size_t)len) {
787: int status = FAILURE;
788: c = php_next_utf8_char((const unsigned char*)s, (size_t) len, &pos, &status);
789:
790: if (status == FAILURE || c > 0xFFU) {
791: c = '?';
792: }
793:
794: newbuf[*newlen] = decoder ? decoder(c) : c;
795: ++*newlen;
796: }
797: if (*newlen < len) {
798: newbuf = erealloc(newbuf, *newlen + 1);
799: }
800: newbuf[*newlen] = '\0';
801: return newbuf;
802: }
803: /* }}} */
804:
805: /* {{{ _xml_xmlcharlen() */
806: static int _xml_xmlcharlen(const XML_Char *s)
807: {
808: int len = 0;
809:
810: while (*s) {
811: len++;
812: s++;
813: }
814: return len;
815: }
816: /* }}} */
817:
818: /* {{{ _xml_zval_strdup() */
819: PHPAPI char *_xml_zval_strdup(zval *val)
820: {
821: if (Z_TYPE_P(val) == IS_STRING) {
822: char *buf = emalloc(Z_STRLEN_P(val) + 1);
823: memcpy(buf, Z_STRVAL_P(val), Z_STRLEN_P(val));
824: buf[Z_STRLEN_P(val)] = '\0';
825: return buf;
826: }
827: return NULL;
828: }
829: /* }}} */
830:
831: /* {{{ _xml_add_to_info */
832: static void _xml_add_to_info(xml_parser *parser,char *name)
833: {
834: zval **element, *values;
835:
836: if (! parser->info) {
837: return;
838: }
839:
840: if (zend_hash_find(Z_ARRVAL_P(parser->info),name,strlen(name) + 1,(void **) &element) == FAILURE) {
841: MAKE_STD_ZVAL(values);
842:
843: array_init(values);
844:
845: zend_hash_update(Z_ARRVAL_P(parser->info), name, strlen(name)+1, (void *) &values, sizeof(zval*), (void **) &element);
846: }
847:
848: add_next_index_long(*element,parser->curtag);
849:
850: parser->curtag++;
851: }
852: /* }}} */
853:
854: /* {{{ _xml_decode_tag() */
855: static char *_xml_decode_tag(xml_parser *parser, const char *tag)
856: {
857: char *newstr;
858: int out_len;
859:
860: newstr = xml_utf8_decode(tag, strlen(tag), &out_len, parser->target_encoding);
861:
862: if (parser->case_folding) {
863: php_strtoupper(newstr, out_len);
864: }
865:
866: return newstr;
867: }
868: /* }}} */
869:
870: /* {{{ _xml_startElementHandler() */
871: void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Char **attributes)
872: {
873: xml_parser *parser = (xml_parser *)userData;
874: const char **attrs = (const char **) attributes;
875: char *tag_name;
876: char *att, *val;
877: int val_len;
878: zval *retval, *args[3];
879:
880: if (parser) {
881: parser->level++;
882:
883: tag_name = _xml_decode_tag(parser, name);
884:
885: if (parser->startElementHandler) {
886: args[0] = _xml_resource_zval(parser->index);
887: args[1] = _xml_string_zval(((char *) tag_name) + parser->toffset);
888: MAKE_STD_ZVAL(args[2]);
889: array_init(args[2]);
890:
891: while (attributes && *attributes) {
892: att = _xml_decode_tag(parser, attributes[0]);
893: val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
894:
895: add_assoc_stringl(args[2], att, val, val_len, 0);
896:
897: attributes += 2;
898:
899: efree(att);
900: }
901:
902: if ((retval = xml_call_handler(parser, parser->startElementHandler, parser->startElementPtr, 3, args))) {
903: zval_ptr_dtor(&retval);
904: }
905: }
906:
907: if (parser->data) {
908: zval *tag, *atr;
909: int atcnt = 0;
910:
911: MAKE_STD_ZVAL(tag);
912: MAKE_STD_ZVAL(atr);
913:
914: array_init(tag);
915: array_init(atr);
916:
917: _xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
918:
919: add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
920: add_assoc_string(tag,"type","open",1);
921: add_assoc_long(tag,"level",parser->level);
922:
923: parser->ltags[parser->level-1] = estrdup(tag_name);
924: parser->lastwasopen = 1;
925:
926: attributes = (const XML_Char **) attrs;
927:
928: while (attributes && *attributes) {
929: att = _xml_decode_tag(parser, attributes[0]);
930: val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
931:
932: add_assoc_stringl(atr,att,val,val_len,0);
933:
934: atcnt++;
935: attributes += 2;
936:
937: efree(att);
938: }
939:
940: if (atcnt) {
941: zend_hash_add(Z_ARRVAL_P(tag),"attributes",sizeof("attributes"),&atr,sizeof(zval*),NULL);
942: } else {
943: zval_ptr_dtor(&atr);
944: }
945:
946: zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),(void *) &parser->ctag);
947: }
948:
949: efree(tag_name);
950: }
951: }
952: /* }}} */
953:
954: /* {{{ _xml_endElementHandler() */
955: void _xml_endElementHandler(void *userData, const XML_Char *name)
956: {
957: xml_parser *parser = (xml_parser *)userData;
958: char *tag_name;
959:
960: if (parser) {
961: zval *retval, *args[2];
962:
963: tag_name = _xml_decode_tag(parser, name);
964:
965: if (parser->endElementHandler) {
966: args[0] = _xml_resource_zval(parser->index);
967: args[1] = _xml_string_zval(((char *) tag_name) + parser->toffset);
968:
969: if ((retval = xml_call_handler(parser, parser->endElementHandler, parser->endElementPtr, 2, args))) {
970: zval_ptr_dtor(&retval);
971: }
972: }
973:
974: if (parser->data) {
975: zval *tag;
976:
977: if (parser->lastwasopen) {
978: add_assoc_string(*(parser->ctag),"type","complete",1);
979: } else {
980: MAKE_STD_ZVAL(tag);
981:
982: array_init(tag);
983:
984: _xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
985:
986: add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
987: add_assoc_string(tag,"type","close",1);
988: add_assoc_long(tag,"level",parser->level);
989:
990: zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
991: }
992:
993: parser->lastwasopen = 0;
994: }
995:
996: efree(tag_name);
997:
998: if (parser->ltags) {
999: efree(parser->ltags[parser->level-1]);
1000: }
1001:
1002: parser->level--;
1003: }
1004: }
1005: /* }}} */
1006:
1007: /* {{{ _xml_characterDataHandler() */
1008: void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
1009: {
1010: xml_parser *parser = (xml_parser *)userData;
1011:
1012: if (parser) {
1013: zval *retval, *args[2];
1014:
1015: if (parser->characterDataHandler) {
1016: args[0] = _xml_resource_zval(parser->index);
1017: args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
1018: if ((retval = xml_call_handler(parser, parser->characterDataHandler, parser->characterDataPtr, 2, args))) {
1019: zval_ptr_dtor(&retval);
1020: }
1021: }
1022:
1023: if (parser->data) {
1024: int i;
1025: int doprint = 0;
1026:
1027: char *decoded_value;
1028: int decoded_len;
1029:
1030: decoded_value = xml_utf8_decode(s,len,&decoded_len,parser->target_encoding);
1031: for (i = 0; i < decoded_len; i++) {
1032: switch (decoded_value[i]) {
1033: case ' ':
1034: case '\t':
1035: case '\n':
1036: continue;
1037: default:
1038: doprint = 1;
1039: break;
1040: }
1041: if (doprint) {
1042: break;
1043: }
1044: }
1045: if (doprint || (! parser->skipwhite)) {
1046: if (parser->lastwasopen) {
1047: zval **myval;
1048:
1049: /* check if the current tag already has a value - if yes append to that! */
1050: if (zend_hash_find(Z_ARRVAL_PP(parser->ctag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
1051: int newlen = Z_STRLEN_PP(myval) + decoded_len;
1052: Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
1053: strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
1054: Z_STRLEN_PP(myval) += decoded_len;
1055: efree(decoded_value);
1056: } else {
1057: add_assoc_string(*(parser->ctag),"value",decoded_value,0);
1058: }
1059:
1060: } else {
1061: zval *tag;
1062: zval **curtag, **mytype, **myval;
1063: HashPosition hpos=NULL;
1064:
1065: zend_hash_internal_pointer_end_ex(Z_ARRVAL_P(parser->data), &hpos);
1066:
1067: if (hpos && (zend_hash_get_current_data_ex(Z_ARRVAL_P(parser->data), (void **) &curtag, &hpos) == SUCCESS)) {
1068: if (zend_hash_find(Z_ARRVAL_PP(curtag),"type",sizeof("type"),(void **) &mytype) == SUCCESS) {
1069: if (!strcmp(Z_STRVAL_PP(mytype), "cdata")) {
1070: if (zend_hash_find(Z_ARRVAL_PP(curtag),"value",sizeof("value"),(void **) &myval) == SUCCESS) {
1071: int newlen = Z_STRLEN_PP(myval) + decoded_len;
1072: Z_STRVAL_PP(myval) = erealloc(Z_STRVAL_PP(myval),newlen+1);
1073: strncpy(Z_STRVAL_PP(myval) + Z_STRLEN_PP(myval), decoded_value, decoded_len + 1);
1074: Z_STRLEN_PP(myval) += decoded_len;
1075: efree(decoded_value);
1076: return;
1077: }
1078: }
1079: }
1080: }
1081:
1082: MAKE_STD_ZVAL(tag);
1083:
1084: array_init(tag);
1085:
1086: _xml_add_to_info(parser,parser->ltags[parser->level-1] + parser->toffset);
1087:
1088: add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset,1);
1089: add_assoc_string(tag,"value",decoded_value,0);
1090: add_assoc_string(tag,"type","cdata",1);
1091: add_assoc_long(tag,"level",parser->level);
1092:
1093: zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
1094: }
1095: } else {
1096: efree(decoded_value);
1097: }
1098: }
1099: }
1100: }
1101: /* }}} */
1102:
1103: /* {{{ _xml_processingInstructionHandler() */
1104: void _xml_processingInstructionHandler(void *userData, const XML_Char *target, const XML_Char *data)
1105: {
1106: xml_parser *parser = (xml_parser *)userData;
1107:
1108: if (parser && parser->processingInstructionHandler) {
1109: zval *retval, *args[3];
1110:
1111: args[0] = _xml_resource_zval(parser->index);
1112: args[1] = _xml_xmlchar_zval(target, 0, parser->target_encoding);
1113: args[2] = _xml_xmlchar_zval(data, 0, parser->target_encoding);
1114: if ((retval = xml_call_handler(parser, parser->processingInstructionHandler, parser->processingInstructionPtr, 3, args))) {
1115: zval_ptr_dtor(&retval);
1116: }
1117: }
1118: }
1119: /* }}} */
1120:
1121: /* {{{ _xml_defaultHandler() */
1122: void _xml_defaultHandler(void *userData, const XML_Char *s, int len)
1123: {
1124: xml_parser *parser = (xml_parser *)userData;
1125:
1126: if (parser && parser->defaultHandler) {
1127: zval *retval, *args[2];
1128:
1129: args[0] = _xml_resource_zval(parser->index);
1130: args[1] = _xml_xmlchar_zval(s, len, parser->target_encoding);
1131: if ((retval = xml_call_handler(parser, parser->defaultHandler, parser->defaultPtr, 2, args))) {
1132: zval_ptr_dtor(&retval);
1133: }
1134: }
1135: }
1136: /* }}} */
1137:
1138: /* {{{ _xml_unparsedEntityDeclHandler() */
1139: void _xml_unparsedEntityDeclHandler(void *userData,
1140: const XML_Char *entityName,
1141: const XML_Char *base,
1142: const XML_Char *systemId,
1143: const XML_Char *publicId,
1144: const XML_Char *notationName)
1145: {
1146: xml_parser *parser = (xml_parser *)userData;
1147:
1148: if (parser && parser->unparsedEntityDeclHandler) {
1149: zval *retval, *args[6];
1150:
1151: args[0] = _xml_resource_zval(parser->index);
1152: args[1] = _xml_xmlchar_zval(entityName, 0, parser->target_encoding);
1153: args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1154: args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1155: args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1156: args[5] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
1157: if ((retval = xml_call_handler(parser, parser->unparsedEntityDeclHandler, parser->unparsedEntityDeclPtr, 6, args))) {
1158: zval_ptr_dtor(&retval);
1159: }
1160: }
1161: }
1162: /* }}} */
1163:
1164: /* {{{ _xml_notationDeclHandler() */
1165: void _xml_notationDeclHandler(void *userData,
1166: const XML_Char *notationName,
1167: const XML_Char *base,
1168: const XML_Char *systemId,
1169: const XML_Char *publicId)
1170: {
1171: xml_parser *parser = (xml_parser *)userData;
1172:
1173: if (parser && parser->notationDeclHandler) {
1174: zval *retval, *args[5];
1175:
1176: args[0] = _xml_resource_zval(parser->index);
1177: args[1] = _xml_xmlchar_zval(notationName, 0, parser->target_encoding);
1178: args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1179: args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1180: args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1181: if ((retval = xml_call_handler(parser, parser->notationDeclHandler, parser->notationDeclPtr, 5, args))) {
1182: zval_ptr_dtor(&retval);
1183: }
1184: }
1185: }
1186: /* }}} */
1187:
1188: /* {{{ _xml_externalEntityRefHandler() */
1189: int _xml_externalEntityRefHandler(XML_Parser parserPtr,
1190: const XML_Char *openEntityNames,
1191: const XML_Char *base,
1192: const XML_Char *systemId,
1193: const XML_Char *publicId)
1194: {
1195: xml_parser *parser = XML_GetUserData(parserPtr);
1196: int ret = 0; /* abort if no handler is set (should be configurable?) */
1197:
1198: if (parser && parser->externalEntityRefHandler) {
1199: zval *retval, *args[5];
1200:
1201: args[0] = _xml_resource_zval(parser->index);
1202: args[1] = _xml_xmlchar_zval(openEntityNames, 0, parser->target_encoding);
1203: args[2] = _xml_xmlchar_zval(base, 0, parser->target_encoding);
1204: args[3] = _xml_xmlchar_zval(systemId, 0, parser->target_encoding);
1205: args[4] = _xml_xmlchar_zval(publicId, 0, parser->target_encoding);
1206: if ((retval = xml_call_handler(parser, parser->externalEntityRefHandler, parser->externalEntityRefPtr, 5, args))) {
1207: convert_to_long(retval);
1208: ret = Z_LVAL_P(retval);
1209: efree(retval);
1210: } else {
1211: ret = 0;
1212: }
1213: }
1214: return ret;
1215: }
1216: /* }}} */
1217:
1218: /* {{{ _xml_startNamespaceDeclHandler() */
1219: void _xml_startNamespaceDeclHandler(void *userData,const XML_Char *prefix, const XML_Char *uri)
1220: {
1221: xml_parser *parser = (xml_parser *)userData;
1222:
1223: if (parser && parser->startNamespaceDeclHandler) {
1224: zval *retval, *args[3];
1225:
1226: args[0] = _xml_resource_zval(parser->index);
1227: args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
1228: args[2] = _xml_xmlchar_zval(uri, 0, parser->target_encoding);
1229: if ((retval = xml_call_handler(parser, parser->startNamespaceDeclHandler, parser->startNamespaceDeclPtr, 3, args))) {
1230: zval_ptr_dtor(&retval);
1231: }
1232: }
1233: }
1234: /* }}} */
1235:
1236: /* {{{ _xml_endNamespaceDeclHandler() */
1237: void _xml_endNamespaceDeclHandler(void *userData, const XML_Char *prefix)
1238: {
1239: xml_parser *parser = (xml_parser *)userData;
1240:
1241: if (parser && parser->endNamespaceDeclHandler) {
1242: zval *retval, *args[2];
1243:
1244: args[0] = _xml_resource_zval(parser->index);
1245: args[1] = _xml_xmlchar_zval(prefix, 0, parser->target_encoding);
1246: if ((retval = xml_call_handler(parser, parser->endNamespaceDeclHandler, parser->endNamespaceDeclPtr, 2, args))) {
1247: zval_ptr_dtor(&retval);
1248: }
1249: }
1250: }
1251: /* }}} */
1252:
1253: /************************* EXTENSION FUNCTIONS *************************/
1254:
1255: static void php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAMETERS, int ns_support) /* {{{ */
1256: {
1257: xml_parser *parser;
1258: int auto_detect = 0;
1259:
1260: char *encoding_param = NULL;
1261: int encoding_param_len = 0;
1262:
1263: char *ns_param = NULL;
1264: int ns_param_len = 0;
1265:
1266: XML_Char *encoding;
1267:
1268: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, (ns_support ? "|ss": "|s"), &encoding_param, &encoding_param_len, &ns_param, &ns_param_len) == FAILURE) {
1269: RETURN_FALSE;
1270: }
1271:
1272: if (encoding_param != NULL) {
1273: /* The supported encoding types are hardcoded here because
1274: * we are limited to the encodings supported by expat/xmltok.
1275: */
1276: if (encoding_param_len == 0) {
1277: encoding = XML(default_encoding);
1278: auto_detect = 1;
1279: } else if (strcasecmp(encoding_param, "ISO-8859-1") == 0) {
1280: encoding = "ISO-8859-1";
1281: } else if (strcasecmp(encoding_param, "UTF-8") == 0) {
1282: encoding = "UTF-8";
1283: } else if (strcasecmp(encoding_param, "US-ASCII") == 0) {
1284: encoding = "US-ASCII";
1285: } else {
1286: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unsupported source encoding \"%s\"", encoding_param);
1287: RETURN_FALSE;
1288: }
1289: } else {
1290: encoding = XML(default_encoding);
1291: }
1292:
1293: if (ns_support && ns_param == NULL){
1294: ns_param = ":";
1295: }
1296:
1297: parser = ecalloc(1, sizeof(xml_parser));
1298: parser->parser = XML_ParserCreate_MM((auto_detect ? NULL : encoding),
1299: &php_xml_mem_hdlrs, ns_param);
1300:
1301: parser->target_encoding = encoding;
1302: parser->case_folding = 1;
1303: parser->object = NULL;
1304: parser->isparsing = 0;
1305:
1306: XML_SetUserData(parser->parser, parser);
1307:
1308: ZEND_REGISTER_RESOURCE(return_value, parser,le_xml_parser);
1309: parser->index = Z_LVAL_P(return_value);
1310: }
1311: /* }}} */
1312:
1313: /* {{{ proto resource xml_parser_create([string encoding])
1314: Create an XML parser */
1315: PHP_FUNCTION(xml_parser_create)
1316: {
1317: php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1318: }
1319: /* }}} */
1320:
1321: /* {{{ proto resource xml_parser_create_ns([string encoding [, string sep]])
1322: Create an XML parser */
1323: PHP_FUNCTION(xml_parser_create_ns)
1324: {
1325: php_xml_parser_create_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1326: }
1327: /* }}} */
1328:
1329: /* {{{ proto int xml_set_object(resource parser, object &obj)
1330: Set up object which should be used for callbacks */
1331: PHP_FUNCTION(xml_set_object)
1332: {
1333: xml_parser *parser;
1334: zval *pind, *mythis;
1335:
1336: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ro", &pind, &mythis) == FAILURE) {
1337: return;
1338: }
1339:
1340: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1341:
1342: /* please leave this commented - or ask thies@thieso.net before doing it (again) */
1343: if (parser->object) {
1344: zval_ptr_dtor(&parser->object);
1345: }
1346:
1347: /* please leave this commented - or ask thies@thieso.net before doing it (again) */
1348: /* #ifdef ZEND_ENGINE_2
1349: zval_add_ref(&parser->object);
1350: #endif */
1351:
1352: ALLOC_ZVAL(parser->object);
1353: MAKE_COPY_ZVAL(&mythis, parser->object);
1354:
1355: RETVAL_TRUE;
1356: }
1357: /* }}} */
1358:
1359: /* {{{ proto int xml_set_element_handler(resource parser, string shdl, string ehdl)
1360: Set up start and end element handlers */
1361: PHP_FUNCTION(xml_set_element_handler)
1362: {
1363: xml_parser *parser;
1364: zval *pind, **shdl, **ehdl;
1365:
1366: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZZ", &pind, &shdl, &ehdl) == FAILURE) {
1367: return;
1368: }
1369:
1370: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1371:
1372: xml_set_handler(&parser->startElementHandler, shdl);
1373: xml_set_handler(&parser->endElementHandler, ehdl);
1374: XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
1375: RETVAL_TRUE;
1376: }
1377: /* }}} */
1378:
1379: /* {{{ proto int xml_set_character_data_handler(resource parser, string hdl)
1380: Set up character data handler */
1381: PHP_FUNCTION(xml_set_character_data_handler)
1382: {
1383: xml_parser *parser;
1384: zval *pind, **hdl;
1385:
1386: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1387: return;
1388: }
1389:
1390: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1391:
1392: xml_set_handler(&parser->characterDataHandler, hdl);
1393: XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
1394: RETVAL_TRUE;
1395: }
1396: /* }}} */
1397:
1398: /* {{{ proto int xml_set_processing_instruction_handler(resource parser, string hdl)
1399: Set up processing instruction (PI) handler */
1400: PHP_FUNCTION(xml_set_processing_instruction_handler)
1401: {
1402: xml_parser *parser;
1403: zval *pind, **hdl;
1404:
1405: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1406: return;
1407: }
1408:
1409: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1410:
1411: xml_set_handler(&parser->processingInstructionHandler, hdl);
1412: XML_SetProcessingInstructionHandler(parser->parser, _xml_processingInstructionHandler);
1413: RETVAL_TRUE;
1414: }
1415: /* }}} */
1416:
1417: /* {{{ proto int xml_set_default_handler(resource parser, string hdl)
1418: Set up default handler */
1419: PHP_FUNCTION(xml_set_default_handler)
1420: {
1421: xml_parser *parser;
1422: zval *pind, **hdl;
1423:
1424: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1425: return;
1426: }
1427: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1428:
1429: xml_set_handler(&parser->defaultHandler, hdl);
1430: XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
1431: RETVAL_TRUE;
1432: }
1433: /* }}} */
1434:
1435: /* {{{ proto int xml_set_unparsed_entity_decl_handler(resource parser, string hdl)
1436: Set up unparsed entity declaration handler */
1437: PHP_FUNCTION(xml_set_unparsed_entity_decl_handler)
1438: {
1439: xml_parser *parser;
1440: zval *pind, **hdl;
1441:
1442: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1443: return;
1444: }
1445:
1446: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1447:
1448: xml_set_handler(&parser->unparsedEntityDeclHandler, hdl);
1449: XML_SetUnparsedEntityDeclHandler(parser->parser, _xml_unparsedEntityDeclHandler);
1450: RETVAL_TRUE;
1451: }
1452: /* }}} */
1453:
1454: /* {{{ proto int xml_set_notation_decl_handler(resource parser, string hdl)
1455: Set up notation declaration handler */
1456: PHP_FUNCTION(xml_set_notation_decl_handler)
1457: {
1458: xml_parser *parser;
1459: zval *pind, **hdl;
1460:
1461: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1462: return;
1463: }
1464: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1465:
1466: xml_set_handler(&parser->notationDeclHandler, hdl);
1467: XML_SetNotationDeclHandler(parser->parser, _xml_notationDeclHandler);
1468: RETVAL_TRUE;
1469: }
1470: /* }}} */
1471:
1472: /* {{{ proto int xml_set_external_entity_ref_handler(resource parser, string hdl)
1473: Set up external entity reference handler */
1474: PHP_FUNCTION(xml_set_external_entity_ref_handler)
1475: {
1476: xml_parser *parser;
1477: zval *pind, **hdl;
1478:
1479: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1480: return;
1481: }
1482: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1483:
1484: xml_set_handler(&parser->externalEntityRefHandler, hdl);
1485: XML_SetExternalEntityRefHandler(parser->parser, (void *) _xml_externalEntityRefHandler);
1486: RETVAL_TRUE;
1487: }
1488: /* }}} */
1489:
1490: /* {{{ proto int xml_set_start_namespace_decl_handler(resource parser, string hdl)
1491: Set up character data handler */
1492: PHP_FUNCTION(xml_set_start_namespace_decl_handler)
1493: {
1494: xml_parser *parser;
1495: zval *pind, **hdl;
1496:
1497: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1498: return;
1499: }
1500:
1501: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1502:
1503: xml_set_handler(&parser->startNamespaceDeclHandler, hdl);
1504: XML_SetStartNamespaceDeclHandler(parser->parser, _xml_startNamespaceDeclHandler);
1505: RETVAL_TRUE;
1506: }
1507: /* }}} */
1508:
1509: /* {{{ proto int xml_set_end_namespace_decl_handler(resource parser, string hdl)
1510: Set up character data handler */
1511: PHP_FUNCTION(xml_set_end_namespace_decl_handler)
1512: {
1513: xml_parser *parser;
1514: zval *pind, **hdl;
1515:
1516: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pind, &hdl) == FAILURE) {
1517: return;
1518: }
1519:
1520: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1521:
1522: xml_set_handler(&parser->endNamespaceDeclHandler, hdl);
1523: XML_SetEndNamespaceDeclHandler(parser->parser, _xml_endNamespaceDeclHandler);
1524: RETVAL_TRUE;
1525: }
1526: /* }}} */
1527:
1528: /* {{{ proto int xml_parse(resource parser, string data [, int isFinal])
1529: Start parsing an XML document */
1530: PHP_FUNCTION(xml_parse)
1531: {
1532: xml_parser *parser;
1533: zval *pind;
1534: char *data;
1535: int data_len, ret;
1536: long isFinal = 0;
1537:
1538: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pind, &data, &data_len, &isFinal) == FAILURE) {
1539: return;
1540: }
1541: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1542:
1543: parser->isparsing = 1;
1544: ret = XML_Parse(parser->parser, data, data_len, isFinal);
1545: parser->isparsing = 0;
1546: RETVAL_LONG(ret);
1547: }
1548:
1549: /* }}} */
1550:
1551: /* {{{ proto int xml_parse_into_struct(resource parser, string data, array &values [, array &index ])
1552: Parsing a XML document */
1553:
1554: PHP_FUNCTION(xml_parse_into_struct)
1555: {
1556: xml_parser *parser;
1557: zval *pind, **xdata, **info = NULL;
1558: char *data;
1559: int data_len, ret;
1560:
1561: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsZ|Z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
1562: return;
1563: }
1564:
1565: if (info) {
1566: zval_dtor(*info);
1567: array_init(*info);
1568: }
1569:
1570: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1571:
1572: zval_dtor(*xdata);
1573: array_init(*xdata);
1574:
1575: parser->data = *xdata;
1576:
1577: if (info) {
1578: parser->info = *info;
1579: }
1580:
1581: parser->level = 0;
1582: parser->ltags = safe_emalloc(XML_MAXLEVEL, sizeof(char *), 0);
1583:
1584: XML_SetDefaultHandler(parser->parser, _xml_defaultHandler);
1585: XML_SetElementHandler(parser->parser, _xml_startElementHandler, _xml_endElementHandler);
1586: XML_SetCharacterDataHandler(parser->parser, _xml_characterDataHandler);
1587:
1588: parser->isparsing = 1;
1589: ret = XML_Parse(parser->parser, data, data_len, 1);
1590: parser->isparsing = 0;
1591:
1592: RETVAL_LONG(ret);
1593: }
1594: /* }}} */
1595:
1596: /* {{{ proto int xml_get_error_code(resource parser)
1597: Get XML parser error code */
1598: PHP_FUNCTION(xml_get_error_code)
1599: {
1600: xml_parser *parser;
1601: zval *pind;
1602:
1603: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1604: return;
1605: }
1606: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1607:
1608: RETVAL_LONG((long)XML_GetErrorCode(parser->parser));
1609: }
1610: /* }}} */
1611:
1612: /* {{{ proto string xml_error_string(int code)
1613: Get XML parser error string */
1614: PHP_FUNCTION(xml_error_string)
1615: {
1616: long code;
1617: char *str;
1618:
1619: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code) == FAILURE) {
1620: return;
1621: }
1622:
1623: str = (char *)XML_ErrorString((int)code);
1624: if (str) {
1625: RETVAL_STRING(str, 1);
1626: }
1627: }
1628: /* }}} */
1629:
1630: /* {{{ proto int xml_get_current_line_number(resource parser)
1631: Get current line number for an XML parser */
1632: PHP_FUNCTION(xml_get_current_line_number)
1633: {
1634: xml_parser *parser;
1635: zval *pind;
1636:
1637: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1638: return;
1639: }
1640: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1641:
1642: RETVAL_LONG(XML_GetCurrentLineNumber(parser->parser));
1643: }
1644: /* }}} */
1645:
1646: /* {{{ proto int xml_get_current_column_number(resource parser)
1647: Get current column number for an XML parser */
1648: PHP_FUNCTION(xml_get_current_column_number)
1649: {
1650: xml_parser *parser;
1651: zval *pind;
1652:
1653: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1654: return;
1655: }
1656: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1657:
1658: RETVAL_LONG(XML_GetCurrentColumnNumber(parser->parser));
1659: }
1660: /* }}} */
1661:
1662: /* {{{ proto int xml_get_current_byte_index(resource parser)
1663: Get current byte index for an XML parser */
1664: PHP_FUNCTION(xml_get_current_byte_index)
1665: {
1666: xml_parser *parser;
1667: zval *pind;
1668:
1669: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1670: return;
1671: }
1672: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1673:
1674: RETVAL_LONG(XML_GetCurrentByteIndex(parser->parser));
1675: }
1676: /* }}} */
1677:
1678: /* {{{ proto int xml_parser_free(resource parser)
1679: Free an XML parser */
1680: PHP_FUNCTION(xml_parser_free)
1681: {
1682: zval *pind;
1683: xml_parser *parser;
1684:
1685: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pind) == FAILURE) {
1686: return;
1687: }
1688:
1689: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1690:
1691: if (parser->isparsing == 1) {
1692: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parser cannot be freed while it is parsing.");
1693: RETURN_FALSE;
1694: }
1695:
1696: if (zend_list_delete(parser->index) == FAILURE) {
1697: RETURN_FALSE;
1698: }
1699:
1700: RETVAL_TRUE;
1701: }
1702: /* }}} */
1703:
1704: /* {{{ proto int xml_parser_set_option(resource parser, int option, mixed value)
1705: Set options in an XML parser */
1706: PHP_FUNCTION(xml_parser_set_option)
1707: {
1708: xml_parser *parser;
1709: zval *pind, **val;
1710: long opt;
1711:
1712: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlZ", &pind, &opt, &val) == FAILURE) {
1713: return;
1714: }
1715: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1716:
1717: switch (opt) {
1718: case PHP_XML_OPTION_CASE_FOLDING:
1719: convert_to_long_ex(val);
1720: parser->case_folding = Z_LVAL_PP(val);
1721: break;
1722: case PHP_XML_OPTION_SKIP_TAGSTART:
1723: convert_to_long_ex(val);
1724: parser->toffset = Z_LVAL_PP(val);
1725: break;
1726: case PHP_XML_OPTION_SKIP_WHITE:
1727: convert_to_long_ex(val);
1728: parser->skipwhite = Z_LVAL_PP(val);
1729: break;
1730: case PHP_XML_OPTION_TARGET_ENCODING: {
1731: xml_encoding *enc;
1732: convert_to_string_ex(val);
1733: enc = xml_get_encoding(Z_STRVAL_PP(val));
1734: if (enc == NULL) {
1735: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported target encoding \"%s\"", Z_STRVAL_PP(val));
1736: RETURN_FALSE;
1737: }
1738: parser->target_encoding = enc->name;
1739: break;
1740: }
1741: default:
1742: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option");
1743: RETURN_FALSE;
1744: break;
1745: }
1746: RETVAL_TRUE;
1747: }
1748: /* }}} */
1749:
1750: /* {{{ proto int xml_parser_get_option(resource parser, int option)
1751: Get options from an XML parser */
1752: PHP_FUNCTION(xml_parser_get_option)
1753: {
1754: xml_parser *parser;
1755: zval *pind;
1756: long opt;
1757:
1758: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pind, &opt) == FAILURE) {
1759: return;
1760: }
1761: ZEND_FETCH_RESOURCE(parser,xml_parser *, &pind, -1, "XML Parser", le_xml_parser);
1762:
1763: switch (opt) {
1764: case PHP_XML_OPTION_CASE_FOLDING:
1765: RETURN_LONG(parser->case_folding);
1766: break;
1767: case PHP_XML_OPTION_TARGET_ENCODING:
1768: RETURN_STRING(parser->target_encoding, 1);
1769: break;
1770: default:
1771: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option");
1772: RETURN_FALSE;
1773: break;
1774: }
1775:
1776: RETVAL_FALSE; /* never reached */
1777: }
1778: /* }}} */
1779:
1780: /* {{{ proto string utf8_encode(string data)
1781: Encodes an ISO-8859-1 string to UTF-8 */
1782: PHP_FUNCTION(utf8_encode)
1783: {
1784: char *arg;
1785: XML_Char *encoded;
1786: int arg_len, len;
1787:
1788: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
1789: return;
1790: }
1791:
1792: encoded = xml_utf8_encode(arg, arg_len, &len, "ISO-8859-1");
1793: if (encoded == NULL) {
1794: RETURN_FALSE;
1795: }
1796: RETVAL_STRINGL(encoded, len, 0);
1797: }
1798: /* }}} */
1799:
1800: /* {{{ proto string utf8_decode(string data)
1801: Converts a UTF-8 encoded string to ISO-8859-1 */
1802: PHP_FUNCTION(utf8_decode)
1803: {
1804: char *arg;
1805: XML_Char *decoded;
1806: int arg_len, len;
1807:
1808: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
1809: return;
1810: }
1811:
1812: decoded = xml_utf8_decode(arg, arg_len, &len, "ISO-8859-1");
1813: if (decoded == NULL) {
1814: RETURN_FALSE;
1815: }
1816: RETVAL_STRINGL(decoded, len, 0);
1817: }
1818: /* }}} */
1819:
1820: #endif
1821:
1822: /*
1823: * Local variables:
1824: * tab-width: 4
1825: * c-basic-offset: 4
1826: * End:
1827: * vim600: sw=4 ts=4 fdm=marker
1828: * vim<600: sw=4 ts=4
1829: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xml.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / xml