xref: /PHP-7.1/ext/xmlwriter/php_xmlwriter.c (revision ccd4716e)
1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 7                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2018 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   | Author: Rob Richards <rrichards@php.net>                             |
16   |         Pierre-A. Joye <pajoye@php.net>                              |
17   +----------------------------------------------------------------------+
18 */
19 
20 /* $Id$ */
21 
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25 
26 
27 #include "php.h"
28 #include "php_ini.h"
29 #include "ext/standard/info.h"
30 #include "php_xmlwriter.h"
31 #include "ext/standard/php_string.h"
32 
33 #if LIBXML_VERSION >= 20605
34 static PHP_FUNCTION(xmlwriter_set_indent);
35 static PHP_FUNCTION(xmlwriter_set_indent_string);
36 #endif
37 static PHP_FUNCTION(xmlwriter_start_attribute);
38 static PHP_FUNCTION(xmlwriter_end_attribute);
39 static PHP_FUNCTION(xmlwriter_write_attribute);
40 #if LIBXML_VERSION > 20617
41 static PHP_FUNCTION(xmlwriter_start_attribute_ns);
42 static PHP_FUNCTION(xmlwriter_write_attribute_ns);
43 #endif
44 static PHP_FUNCTION(xmlwriter_start_element);
45 static PHP_FUNCTION(xmlwriter_end_element);
46 static PHP_FUNCTION(xmlwriter_full_end_element);
47 static PHP_FUNCTION(xmlwriter_start_element_ns);
48 static PHP_FUNCTION(xmlwriter_write_element);
49 static PHP_FUNCTION(xmlwriter_write_element_ns);
50 static PHP_FUNCTION(xmlwriter_start_pi);
51 static PHP_FUNCTION(xmlwriter_end_pi);
52 static PHP_FUNCTION(xmlwriter_write_pi);
53 static PHP_FUNCTION(xmlwriter_start_cdata);
54 static PHP_FUNCTION(xmlwriter_end_cdata);
55 static PHP_FUNCTION(xmlwriter_write_cdata);
56 static PHP_FUNCTION(xmlwriter_text);
57 static PHP_FUNCTION(xmlwriter_write_raw);
58 static PHP_FUNCTION(xmlwriter_start_document);
59 static PHP_FUNCTION(xmlwriter_end_document);
60 #if LIBXML_VERSION >= 20607
61 static PHP_FUNCTION(xmlwriter_start_comment);
62 static PHP_FUNCTION(xmlwriter_end_comment);
63 #endif
64 static PHP_FUNCTION(xmlwriter_write_comment);
65 static PHP_FUNCTION(xmlwriter_start_dtd);
66 static PHP_FUNCTION(xmlwriter_end_dtd);
67 static PHP_FUNCTION(xmlwriter_write_dtd);
68 static PHP_FUNCTION(xmlwriter_start_dtd_element);
69 static PHP_FUNCTION(xmlwriter_end_dtd_element);
70 static PHP_FUNCTION(xmlwriter_write_dtd_element);
71 #if LIBXML_VERSION > 20608
72 static PHP_FUNCTION(xmlwriter_start_dtd_attlist);
73 static PHP_FUNCTION(xmlwriter_end_dtd_attlist);
74 static PHP_FUNCTION(xmlwriter_write_dtd_attlist);
75 static PHP_FUNCTION(xmlwriter_start_dtd_entity);
76 static PHP_FUNCTION(xmlwriter_end_dtd_entity);
77 static PHP_FUNCTION(xmlwriter_write_dtd_entity);
78 #endif
79 static PHP_FUNCTION(xmlwriter_open_uri);
80 static PHP_FUNCTION(xmlwriter_open_memory);
81 static PHP_FUNCTION(xmlwriter_output_memory);
82 static PHP_FUNCTION(xmlwriter_flush);
83 
84 static zend_class_entry *xmlwriter_class_entry_ce;
85 
86 static void xmlwriter_free_resource_ptr(xmlwriter_object *intern);
87 static void xmlwriter_dtor(zend_resource *rsrc);
88 
89 typedef int (*xmlwriter_read_one_char_t)(xmlTextWriterPtr writer, const xmlChar *content);
90 typedef int (*xmlwriter_read_int_t)(xmlTextWriterPtr writer);
91 
92 /* {{{ xmlwriter_object_free_storage */
xmlwriter_free_resource_ptr(xmlwriter_object * intern)93 static void xmlwriter_free_resource_ptr(xmlwriter_object *intern)
94 {
95 	if (intern) {
96 		if (intern->ptr) {
97 			xmlFreeTextWriter(intern->ptr);
98 			intern->ptr = NULL;
99 		}
100 		if (intern->output) {
101 			xmlBufferFree(intern->output);
102 			intern->output = NULL;
103 		}
104 		efree(intern);
105 	}
106 }
107 /* }}} */
108 
109 /* {{{ XMLWRITER_FROM_OBJECT */
110 #define XMLWRITER_FROM_OBJECT(intern, object) \
111 	{ \
112 		ze_xmlwriter_object *obj = Z_XMLWRITER_P(object); \
113 		intern = obj->xmlwriter_ptr; \
114 		if (!intern) { \
115 			php_error_docref(NULL, E_WARNING, "Invalid or uninitialized XMLWriter object"); \
116 			RETURN_FALSE; \
117 		} \
118 	}
119 /* }}} */
120 
121 static zend_object_handlers xmlwriter_object_handlers;
122 
123 /* {{{ xmlwriter_object_free_storage */
xmlwriter_object_free_storage(zend_object * object)124 static void xmlwriter_object_free_storage(zend_object *object)
125 {
126 	ze_xmlwriter_object *intern = php_xmlwriter_fetch_object(object);
127 	if (!intern) {
128 		return;
129 	}
130 	if (intern->xmlwriter_ptr) {
131 		xmlwriter_free_resource_ptr(intern->xmlwriter_ptr);
132 	}
133 	intern->xmlwriter_ptr = NULL;
134 	zend_object_std_dtor(&intern->std);
135 }
136 /* }}} */
137 
138 
139 /* {{{ xmlwriter_object_new */
xmlwriter_object_new(zend_class_entry * class_type)140 static zend_object *xmlwriter_object_new(zend_class_entry *class_type)
141 {
142 	ze_xmlwriter_object *intern;
143 
144 	intern = ecalloc(1, sizeof(ze_xmlwriter_object) + zend_object_properties_size(class_type));
145 	zend_object_std_init(&intern->std, class_type);
146 	object_properties_init(&intern->std, class_type);
147 	intern->std.handlers = &xmlwriter_object_handlers;
148 
149 	return &intern->std;
150 }
151 /* }}} */
152 
153 #define XMLW_NAME_CHK(__err) \
154 	if (xmlValidateName((xmlChar *) name, 0) != 0) {	\
155 		php_error_docref(NULL, E_WARNING, "%s", __err);	\
156 		RETURN_FALSE;	\
157 	}	\
158 
159 /* {{{ arginfo */
160 ZEND_BEGIN_ARG_INFO(arginfo_xmlwriter_void, 0)
161 ZEND_END_ARG_INFO()
162 
163 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_resource, 0, 0, 1)
164 	ZEND_ARG_INFO(0, xmlwriter)
165 ZEND_END_ARG_INFO()
166 
167 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_open_uri, 0, 0, 1)
168 	ZEND_ARG_INFO(0, uri)
169 ZEND_END_ARG_INFO()
170 
171 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_set_indent, 0, 0, 2)
172 	ZEND_ARG_INFO(0, xmlwriter)
173 	ZEND_ARG_INFO(0, indent)
174 ZEND_END_ARG_INFO()
175 
176 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_set_indent, 0, 0, 1)
177 	ZEND_ARG_INFO(0, indent)
178 ZEND_END_ARG_INFO()
179 
180 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_set_indent_string, 0, 0, 2)
181 	ZEND_ARG_INFO(0, xmlwriter)
182 	ZEND_ARG_INFO(0, indentString)
183 ZEND_END_ARG_INFO()
184 
185 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_set_indent_string, 0, 0, 1)
186 	ZEND_ARG_INFO(0, indentString)
187 ZEND_END_ARG_INFO()
188 
189 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_attribute, 0, 0, 2)
190 	ZEND_ARG_INFO(0, xmlwriter)
191 	ZEND_ARG_INFO(0, name)
192 ZEND_END_ARG_INFO()
193 
194 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_attribute, 0, 0, 1)
195 	ZEND_ARG_INFO(0, name)
196 ZEND_END_ARG_INFO()
197 
198 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_attribute_ns, 0, 0, 4)
199 	ZEND_ARG_INFO(0, xmlwriter)
200 	ZEND_ARG_INFO(0, prefix)
201 	ZEND_ARG_INFO(0, name)
202 	ZEND_ARG_INFO(0, uri)
203 ZEND_END_ARG_INFO()
204 
205 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_attribute_ns, 0, 0, 3)
206 	ZEND_ARG_INFO(0, prefix)
207 	ZEND_ARG_INFO(0, name)
208 	ZEND_ARG_INFO(0, uri)
209 ZEND_END_ARG_INFO()
210 
211 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_attribute_ns, 0, 0, 5)
212 	ZEND_ARG_INFO(0, xmlwriter)
213 	ZEND_ARG_INFO(0, prefix)
214 	ZEND_ARG_INFO(0, name)
215 	ZEND_ARG_INFO(0, uri)
216 	ZEND_ARG_INFO(0, content)
217 ZEND_END_ARG_INFO()
218 
219 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_attribute_ns, 0, 0, 4)
220 	ZEND_ARG_INFO(0, prefix)
221 	ZEND_ARG_INFO(0, name)
222 	ZEND_ARG_INFO(0, uri)
223 	ZEND_ARG_INFO(0, content)
224 ZEND_END_ARG_INFO()
225 
226 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_attribute, 0, 0, 3)
227 	ZEND_ARG_INFO(0, xmlwriter)
228 	ZEND_ARG_INFO(0, name)
229 	ZEND_ARG_INFO(0, value)
230 ZEND_END_ARG_INFO()
231 
232 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_attribute, 0, 0, 2)
233 	ZEND_ARG_INFO(0, name)
234 	ZEND_ARG_INFO(0, value)
235 ZEND_END_ARG_INFO()
236 
237 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_element, 0, 0, 2)
238 	ZEND_ARG_INFO(0, xmlwriter)
239 	ZEND_ARG_INFO(0, name)
240 ZEND_END_ARG_INFO()
241 
242 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_element, 0, 0, 1)
243 	ZEND_ARG_INFO(0, name)
244 ZEND_END_ARG_INFO()
245 
246 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_element_ns, 0, 0, 4)
247 	ZEND_ARG_INFO(0, xmlwriter)
248 	ZEND_ARG_INFO(0, prefix)
249 	ZEND_ARG_INFO(0, name)
250 	ZEND_ARG_INFO(0, uri)
251 ZEND_END_ARG_INFO()
252 
253 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_element_ns, 0, 0, 3)
254 	ZEND_ARG_INFO(0, prefix)
255 	ZEND_ARG_INFO(0, name)
256 	ZEND_ARG_INFO(0, uri)
257 ZEND_END_ARG_INFO()
258 
259 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_element, 0, 0, 2)
260 	ZEND_ARG_INFO(0, xmlwriter)
261 	ZEND_ARG_INFO(0, name)
262 	ZEND_ARG_INFO(0, content)
263 ZEND_END_ARG_INFO()
264 
265 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_element, 0, 0, 1)
266 	ZEND_ARG_INFO(0, name)
267 	ZEND_ARG_INFO(0, content)
268 ZEND_END_ARG_INFO()
269 
270 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_element_ns, 0, 0, 4)
271 	ZEND_ARG_INFO(0, xmlwriter)
272 	ZEND_ARG_INFO(0, prefix)
273 	ZEND_ARG_INFO(0, name)
274 	ZEND_ARG_INFO(0, uri)
275 	ZEND_ARG_INFO(0, content)
276 ZEND_END_ARG_INFO()
277 
278 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_element_ns, 0, 0, 3)
279 	ZEND_ARG_INFO(0, prefix)
280 	ZEND_ARG_INFO(0, name)
281 	ZEND_ARG_INFO(0, uri)
282 	ZEND_ARG_INFO(0, content)
283 ZEND_END_ARG_INFO()
284 
285 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_pi, 0, 0, 2)
286 	ZEND_ARG_INFO(0, xmlwriter)
287 	ZEND_ARG_INFO(0, target)
288 ZEND_END_ARG_INFO()
289 
290 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_pi, 0, 0, 1)
291 	ZEND_ARG_INFO(0, target)
292 ZEND_END_ARG_INFO()
293 
294 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_pi, 0, 0, 3)
295 	ZEND_ARG_INFO(0, xmlwriter)
296 	ZEND_ARG_INFO(0, target)
297 	ZEND_ARG_INFO(0, content)
298 ZEND_END_ARG_INFO()
299 
300 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_pi, 0, 0, 2)
301 	ZEND_ARG_INFO(0, target)
302 	ZEND_ARG_INFO(0, content)
303 ZEND_END_ARG_INFO()
304 
305 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_cdata, 0, 0, 2)
306 	ZEND_ARG_INFO(0, xmlwriter)
307 	ZEND_ARG_INFO(0, content)
308 ZEND_END_ARG_INFO()
309 
310 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_cdata, 0, 0, 1)
311 	ZEND_ARG_INFO(0, content)
312 ZEND_END_ARG_INFO()
313 
314 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_text, 0, 0, 2)
315 	ZEND_ARG_INFO(0, xmlwriter)
316 	ZEND_ARG_INFO(0, content)
317 ZEND_END_ARG_INFO()
318 
319 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_text, 0, 0, 1)
320 	ZEND_ARG_INFO(0, content)
321 ZEND_END_ARG_INFO()
322 
323 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_raw, 0, 0, 2)
324 	ZEND_ARG_INFO(0, xmlwriter)
325 	ZEND_ARG_INFO(0, content)
326 ZEND_END_ARG_INFO()
327 
328 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_raw, 0, 0, 1)
329 	ZEND_ARG_INFO(0, content)
330 ZEND_END_ARG_INFO()
331 
332 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_document, 0, 0, 1)
333 	ZEND_ARG_INFO(0, xmlwriter)
334 	ZEND_ARG_INFO(0, version)
335 	ZEND_ARG_INFO(0, encoding)
336 	ZEND_ARG_INFO(0, standalone)
337 ZEND_END_ARG_INFO()
338 
339 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_document, 0, 0, 0)
340 	ZEND_ARG_INFO(0, version)
341 	ZEND_ARG_INFO(0, encoding)
342 	ZEND_ARG_INFO(0, standalone)
343 ZEND_END_ARG_INFO()
344 
345 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_comment, 0, 0, 2)
346 	ZEND_ARG_INFO(0, xmlwriter)
347 	ZEND_ARG_INFO(0, content)
348 ZEND_END_ARG_INFO()
349 
350 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_comment, 0, 0, 1)
351 	ZEND_ARG_INFO(0, content)
352 ZEND_END_ARG_INFO()
353 
354 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_dtd, 0, 0, 2)
355 	ZEND_ARG_INFO(0, xmlwriter)
356 	ZEND_ARG_INFO(0, qualifiedName)
357 	ZEND_ARG_INFO(0, publicId)
358 	ZEND_ARG_INFO(0, systemId)
359 ZEND_END_ARG_INFO()
360 
361 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_dtd, 0, 0, 1)
362 	ZEND_ARG_INFO(0, qualifiedName)
363 	ZEND_ARG_INFO(0, publicId)
364 	ZEND_ARG_INFO(0, systemId)
365 ZEND_END_ARG_INFO()
366 
367 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_dtd, 0, 0, 2)
368 	ZEND_ARG_INFO(0, xmlwriter)
369 	ZEND_ARG_INFO(0, name)
370 	ZEND_ARG_INFO(0, publicId)
371 	ZEND_ARG_INFO(0, systemId)
372 	ZEND_ARG_INFO(0, subset)
373 ZEND_END_ARG_INFO()
374 
375 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_dtd, 0, 0, 1)
376 	ZEND_ARG_INFO(0, name)
377 	ZEND_ARG_INFO(0, publicId)
378 	ZEND_ARG_INFO(0, systemId)
379 	ZEND_ARG_INFO(0, subset)
380 ZEND_END_ARG_INFO()
381 
382 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_dtd_element, 0, 0, 2)
383 	ZEND_ARG_INFO(0, xmlwriter)
384 	ZEND_ARG_INFO(0, qualifiedName)
385 ZEND_END_ARG_INFO()
386 
387 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_dtd_element, 0, 0, 1)
388 	ZEND_ARG_INFO(0, qualifiedName)
389 ZEND_END_ARG_INFO()
390 
391 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_dtd_element, 0, 0, 3)
392 	ZEND_ARG_INFO(0, xmlwriter)
393 	ZEND_ARG_INFO(0, name)
394 	ZEND_ARG_INFO(0, content)
395 ZEND_END_ARG_INFO()
396 
397 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_dtd_element, 0, 0, 2)
398 	ZEND_ARG_INFO(0, name)
399 	ZEND_ARG_INFO(0, content)
400 ZEND_END_ARG_INFO()
401 
402 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_dtd_attlist, 0, 0, 2)
403 	ZEND_ARG_INFO(0, xmlwriter)
404 	ZEND_ARG_INFO(0, name)
405 ZEND_END_ARG_INFO()
406 
407 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_dtd_attlist, 0, 0, 1)
408 	ZEND_ARG_INFO(0, name)
409 ZEND_END_ARG_INFO()
410 
411 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_dtd_attlist, 0, 0, 3)
412 	ZEND_ARG_INFO(0, xmlwriter)
413 	ZEND_ARG_INFO(0, name)
414 	ZEND_ARG_INFO(0, content)
415 ZEND_END_ARG_INFO()
416 
417 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_dtd_attlist, 0, 0, 2)
418 	ZEND_ARG_INFO(0, name)
419 	ZEND_ARG_INFO(0, content)
420 ZEND_END_ARG_INFO()
421 
422 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_start_dtd_entity, 0, 0, 3)
423 	ZEND_ARG_INFO(0, xmlwriter)
424 	ZEND_ARG_INFO(0, name)
425 	ZEND_ARG_INFO(0, isparam)
426 ZEND_END_ARG_INFO()
427 
428 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_start_dtd_entity, 0, 0, 2)
429 	ZEND_ARG_INFO(0, name)
430 	ZEND_ARG_INFO(0, isparam)
431 ZEND_END_ARG_INFO()
432 
433 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_write_dtd_entity, 0, 0, 3)
434 	ZEND_ARG_INFO(0, xmlwriter)
435 	ZEND_ARG_INFO(0, name)
436 	ZEND_ARG_INFO(0, content)
437 ZEND_END_ARG_INFO()
438 
439 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_write_dtd_entity, 0, 0, 2)
440 	ZEND_ARG_INFO(0, name)
441 	ZEND_ARG_INFO(0, content)
442 ZEND_END_ARG_INFO()
443 
444 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_output_memory, 0, 0, 1)
445 	ZEND_ARG_INFO(0, xmlwriter)
446 	ZEND_ARG_INFO(0, flush)
447 ZEND_END_ARG_INFO()
448 
449 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_output_memory, 0, 0, 0)
450 	ZEND_ARG_INFO(0, flush)
451 ZEND_END_ARG_INFO()
452 
453 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_flush, 0, 0, 1)
454 	ZEND_ARG_INFO(0, xmlwriter)
455 	ZEND_ARG_INFO(0, empty)
456 ZEND_END_ARG_INFO()
457 
458 ZEND_BEGIN_ARG_INFO_EX(arginfo_xmlwriter_method_flush, 0, 0, 0)
459 	ZEND_ARG_INFO(0, empty)
460 ZEND_END_ARG_INFO()
461 /* }}} */
462 
463 /* {{{ xmlwriter_functions */
464 static const zend_function_entry xmlwriter_functions[] = {
465 	PHP_FE(xmlwriter_open_uri,			arginfo_xmlwriter_open_uri)
466 	PHP_FE(xmlwriter_open_memory,		arginfo_xmlwriter_void)
467 #if LIBXML_VERSION >= 20605
468 	PHP_FE(xmlwriter_set_indent,		arginfo_xmlwriter_set_indent)
469 	PHP_FE(xmlwriter_set_indent_string, arginfo_xmlwriter_set_indent_string)
470 #endif
471 #if LIBXML_VERSION >= 20607
472 	PHP_FE(xmlwriter_start_comment,		arginfo_xmlwriter_resource)
473 	PHP_FE(xmlwriter_end_comment,		arginfo_xmlwriter_resource)
474 #endif
475 	PHP_FE(xmlwriter_start_attribute,	arginfo_xmlwriter_start_attribute)
476 	PHP_FE(xmlwriter_end_attribute,		arginfo_xmlwriter_resource)
477 	PHP_FE(xmlwriter_write_attribute,	arginfo_xmlwriter_write_attribute)
478 #if LIBXML_VERSION > 20617
479 	PHP_FE(xmlwriter_start_attribute_ns,arginfo_xmlwriter_start_attribute_ns)
480 	PHP_FE(xmlwriter_write_attribute_ns,arginfo_xmlwriter_write_attribute_ns)
481 #endif
482 	PHP_FE(xmlwriter_start_element,		arginfo_xmlwriter_start_element)
483 	PHP_FE(xmlwriter_end_element,		arginfo_xmlwriter_resource)
484 	PHP_FE(xmlwriter_full_end_element,	arginfo_xmlwriter_resource)
485 	PHP_FE(xmlwriter_start_element_ns,	arginfo_xmlwriter_start_element_ns)
486 	PHP_FE(xmlwriter_write_element,		arginfo_xmlwriter_write_element)
487 	PHP_FE(xmlwriter_write_element_ns,	arginfo_xmlwriter_write_element_ns)
488 	PHP_FE(xmlwriter_start_pi,			arginfo_xmlwriter_start_pi)
489 	PHP_FE(xmlwriter_end_pi,			arginfo_xmlwriter_resource)
490 	PHP_FE(xmlwriter_write_pi,			arginfo_xmlwriter_write_pi)
491 	PHP_FE(xmlwriter_start_cdata,		arginfo_xmlwriter_resource)
492 	PHP_FE(xmlwriter_end_cdata,			arginfo_xmlwriter_resource)
493 	PHP_FE(xmlwriter_write_cdata,		arginfo_xmlwriter_write_cdata)
494 	PHP_FE(xmlwriter_text,				arginfo_xmlwriter_text)
495 	PHP_FE(xmlwriter_write_raw,			arginfo_xmlwriter_write_raw)
496 	PHP_FE(xmlwriter_start_document,	arginfo_xmlwriter_start_document)
497 	PHP_FE(xmlwriter_end_document,		arginfo_xmlwriter_resource)
498 	PHP_FE(xmlwriter_write_comment,		arginfo_xmlwriter_write_comment)
499 	PHP_FE(xmlwriter_start_dtd,			arginfo_xmlwriter_start_dtd)
500 	PHP_FE(xmlwriter_end_dtd,			arginfo_xmlwriter_resource)
501 	PHP_FE(xmlwriter_write_dtd,			arginfo_xmlwriter_write_dtd)
502 	PHP_FE(xmlwriter_start_dtd_element,	arginfo_xmlwriter_start_dtd_element)
503 	PHP_FE(xmlwriter_end_dtd_element,	arginfo_xmlwriter_resource)
504 	PHP_FE(xmlwriter_write_dtd_element,	arginfo_xmlwriter_write_dtd_element)
505 #if LIBXML_VERSION > 20608
506 	PHP_FE(xmlwriter_start_dtd_attlist,	arginfo_xmlwriter_start_dtd_attlist)
507 	PHP_FE(xmlwriter_end_dtd_attlist,	arginfo_xmlwriter_resource)
508 	PHP_FE(xmlwriter_write_dtd_attlist,	arginfo_xmlwriter_write_dtd_attlist)
509 	PHP_FE(xmlwriter_start_dtd_entity,	arginfo_xmlwriter_start_dtd_entity)
510 	PHP_FE(xmlwriter_end_dtd_entity,	arginfo_xmlwriter_resource)
511 	PHP_FE(xmlwriter_write_dtd_entity,	arginfo_xmlwriter_write_dtd_entity)
512 #endif
513 	PHP_FE(xmlwriter_output_memory,		arginfo_xmlwriter_output_memory)
514 	PHP_FE(xmlwriter_flush,				arginfo_xmlwriter_flush)
515 	PHP_FE_END
516 };
517 /* }}} */
518 
519 /* {{{ xmlwriter_class_functions */
520 static const zend_function_entry xmlwriter_class_functions[] = {
521 	PHP_ME_MAPPING(openUri,		xmlwriter_open_uri,		arginfo_xmlwriter_open_uri, 0)
522 	PHP_ME_MAPPING(openMemory,	xmlwriter_open_memory, 	arginfo_xmlwriter_void, 0)
523 #if LIBXML_VERSION >= 20605
524 	PHP_ME_MAPPING(setIndent,	xmlwriter_set_indent,	arginfo_xmlwriter_method_set_indent, 0)
525 	PHP_ME_MAPPING(setIndentString,	xmlwriter_set_indent_string, arginfo_xmlwriter_method_set_indent_string, 0)
526 #endif
527 #if LIBXML_VERSION >= 20607
528 	PHP_ME_MAPPING(startComment,	xmlwriter_start_comment,	arginfo_xmlwriter_void, 0)
529 	PHP_ME_MAPPING(endComment,		xmlwriter_end_comment,		arginfo_xmlwriter_void, 0)
530 #endif
531 	PHP_ME_MAPPING(startAttribute,	xmlwriter_start_attribute,	arginfo_xmlwriter_method_start_attribute, 0)
532 	PHP_ME_MAPPING(endAttribute,	xmlwriter_end_attribute,	arginfo_xmlwriter_void, 0)
533 	PHP_ME_MAPPING(writeAttribute,	xmlwriter_write_attribute,	arginfo_xmlwriter_method_write_attribute, 0)
534 #if LIBXML_VERSION > 20617
535 	PHP_ME_MAPPING(startAttributeNs,	xmlwriter_start_attribute_ns,arginfo_xmlwriter_method_start_attribute_ns, 0)
536 	PHP_ME_MAPPING(writeAttributeNs,	xmlwriter_write_attribute_ns,arginfo_xmlwriter_method_write_attribute_ns, 0)
537 #endif
538 	PHP_ME_MAPPING(startElement,	xmlwriter_start_element,	arginfo_xmlwriter_method_start_element, 0)
539 	PHP_ME_MAPPING(endElement,		xmlwriter_end_element,		arginfo_xmlwriter_void, 0)
540 	PHP_ME_MAPPING(fullEndElement,	xmlwriter_full_end_element,	arginfo_xmlwriter_void, 0)
541 	PHP_ME_MAPPING(startElementNs,	xmlwriter_start_element_ns,	arginfo_xmlwriter_method_start_element_ns, 0)
542 	PHP_ME_MAPPING(writeElement,	xmlwriter_write_element,	arginfo_xmlwriter_method_write_element, 0)
543 	PHP_ME_MAPPING(writeElementNs,	xmlwriter_write_element_ns,	arginfo_xmlwriter_method_write_element_ns, 0)
544 	PHP_ME_MAPPING(startPi,			xmlwriter_start_pi,			arginfo_xmlwriter_method_start_pi, 0)
545 	PHP_ME_MAPPING(endPi,			xmlwriter_end_pi,			arginfo_xmlwriter_void, 0)
546 	PHP_ME_MAPPING(writePi,			xmlwriter_write_pi,			arginfo_xmlwriter_method_write_pi, 0)
547 	PHP_ME_MAPPING(startCdata,		xmlwriter_start_cdata,		arginfo_xmlwriter_void, 0)
548 	PHP_ME_MAPPING(endCdata,		xmlwriter_end_cdata,		arginfo_xmlwriter_void, 0)
549 	PHP_ME_MAPPING(writeCdata,		xmlwriter_write_cdata,		arginfo_xmlwriter_method_write_cdata, 0)
550 	PHP_ME_MAPPING(text,			xmlwriter_text,				arginfo_xmlwriter_method_text, 0)
551 	PHP_ME_MAPPING(writeRaw,		xmlwriter_write_raw,		arginfo_xmlwriter_method_write_raw, 0)
552 	PHP_ME_MAPPING(startDocument,	xmlwriter_start_document,	arginfo_xmlwriter_method_start_document, 0)
553 	PHP_ME_MAPPING(endDocument,		xmlwriter_end_document,		arginfo_xmlwriter_void, 0)
554 	PHP_ME_MAPPING(writeComment,	xmlwriter_write_comment,	arginfo_xmlwriter_method_write_comment, 0)
555 	PHP_ME_MAPPING(startDtd,		xmlwriter_start_dtd,		arginfo_xmlwriter_method_start_dtd, 0)
556 	PHP_ME_MAPPING(endDtd,			xmlwriter_end_dtd,			arginfo_xmlwriter_void, 0)
557 	PHP_ME_MAPPING(writeDtd,		xmlwriter_write_dtd,		arginfo_xmlwriter_method_write_dtd, 0)
558 	PHP_ME_MAPPING(startDtdElement,	xmlwriter_start_dtd_element,arginfo_xmlwriter_method_start_dtd_element, 0)
559 	PHP_ME_MAPPING(endDtdElement,	xmlwriter_end_dtd_element,	arginfo_xmlwriter_void, 0)
560 	PHP_ME_MAPPING(writeDtdElement,	xmlwriter_write_dtd_element,	arginfo_xmlwriter_method_write_dtd_element, 0)
561 #if LIBXML_VERSION > 20608
562 	PHP_ME_MAPPING(startDtdAttlist,	xmlwriter_start_dtd_attlist,	arginfo_xmlwriter_method_start_dtd_attlist, 0)
563 	PHP_ME_MAPPING(endDtdAttlist,	xmlwriter_end_dtd_attlist,	arginfo_xmlwriter_void, 0)
564 	PHP_ME_MAPPING(writeDtdAttlist,	xmlwriter_write_dtd_attlist,	arginfo_xmlwriter_method_write_dtd_attlist, 0)
565 	PHP_ME_MAPPING(startDtdEntity,	xmlwriter_start_dtd_entity,	arginfo_xmlwriter_method_start_dtd_entity, 0)
566 	PHP_ME_MAPPING(endDtdEntity,	xmlwriter_end_dtd_entity,	arginfo_xmlwriter_void, 0)
567 	PHP_ME_MAPPING(writeDtdEntity,	xmlwriter_write_dtd_entity,	arginfo_xmlwriter_method_write_dtd_entity, 0)
568 #endif
569 	PHP_ME_MAPPING(outputMemory,	xmlwriter_output_memory,	arginfo_xmlwriter_method_output_memory, 0)
570 	PHP_ME_MAPPING(flush,			xmlwriter_flush,			arginfo_xmlwriter_method_flush, 0)
571 	PHP_FE_END
572 };
573 /* }}} */
574 
575 /* {{{ function prototypes */
576 static PHP_MINIT_FUNCTION(xmlwriter);
577 static PHP_MSHUTDOWN_FUNCTION(xmlwriter);
578 static PHP_MINFO_FUNCTION(xmlwriter);
579 
580 static int le_xmlwriter;
581 /* }}} */
582 
583 /* _xmlwriter_get_valid_file_path should be made a
584 	common function in libxml extension as code is common to a few xml extensions */
585 /* {{{ _xmlwriter_get_valid_file_path */
_xmlwriter_get_valid_file_path(char * source,char * resolved_path,int resolved_path_len)586 static char *_xmlwriter_get_valid_file_path(char *source, char *resolved_path, int resolved_path_len ) {
587 	xmlURI *uri;
588 	xmlChar *escsource;
589 	char *file_dest;
590 	int isFileUri = 0;
591 
592 	uri = xmlCreateURI();
593 	escsource = xmlURIEscapeStr((xmlChar *)source, (xmlChar *) ":");
594 	xmlParseURIReference(uri, (char *)escsource);
595 	xmlFree(escsource);
596 
597 	if (uri->scheme != NULL) {
598 		/* absolute file uris - libxml only supports localhost or empty host */
599 		if (strncasecmp(source, "file:///", 8) == 0) {
600 			if (source[sizeof("file:///") - 1] == '\0') {
601 				xmlFreeURI(uri);
602 				return NULL;
603 			}
604 			isFileUri = 1;
605 #ifdef PHP_WIN32
606 			source += 8;
607 #else
608 			source += 7;
609 #endif
610 		} else if (strncasecmp(source, "file://localhost/",17) == 0) {
611 			if (source[sizeof("file://localhost/") - 1] == '\0') {
612 				xmlFreeURI(uri);
613 				return NULL;
614 			}
615 
616 			isFileUri = 1;
617 #ifdef PHP_WIN32
618 			source += 17;
619 #else
620 			source += 16;
621 #endif
622 		}
623 	}
624 
625 	if ((uri->scheme == NULL || isFileUri)) {
626 		char file_dirname[MAXPATHLEN];
627 		size_t dir_len;
628 
629 		if (!VCWD_REALPATH(source, resolved_path) && !expand_filepath(source, resolved_path)) {
630 			xmlFreeURI(uri);
631 			return NULL;
632 		}
633 
634 		memcpy(file_dirname, source, strlen(source));
635 		dir_len = php_dirname(file_dirname, strlen(source));
636 
637 		if (dir_len > 0) {
638 			zend_stat_t buf;
639 			if (php_sys_stat(file_dirname, &buf) != 0) {
640 				xmlFreeURI(uri);
641 				return NULL;
642 			}
643 		}
644 
645 		file_dest = resolved_path;
646 	} else {
647 		file_dest = source;
648 	}
649 
650 	xmlFreeURI(uri);
651 
652 	return file_dest;
653 }
654 /* }}} */
655 
656 /* {{{ xmlwriter_module_entry
657  */
658 zend_module_entry xmlwriter_module_entry = {
659 	STANDARD_MODULE_HEADER,
660 	"xmlwriter",
661 	xmlwriter_functions,
662 	PHP_MINIT(xmlwriter),
663 	PHP_MSHUTDOWN(xmlwriter),
664 	NULL,
665 	NULL,
666 	PHP_MINFO(xmlwriter),
667 	PHP_XMLWRITER_VERSION,
668 	STANDARD_MODULE_PROPERTIES
669 };
670 /* }}} */
671 
672 #ifdef COMPILE_DL_XMLWRITER
ZEND_GET_MODULE(xmlwriter)673 ZEND_GET_MODULE(xmlwriter)
674 #endif
675 
676 /* {{{ xmlwriter_objects_clone
677 static void xmlwriter_objects_clone(void *object, void **object_clone)
678 {
679 	TODO
680 }
681 }}} */
682 
683 /* {{{ xmlwriter_dtor */
684 static void xmlwriter_dtor(zend_resource *rsrc) {
685 	xmlwriter_object *intern;
686 
687 	intern = (xmlwriter_object *) rsrc->ptr;
688 	xmlwriter_free_resource_ptr(intern);
689 }
690 /* }}} */
691 
php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAMETERS,xmlwriter_read_one_char_t internal_function,char * err_string)692 static void php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAMETERS, xmlwriter_read_one_char_t internal_function, char *err_string)
693 {
694 	zval *pind;
695 	xmlwriter_object *intern;
696 	xmlTextWriterPtr ptr;
697 	char *name;
698 	size_t name_len;
699 	int retval;
700 
701 	zval *self = getThis();
702 
703 	if (self) {
704 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name, &name_len) == FAILURE) {
705 			return;
706 		}
707 		XMLWRITER_FROM_OBJECT(intern, self);
708 	} else {
709 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &pind, &name, &name_len) == FAILURE) {
710 			return;
711 		}
712 
713 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
714 			RETURN_FALSE;
715 		}
716 	}
717 
718 	if (err_string != NULL) {
719 		XMLW_NAME_CHK(err_string);
720 	}
721 
722 	ptr = intern->ptr;
723 
724 	if (ptr) {
725 		retval = internal_function(ptr, (xmlChar *) name);
726 		if (retval != -1) {
727 			RETURN_TRUE;
728 		}
729 	}
730 
731 	RETURN_FALSE;
732 }
733 
php_xmlwriter_end(INTERNAL_FUNCTION_PARAMETERS,xmlwriter_read_int_t internal_function)734 static void php_xmlwriter_end(INTERNAL_FUNCTION_PARAMETERS, xmlwriter_read_int_t internal_function)
735 {
736 	zval *pind;
737 	xmlwriter_object *intern;
738 	xmlTextWriterPtr ptr;
739 	int retval;
740 	zval *self = getThis();
741 
742 	if (self) {
743 		XMLWRITER_FROM_OBJECT(intern, self);
744 		if (zend_parse_parameters_none() == FAILURE) {
745 			return;
746 		}
747 	} else {
748 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pind) == FAILURE) {
749 			return;
750 		}
751 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
752 			RETURN_FALSE;
753 		}
754 	}
755 
756 	ptr = intern->ptr;
757 
758 	if (ptr) {
759 		retval = internal_function(ptr);
760 		if (retval != -1) {
761 			RETURN_TRUE;
762 		}
763 	}
764 
765 	RETURN_FALSE;
766 }
767 
768 #if LIBXML_VERSION >= 20605
769 /* {{{ proto bool xmlwriter_set_indent(resource xmlwriter, bool indent)
770 Toggle indentation on/off - returns FALSE on error */
PHP_FUNCTION(xmlwriter_set_indent)771 static PHP_FUNCTION(xmlwriter_set_indent)
772 {
773 	zval *pind;
774 	xmlwriter_object *intern;
775 	xmlTextWriterPtr ptr;
776 	int retval;
777 	zend_bool indent;
778 
779 	zval *self = getThis();
780 
781 	if (self) {
782 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &indent) == FAILURE) {
783 			return;
784 		}
785 		XMLWRITER_FROM_OBJECT(intern, self);
786 	} else {
787 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rb", &pind, &indent) == FAILURE) {
788 			return;
789 		}
790 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
791 			RETURN_FALSE;
792 		}
793 	}
794 
795 
796 	ptr = intern->ptr;
797 	if (ptr) {
798 		retval = xmlTextWriterSetIndent(ptr, indent);
799 		if (retval == 0) {
800 			RETURN_TRUE;
801 		}
802 	}
803 
804 	RETURN_FALSE;
805 }
806 /* }}} */
807 
808 /* {{{ proto bool xmlwriter_set_indent_string(resource xmlwriter, string indentString)
809 Set string used for indenting - returns FALSE on error */
PHP_FUNCTION(xmlwriter_set_indent_string)810 static PHP_FUNCTION(xmlwriter_set_indent_string)
811 {
812 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterSetIndentString, NULL);
813 }
814 /* }}} */
815 
816 #endif
817 
818 /* {{{ proto bool xmlwriter_start_attribute(resource xmlwriter, string name)
819 Create start attribute - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_attribute)820 static PHP_FUNCTION(xmlwriter_start_attribute)
821 {
822 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterStartAttribute, "Invalid Attribute Name");
823 }
824 /* }}} */
825 
826 /* {{{ proto bool xmlwriter_end_attribute(resource xmlwriter)
827 End attribute - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_attribute)828 static PHP_FUNCTION(xmlwriter_end_attribute)
829 {
830 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndAttribute);
831 }
832 /* }}} */
833 
834 #if LIBXML_VERSION > 20617
835 /* {{{ proto bool xmlwriter_start_attribute_ns(resource xmlwriter, string prefix, string name, string uri)
836 Create start namespaced attribute - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_attribute_ns)837 static PHP_FUNCTION(xmlwriter_start_attribute_ns)
838 {
839 	zval *pind;
840 	xmlwriter_object *intern;
841 	xmlTextWriterPtr ptr;
842 	char *name, *prefix, *uri;
843 	size_t name_len, prefix_len, uri_len;
844 	int retval;
845 	zval *self = getThis();
846 
847 	if (self) {
848 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss!",
849 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len) == FAILURE) {
850 			return;
851 		}
852 		XMLWRITER_FROM_OBJECT(intern, self);
853 	} else {
854 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsss!", &pind,
855 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len) == FAILURE) {
856 			return;
857 		}
858 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
859 			RETURN_FALSE;
860 		}
861 	}
862 
863 	XMLW_NAME_CHK("Invalid Attribute Name");
864 
865 	ptr = intern->ptr;
866 
867 	if (ptr) {
868 		retval = xmlTextWriterStartAttributeNS(ptr, (xmlChar *)prefix, (xmlChar *)name, (xmlChar *)uri);
869 		if (retval != -1) {
870 			RETURN_TRUE;
871 		}
872 	}
873 
874 	RETURN_FALSE;
875 }
876 /* }}} */
877 #endif
878 
879 /* {{{ proto bool xmlwriter_write_attribute(resource xmlwriter, string name, string content)
880 Write full attribute - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_attribute)881 static PHP_FUNCTION(xmlwriter_write_attribute)
882 {
883 	zval *pind;
884 	xmlwriter_object *intern;
885 	xmlTextWriterPtr ptr;
886 	char *name, *content;
887 	size_t name_len, content_len;
888 	int retval;
889 	zval *self = getThis();
890 
891 	if (self) {
892 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
893 			&name, &name_len, &content, &content_len) == FAILURE) {
894 			return;
895 		}
896 		XMLWRITER_FROM_OBJECT(intern, self);
897 	} else {
898 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &pind,
899 			&name, &name_len, &content, &content_len) == FAILURE) {
900 			return;
901 		}
902 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
903 			RETURN_FALSE;
904 		}
905 	}
906 
907 	XMLW_NAME_CHK("Invalid Attribute Name");
908 
909 	ptr = intern->ptr;
910 
911 	if (ptr) {
912 		retval = xmlTextWriterWriteAttribute(ptr, (xmlChar *)name, (xmlChar *)content);
913 		if (retval != -1) {
914 			RETURN_TRUE;
915 		}
916 	}
917 
918 	RETURN_FALSE;
919 }
920 /* }}} */
921 
922 #if LIBXML_VERSION > 20617
923 /* {{{ proto bool xmlwriter_write_attribute_ns(resource xmlwriter, string prefix, string name, string uri, string content)
924 Write full namespaced attribute - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_attribute_ns)925 static PHP_FUNCTION(xmlwriter_write_attribute_ns)
926 {
927 	zval *pind;
928 	xmlwriter_object *intern;
929 	xmlTextWriterPtr ptr;
930 	char *name, *prefix, *uri, *content;
931 	size_t name_len, prefix_len, uri_len, content_len;
932 	int retval;
933 
934 	zval *self = getThis();
935 
936 	if (self) {
937 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss!s",
938 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len, &content, &content_len) == FAILURE) {
939 			return;
940 		}
941 		XMLWRITER_FROM_OBJECT(intern, self);
942 	} else {
943 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsss!s", &pind,
944 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len, &content, &content_len) == FAILURE) {
945 			return;
946 		}
947 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
948 			RETURN_FALSE;
949 		}
950 	}
951 
952 	XMLW_NAME_CHK("Invalid Attribute Name");
953 
954 	ptr = intern->ptr;
955 
956 	if (ptr) {
957 		retval = xmlTextWriterWriteAttributeNS(ptr, (xmlChar *)prefix, (xmlChar *)name, (xmlChar *)uri, (xmlChar *)content);
958 		if (retval != -1) {
959 			RETURN_TRUE;
960 		}
961 	}
962 
963 	RETURN_FALSE;
964 }
965 /* }}} */
966 #endif
967 
968 /* {{{ proto bool xmlwriter_start_element(resource xmlwriter, string name)
969 Create start element tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_element)970 static PHP_FUNCTION(xmlwriter_start_element)
971 {
972 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterStartElement, "Invalid Element Name");
973 }
974 /* }}} */
975 
976 /* {{{ proto bool xmlwriter_start_element_ns(resource xmlwriter, string prefix, string name, string uri)
977 Create start namespaced element tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_element_ns)978 static PHP_FUNCTION(xmlwriter_start_element_ns)
979 {
980 	zval *pind;
981 	xmlwriter_object *intern;
982 	xmlTextWriterPtr ptr;
983 	char *name, *prefix, *uri;
984 	size_t name_len, prefix_len, uri_len;
985 	int retval;
986 	zval *self = getThis();
987 
988 	if (self) {
989 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!ss!",
990 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len) == FAILURE) {
991 			return;
992 		}
993 		XMLWRITER_FROM_OBJECT(intern, self);
994 	} else {
995 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs!ss!", &pind,
996 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len) == FAILURE) {
997 			return;
998 		}
999 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1000 			RETURN_FALSE;
1001 		}
1002 	}
1003 
1004 	XMLW_NAME_CHK("Invalid Element Name");
1005 
1006 	ptr = intern->ptr;
1007 
1008 	if (ptr) {
1009 		retval = xmlTextWriterStartElementNS(ptr, (xmlChar *)prefix, (xmlChar *)name, (xmlChar *)uri);
1010 		if (retval != -1) {
1011 			RETURN_TRUE;
1012 		}
1013 
1014 	}
1015 
1016 	RETURN_FALSE;
1017 }
1018 /* }}} */
1019 
1020 /* {{{ proto bool xmlwriter_end_element(resource xmlwriter)
1021 End current element - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_element)1022 static PHP_FUNCTION(xmlwriter_end_element)
1023 {
1024 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndElement);
1025 }
1026 /* }}} */
1027 
1028 /* {{{ proto bool xmlwriter_full_end_element(resource xmlwriter)
1029 End current element - returns FALSE on error */
PHP_FUNCTION(xmlwriter_full_end_element)1030 static PHP_FUNCTION(xmlwriter_full_end_element)
1031 {
1032 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterFullEndElement);
1033 }
1034 /* }}} */
1035 
1036 /* {{{ proto bool xmlwriter_write_element(resource xmlwriter, string name[, string content])
1037 Write full element tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_element)1038 static PHP_FUNCTION(xmlwriter_write_element)
1039 {
1040 	zval *pind;
1041 	xmlwriter_object *intern;
1042 	xmlTextWriterPtr ptr;
1043 	char *name, *content = NULL;
1044 	size_t name_len, content_len;
1045 	int retval;
1046 	zval *self = getThis();
1047 
1048 	if (self) {
1049 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!",
1050 			&name, &name_len, &content, &content_len) == FAILURE) {
1051 			return;
1052 		}
1053 		XMLWRITER_FROM_OBJECT(intern, self);
1054 	} else {
1055 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|s!", &pind,
1056 			&name, &name_len, &content, &content_len) == FAILURE) {
1057 			return;
1058 		}
1059 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1060 			RETURN_FALSE;
1061 		}
1062 	}
1063 
1064 	XMLW_NAME_CHK("Invalid Element Name");
1065 
1066 	ptr = intern->ptr;
1067 
1068 	if (ptr) {
1069 		if (!content) {
1070 			retval = xmlTextWriterStartElement(ptr, (xmlChar *)name);
1071             if (retval == -1) {
1072                 RETURN_FALSE;
1073             }
1074 			xmlTextWriterEndElement(ptr);
1075             if (retval == -1) {
1076                 RETURN_FALSE;
1077             }
1078 		} else {
1079 			retval = xmlTextWriterWriteElement(ptr, (xmlChar *)name, (xmlChar *)content);
1080 		}
1081 		if (retval != -1) {
1082 			RETURN_TRUE;
1083 		}
1084 	}
1085 
1086 	RETURN_FALSE;
1087 }
1088 /* }}} */
1089 
1090 /* {{{ proto bool xmlwriter_write_element_ns(resource xmlwriter, string prefix, string name, string uri[, string content])
1091 Write full namesapced element tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_element_ns)1092 static PHP_FUNCTION(xmlwriter_write_element_ns)
1093 {
1094 	zval *pind;
1095 	xmlwriter_object *intern;
1096 	xmlTextWriterPtr ptr;
1097 	char *name, *prefix, *uri, *content = NULL;
1098 	size_t name_len, prefix_len, uri_len, content_len;
1099 	int retval;
1100 	zval *self = getThis();
1101 
1102 	if (self) {
1103 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!ss!|s!",
1104 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len, &content, &content_len) == FAILURE) {
1105 			return;
1106 		}
1107 		XMLWRITER_FROM_OBJECT(intern, self);
1108 	} else {
1109 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs!ss!|s!", &pind,
1110 			&prefix, &prefix_len, &name, &name_len, &uri, &uri_len, &content, &content_len) == FAILURE) {
1111 			return;
1112 		}
1113 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1114 			RETURN_FALSE;
1115 		}
1116 	}
1117 
1118 	XMLW_NAME_CHK("Invalid Element Name");
1119 
1120 	ptr = intern->ptr;
1121 
1122 	if (ptr) {
1123 		if (!content) {
1124 			retval = xmlTextWriterStartElementNS(ptr,(xmlChar *)prefix, (xmlChar *)name, (xmlChar *)uri);
1125             if (retval == -1) {
1126                 RETURN_FALSE;
1127             }
1128 			retval = xmlTextWriterEndElement(ptr);
1129             if (retval == -1) {
1130                 RETURN_FALSE;
1131             }
1132 		} else {
1133 			retval = xmlTextWriterWriteElementNS(ptr, (xmlChar *)prefix, (xmlChar *)name, (xmlChar *)uri, (xmlChar *)content);
1134 		}
1135 		if (retval != -1) {
1136 			RETURN_TRUE;
1137 		}
1138 	}
1139 
1140 	RETURN_FALSE;
1141 }
1142 /* }}} */
1143 
1144 /* {{{ proto bool xmlwriter_start_pi(resource xmlwriter, string target)
1145 Create start PI tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_pi)1146 static PHP_FUNCTION(xmlwriter_start_pi)
1147 {
1148 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterStartPI, "Invalid PI Target");
1149 }
1150 /* }}} */
1151 
1152 /* {{{ proto bool xmlwriter_end_pi(resource xmlwriter)
1153 End current PI - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_pi)1154 static PHP_FUNCTION(xmlwriter_end_pi)
1155 {
1156 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndPI);
1157 }
1158 /* }}} */
1159 
1160 /* {{{ proto bool xmlwriter_write_pi(resource xmlwriter, string target, string content)
1161 Write full PI tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_pi)1162 static PHP_FUNCTION(xmlwriter_write_pi)
1163 {
1164 	zval *pind;
1165 	xmlwriter_object *intern;
1166 	xmlTextWriterPtr ptr;
1167 	char *name, *content;
1168 	size_t name_len, content_len;
1169 	int retval;
1170 
1171 	zval *self = getThis();
1172 
1173 	if (self) {
1174 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
1175 			&name, &name_len, &content, &content_len) == FAILURE) {
1176 			return;
1177 		}
1178 		XMLWRITER_FROM_OBJECT(intern, self);
1179 	} else {
1180 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &pind,
1181 			&name, &name_len, &content, &content_len) == FAILURE) {
1182 			return;
1183 		}
1184 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1185 			RETURN_FALSE;
1186 		}
1187 	}
1188 
1189 	XMLW_NAME_CHK("Invalid PI Target");
1190 
1191 	ptr = intern->ptr;
1192 
1193 	if (ptr) {
1194 		retval = xmlTextWriterWritePI(ptr, (xmlChar *)name, (xmlChar *)content);
1195 		if (retval != -1) {
1196 			RETURN_TRUE;
1197 		}
1198 	}
1199 
1200 	RETURN_FALSE;
1201 }
1202 /* }}} */
1203 
1204 /* {{{ proto bool xmlwriter_start_cdata(resource xmlwriter)
1205 Create start CDATA tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_cdata)1206 static PHP_FUNCTION(xmlwriter_start_cdata)
1207 {
1208 	zval *pind;
1209 	xmlwriter_object *intern;
1210 	xmlTextWriterPtr ptr;
1211 	int retval;
1212 	zval *self = getThis();
1213 
1214 	if (self) {
1215 		XMLWRITER_FROM_OBJECT(intern, self);
1216 	} else {
1217 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pind) == FAILURE) {
1218 			return;
1219 		}
1220 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1221 			RETURN_FALSE;
1222 		}
1223 	}
1224 
1225 	ptr = intern->ptr;
1226 
1227 	if (ptr) {
1228 		retval = xmlTextWriterStartCDATA(ptr);
1229 		if (retval != -1) {
1230 			RETURN_TRUE;
1231 		}
1232 	}
1233 
1234 	RETURN_FALSE;
1235 }
1236 /* }}} */
1237 
1238 /* {{{ proto bool xmlwriter_end_cdata(resource xmlwriter)
1239 End current CDATA - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_cdata)1240 static PHP_FUNCTION(xmlwriter_end_cdata)
1241 {
1242 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndCDATA);
1243 }
1244 /* }}} */
1245 
1246 /* {{{ proto bool xmlwriter_write_cdata(resource xmlwriter, string content)
1247 Write full CDATA tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_cdata)1248 static PHP_FUNCTION(xmlwriter_write_cdata)
1249 {
1250 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterWriteCDATA, NULL);
1251 }
1252 /* }}} */
1253 
1254 /* {{{ proto bool xmlwriter_write_raw(resource xmlwriter, string content)
1255 Write text - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_raw)1256 static PHP_FUNCTION(xmlwriter_write_raw)
1257 {
1258 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterWriteRaw, NULL);
1259 }
1260 /* }}} */
1261 
1262 /* {{{ proto bool xmlwriter_text(resource xmlwriter, string content)
1263 Write text - returns FALSE on error */
PHP_FUNCTION(xmlwriter_text)1264 static PHP_FUNCTION(xmlwriter_text)
1265 {
1266 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterWriteString, NULL);
1267 }
1268 /* }}} */
1269 
1270 #if LIBXML_VERSION >= 20607
1271 /* {{{ proto bool xmlwriter_start_comment(resource xmlwriter)
1272 Create start comment - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_comment)1273 static PHP_FUNCTION(xmlwriter_start_comment)
1274 {
1275 	zval *pind;
1276 	xmlwriter_object *intern;
1277 	xmlTextWriterPtr ptr;
1278 	int retval;
1279 	zval *self = getThis();
1280 
1281 	if (self) {
1282 		XMLWRITER_FROM_OBJECT(intern, self);
1283 	} else {
1284 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &pind) == FAILURE) {
1285 			return;
1286 		}
1287 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1288 			RETURN_FALSE;
1289 		}
1290 	}
1291 
1292 	ptr = intern->ptr;
1293 
1294 	if (ptr) {
1295 		retval = xmlTextWriterStartComment(ptr);
1296 		if (retval != -1) {
1297 			RETURN_TRUE;
1298 		}
1299 	}
1300 
1301 	RETURN_FALSE;
1302 }
1303 /* }}} */
1304 
1305 /* {{{ proto bool xmlwriter_end_comment(resource xmlwriter)
1306 Create end comment - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_comment)1307 static PHP_FUNCTION(xmlwriter_end_comment)
1308 {
1309 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndComment);
1310 }
1311 /* }}} */
1312 #endif  /* LIBXML_VERSION >= 20607 */
1313 
1314 
1315 /* {{{ proto bool xmlwriter_write_comment(resource xmlwriter, string content)
1316 Write full comment tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_comment)1317 static PHP_FUNCTION(xmlwriter_write_comment)
1318 {
1319 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterWriteComment, NULL);
1320 }
1321 /* }}} */
1322 
1323 /* {{{ proto bool xmlwriter_start_document(resource xmlwriter, string version, string encoding, string standalone)
1324 Create document tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_document)1325 static PHP_FUNCTION(xmlwriter_start_document)
1326 {
1327 	zval *pind;
1328 	xmlwriter_object *intern;
1329 	xmlTextWriterPtr ptr;
1330 	char *version = NULL, *enc = NULL, *alone = NULL;
1331 	size_t version_len, enc_len, alone_len;
1332 	int retval;
1333 
1334 	zval *self = getThis();
1335 
1336 	if (self) {
1337 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s!s!s!", &version, &version_len, &enc, &enc_len, &alone, &alone_len) == FAILURE) {
1338 			return;
1339 		}
1340 		XMLWRITER_FROM_OBJECT(intern, self);
1341 	} else {
1342 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|s!s!s!", &pind, &version, &version_len, &enc, &enc_len, &alone, &alone_len) == FAILURE) {
1343 			return;
1344 		}
1345 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1346 			RETURN_FALSE;
1347 		}
1348 	}
1349 
1350 	ptr = intern->ptr;
1351 
1352 	if (ptr) {
1353 		retval = xmlTextWriterStartDocument(ptr, version, enc, alone);
1354 		if (retval != -1) {
1355 			RETURN_TRUE;
1356 		}
1357 	}
1358 
1359 	RETURN_FALSE;
1360 }
1361 /* }}} */
1362 
1363 /* {{{ proto bool xmlwriter_end_document(resource xmlwriter)
1364 End current document - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_document)1365 static PHP_FUNCTION(xmlwriter_end_document)
1366 {
1367 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndDocument);
1368 }
1369 /* }}} */
1370 
1371 /* {{{ proto bool xmlwriter_start_dtd(resource xmlwriter, string name, string pubid, string sysid)
1372 Create start DTD tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_dtd)1373 static PHP_FUNCTION(xmlwriter_start_dtd)
1374 {
1375 	zval *pind;
1376 	xmlwriter_object *intern;
1377 	xmlTextWriterPtr ptr;
1378 	char *name, *pubid = NULL, *sysid = NULL;
1379 	size_t name_len, pubid_len, sysid_len;
1380 	int retval;
1381 	zval *self = getThis();
1382 
1383 	if (self) {
1384 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!s!", &name, &name_len, &pubid, &pubid_len, &sysid, &sysid_len) == FAILURE) {
1385 			return;
1386 		}
1387 
1388 		XMLWRITER_FROM_OBJECT(intern, self);
1389 	} else {
1390 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|s!s!", &pind, &name, &name_len, &pubid, &pubid_len, &sysid, &sysid_len) == FAILURE) {
1391 			return;
1392 		}
1393 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1394 			RETURN_FALSE;
1395 		}
1396 	}
1397 	ptr = intern->ptr;
1398 
1399 	if (ptr) {
1400 		retval = xmlTextWriterStartDTD(ptr, (xmlChar *)name, (xmlChar *)pubid, (xmlChar *)sysid);
1401 		if (retval != -1) {
1402 			RETURN_TRUE;
1403 		}
1404 	}
1405 
1406 	RETURN_FALSE;
1407 }
1408 /* }}} */
1409 
1410 /* {{{ proto bool xmlwriter_end_dtd(resource xmlwriter)
1411 End current DTD - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_dtd)1412 static PHP_FUNCTION(xmlwriter_end_dtd)
1413 {
1414 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndDTD);
1415 }
1416 /* }}} */
1417 
1418 /* {{{ proto bool xmlwriter_write_dtd(resource xmlwriter, string name, string pubid, string sysid, string subset)
1419 Write full DTD tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_dtd)1420 static PHP_FUNCTION(xmlwriter_write_dtd)
1421 {
1422 	zval *pind;
1423 	xmlwriter_object *intern;
1424 	xmlTextWriterPtr ptr;
1425 	char *name, *pubid = NULL, *sysid = NULL, *subset = NULL;
1426 	size_t name_len, pubid_len, sysid_len, subset_len;
1427 	int retval;
1428 	zval *self = getThis();
1429 
1430 	if (self) {
1431 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!s!s!", &name, &name_len, &pubid, &pubid_len, &sysid, &sysid_len, &subset, &subset_len) == FAILURE) {
1432 			return;
1433 		}
1434 
1435 		XMLWRITER_FROM_OBJECT(intern, self);
1436 	} else {
1437 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|s!s!s!", &pind, &name, &name_len, &pubid, &pubid_len, &sysid, &sysid_len, &subset, &subset_len) == FAILURE) {
1438 			return;
1439 		}
1440 
1441 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1442 			RETURN_FALSE;
1443 		}
1444 	}
1445 
1446 	ptr = intern->ptr;
1447 
1448 	if (ptr) {
1449 		retval = xmlTextWriterWriteDTD(ptr, (xmlChar *)name, (xmlChar *)pubid, (xmlChar *)sysid, (xmlChar *)subset);
1450 		if (retval != -1) {
1451 			RETURN_TRUE;
1452 		}
1453 	}
1454 
1455 	RETURN_FALSE;
1456 }
1457 /* }}} */
1458 
1459 /* {{{ proto bool xmlwriter_start_dtd_element(resource xmlwriter, string name)
1460 Create start DTD element - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_dtd_element)1461 static PHP_FUNCTION(xmlwriter_start_dtd_element)
1462 {
1463 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterStartDTDElement, "Invalid Element Name");
1464 }
1465 /* }}} */
1466 
1467 /* {{{ proto bool xmlwriter_end_dtd_element(resource xmlwriter)
1468 End current DTD element - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_dtd_element)1469 static PHP_FUNCTION(xmlwriter_end_dtd_element)
1470 {
1471 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndDTDElement);
1472 }
1473 /* }}} */
1474 
1475 /* {{{ proto bool xmlwriter_write_dtd_element(resource xmlwriter, string name, string content)
1476 Write full DTD element tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_dtd_element)1477 static PHP_FUNCTION(xmlwriter_write_dtd_element)
1478 {
1479 	zval *pind;
1480 	xmlwriter_object *intern;
1481 	xmlTextWriterPtr ptr;
1482 	char *name, *content;
1483 	size_t name_len, content_len;
1484 	int retval;
1485 	zval *self = getThis();
1486 
1487 	if (self) {
1488 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name, &name_len, &content, &content_len) == FAILURE) {
1489 			return;
1490 		}
1491 		XMLWRITER_FROM_OBJECT(intern, self);
1492 	} else {
1493 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &pind,
1494 			&name, &name_len, &content, &content_len) == FAILURE) {
1495 			return;
1496 		}
1497 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1498 			RETURN_FALSE;
1499 		}
1500 	}
1501 
1502 	XMLW_NAME_CHK("Invalid Element Name");
1503 
1504 	ptr = intern->ptr;
1505 
1506 	if (ptr) {
1507 		retval = xmlTextWriterWriteDTDElement(ptr, (xmlChar *)name, (xmlChar *)content);
1508 		if (retval != -1) {
1509 			RETURN_TRUE;
1510 		}
1511 	}
1512 
1513 	RETURN_FALSE;
1514 }
1515 /* }}} */
1516 
1517 #if LIBXML_VERSION > 20608
1518 /* {{{ proto bool xmlwriter_start_dtd_attlist(resource xmlwriter, string name)
1519 Create start DTD AttList - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_dtd_attlist)1520 static PHP_FUNCTION(xmlwriter_start_dtd_attlist)
1521 {
1522 	php_xmlwriter_string_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterStartDTDAttlist, "Invalid Element Name");
1523 }
1524 /* }}} */
1525 
1526 /* {{{ proto bool xmlwriter_end_dtd_attlist(resource xmlwriter)
1527 End current DTD AttList - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_dtd_attlist)1528 static PHP_FUNCTION(xmlwriter_end_dtd_attlist)
1529 {
1530 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndDTDAttlist);
1531 }
1532 /* }}} */
1533 
1534 /* {{{ proto bool xmlwriter_write_dtd_attlist(resource xmlwriter, string name, string content)
1535 Write full DTD AttList tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_dtd_attlist)1536 static PHP_FUNCTION(xmlwriter_write_dtd_attlist)
1537 {
1538 	zval *pind;
1539 	xmlwriter_object *intern;
1540 	xmlTextWriterPtr ptr;
1541 	char *name, *content;
1542 	size_t name_len, content_len;
1543 	int retval;
1544 	zval *self = getThis();
1545 
1546 	if (self) {
1547 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
1548 			&name, &name_len, &content, &content_len) == FAILURE) {
1549 			return;
1550 		}
1551 		XMLWRITER_FROM_OBJECT(intern, self);
1552 	} else {
1553 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &pind,
1554 			&name, &name_len, &content, &content_len) == FAILURE) {
1555 			return;
1556 		}
1557 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1558 			RETURN_FALSE;
1559 		}
1560 	}
1561 
1562 	XMLW_NAME_CHK("Invalid Element Name");
1563 
1564 	ptr = intern->ptr;
1565 
1566 	if (ptr) {
1567 		retval = xmlTextWriterWriteDTDAttlist(ptr, (xmlChar *)name, (xmlChar *)content);
1568 		if (retval != -1) {
1569 			RETURN_TRUE;
1570 		}
1571 	}
1572 
1573 	RETURN_FALSE;
1574 }
1575 /* }}} */
1576 
1577 /* {{{ proto bool xmlwriter_start_dtd_entity(resource xmlwriter, string name, bool isparam)
1578 Create start DTD Entity - returns FALSE on error */
PHP_FUNCTION(xmlwriter_start_dtd_entity)1579 static PHP_FUNCTION(xmlwriter_start_dtd_entity)
1580 {
1581 	zval *pind;
1582 	xmlwriter_object *intern;
1583 	xmlTextWriterPtr ptr;
1584 	char *name;
1585 	size_t name_len;
1586 	int retval;
1587 	zend_bool isparm;
1588 	zval *self = getThis();
1589 
1590 	if (self) {
1591 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "sb", &name, &name_len, &isparm) == FAILURE) {
1592 			return;
1593 		}
1594 		XMLWRITER_FROM_OBJECT(intern, self);
1595 	} else {
1596 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsb", &pind, &name, &name_len, &isparm) == FAILURE) {
1597 			return;
1598 		}
1599 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1600 			RETURN_FALSE;
1601 		}
1602 	}
1603 
1604 	XMLW_NAME_CHK("Invalid Attribute Name");
1605 
1606 	ptr = intern->ptr;
1607 
1608 	if (ptr) {
1609 		retval = xmlTextWriterStartDTDEntity(ptr, isparm, (xmlChar *)name);
1610 		if (retval != -1) {
1611 			RETURN_TRUE;
1612 		}
1613 	}
1614 
1615 	RETURN_FALSE;
1616 }
1617 /* }}} */
1618 
1619 /* {{{ proto bool xmlwriter_end_dtd_entity(resource xmlwriter)
1620 End current DTD Entity - returns FALSE on error */
PHP_FUNCTION(xmlwriter_end_dtd_entity)1621 static PHP_FUNCTION(xmlwriter_end_dtd_entity)
1622 {
1623 	php_xmlwriter_end(INTERNAL_FUNCTION_PARAM_PASSTHRU, xmlTextWriterEndDTDEntity);
1624 }
1625 /* }}} */
1626 
1627 /* {{{ proto bool xmlwriter_write_dtd_entity(resource xmlwriter, string name, string content [, bool pe [, string pubid [, string sysid [, string ndataid]]]])
1628 Write full DTD Entity tag - returns FALSE on error */
PHP_FUNCTION(xmlwriter_write_dtd_entity)1629 static PHP_FUNCTION(xmlwriter_write_dtd_entity)
1630 {
1631 	zval *pind;
1632 	xmlwriter_object *intern;
1633 	xmlTextWriterPtr ptr;
1634 	char *name, *content;
1635 	size_t name_len, content_len;
1636 	int retval;
1637 	/* Optional parameters */
1638 	char *pubid = NULL, *sysid = NULL, *ndataid = NULL;
1639 	zend_bool pe = 0;
1640 	size_t pubid_len, sysid_len, ndataid_len;
1641 	zval *self = getThis();
1642 
1643 	if (self) {
1644 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|bsss",
1645 			&name, &name_len, &content, &content_len, &pe, &pubid, &pubid_len,
1646 			&sysid, &sysid_len, &ndataid, &ndataid_len) == FAILURE) {
1647 			return;
1648 		}
1649 		XMLWRITER_FROM_OBJECT(intern, self);
1650 	} else {
1651 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss|bsss", &pind,
1652 			&name, &name_len, &content, &content_len, &pe, &pubid, &pubid_len,
1653 			&sysid, &sysid_len, &ndataid, &ndataid_len) == FAILURE) {
1654 			return;
1655 		}
1656 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1657 			RETURN_FALSE;
1658 		}
1659 	}
1660 
1661 	XMLW_NAME_CHK("Invalid Element Name");
1662 
1663 	ptr = intern->ptr;
1664 
1665 	if (ptr) {
1666 		retval = xmlTextWriterWriteDTDEntity(ptr, pe, (xmlChar *)name, (xmlChar *)pubid, (xmlChar *)sysid, (xmlChar *)ndataid, (xmlChar *)content);
1667 		if (retval != -1) {
1668 			RETURN_TRUE;
1669 		}
1670 	}
1671 
1672 	RETURN_FALSE;
1673 }
1674 /* }}} */
1675 #endif
1676 
1677 /* {{{ proto resource xmlwriter_open_uri(string source)
1678 Create new xmlwriter using source uri for output */
PHP_FUNCTION(xmlwriter_open_uri)1679 static PHP_FUNCTION(xmlwriter_open_uri)
1680 {
1681 	char *valid_file = NULL;
1682 	xmlwriter_object *intern;
1683 	xmlTextWriterPtr ptr;
1684 	char *source;
1685 	char resolved_path[MAXPATHLEN + 1];
1686 	size_t source_len;
1687 	zval *self = getThis();
1688 	ze_xmlwriter_object *ze_obj = NULL;
1689 
1690 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &source, &source_len) == FAILURE) {
1691 		return;
1692 	}
1693 
1694 	if (self) {
1695 		/* We do not use XMLWRITER_FROM_OBJECT, xmlwriter init function here */
1696 		ze_obj = Z_XMLWRITER_P(self);
1697 	}
1698 
1699 	if (source_len == 0) {
1700 		php_error_docref(NULL, E_WARNING, "Empty string as source");
1701 		RETURN_FALSE;
1702 	}
1703 
1704 	valid_file = _xmlwriter_get_valid_file_path(source, resolved_path, MAXPATHLEN);
1705 	if (!valid_file) {
1706 		php_error_docref(NULL, E_WARNING, "Unable to resolve file path");
1707 		RETURN_FALSE;
1708 	}
1709 
1710 	ptr = xmlNewTextWriterFilename(valid_file, 0);
1711 
1712 	if (!ptr) {
1713 		RETURN_FALSE;
1714 	}
1715 
1716 	intern = emalloc(sizeof(xmlwriter_object));
1717 	intern->ptr = ptr;
1718 	intern->output = NULL;
1719 	if (self) {
1720 		if (ze_obj->xmlwriter_ptr) {
1721 			xmlwriter_free_resource_ptr(ze_obj->xmlwriter_ptr);
1722 		}
1723 		ze_obj->xmlwriter_ptr = intern;
1724 		RETURN_TRUE;
1725 	} else {
1726 		RETURN_RES(zend_register_resource(intern, le_xmlwriter));
1727 	}
1728 }
1729 /* }}} */
1730 
1731 /* {{{ proto resource xmlwriter_open_memory()
1732 Create new xmlwriter using memory for string output */
PHP_FUNCTION(xmlwriter_open_memory)1733 static PHP_FUNCTION(xmlwriter_open_memory)
1734 {
1735 	xmlwriter_object *intern;
1736 	xmlTextWriterPtr ptr;
1737 	xmlBufferPtr buffer;
1738 	zval *self = getThis();
1739 	ze_xmlwriter_object *ze_obj = NULL;
1740 
1741 	if (self) {
1742 		/* We do not use XMLWRITER_FROM_OBJECT, xmlwriter init function here */
1743 		ze_obj = Z_XMLWRITER_P(self);
1744 	}
1745 
1746 	buffer = xmlBufferCreate();
1747 
1748 	if (buffer == NULL) {
1749 		php_error_docref(NULL, E_WARNING, "Unable to create output buffer");
1750 		RETURN_FALSE;
1751 	}
1752 
1753 	ptr = xmlNewTextWriterMemory(buffer, 0);
1754 	if (! ptr) {
1755 		xmlBufferFree(buffer);
1756 		RETURN_FALSE;
1757 	}
1758 
1759 	intern = emalloc(sizeof(xmlwriter_object));
1760 	intern->ptr = ptr;
1761 	intern->output = buffer;
1762 	if (self) {
1763 		if (ze_obj->xmlwriter_ptr) {
1764 			xmlwriter_free_resource_ptr(ze_obj->xmlwriter_ptr);
1765 		}
1766 		ze_obj->xmlwriter_ptr = intern;
1767 		RETURN_TRUE;
1768 	} else {
1769 		RETURN_RES(zend_register_resource(intern, le_xmlwriter));
1770 	}
1771 
1772 }
1773 /* }}} */
1774 
1775 /* {{{ php_xmlwriter_flush */
php_xmlwriter_flush(INTERNAL_FUNCTION_PARAMETERS,int force_string)1776 static void php_xmlwriter_flush(INTERNAL_FUNCTION_PARAMETERS, int force_string) {
1777 	zval *pind;
1778 	xmlwriter_object *intern;
1779 	xmlTextWriterPtr ptr;
1780 	xmlBufferPtr buffer;
1781 	zend_bool empty = 1;
1782 	int output_bytes;
1783 	zval *self = getThis();
1784 
1785 	if (self) {
1786 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &empty) == FAILURE) {
1787 			return;
1788 		}
1789 		XMLWRITER_FROM_OBJECT(intern, self);
1790 	} else {
1791 		if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|b", &pind, &empty) == FAILURE) {
1792 			return;
1793 		}
1794 
1795 		if ((intern = (xmlwriter_object *)zend_fetch_resource(Z_RES_P(pind), "XMLWriter", le_xmlwriter)) == NULL) {
1796 			RETURN_FALSE;
1797 		}
1798 	}
1799 	ptr = intern->ptr;
1800 
1801 	if (ptr) {
1802 		buffer = intern->output;
1803 		if (force_string == 1 && buffer == NULL) {
1804 			RETURN_EMPTY_STRING();
1805 		}
1806 		output_bytes = xmlTextWriterFlush(ptr);
1807 		if (buffer) {
1808 			RETVAL_STRING((char *) buffer->content);
1809 			if (empty) {
1810 				xmlBufferEmpty(buffer);
1811 			}
1812 		} else {
1813 			RETVAL_LONG(output_bytes);
1814 		}
1815 		return;
1816 	}
1817 
1818 	RETURN_EMPTY_STRING();
1819 }
1820 /* }}} */
1821 
1822 /* {{{ proto string xmlwriter_output_memory(resource xmlwriter [,bool flush])
1823 Output current buffer as string */
PHP_FUNCTION(xmlwriter_output_memory)1824 static PHP_FUNCTION(xmlwriter_output_memory)
1825 {
1826 	php_xmlwriter_flush(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1827 }
1828 /* }}} */
1829 
1830 /* {{{ proto mixed xmlwriter_flush(resource xmlwriter [,bool empty])
1831 Output current buffer */
PHP_FUNCTION(xmlwriter_flush)1832 static PHP_FUNCTION(xmlwriter_flush)
1833 {
1834 	php_xmlwriter_flush(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1835 }
1836 /* }}} */
1837 
1838 /* {{{ PHP_MINIT_FUNCTION
1839  */
PHP_MINIT_FUNCTION(xmlwriter)1840 static PHP_MINIT_FUNCTION(xmlwriter)
1841 {
1842 	zend_class_entry ce;
1843 	le_xmlwriter = zend_register_list_destructors_ex(xmlwriter_dtor, NULL, "xmlwriter", module_number);
1844 
1845 	memcpy(&xmlwriter_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1846 	xmlwriter_object_handlers.offset = XtOffsetOf(ze_xmlwriter_object, std);
1847 	xmlwriter_object_handlers.free_obj = xmlwriter_object_free_storage;
1848 	xmlwriter_object_handlers.clone_obj = NULL;
1849 	INIT_CLASS_ENTRY(ce, "XMLWriter", xmlwriter_class_functions);
1850 	ce.create_object = xmlwriter_object_new;
1851 	xmlwriter_class_entry_ce = zend_register_internal_class(&ce);
1852 
1853 	return SUCCESS;
1854 }
1855 /* }}} */
1856 
1857 /* {{{ PHP_MSHUTDOWN_FUNCTION
1858  */
PHP_MSHUTDOWN_FUNCTION(xmlwriter)1859 static PHP_MSHUTDOWN_FUNCTION(xmlwriter)
1860 {
1861 	return SUCCESS;
1862 }
1863 /* }}} */
1864 
1865 /* {{{ PHP_MINFO_FUNCTION
1866  */
PHP_MINFO_FUNCTION(xmlwriter)1867 static PHP_MINFO_FUNCTION(xmlwriter)
1868 {
1869 	php_info_print_table_start();
1870 	{
1871 		php_info_print_table_row(2, "XMLWriter", "enabled");
1872 	}
1873 	php_info_print_table_end();
1874 }
1875 /* }}} */
1876 
1877 /*
1878  * Local variables:
1879  * tab-width: 4
1880  * c-basic-offset: 4
1881  * End:
1882  * vim600: noet sw=4 ts=4 fdm=marker
1883  * vim<600: noet sw=4 ts=4
1884  */
1885