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: John Coggeshall <john@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 /* $Id: c6d6b80d55c5d351deaa745c3c540971e5583c24 $ */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "php.h"
26 #include "php_tidy.h"
27
28 #if HAVE_TIDY
29
30 #include "php_ini.h"
31 #include "ext/standard/info.h"
32
33 #include "tidy.h"
34
35 #if HAVE_TIDYBUFFIO_H
36 #include "tidybuffio.h"
37 #else
38 #include "buffio.h"
39 #endif
40
41 /* compatibility with older versions of libtidy */
42 #ifndef TIDY_CALL
43 #define TIDY_CALL
44 #endif
45
46 /* {{{ ext/tidy macros
47 */
48 #define FIX_BUFFER(bptr) do { if ((bptr)->size) { (bptr)->bp[(bptr)->size-1] = '\0'; } } while(0)
49
50 #define TIDY_SET_CONTEXT \
51 zval *object = getThis();
52
53 #define TIDY_FETCH_OBJECT \
54 PHPTidyObj *obj; \
55 TIDY_SET_CONTEXT; \
56 if (object) { \
57 if (zend_parse_parameters_none() == FAILURE) { \
58 return; \
59 } \
60 } else { \
61 if (zend_parse_method_parameters(ZEND_NUM_ARGS(), NULL, "O", &object, tidy_ce_doc) == FAILURE) { \
62 RETURN_FALSE; \
63 } \
64 } \
65 obj = Z_TIDY_P(object); \
66
67 #define TIDY_FETCH_ONLY_OBJECT \
68 PHPTidyObj *obj; \
69 TIDY_SET_CONTEXT; \
70 if (zend_parse_parameters_none() == FAILURE) { \
71 return; \
72 } \
73 obj = Z_TIDY_P(object); \
74
75 #define TIDY_APPLY_CONFIG_ZVAL(_doc, _val) \
76 if(_val) { \
77 if(Z_TYPE_P(_val) == IS_ARRAY) { \
78 _php_tidy_apply_config_array(_doc, Z_ARRVAL_P(_val)); \
79 } else { \
80 convert_to_string_ex(_val); \
81 TIDY_OPEN_BASE_DIR_CHECK(Z_STRVAL_P(_val)); \
82 switch (tidyLoadConfig(_doc, Z_STRVAL_P(_val))) { \
83 case -1: \
84 php_error_docref(NULL, E_WARNING, "Could not load configuration file '%s'", Z_STRVAL_P(_val)); \
85 break; \
86 case 1: \
87 php_error_docref(NULL, E_NOTICE, "There were errors while parsing the configuration file '%s'", Z_STRVAL_P(_val)); \
88 break; \
89 } \
90 } \
91 }
92
93 #define REGISTER_TIDY_CLASS(classname, name, parent, __flags) \
94 { \
95 zend_class_entry ce; \
96 INIT_CLASS_ENTRY(ce, # classname, tidy_funcs_ ## name); \
97 ce.create_object = tidy_object_new_ ## name; \
98 tidy_ce_ ## name = zend_register_internal_class_ex(&ce, parent); \
99 tidy_ce_ ## name->ce_flags |= __flags; \
100 memcpy(&tidy_object_handlers_ ## name, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \
101 tidy_object_handlers_ ## name.clone_obj = NULL; \
102 }
103
104 #define TIDY_TAG_CONST(tag) REGISTER_LONG_CONSTANT("TIDY_TAG_" #tag, TidyTag_##tag, CONST_CS | CONST_PERSISTENT)
105 #define TIDY_NODE_CONST(name, type) REGISTER_LONG_CONSTANT("TIDY_NODETYPE_" #name, TidyNode_##type, CONST_CS | CONST_PERSISTENT)
106
107 #ifndef TRUE
108 #define TRUE 1
109 #endif
110
111 #ifndef FALSE
112 #define FALSE 0
113 #endif
114
115 #define ADD_PROPERTY_STRING(_table, _key, _string) \
116 { \
117 zval tmp; \
118 if (_string) { \
119 ZVAL_STRING(&tmp, (char *)_string); \
120 } else { \
121 ZVAL_EMPTY_STRING(&tmp); \
122 } \
123 zend_hash_str_update(_table, #_key, sizeof(#_key) - 1, &tmp); \
124 }
125
126 #define ADD_PROPERTY_STRINGL(_table, _key, _string, _len) \
127 { \
128 zval tmp; \
129 if (_string) { \
130 ZVAL_STRINGL(&tmp, (char *)_string, _len); \
131 } else { \
132 ZVAL_EMPTY_STRING(&tmp); \
133 } \
134 zend_hash_str_update(_table, #_key, sizeof(#_key) - 1, &tmp); \
135 }
136
137 #define ADD_PROPERTY_LONG(_table, _key, _long) \
138 { \
139 zval tmp; \
140 ZVAL_LONG(&tmp, _long); \
141 zend_hash_str_update(_table, #_key, sizeof(#_key) - 1, &tmp); \
142 }
143
144 #define ADD_PROPERTY_NULL(_table, _key) \
145 { \
146 zval tmp; \
147 ZVAL_NULL(&tmp); \
148 zend_hash_str_update(_table, #_key, sizeof(#_key) - 1, &tmp); \
149 }
150
151 #define ADD_PROPERTY_BOOL(_table, _key, _bool) \
152 { \
153 zval tmp; \
154 ZVAL_BOOL(&tmp, _bool); \
155 zend_hash_str_update(_table, #_key, sizeof(#_key) - 1, &tmp); \
156 }
157
158 #define TIDY_OPEN_BASE_DIR_CHECK(filename) \
159 if (php_check_open_basedir(filename)) { \
160 RETURN_FALSE; \
161 } \
162
163 #define TIDY_SET_DEFAULT_CONFIG(_doc) \
164 if (TG(default_config) && TG(default_config)[0]) { \
165 if (tidyLoadConfig(_doc, TG(default_config)) < 0) { \
166 php_error_docref(NULL, E_WARNING, "Unable to load Tidy configuration file at '%s'.", TG(default_config)); \
167 } \
168 }
169 /* }}} */
170
171 /* {{{ ext/tidy structs
172 */
173 typedef struct _PHPTidyDoc PHPTidyDoc;
174 typedef struct _PHPTidyObj PHPTidyObj;
175
176 typedef enum {
177 is_node,
178 is_doc
179 } tidy_obj_type;
180
181 typedef enum {
182 is_root_node,
183 is_html_node,
184 is_head_node,
185 is_body_node
186 } tidy_base_nodetypes;
187
188 struct _PHPTidyDoc {
189 TidyDoc doc;
190 TidyBuffer *errbuf;
191 unsigned int ref_count;
192 unsigned int initialized:1;
193 };
194
195 struct _PHPTidyObj {
196 TidyNode node;
197 tidy_obj_type type;
198 PHPTidyDoc *ptdoc;
199 zend_object std;
200 };
201
php_tidy_fetch_object(zend_object * obj)202 static inline PHPTidyObj *php_tidy_fetch_object(zend_object *obj) {
203 return (PHPTidyObj *)((char*)(obj) - XtOffsetOf(PHPTidyObj, std));
204 }
205
206 #define Z_TIDY_P(zv) php_tidy_fetch_object(Z_OBJ_P((zv)))
207 /* }}} */
208
209 /* {{{ ext/tidy prototypes
210 */
211 static zend_string *php_tidy_file_to_mem(char *, zend_bool);
212 static void tidy_object_free_storage(zend_object *);
213 static zend_object *tidy_object_new_node(zend_class_entry *);
214 static zend_object *tidy_object_new_doc(zend_class_entry *);
215 static zval * tidy_instanciate(zend_class_entry *, zval *);
216 static int tidy_doc_cast_handler(zval *, zval *, int);
217 static int tidy_node_cast_handler(zval *, zval *, int);
218 static void tidy_doc_update_properties(PHPTidyObj *);
219 static void tidy_add_default_properties(PHPTidyObj *, tidy_obj_type);
220 static void *php_tidy_get_opt_val(PHPTidyDoc *, TidyOption, TidyOptionType *);
221 static void php_tidy_create_node(INTERNAL_FUNCTION_PARAMETERS, tidy_base_nodetypes);
222 static int _php_tidy_set_tidy_opt(TidyDoc, char *, zval *);
223 static int _php_tidy_apply_config_array(TidyDoc doc, HashTable *ht_options);
224 static void _php_tidy_register_nodetypes(INIT_FUNC_ARGS);
225 static void _php_tidy_register_tags(INIT_FUNC_ARGS);
226 static PHP_INI_MH(php_tidy_set_clean_output);
227 static void php_tidy_clean_output_start(const char *name, size_t name_len);
228 static php_output_handler *php_tidy_output_handler_init(const char *handler_name, size_t handler_name_len, size_t chunk_size, int flags);
229 static int php_tidy_output_handler(void **nothing, php_output_context *output_context);
230
231 static PHP_MINIT_FUNCTION(tidy);
232 static PHP_MSHUTDOWN_FUNCTION(tidy);
233 static PHP_RINIT_FUNCTION(tidy);
234 static PHP_MINFO_FUNCTION(tidy);
235
236 static PHP_FUNCTION(tidy_getopt);
237 static PHP_FUNCTION(tidy_parse_string);
238 static PHP_FUNCTION(tidy_parse_file);
239 static PHP_FUNCTION(tidy_clean_repair);
240 static PHP_FUNCTION(tidy_repair_string);
241 static PHP_FUNCTION(tidy_repair_file);
242 static PHP_FUNCTION(tidy_diagnose);
243 static PHP_FUNCTION(tidy_get_output);
244 static PHP_FUNCTION(tidy_get_error_buffer);
245 static PHP_FUNCTION(tidy_get_release);
246 static PHP_FUNCTION(tidy_get_config);
247 static PHP_FUNCTION(tidy_get_status);
248 static PHP_FUNCTION(tidy_get_html_ver);
249 #if HAVE_TIDYOPTGETDOC
250 static PHP_FUNCTION(tidy_get_opt_doc);
251 #endif
252 static PHP_FUNCTION(tidy_is_xhtml);
253 static PHP_FUNCTION(tidy_is_xml);
254 static PHP_FUNCTION(tidy_error_count);
255 static PHP_FUNCTION(tidy_warning_count);
256 static PHP_FUNCTION(tidy_access_count);
257 static PHP_FUNCTION(tidy_config_count);
258
259 static PHP_FUNCTION(tidy_get_root);
260 static PHP_FUNCTION(tidy_get_html);
261 static PHP_FUNCTION(tidy_get_head);
262 static PHP_FUNCTION(tidy_get_body);
263
264 static TIDY_DOC_METHOD(__construct);
265 static TIDY_DOC_METHOD(parseFile);
266 static TIDY_DOC_METHOD(parseString);
267
268 static TIDY_NODE_METHOD(hasChildren);
269 static TIDY_NODE_METHOD(hasSiblings);
270 static TIDY_NODE_METHOD(isComment);
271 static TIDY_NODE_METHOD(isHtml);
272 static TIDY_NODE_METHOD(isText);
273 static TIDY_NODE_METHOD(isJste);
274 static TIDY_NODE_METHOD(isAsp);
275 static TIDY_NODE_METHOD(isPhp);
276 static TIDY_NODE_METHOD(getParent);
277 static TIDY_NODE_METHOD(__construct);
278 /* }}} */
279
280 ZEND_DECLARE_MODULE_GLOBALS(tidy)
281
282 PHP_INI_BEGIN()
283 STD_PHP_INI_ENTRY("tidy.default_config", "", PHP_INI_SYSTEM, OnUpdateString, default_config, zend_tidy_globals, tidy_globals)
284 STD_PHP_INI_ENTRY("tidy.clean_output", "0", PHP_INI_USER, php_tidy_set_clean_output, clean_output, zend_tidy_globals, tidy_globals)
285 PHP_INI_END()
286
287 /* {{{ arginfo */
288 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_parse_string, 0, 0, 1)
289 ZEND_ARG_INFO(0, input)
290 ZEND_ARG_INFO(0, config_options)
291 ZEND_ARG_INFO(0, encoding)
292 ZEND_END_ARG_INFO()
293
294 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_error_buffer, 0)
295 ZEND_END_ARG_INFO()
296
297 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_output, 0)
298 ZEND_END_ARG_INFO()
299
300 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_parse_file, 0, 0, 1)
301 ZEND_ARG_INFO(0, file)
302 ZEND_ARG_INFO(0, config_options)
303 ZEND_ARG_INFO(0, encoding)
304 ZEND_ARG_INFO(0, use_include_path)
305 ZEND_END_ARG_INFO()
306
307 ZEND_BEGIN_ARG_INFO(arginfo_tidy_clean_repair, 0)
308 ZEND_END_ARG_INFO()
309
310 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_repair_string, 0, 0, 1)
311 ZEND_ARG_INFO(0, data)
312 ZEND_ARG_INFO(0, config_file)
313 ZEND_ARG_INFO(0, encoding)
314 ZEND_END_ARG_INFO()
315
316 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_repair_file, 0, 0, 1)
317 ZEND_ARG_INFO(0, filename)
318 ZEND_ARG_INFO(0, config_file)
319 ZEND_ARG_INFO(0, encoding)
320 ZEND_ARG_INFO(0, use_include_path)
321 ZEND_END_ARG_INFO()
322
323 ZEND_BEGIN_ARG_INFO(arginfo_tidy_diagnose, 0)
324 ZEND_END_ARG_INFO()
325
326 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_release, 0)
327 ZEND_END_ARG_INFO()
328
329 #if HAVE_TIDYOPTGETDOC
330 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_get_opt_doc, 0, 0, 2)
331 ZEND_ARG_INFO(0, resource)
332 ZEND_ARG_INFO(0, optname)
333 ZEND_END_ARG_INFO()
334 #endif
335
336 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_config, 0)
337 ZEND_END_ARG_INFO()
338
339 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_status, 0)
340 ZEND_END_ARG_INFO()
341
342 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_html_ver, 0)
343 ZEND_END_ARG_INFO()
344
345 ZEND_BEGIN_ARG_INFO(arginfo_tidy_is_xhtml, 0)
346 ZEND_END_ARG_INFO()
347
348 ZEND_BEGIN_ARG_INFO(arginfo_tidy_is_xml, 0)
349 ZEND_END_ARG_INFO()
350
351 ZEND_BEGIN_ARG_INFO(arginfo_tidy_error_count, 0)
352 ZEND_END_ARG_INFO()
353
354 ZEND_BEGIN_ARG_INFO(arginfo_tidy_warning_count, 0)
355 ZEND_END_ARG_INFO()
356
357 ZEND_BEGIN_ARG_INFO(arginfo_tidy_access_count, 0)
358 ZEND_END_ARG_INFO()
359
360 ZEND_BEGIN_ARG_INFO(arginfo_tidy_config_count, 0)
361 ZEND_END_ARG_INFO()
362
363 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_getopt, 0, 0, 1)
364 ZEND_ARG_INFO(0, option)
365 ZEND_END_ARG_INFO()
366
367 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_root, 0)
368 ZEND_END_ARG_INFO()
369
370 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_html, 0)
371 ZEND_END_ARG_INFO()
372
373 ZEND_BEGIN_ARG_INFO(arginfo_tidy_get_head, 0)
374 ZEND_END_ARG_INFO()
375
376 ZEND_BEGIN_ARG_INFO_EX(arginfo_tidy_get_body, 0, 0, 1)
377 ZEND_ARG_INFO(0, tidy)
378 ZEND_END_ARG_INFO()
379 /* }}} */
380
381 static const zend_function_entry tidy_functions[] = {
382 PHP_FE(tidy_getopt, arginfo_tidy_getopt)
383 PHP_FE(tidy_parse_string, arginfo_tidy_parse_string)
384 PHP_FE(tidy_parse_file, arginfo_tidy_parse_file)
385 PHP_FE(tidy_get_output, arginfo_tidy_get_output)
386 PHP_FE(tidy_get_error_buffer, arginfo_tidy_get_error_buffer)
387 PHP_FE(tidy_clean_repair, arginfo_tidy_clean_repair)
388 PHP_FE(tidy_repair_string, arginfo_tidy_repair_string)
389 PHP_FE(tidy_repair_file, arginfo_tidy_repair_file)
390 PHP_FE(tidy_diagnose, arginfo_tidy_diagnose)
391 PHP_FE(tidy_get_release, arginfo_tidy_get_release)
392 PHP_FE(tidy_get_config, arginfo_tidy_get_config)
393 PHP_FE(tidy_get_status, arginfo_tidy_get_status)
394 PHP_FE(tidy_get_html_ver, arginfo_tidy_get_html_ver)
395 PHP_FE(tidy_is_xhtml, arginfo_tidy_is_xhtml)
396 PHP_FE(tidy_is_xml, arginfo_tidy_is_xml)
397 PHP_FE(tidy_error_count, arginfo_tidy_error_count)
398 PHP_FE(tidy_warning_count, arginfo_tidy_warning_count)
399 PHP_FE(tidy_access_count, arginfo_tidy_access_count)
400 PHP_FE(tidy_config_count, arginfo_tidy_config_count)
401 #if HAVE_TIDYOPTGETDOC
402 PHP_FE(tidy_get_opt_doc, arginfo_tidy_get_opt_doc)
403 #endif
404 PHP_FE(tidy_get_root, arginfo_tidy_get_root)
405 PHP_FE(tidy_get_head, arginfo_tidy_get_head)
406 PHP_FE(tidy_get_html, arginfo_tidy_get_html)
407 PHP_FE(tidy_get_body, arginfo_tidy_get_body)
408 PHP_FE_END
409 };
410
411 static const zend_function_entry tidy_funcs_doc[] = {
412 TIDY_METHOD_MAP(getOpt, tidy_getopt, NULL)
413 TIDY_METHOD_MAP(cleanRepair, tidy_clean_repair, NULL)
414 TIDY_DOC_ME(parseFile, NULL)
415 TIDY_DOC_ME(parseString, NULL)
416 TIDY_METHOD_MAP(repairString, tidy_repair_string, NULL)
417 TIDY_METHOD_MAP(repairFile, tidy_repair_file, NULL)
418 TIDY_METHOD_MAP(diagnose, tidy_diagnose, NULL)
419 TIDY_METHOD_MAP(getRelease, tidy_get_release, NULL)
420 TIDY_METHOD_MAP(getConfig, tidy_get_config, NULL)
421 TIDY_METHOD_MAP(getStatus, tidy_get_status, NULL)
422 TIDY_METHOD_MAP(getHtmlVer, tidy_get_html_ver, NULL)
423 #if HAVE_TIDYOPTGETDOC
424 TIDY_METHOD_MAP(getOptDoc, tidy_get_opt_doc, NULL)
425 #endif
426 TIDY_METHOD_MAP(isXhtml, tidy_is_xhtml, NULL)
427 TIDY_METHOD_MAP(isXml, tidy_is_xml, NULL)
428 TIDY_METHOD_MAP(root, tidy_get_root, NULL)
429 TIDY_METHOD_MAP(head, tidy_get_head, NULL)
430 TIDY_METHOD_MAP(html, tidy_get_html, NULL)
431 TIDY_METHOD_MAP(body, tidy_get_body, NULL)
432 TIDY_DOC_ME(__construct, NULL)
433 PHP_FE_END
434 };
435
436 static const zend_function_entry tidy_funcs_node[] = {
437 TIDY_NODE_ME(hasChildren, NULL)
438 TIDY_NODE_ME(hasSiblings, NULL)
439 TIDY_NODE_ME(isComment, NULL)
440 TIDY_NODE_ME(isHtml, NULL)
441 TIDY_NODE_ME(isText, NULL)
442 TIDY_NODE_ME(isJste, NULL)
443 TIDY_NODE_ME(isAsp, NULL)
444 TIDY_NODE_ME(isPhp, NULL)
445 TIDY_NODE_ME(getParent, NULL)
446 TIDY_NODE_PRIVATE_ME(__construct, NULL)
447 PHP_FE_END
448 };
449
450 static zend_class_entry *tidy_ce_doc, *tidy_ce_node;
451
452 static zend_object_handlers tidy_object_handlers_doc;
453 static zend_object_handlers tidy_object_handlers_node;
454
455 zend_module_entry tidy_module_entry = {
456 STANDARD_MODULE_HEADER,
457 "tidy",
458 tidy_functions,
459 PHP_MINIT(tidy),
460 PHP_MSHUTDOWN(tidy),
461 PHP_RINIT(tidy),
462 NULL,
463 PHP_MINFO(tidy),
464 PHP_TIDY_VERSION,
465 PHP_MODULE_GLOBALS(tidy),
466 NULL,
467 NULL,
468 NULL,
469 STANDARD_MODULE_PROPERTIES_EX
470 };
471
472 #ifdef COMPILE_DL_TIDY
473 #ifdef ZTS
474 ZEND_TSRMLS_CACHE_DEFINE()
475 #endif
ZEND_GET_MODULE(tidy)476 ZEND_GET_MODULE(tidy)
477 #endif
478
479 static void* TIDY_CALL php_tidy_malloc(size_t len)
480 {
481 return emalloc(len);
482 }
483
php_tidy_realloc(void * buf,size_t len)484 static void* TIDY_CALL php_tidy_realloc(void *buf, size_t len)
485 {
486 return erealloc(buf, len);
487 }
488
php_tidy_free(void * buf)489 static void TIDY_CALL php_tidy_free(void *buf)
490 {
491 efree(buf);
492 }
493
php_tidy_panic(ctmbstr msg)494 static void TIDY_CALL php_tidy_panic(ctmbstr msg)
495 {
496 php_error_docref(NULL, E_ERROR, "Could not allocate memory for tidy! (Reason: %s)", (char *)msg);
497 }
498
_php_tidy_set_tidy_opt(TidyDoc doc,char * optname,zval * value)499 static int _php_tidy_set_tidy_opt(TidyDoc doc, char *optname, zval *value)
500 {
501 TidyOption opt = tidyGetOptionByName(doc, optname);
502 zval conv;
503
504 ZVAL_COPY_VALUE(&conv, value);
505
506 if (!opt) {
507 php_error_docref(NULL, E_NOTICE, "Unknown Tidy Configuration Option '%s'", optname);
508 return FAILURE;
509 }
510
511 if (tidyOptIsReadOnly(opt)) {
512 php_error_docref(NULL, E_NOTICE, "Attempting to set read-only option '%s'", optname);
513 return FAILURE;
514 }
515
516 switch(tidyOptGetType(opt)) {
517 case TidyString:
518 if (Z_TYPE(conv) != IS_STRING) {
519 zval_copy_ctor(&conv);
520 convert_to_string(&conv);
521 }
522 if (tidyOptSetValue(doc, tidyOptGetId(opt), Z_STRVAL(conv))) {
523 if (Z_TYPE(conv) != Z_TYPE_P(value)) {
524 zval_dtor(&conv);
525 }
526 return SUCCESS;
527 }
528 if (Z_TYPE(conv) != Z_TYPE_P(value)) {
529 zval_dtor(&conv);
530 }
531 break;
532
533 case TidyInteger:
534 if (Z_TYPE(conv) != IS_LONG) {
535 zval_copy_ctor(&conv);
536 convert_to_long(&conv);
537 }
538 if (tidyOptSetInt(doc, tidyOptGetId(opt), Z_LVAL(conv))) {
539 return SUCCESS;
540 }
541 break;
542
543 case TidyBoolean:
544 if (Z_TYPE(conv) != IS_LONG) {
545 zval_copy_ctor(&conv);
546 convert_to_long(&conv);
547 }
548 if (tidyOptSetBool(doc, tidyOptGetId(opt), Z_LVAL(conv))) {
549 return SUCCESS;
550 }
551 break;
552
553 default:
554 php_error_docref(NULL, E_WARNING, "Unable to determine type of configuration option");
555 break;
556 }
557
558 return FAILURE;
559 }
560
php_tidy_quick_repair(INTERNAL_FUNCTION_PARAMETERS,zend_bool is_file)561 static void php_tidy_quick_repair(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_file)
562 {
563 char *enc = NULL;
564 size_t enc_len = 0;
565 zend_bool use_include_path = 0;
566 TidyDoc doc;
567 TidyBuffer *errbuf;
568 zend_string *data, *arg1;
569 zval *config = NULL;
570
571 if (is_file) {
572 if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) {
573 RETURN_FALSE;
574 }
575 if (!(data = php_tidy_file_to_mem(ZSTR_VAL(arg1), use_include_path))) {
576 RETURN_FALSE;
577 }
578 } else {
579 if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) {
580 RETURN_FALSE;
581 }
582 data = arg1;
583 }
584
585 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(data))) {
586 php_error_docref(NULL, E_WARNING, "Input string is too long");
587 RETURN_FALSE;
588 }
589
590 doc = tidyCreate();
591 errbuf = emalloc(sizeof(TidyBuffer));
592 tidyBufInit(errbuf);
593
594 if (tidySetErrorBuffer(doc, errbuf) != 0) {
595 tidyBufFree(errbuf);
596 efree(errbuf);
597 tidyRelease(doc);
598 php_error_docref(NULL, E_ERROR, "Could not set Tidy error buffer");
599 }
600
601 tidyOptSetBool(doc, TidyForceOutput, yes);
602 tidyOptSetBool(doc, TidyMark, no);
603
604 TIDY_SET_DEFAULT_CONFIG(doc);
605
606 if (config) {
607 TIDY_APPLY_CONFIG_ZVAL(doc, config);
608 }
609
610 if(enc_len) {
611 if (tidySetCharEncoding(doc, enc) < 0) {
612 php_error_docref(NULL, E_WARNING, "Could not set encoding '%s'", enc);
613 RETVAL_FALSE;
614 }
615 }
616
617 if (data) {
618 TidyBuffer buf;
619
620 tidyBufInit(&buf);
621 tidyBufAttach(&buf, (byte *) ZSTR_VAL(data), (uint)ZSTR_LEN(data));
622
623 if (tidyParseBuffer(doc, &buf) < 0) {
624 php_error_docref(NULL, E_WARNING, "%s", errbuf->bp);
625 RETVAL_FALSE;
626 } else {
627 if (tidyCleanAndRepair(doc) >= 0) {
628 TidyBuffer output;
629 tidyBufInit(&output);
630
631 tidySaveBuffer (doc, &output);
632 FIX_BUFFER(&output);
633 RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0);
634 tidyBufFree(&output);
635 } else {
636 RETVAL_FALSE;
637 }
638 }
639 }
640
641 if (is_file) {
642 zend_string_release(data);
643 }
644
645 tidyBufFree(errbuf);
646 efree(errbuf);
647 tidyRelease(doc);
648 }
649
php_tidy_file_to_mem(char * filename,zend_bool use_include_path)650 static zend_string *php_tidy_file_to_mem(char *filename, zend_bool use_include_path)
651 {
652 php_stream *stream;
653 zend_string *data = NULL;
654
655 if (!(stream = php_stream_open_wrapper(filename, "rb", (use_include_path ? USE_PATH : 0), NULL))) {
656 return NULL;
657 }
658 if ((data = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) == NULL) {
659 data = ZSTR_EMPTY_ALLOC();
660 }
661 php_stream_close(stream);
662
663 return data;
664 }
665
tidy_object_free_storage(zend_object * object)666 static void tidy_object_free_storage(zend_object *object)
667 {
668 PHPTidyObj *intern = php_tidy_fetch_object(object);
669
670 zend_object_std_dtor(&intern->std);
671
672 if (intern->ptdoc) {
673 intern->ptdoc->ref_count--;
674
675 if (intern->ptdoc->ref_count <= 0) {
676 tidyBufFree(intern->ptdoc->errbuf);
677 efree(intern->ptdoc->errbuf);
678 tidyRelease(intern->ptdoc->doc);
679 efree(intern->ptdoc);
680 }
681 }
682 }
683
tidy_object_new(zend_class_entry * class_type,zend_object_handlers * handlers,tidy_obj_type objtype)684 static zend_object *tidy_object_new(zend_class_entry *class_type, zend_object_handlers *handlers, tidy_obj_type objtype)
685 {
686 PHPTidyObj *intern;
687
688 intern = ecalloc(1, sizeof(PHPTidyObj) + zend_object_properties_size(class_type));
689 zend_object_std_init(&intern->std, class_type);
690 object_properties_init(&intern->std, class_type);
691
692 switch(objtype) {
693 case is_node:
694 break;
695
696 case is_doc:
697 intern->ptdoc = emalloc(sizeof(PHPTidyDoc));
698 intern->ptdoc->doc = tidyCreate();
699 intern->ptdoc->ref_count = 1;
700 intern->ptdoc->initialized = 0;
701 intern->ptdoc->errbuf = emalloc(sizeof(TidyBuffer));
702 tidyBufInit(intern->ptdoc->errbuf);
703
704 if (tidySetErrorBuffer(intern->ptdoc->doc, intern->ptdoc->errbuf) != 0) {
705 tidyBufFree(intern->ptdoc->errbuf);
706 efree(intern->ptdoc->errbuf);
707 tidyRelease(intern->ptdoc->doc);
708 efree(intern->ptdoc);
709 efree(intern);
710 php_error_docref(NULL, E_ERROR, "Could not set Tidy error buffer");
711 }
712
713 tidyOptSetBool(intern->ptdoc->doc, TidyForceOutput, yes);
714 tidyOptSetBool(intern->ptdoc->doc, TidyMark, no);
715
716 TIDY_SET_DEFAULT_CONFIG(intern->ptdoc->doc);
717
718 tidy_add_default_properties(intern, is_doc);
719 break;
720 }
721
722 intern->std.handlers = handlers;
723
724 return &intern->std;
725 }
726
tidy_object_new_node(zend_class_entry * class_type)727 static zend_object *tidy_object_new_node(zend_class_entry *class_type)
728 {
729 return tidy_object_new(class_type, &tidy_object_handlers_node, is_node);
730 }
731
tidy_object_new_doc(zend_class_entry * class_type)732 static zend_object *tidy_object_new_doc(zend_class_entry *class_type)
733 {
734 return tidy_object_new(class_type, &tidy_object_handlers_doc, is_doc);
735 }
736
tidy_instanciate(zend_class_entry * pce,zval * object)737 static zval * tidy_instanciate(zend_class_entry *pce, zval *object)
738 {
739 object_init_ex(object, pce);
740 return object;
741 }
742
tidy_doc_cast_handler(zval * in,zval * out,int type)743 static int tidy_doc_cast_handler(zval *in, zval *out, int type)
744 {
745 TidyBuffer output;
746 PHPTidyObj *obj;
747
748 switch (type) {
749 case IS_LONG:
750 ZVAL_LONG(out, 0);
751 break;
752
753 case IS_DOUBLE:
754 ZVAL_DOUBLE(out, 0);
755 break;
756
757 case _IS_BOOL:
758 ZVAL_TRUE(out);
759 break;
760
761 case IS_STRING:
762 obj = Z_TIDY_P(in);
763 tidyBufInit(&output);
764 tidySaveBuffer (obj->ptdoc->doc, &output);
765 ZVAL_STRINGL(out, (char *) output.bp, output.size ? output.size-1 : 0);
766 tidyBufFree(&output);
767 break;
768
769 default:
770 return FAILURE;
771 }
772
773 return SUCCESS;
774 }
775
tidy_node_cast_handler(zval * in,zval * out,int type)776 static int tidy_node_cast_handler(zval *in, zval *out, int type)
777 {
778 TidyBuffer buf;
779 PHPTidyObj *obj;
780
781 switch(type) {
782 case IS_LONG:
783 ZVAL_LONG(out, 0);
784 break;
785
786 case IS_DOUBLE:
787 ZVAL_DOUBLE(out, 0);
788 break;
789
790 case _IS_BOOL:
791 ZVAL_TRUE(out);
792 break;
793
794 case IS_STRING:
795 obj = Z_TIDY_P(in);
796 tidyBufInit(&buf);
797 if (obj->ptdoc) {
798 tidyNodeGetText(obj->ptdoc->doc, obj->node, &buf);
799 ZVAL_STRINGL(out, (char *) buf.bp, buf.size-1);
800 } else {
801 ZVAL_EMPTY_STRING(out);
802 }
803 tidyBufFree(&buf);
804 break;
805
806 default:
807 return FAILURE;
808 }
809
810 return SUCCESS;
811 }
812
tidy_doc_update_properties(PHPTidyObj * obj)813 static void tidy_doc_update_properties(PHPTidyObj *obj)
814 {
815
816 TidyBuffer output;
817 zval temp;
818
819 tidyBufInit(&output);
820 tidySaveBuffer (obj->ptdoc->doc, &output);
821
822 if (output.size) {
823 if (!obj->std.properties) {
824 rebuild_object_properties(&obj->std);
825 }
826 ZVAL_STRINGL(&temp, (char*)output.bp, output.size-1);
827 zend_hash_str_update(obj->std.properties, "value", sizeof("value") - 1, &temp);
828 }
829
830 tidyBufFree(&output);
831
832 if (obj->ptdoc->errbuf->size) {
833 if (!obj->std.properties) {
834 rebuild_object_properties(&obj->std);
835 }
836 ZVAL_STRINGL(&temp, (char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1);
837 zend_hash_str_update(obj->std.properties, "errorBuffer", sizeof("errorBuffer") - 1, &temp);
838 }
839 }
840
tidy_add_default_properties(PHPTidyObj * obj,tidy_obj_type type)841 static void tidy_add_default_properties(PHPTidyObj *obj, tidy_obj_type type)
842 {
843
844 TidyBuffer buf;
845 TidyAttr tempattr;
846 TidyNode tempnode;
847 zval attribute, children, temp;
848 PHPTidyObj *newobj;
849
850 switch(type) {
851
852 case is_node:
853 if (!obj->std.properties) {
854 rebuild_object_properties(&obj->std);
855 }
856 tidyBufInit(&buf);
857 tidyNodeGetText(obj->ptdoc->doc, obj->node, &buf);
858 ADD_PROPERTY_STRINGL(obj->std.properties, value, buf.bp, buf.size ? buf.size-1 : 0);
859 tidyBufFree(&buf);
860
861 ADD_PROPERTY_STRING(obj->std.properties, name, tidyNodeGetName(obj->node));
862 ADD_PROPERTY_LONG(obj->std.properties, type, tidyNodeGetType(obj->node));
863 ADD_PROPERTY_LONG(obj->std.properties, line, tidyNodeLine(obj->node));
864 ADD_PROPERTY_LONG(obj->std.properties, column, tidyNodeColumn(obj->node));
865 ADD_PROPERTY_BOOL(obj->std.properties, proprietary, tidyNodeIsProp(obj->ptdoc->doc, obj->node));
866
867 switch(tidyNodeGetType(obj->node)) {
868 case TidyNode_Root:
869 case TidyNode_DocType:
870 case TidyNode_Text:
871 case TidyNode_Comment:
872 break;
873
874 default:
875 ADD_PROPERTY_LONG(obj->std.properties, id, tidyNodeGetId(obj->node));
876 }
877
878 tempattr = tidyAttrFirst(obj->node);
879
880 if (tempattr) {
881 char *name, *val;
882 array_init(&attribute);
883
884 do {
885 name = (char *)tidyAttrName(tempattr);
886 val = (char *)tidyAttrValue(tempattr);
887 if (name && val) {
888 add_assoc_string(&attribute, name, val);
889 }
890 } while((tempattr = tidyAttrNext(tempattr)));
891 } else {
892 ZVAL_NULL(&attribute);
893 }
894 zend_hash_str_update(obj->std.properties, "attribute", sizeof("attribute") - 1, &attribute);
895
896 tempnode = tidyGetChild(obj->node);
897
898 if (tempnode) {
899 array_init(&children);
900 do {
901 tidy_instanciate(tidy_ce_node, &temp);
902 newobj = Z_TIDY_P(&temp);
903 newobj->node = tempnode;
904 newobj->type = is_node;
905 newobj->ptdoc = obj->ptdoc;
906 newobj->ptdoc->ref_count++;
907
908 tidy_add_default_properties(newobj, is_node);
909 add_next_index_zval(&children, &temp);
910
911 } while((tempnode = tidyGetNext(tempnode)));
912
913 } else {
914 ZVAL_NULL(&children);
915 }
916
917 zend_hash_str_update(obj->std.properties, "child", sizeof("child") - 1, &children);
918
919 break;
920
921 case is_doc:
922 if (!obj->std.properties) {
923 rebuild_object_properties(&obj->std);
924 }
925 ADD_PROPERTY_NULL(obj->std.properties, errorBuffer);
926 ADD_PROPERTY_NULL(obj->std.properties, value);
927 break;
928 }
929 }
930
php_tidy_get_opt_val(PHPTidyDoc * ptdoc,TidyOption opt,TidyOptionType * type)931 static void *php_tidy_get_opt_val(PHPTidyDoc *ptdoc, TidyOption opt, TidyOptionType *type)
932 {
933 *type = tidyOptGetType(opt);
934
935 switch (*type) {
936 case TidyString: {
937 char *val = (char *) tidyOptGetValue(ptdoc->doc, tidyOptGetId(opt));
938 if (val) {
939 return (void *) zend_string_init(val, strlen(val), 0);
940 } else {
941 return (void *) ZSTR_EMPTY_ALLOC();
942 }
943 }
944 break;
945
946 case TidyInteger:
947 return (void *) (uintptr_t) tidyOptGetInt(ptdoc->doc, tidyOptGetId(opt));
948 break;
949
950 case TidyBoolean:
951 return (void *) tidyOptGetBool(ptdoc->doc, tidyOptGetId(opt));
952 break;
953 }
954
955 /* should not happen */
956 return NULL;
957 }
958
php_tidy_create_node(INTERNAL_FUNCTION_PARAMETERS,tidy_base_nodetypes node_type)959 static void php_tidy_create_node(INTERNAL_FUNCTION_PARAMETERS, tidy_base_nodetypes node_type)
960 {
961 PHPTidyObj *newobj;
962 TidyNode node;
963 TIDY_FETCH_OBJECT;
964
965 switch (node_type) {
966 case is_root_node:
967 node = tidyGetRoot(obj->ptdoc->doc);
968 break;
969
970 case is_html_node:
971 node = tidyGetHtml(obj->ptdoc->doc);
972 break;
973
974 case is_head_node:
975 node = tidyGetHead(obj->ptdoc->doc);
976 break;
977
978 case is_body_node:
979 node = tidyGetBody(obj->ptdoc->doc);
980 break;
981
982 default:
983 RETURN_NULL();
984 break;
985 }
986
987 if (!node) {
988 RETURN_NULL();
989 }
990
991 tidy_instanciate(tidy_ce_node, return_value);
992 newobj = Z_TIDY_P(return_value);
993 newobj->type = is_node;
994 newobj->ptdoc = obj->ptdoc;
995 newobj->node = node;
996 newobj->ptdoc->ref_count++;
997
998 tidy_add_default_properties(newobj, is_node);
999 }
1000
_php_tidy_apply_config_array(TidyDoc doc,HashTable * ht_options)1001 static int _php_tidy_apply_config_array(TidyDoc doc, HashTable *ht_options)
1002 {
1003 zval *opt_val;
1004 zend_string *opt_name;
1005
1006 ZEND_HASH_FOREACH_STR_KEY_VAL(ht_options, opt_name, opt_val) {
1007 if (opt_name == NULL) {
1008 continue;
1009 }
1010 _php_tidy_set_tidy_opt(doc, ZSTR_VAL(opt_name), opt_val);
1011 } ZEND_HASH_FOREACH_END();
1012
1013 return SUCCESS;
1014 }
1015
php_tidy_parse_string(PHPTidyObj * obj,char * string,uint len,char * enc)1016 static int php_tidy_parse_string(PHPTidyObj *obj, char *string, uint len, char *enc)
1017 {
1018 TidyBuffer buf;
1019
1020 if(enc) {
1021 if (tidySetCharEncoding(obj->ptdoc->doc, enc) < 0) {
1022 php_error_docref(NULL, E_WARNING, "Could not set encoding '%s'", enc);
1023 return FAILURE;
1024 }
1025 }
1026
1027 obj->ptdoc->initialized = 1;
1028
1029 tidyBufInit(&buf);
1030 tidyBufAttach(&buf, (byte *) string, len);
1031 if (tidyParseBuffer(obj->ptdoc->doc, &buf) < 0) {
1032 php_error_docref(NULL, E_WARNING, "%s", obj->ptdoc->errbuf->bp);
1033 return FAILURE;
1034 }
1035 tidy_doc_update_properties(obj);
1036
1037 return SUCCESS;
1038 }
1039
PHP_MINIT_FUNCTION(tidy)1040 static PHP_MINIT_FUNCTION(tidy)
1041 {
1042 tidySetMallocCall(php_tidy_malloc);
1043 tidySetReallocCall(php_tidy_realloc);
1044 tidySetFreeCall(php_tidy_free);
1045 tidySetPanicCall(php_tidy_panic);
1046
1047 REGISTER_INI_ENTRIES();
1048 REGISTER_TIDY_CLASS(tidy, doc, NULL, 0);
1049 REGISTER_TIDY_CLASS(tidyNode, node, NULL, ZEND_ACC_FINAL);
1050
1051 tidy_object_handlers_doc.cast_object = tidy_doc_cast_handler;
1052 tidy_object_handlers_node.cast_object = tidy_node_cast_handler;
1053
1054 tidy_object_handlers_node.offset = tidy_object_handlers_doc.offset = XtOffsetOf(PHPTidyObj, std);
1055 tidy_object_handlers_node.free_obj = tidy_object_handlers_doc.free_obj = tidy_object_free_storage;
1056
1057 _php_tidy_register_tags(INIT_FUNC_ARGS_PASSTHRU);
1058 _php_tidy_register_nodetypes(INIT_FUNC_ARGS_PASSTHRU);
1059
1060 php_output_handler_alias_register(ZEND_STRL("ob_tidyhandler"), php_tidy_output_handler_init);
1061
1062 return SUCCESS;
1063 }
1064
PHP_RINIT_FUNCTION(tidy)1065 static PHP_RINIT_FUNCTION(tidy)
1066 {
1067 #if defined(COMPILE_DL_TIDY) && defined(ZTS)
1068 ZEND_TSRMLS_CACHE_UPDATE();
1069 #endif
1070
1071 php_tidy_clean_output_start(ZEND_STRL("ob_tidyhandler"));
1072
1073 return SUCCESS;
1074 }
1075
PHP_MSHUTDOWN_FUNCTION(tidy)1076 static PHP_MSHUTDOWN_FUNCTION(tidy)
1077 {
1078 UNREGISTER_INI_ENTRIES();
1079 return SUCCESS;
1080 }
1081
PHP_MINFO_FUNCTION(tidy)1082 static PHP_MINFO_FUNCTION(tidy)
1083 {
1084 php_info_print_table_start();
1085 php_info_print_table_header(2, "Tidy support", "enabled");
1086 #if HAVE_TIDYBUFFIO_H
1087 php_info_print_table_row(2, "libTidy Version", (char *)tidyLibraryVersion());
1088 #endif
1089 php_info_print_table_row(2, "libTidy Release", (char *)tidyReleaseDate());
1090 php_info_print_table_row(2, "Extension Version", PHP_TIDY_VERSION " ($Id: c6d6b80d55c5d351deaa745c3c540971e5583c24 $)");
1091 php_info_print_table_end();
1092
1093 DISPLAY_INI_ENTRIES();
1094 }
1095
PHP_INI_MH(php_tidy_set_clean_output)1096 static PHP_INI_MH(php_tidy_set_clean_output)
1097 {
1098 int status;
1099 zend_bool value;
1100
1101 if (ZSTR_LEN(new_value)==2 && strcasecmp("on", ZSTR_VAL(new_value))==0) {
1102 value = (zend_bool) 1;
1103 } else if (ZSTR_LEN(new_value)==3 && strcasecmp("yes", ZSTR_VAL(new_value))==0) {
1104 value = (zend_bool) 1;
1105 } else if (ZSTR_LEN(new_value)==4 && strcasecmp("true", ZSTR_VAL(new_value))==0) {
1106 value = (zend_bool) 1;
1107 } else {
1108 value = (zend_bool) atoi(ZSTR_VAL(new_value));
1109 }
1110
1111 if (stage == PHP_INI_STAGE_RUNTIME) {
1112 status = php_output_get_status();
1113
1114 if (value && (status & PHP_OUTPUT_WRITTEN)) {
1115 php_error_docref(NULL, E_WARNING, "Cannot enable tidy.clean_output - there has already been output");
1116 return FAILURE;
1117 }
1118 if (status & PHP_OUTPUT_SENT) {
1119 php_error_docref(NULL, E_WARNING, "Cannot change tidy.clean_output - headers already sent");
1120 return FAILURE;
1121 }
1122 }
1123
1124 status = OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
1125
1126 if (stage == PHP_INI_STAGE_RUNTIME && value) {
1127 if (!php_output_handler_started(ZEND_STRL("ob_tidyhandler"))) {
1128 php_tidy_clean_output_start(ZEND_STRL("ob_tidyhandler"));
1129 }
1130 }
1131
1132 return status;
1133 }
1134
1135 /*
1136 * NOTE: tidy does not support iterative/cumulative parsing, so chunk-sized output handler is not possible
1137 */
1138
php_tidy_clean_output_start(const char * name,size_t name_len)1139 static void php_tidy_clean_output_start(const char *name, size_t name_len)
1140 {
1141 php_output_handler *h;
1142
1143 if (TG(clean_output) && (h = php_tidy_output_handler_init(name, name_len, 0, PHP_OUTPUT_HANDLER_STDFLAGS))) {
1144 php_output_handler_start(h);
1145 }
1146 }
1147
php_tidy_output_handler_init(const char * handler_name,size_t handler_name_len,size_t chunk_size,int flags)1148 static php_output_handler *php_tidy_output_handler_init(const char *handler_name, size_t handler_name_len, size_t chunk_size, int flags)
1149 {
1150 if (chunk_size) {
1151 php_error_docref(NULL, E_WARNING, "Cannot use a chunk size for ob_tidyhandler");
1152 return NULL;
1153 }
1154 if (!TG(clean_output)) {
1155 TG(clean_output) = 1;
1156 }
1157 return php_output_handler_create_internal(handler_name, handler_name_len, php_tidy_output_handler, chunk_size, flags);
1158 }
1159
php_tidy_output_handler(void ** nothing,php_output_context * output_context)1160 static int php_tidy_output_handler(void **nothing, php_output_context *output_context)
1161 {
1162 int status = FAILURE;
1163 TidyDoc doc;
1164 TidyBuffer inbuf, outbuf, errbuf;
1165
1166 if (TG(clean_output) && (output_context->op & PHP_OUTPUT_HANDLER_START) && (output_context->op & PHP_OUTPUT_HANDLER_FINAL)) {
1167 doc = tidyCreate();
1168 tidyBufInit(&errbuf);
1169
1170 if (0 == tidySetErrorBuffer(doc, &errbuf)) {
1171 tidyOptSetBool(doc, TidyForceOutput, yes);
1172 tidyOptSetBool(doc, TidyMark, no);
1173
1174 if (ZEND_SIZE_T_UINT_OVFL(output_context->in.used)) {
1175 php_error_docref(NULL, E_WARNING, "Input string is too long");
1176 return status;
1177 }
1178
1179 TIDY_SET_DEFAULT_CONFIG(doc);
1180
1181 tidyBufInit(&inbuf);
1182 tidyBufAttach(&inbuf, (byte *) output_context->in.data, (uint)output_context->in.used);
1183
1184 if (0 <= tidyParseBuffer(doc, &inbuf) && 0 <= tidyCleanAndRepair(doc)) {
1185 tidyBufInit(&outbuf);
1186 tidySaveBuffer(doc, &outbuf);
1187 FIX_BUFFER(&outbuf);
1188 output_context->out.data = (char *) outbuf.bp;
1189 output_context->out.used = outbuf.size ? outbuf.size-1 : 0;
1190 output_context->out.free = 1;
1191 status = SUCCESS;
1192 }
1193 }
1194
1195 tidyRelease(doc);
1196 tidyBufFree(&errbuf);
1197 }
1198
1199 return status;
1200 }
1201
1202 /* {{{ proto bool tidy_parse_string(string input [, mixed config_options [, string encoding]])
1203 Parse a document stored in a string */
PHP_FUNCTION(tidy_parse_string)1204 static PHP_FUNCTION(tidy_parse_string)
1205 {
1206 char *enc = NULL;
1207 size_t enc_len = 0;
1208 zend_string *input;
1209 zval *options = NULL;
1210 PHPTidyObj *obj;
1211
1212 if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zs", &input, &options, &enc, &enc_len) == FAILURE) {
1213 RETURN_FALSE;
1214 }
1215
1216 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(input))) {
1217 php_error_docref(NULL, E_WARNING, "Input string is too long");
1218 RETURN_FALSE;
1219 }
1220
1221 tidy_instanciate(tidy_ce_doc, return_value);
1222 obj = Z_TIDY_P(return_value);
1223
1224 TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
1225
1226 if (php_tidy_parse_string(obj, ZSTR_VAL(input), (uint)ZSTR_LEN(input), enc) == FAILURE) {
1227 zval_ptr_dtor(return_value);
1228 RETURN_FALSE;
1229 }
1230 }
1231 /* }}} */
1232
1233 /* {{{ proto string tidy_get_error_buffer()
1234 Return warnings and errors which occurred parsing the specified document*/
PHP_FUNCTION(tidy_get_error_buffer)1235 static PHP_FUNCTION(tidy_get_error_buffer)
1236 {
1237 TIDY_FETCH_OBJECT;
1238
1239 if (obj->ptdoc->errbuf && obj->ptdoc->errbuf->bp) {
1240 RETURN_STRINGL((char*)obj->ptdoc->errbuf->bp, obj->ptdoc->errbuf->size-1);
1241 } else {
1242 RETURN_FALSE;
1243 }
1244 }
1245 /* }}} */
1246
1247 /* {{{ proto string tidy_get_output()
1248 Return a string representing the parsed tidy markup */
PHP_FUNCTION(tidy_get_output)1249 static PHP_FUNCTION(tidy_get_output)
1250 {
1251 TidyBuffer output;
1252 TIDY_FETCH_OBJECT;
1253
1254 tidyBufInit(&output);
1255 tidySaveBuffer(obj->ptdoc->doc, &output);
1256 FIX_BUFFER(&output);
1257 RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0);
1258 tidyBufFree(&output);
1259 }
1260 /* }}} */
1261
1262 /* {{{ proto boolean tidy_parse_file(string file [, mixed config_options [, string encoding [, bool use_include_path]]])
1263 Parse markup in file or URI */
PHP_FUNCTION(tidy_parse_file)1264 static PHP_FUNCTION(tidy_parse_file)
1265 {
1266 char *enc = NULL;
1267 size_t enc_len = 0;
1268 zend_bool use_include_path = 0;
1269 zend_string *inputfile, *contents;
1270 zval *options = NULL;
1271
1272 PHPTidyObj *obj;
1273
1274 if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &inputfile,
1275 &options, &enc, &enc_len, &use_include_path) == FAILURE) {
1276 RETURN_FALSE;
1277 }
1278
1279 tidy_instanciate(tidy_ce_doc, return_value);
1280 obj = Z_TIDY_P(return_value);
1281
1282 if (!(contents = php_tidy_file_to_mem(ZSTR_VAL(inputfile), use_include_path))) {
1283 php_error_docref(NULL, E_WARNING, "Cannot Load '%s' into memory%s", ZSTR_VAL(inputfile), (use_include_path) ? " (Using include path)" : "");
1284 RETURN_FALSE;
1285 }
1286
1287 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(contents))) {
1288 php_error_docref(NULL, E_WARNING, "Input string is too long");
1289 RETURN_FALSE;
1290 }
1291
1292 TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
1293
1294 if (php_tidy_parse_string(obj, ZSTR_VAL(contents), (uint)ZSTR_LEN(contents), enc) == FAILURE) {
1295 zval_ptr_dtor(return_value);
1296 RETVAL_FALSE;
1297 }
1298
1299 zend_string_release(contents);
1300 }
1301 /* }}} */
1302
1303 /* {{{ proto boolean tidy_clean_repair()
1304 Execute configured cleanup and repair operations on parsed markup */
PHP_FUNCTION(tidy_clean_repair)1305 static PHP_FUNCTION(tidy_clean_repair)
1306 {
1307 TIDY_FETCH_OBJECT;
1308
1309 if (tidyCleanAndRepair(obj->ptdoc->doc) >= 0) {
1310 tidy_doc_update_properties(obj);
1311 RETURN_TRUE;
1312 }
1313
1314 RETURN_FALSE;
1315 }
1316 /* }}} */
1317
1318 /* {{{ proto boolean tidy_repair_string(string data [, mixed config_file [, string encoding]])
1319 Repair a string using an optionally provided configuration file */
PHP_FUNCTION(tidy_repair_string)1320 static PHP_FUNCTION(tidy_repair_string)
1321 {
1322 php_tidy_quick_repair(INTERNAL_FUNCTION_PARAM_PASSTHRU, FALSE);
1323 }
1324 /* }}} */
1325
1326 /* {{{ proto boolean tidy_repair_file(string filename [, mixed config_file [, string encoding [, bool use_include_path]]])
1327 Repair a file using an optionally provided configuration file */
PHP_FUNCTION(tidy_repair_file)1328 static PHP_FUNCTION(tidy_repair_file)
1329 {
1330 php_tidy_quick_repair(INTERNAL_FUNCTION_PARAM_PASSTHRU, TRUE);
1331 }
1332 /* }}} */
1333
1334 /* {{{ proto boolean tidy_diagnose()
1335 Run configured diagnostics on parsed and repaired markup. */
PHP_FUNCTION(tidy_diagnose)1336 static PHP_FUNCTION(tidy_diagnose)
1337 {
1338 TIDY_FETCH_OBJECT;
1339
1340 if (obj->ptdoc->initialized && tidyRunDiagnostics(obj->ptdoc->doc) >= 0) {
1341 tidy_doc_update_properties(obj);
1342 RETURN_TRUE;
1343 }
1344
1345 RETURN_FALSE;
1346 }
1347 /* }}} */
1348
1349 /* {{{ proto string tidy_get_release()
1350 Get release date (version) for Tidy library */
PHP_FUNCTION(tidy_get_release)1351 static PHP_FUNCTION(tidy_get_release)
1352 {
1353 if (zend_parse_parameters_none() == FAILURE) {
1354 return;
1355 }
1356
1357 RETURN_STRING((char *)tidyReleaseDate());
1358 }
1359 /* }}} */
1360
1361
1362 #if HAVE_TIDYOPTGETDOC
1363 /* {{{ proto string tidy_get_opt_doc(tidy resource, string optname)
1364 Returns the documentation for the given option name */
PHP_FUNCTION(tidy_get_opt_doc)1365 static PHP_FUNCTION(tidy_get_opt_doc)
1366 {
1367 PHPTidyObj *obj;
1368 char *optval, *optname;
1369 size_t optname_len;
1370 TidyOption opt;
1371
1372 TIDY_SET_CONTEXT;
1373
1374 if (object) {
1375 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &optname, &optname_len) == FAILURE) {
1376 RETURN_FALSE;
1377 }
1378 } else {
1379 if (zend_parse_method_parameters(ZEND_NUM_ARGS(), NULL, "Os", &object, tidy_ce_doc, &optname, &optname_len) == FAILURE) {
1380 RETURN_FALSE;
1381 }
1382 }
1383
1384 obj = Z_TIDY_P(object);
1385
1386 opt = tidyGetOptionByName(obj->ptdoc->doc, optname);
1387
1388 if (!opt) {
1389 php_error_docref(NULL, E_WARNING, "Unknown Tidy Configuration Option '%s'", optname);
1390 RETURN_FALSE;
1391 }
1392
1393 if ( (optval = (char *) tidyOptGetDoc(obj->ptdoc->doc, opt)) ) {
1394 RETURN_STRING(optval);
1395 }
1396
1397 RETURN_FALSE;
1398 }
1399 /* }}} */
1400 #endif
1401
1402
1403 /* {{{ proto array tidy_get_config()
1404 Get current Tidy configuration */
PHP_FUNCTION(tidy_get_config)1405 static PHP_FUNCTION(tidy_get_config)
1406 {
1407 TidyIterator itOpt;
1408 char *opt_name;
1409 void *opt_value;
1410 TidyOptionType optt;
1411
1412 TIDY_FETCH_OBJECT;
1413
1414 itOpt = tidyGetOptionList(obj->ptdoc->doc);
1415
1416 array_init(return_value);
1417
1418 while (itOpt) {
1419 TidyOption opt = tidyGetNextOption(obj->ptdoc->doc, &itOpt);
1420
1421 opt_name = (char *)tidyOptGetName(opt);
1422 opt_value = php_tidy_get_opt_val(obj->ptdoc, opt, &optt);
1423 switch (optt) {
1424 case TidyString:
1425 add_assoc_str(return_value, opt_name, (zend_string*)opt_value);
1426 break;
1427
1428 case TidyInteger:
1429 add_assoc_long(return_value, opt_name, (zend_long)opt_value);
1430 break;
1431
1432 case TidyBoolean:
1433 add_assoc_bool(return_value, opt_name, opt_value ? 1 : 0);
1434 break;
1435 }
1436 }
1437
1438 return;
1439 }
1440 /* }}} */
1441
1442 /* {{{ proto int tidy_get_status()
1443 Get status of specified document. */
PHP_FUNCTION(tidy_get_status)1444 static PHP_FUNCTION(tidy_get_status)
1445 {
1446 TIDY_FETCH_OBJECT;
1447
1448 RETURN_LONG(tidyStatus(obj->ptdoc->doc));
1449 }
1450 /* }}} */
1451
1452 /* {{{ proto int tidy_get_html_ver()
1453 Get the Detected HTML version for the specified document. */
PHP_FUNCTION(tidy_get_html_ver)1454 static PHP_FUNCTION(tidy_get_html_ver)
1455 {
1456 TIDY_FETCH_OBJECT;
1457
1458 RETURN_LONG(tidyDetectedHtmlVersion(obj->ptdoc->doc));
1459 }
1460 /* }}} */
1461
1462 /* {{{ proto boolean tidy_is_xhtml()
1463 Indicates if the document is a XHTML document. */
PHP_FUNCTION(tidy_is_xhtml)1464 static PHP_FUNCTION(tidy_is_xhtml)
1465 {
1466 TIDY_FETCH_OBJECT;
1467
1468 RETURN_BOOL(tidyDetectedXhtml(obj->ptdoc->doc));
1469 }
1470 /* }}} */
1471
1472 /* {{{ proto boolean tidy_is_xml()
1473 Indicates if the document is a generic (non HTML/XHTML) XML document. */
PHP_FUNCTION(tidy_is_xml)1474 static PHP_FUNCTION(tidy_is_xml)
1475 {
1476 TIDY_FETCH_OBJECT;
1477
1478 RETURN_BOOL(tidyDetectedGenericXml(obj->ptdoc->doc));
1479 }
1480 /* }}} */
1481
1482 /* {{{ proto int tidy_error_count()
1483 Returns the Number of Tidy errors encountered for specified document. */
PHP_FUNCTION(tidy_error_count)1484 static PHP_FUNCTION(tidy_error_count)
1485 {
1486 TIDY_FETCH_OBJECT;
1487
1488 RETURN_LONG(tidyErrorCount(obj->ptdoc->doc));
1489 }
1490 /* }}} */
1491
1492 /* {{{ proto int tidy_warning_count()
1493 Returns the Number of Tidy warnings encountered for specified document. */
PHP_FUNCTION(tidy_warning_count)1494 static PHP_FUNCTION(tidy_warning_count)
1495 {
1496 TIDY_FETCH_OBJECT;
1497
1498 RETURN_LONG(tidyWarningCount(obj->ptdoc->doc));
1499 }
1500 /* }}} */
1501
1502 /* {{{ proto int tidy_access_count()
1503 Returns the Number of Tidy accessibility warnings encountered for specified document. */
PHP_FUNCTION(tidy_access_count)1504 static PHP_FUNCTION(tidy_access_count)
1505 {
1506 TIDY_FETCH_OBJECT;
1507
1508 RETURN_LONG(tidyAccessWarningCount(obj->ptdoc->doc));
1509 }
1510 /* }}} */
1511
1512 /* {{{ proto int tidy_config_count()
1513 Returns the Number of Tidy configuration errors encountered for specified document. */
PHP_FUNCTION(tidy_config_count)1514 static PHP_FUNCTION(tidy_config_count)
1515 {
1516 TIDY_FETCH_OBJECT;
1517
1518 RETURN_LONG(tidyConfigErrorCount(obj->ptdoc->doc));
1519 }
1520 /* }}} */
1521
1522 /* {{{ proto mixed tidy_getopt(string option)
1523 Returns the value of the specified configuration option for the tidy document. */
PHP_FUNCTION(tidy_getopt)1524 static PHP_FUNCTION(tidy_getopt)
1525 {
1526 PHPTidyObj *obj;
1527 char *optname;
1528 void *optval;
1529 size_t optname_len;
1530 TidyOption opt;
1531 TidyOptionType optt;
1532
1533 TIDY_SET_CONTEXT;
1534
1535 if (object) {
1536 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &optname, &optname_len) == FAILURE) {
1537 RETURN_FALSE;
1538 }
1539 } else {
1540 if (zend_parse_method_parameters(ZEND_NUM_ARGS(), NULL, "Os", &object, tidy_ce_doc, &optname, &optname_len) == FAILURE) {
1541 RETURN_FALSE;
1542 }
1543 }
1544
1545 obj = Z_TIDY_P(object);
1546
1547 opt = tidyGetOptionByName(obj->ptdoc->doc, optname);
1548
1549 if (!opt) {
1550 php_error_docref(NULL, E_WARNING, "Unknown Tidy Configuration Option '%s'", optname);
1551 RETURN_FALSE;
1552 }
1553
1554 optval = php_tidy_get_opt_val(obj->ptdoc, opt, &optt);
1555 switch (optt) {
1556 case TidyString:
1557 RETVAL_STR((zend_string*)optval);
1558 return;
1559
1560 case TidyInteger:
1561 RETURN_LONG((zend_long)optval);
1562 break;
1563
1564 case TidyBoolean:
1565 if (optval) {
1566 RETURN_TRUE;
1567 } else {
1568 RETURN_FALSE;
1569 }
1570 break;
1571
1572 default:
1573 php_error_docref(NULL, E_WARNING, "Unable to determine type of configuration option");
1574 break;
1575 }
1576
1577 RETURN_FALSE;
1578 }
1579 /* }}} */
1580
TIDY_DOC_METHOD(__construct)1581 static TIDY_DOC_METHOD(__construct)
1582 {
1583 char *enc = NULL;
1584 size_t enc_len = 0;
1585 zend_bool use_include_path = 0;
1586 zval *options = NULL;
1587 zend_string *contents, *inputfile = NULL;
1588
1589 PHPTidyObj *obj;
1590 TIDY_SET_CONTEXT;
1591
1592 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|Pzsb", &inputfile,
1593 &options, &enc, &enc_len, &use_include_path) == FAILURE) {
1594 RETURN_FALSE;
1595 }
1596
1597 obj = Z_TIDY_P(object);
1598
1599 if (inputfile) {
1600 if (!(contents = php_tidy_file_to_mem(ZSTR_VAL(inputfile), use_include_path))) {
1601 php_error_docref(NULL, E_WARNING, "Cannot Load '%s' into memory%s", ZSTR_VAL(inputfile), (use_include_path) ? " (Using include path)" : "");
1602 return;
1603 }
1604
1605 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(contents))) {
1606 php_error_docref(NULL, E_WARNING, "Input string is too long");
1607 RETURN_FALSE;
1608 }
1609
1610 TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
1611
1612 php_tidy_parse_string(obj, ZSTR_VAL(contents), (uint)ZSTR_LEN(contents), enc);
1613
1614 zend_string_release(contents);
1615 }
1616 }
1617
TIDY_DOC_METHOD(parseFile)1618 static TIDY_DOC_METHOD(parseFile)
1619 {
1620 char *enc = NULL;
1621 size_t enc_len = 0;
1622 zend_bool use_include_path = 0;
1623 zval *options = NULL;
1624 zend_string *inputfile, *contents;
1625 PHPTidyObj *obj;
1626
1627 TIDY_SET_CONTEXT;
1628
1629 obj = Z_TIDY_P(object);
1630
1631 if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &inputfile,
1632 &options, &enc, &enc_len, &use_include_path) == FAILURE) {
1633 RETURN_FALSE;
1634 }
1635
1636 if (!(contents = php_tidy_file_to_mem(ZSTR_VAL(inputfile), use_include_path))) {
1637 php_error_docref(NULL, E_WARNING, "Cannot Load '%s' into memory%s", ZSTR_VAL(inputfile), (use_include_path) ? " (Using include path)" : "");
1638 RETURN_FALSE;
1639 }
1640
1641 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(contents))) {
1642 php_error_docref(NULL, E_WARNING, "Input string is too long");
1643 RETURN_FALSE;
1644 }
1645
1646 TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
1647
1648 if (php_tidy_parse_string(obj, ZSTR_VAL(contents), (uint)ZSTR_LEN(contents), enc) == FAILURE) {
1649 RETVAL_FALSE;
1650 } else {
1651 RETVAL_TRUE;
1652 }
1653
1654 zend_string_release(contents);
1655 }
1656
TIDY_DOC_METHOD(parseString)1657 static TIDY_DOC_METHOD(parseString)
1658 {
1659 char *enc = NULL;
1660 size_t enc_len = 0;
1661 zval *options = NULL;
1662 PHPTidyObj *obj;
1663 zend_string *input;
1664
1665 TIDY_SET_CONTEXT;
1666
1667 if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zs", &input, &options, &enc, &enc_len) == FAILURE) {
1668 RETURN_FALSE;
1669 }
1670
1671 if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(input))) {
1672 php_error_docref(NULL, E_WARNING, "Input string is too long");
1673 RETURN_FALSE;
1674 }
1675
1676 obj = Z_TIDY_P(object);
1677
1678 TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
1679
1680 if(php_tidy_parse_string(obj, ZSTR_VAL(input), (uint)ZSTR_LEN(input), enc) == SUCCESS) {
1681 RETURN_TRUE;
1682 }
1683
1684 RETURN_FALSE;
1685 }
1686
1687
1688 /* {{{ proto TidyNode tidy_get_root()
1689 Returns a TidyNode Object representing the root of the tidy parse tree */
PHP_FUNCTION(tidy_get_root)1690 static PHP_FUNCTION(tidy_get_root)
1691 {
1692 php_tidy_create_node(INTERNAL_FUNCTION_PARAM_PASSTHRU, is_root_node);
1693 }
1694 /* }}} */
1695
1696 /* {{{ proto TidyNode tidy_get_html()
1697 Returns a TidyNode Object starting from the <HTML> tag of the tidy parse tree */
PHP_FUNCTION(tidy_get_html)1698 static PHP_FUNCTION(tidy_get_html)
1699 {
1700 php_tidy_create_node(INTERNAL_FUNCTION_PARAM_PASSTHRU, is_html_node);
1701 }
1702 /* }}} */
1703
1704 /* {{{ proto TidyNode tidy_get_head()
1705 Returns a TidyNode Object starting from the <HEAD> tag of the tidy parse tree */
PHP_FUNCTION(tidy_get_head)1706 static PHP_FUNCTION(tidy_get_head)
1707 {
1708 php_tidy_create_node(INTERNAL_FUNCTION_PARAM_PASSTHRU, is_head_node);
1709 }
1710 /* }}} */
1711
1712 /* {{{ proto TidyNode tidy_get_body(resource tidy)
1713 Returns a TidyNode Object starting from the <BODY> tag of the tidy parse tree */
PHP_FUNCTION(tidy_get_body)1714 static PHP_FUNCTION(tidy_get_body)
1715 {
1716 php_tidy_create_node(INTERNAL_FUNCTION_PARAM_PASSTHRU, is_body_node);
1717 }
1718 /* }}} */
1719
1720 /* {{{ proto boolean tidyNode::hasChildren()
1721 Returns true if this node has children */
TIDY_NODE_METHOD(hasChildren)1722 static TIDY_NODE_METHOD(hasChildren)
1723 {
1724 TIDY_FETCH_ONLY_OBJECT;
1725
1726 if (tidyGetChild(obj->node)) {
1727 RETURN_TRUE;
1728 } else {
1729 RETURN_FALSE;
1730 }
1731 }
1732 /* }}} */
1733
1734 /* {{{ proto boolean tidyNode::hasSiblings()
1735 Returns true if this node has siblings */
TIDY_NODE_METHOD(hasSiblings)1736 static TIDY_NODE_METHOD(hasSiblings)
1737 {
1738 TIDY_FETCH_ONLY_OBJECT;
1739
1740 if (obj->node && tidyGetNext(obj->node)) {
1741 RETURN_TRUE;
1742 } else {
1743 RETURN_FALSE;
1744 }
1745 }
1746 /* }}} */
1747
1748 /* {{{ proto boolean tidyNode::isComment()
1749 Returns true if this node represents a comment */
TIDY_NODE_METHOD(isComment)1750 static TIDY_NODE_METHOD(isComment)
1751 {
1752 TIDY_FETCH_ONLY_OBJECT;
1753
1754 if (tidyNodeGetType(obj->node) == TidyNode_Comment) {
1755 RETURN_TRUE;
1756 } else {
1757 RETURN_FALSE;
1758 }
1759 }
1760 /* }}} */
1761
1762 /* {{{ proto boolean tidyNode::isHtml()
1763 Returns true if this node is part of a HTML document */
TIDY_NODE_METHOD(isHtml)1764 static TIDY_NODE_METHOD(isHtml)
1765 {
1766 TIDY_FETCH_ONLY_OBJECT;
1767
1768 if (tidyNodeGetType(obj->node) & (TidyNode_Start | TidyNode_End | TidyNode_StartEnd)) {
1769 RETURN_TRUE;
1770 }
1771
1772 RETURN_FALSE;
1773 }
1774 /* }}} */
1775
1776 /* {{{ proto boolean tidyNode::isText()
1777 Returns true if this node represents text (no markup) */
TIDY_NODE_METHOD(isText)1778 static TIDY_NODE_METHOD(isText)
1779 {
1780 TIDY_FETCH_ONLY_OBJECT;
1781
1782 if (tidyNodeGetType(obj->node) == TidyNode_Text) {
1783 RETURN_TRUE;
1784 } else {
1785 RETURN_FALSE;
1786 }
1787 }
1788 /* }}} */
1789
1790 /* {{{ proto boolean tidyNode::isJste()
1791 Returns true if this node is JSTE */
TIDY_NODE_METHOD(isJste)1792 static TIDY_NODE_METHOD(isJste)
1793 {
1794 TIDY_FETCH_ONLY_OBJECT;
1795
1796 if (tidyNodeGetType(obj->node) == TidyNode_Jste) {
1797 RETURN_TRUE;
1798 } else {
1799 RETURN_FALSE;
1800 }
1801 }
1802 /* }}} */
1803
1804 /* {{{ proto boolean tidyNode::isAsp()
1805 Returns true if this node is ASP */
TIDY_NODE_METHOD(isAsp)1806 static TIDY_NODE_METHOD(isAsp)
1807 {
1808 TIDY_FETCH_ONLY_OBJECT;
1809
1810 if (tidyNodeGetType(obj->node) == TidyNode_Asp) {
1811 RETURN_TRUE;
1812 } else {
1813 RETURN_FALSE;
1814 }
1815 }
1816 /* }}} */
1817
1818 /* {{{ proto boolean tidyNode::isPhp()
1819 Returns true if this node is PHP */
TIDY_NODE_METHOD(isPhp)1820 static TIDY_NODE_METHOD(isPhp)
1821 {
1822 TIDY_FETCH_ONLY_OBJECT;
1823
1824 if (tidyNodeGetType(obj->node) == TidyNode_Php) {
1825 RETURN_TRUE;
1826 } else {
1827 RETURN_FALSE;
1828 }
1829 }
1830 /* }}} */
1831
1832 /* {{{ proto tidyNode tidyNode::getParent()
1833 Returns the parent node if available or NULL */
TIDY_NODE_METHOD(getParent)1834 static TIDY_NODE_METHOD(getParent)
1835 {
1836 TidyNode parent_node;
1837 PHPTidyObj *newobj;
1838 TIDY_FETCH_ONLY_OBJECT;
1839
1840 parent_node = tidyGetParent(obj->node);
1841 if(parent_node) {
1842 tidy_instanciate(tidy_ce_node, return_value);
1843 newobj = Z_TIDY_P(return_value);
1844 newobj->node = parent_node;
1845 newobj->type = is_node;
1846 newobj->ptdoc = obj->ptdoc;
1847 newobj->ptdoc->ref_count++;
1848 tidy_add_default_properties(newobj, is_node);
1849 } else {
1850 ZVAL_NULL(return_value);
1851 }
1852 }
1853 /* }}} */
1854
1855
1856 /* {{{ proto void tidyNode::__construct()
1857 __constructor for tidyNode. */
TIDY_NODE_METHOD(__construct)1858 static TIDY_NODE_METHOD(__construct)
1859 {
1860 zend_throw_error(NULL, "You should not create a tidyNode manually");
1861 }
1862 /* }}} */
1863
_php_tidy_register_nodetypes(INIT_FUNC_ARGS)1864 static void _php_tidy_register_nodetypes(INIT_FUNC_ARGS)
1865 {
1866 TIDY_NODE_CONST(ROOT, Root);
1867 TIDY_NODE_CONST(DOCTYPE, DocType);
1868 TIDY_NODE_CONST(COMMENT, Comment);
1869 TIDY_NODE_CONST(PROCINS, ProcIns);
1870 TIDY_NODE_CONST(TEXT, Text);
1871 TIDY_NODE_CONST(START, Start);
1872 TIDY_NODE_CONST(END, End);
1873 TIDY_NODE_CONST(STARTEND, StartEnd);
1874 TIDY_NODE_CONST(CDATA, CDATA);
1875 TIDY_NODE_CONST(SECTION, Section);
1876 TIDY_NODE_CONST(ASP, Asp);
1877 TIDY_NODE_CONST(JSTE, Jste);
1878 TIDY_NODE_CONST(PHP, Php);
1879 TIDY_NODE_CONST(XMLDECL, XmlDecl);
1880 }
1881
_php_tidy_register_tags(INIT_FUNC_ARGS)1882 static void _php_tidy_register_tags(INIT_FUNC_ARGS)
1883 {
1884 TIDY_TAG_CONST(UNKNOWN);
1885 TIDY_TAG_CONST(A);
1886 TIDY_TAG_CONST(ABBR);
1887 TIDY_TAG_CONST(ACRONYM);
1888 TIDY_TAG_CONST(ADDRESS);
1889 TIDY_TAG_CONST(ALIGN);
1890 TIDY_TAG_CONST(APPLET);
1891 TIDY_TAG_CONST(AREA);
1892 TIDY_TAG_CONST(B);
1893 TIDY_TAG_CONST(BASE);
1894 TIDY_TAG_CONST(BASEFONT);
1895 TIDY_TAG_CONST(BDO);
1896 TIDY_TAG_CONST(BGSOUND);
1897 TIDY_TAG_CONST(BIG);
1898 TIDY_TAG_CONST(BLINK);
1899 TIDY_TAG_CONST(BLOCKQUOTE);
1900 TIDY_TAG_CONST(BODY);
1901 TIDY_TAG_CONST(BR);
1902 TIDY_TAG_CONST(BUTTON);
1903 TIDY_TAG_CONST(CAPTION);
1904 TIDY_TAG_CONST(CENTER);
1905 TIDY_TAG_CONST(CITE);
1906 TIDY_TAG_CONST(CODE);
1907 TIDY_TAG_CONST(COL);
1908 TIDY_TAG_CONST(COLGROUP);
1909 TIDY_TAG_CONST(COMMENT);
1910 TIDY_TAG_CONST(DD);
1911 TIDY_TAG_CONST(DEL);
1912 TIDY_TAG_CONST(DFN);
1913 TIDY_TAG_CONST(DIR);
1914 TIDY_TAG_CONST(DIV);
1915 TIDY_TAG_CONST(DL);
1916 TIDY_TAG_CONST(DT);
1917 TIDY_TAG_CONST(EM);
1918 TIDY_TAG_CONST(EMBED);
1919 TIDY_TAG_CONST(FIELDSET);
1920 TIDY_TAG_CONST(FONT);
1921 TIDY_TAG_CONST(FORM);
1922 TIDY_TAG_CONST(FRAME);
1923 TIDY_TAG_CONST(FRAMESET);
1924 TIDY_TAG_CONST(H1);
1925 TIDY_TAG_CONST(H2);
1926 TIDY_TAG_CONST(H3);
1927 TIDY_TAG_CONST(H4);
1928 TIDY_TAG_CONST(H5);
1929 TIDY_TAG_CONST(H6);
1930 TIDY_TAG_CONST(HEAD);
1931 TIDY_TAG_CONST(HR);
1932 TIDY_TAG_CONST(HTML);
1933 TIDY_TAG_CONST(I);
1934 TIDY_TAG_CONST(IFRAME);
1935 TIDY_TAG_CONST(ILAYER);
1936 TIDY_TAG_CONST(IMG);
1937 TIDY_TAG_CONST(INPUT);
1938 TIDY_TAG_CONST(INS);
1939 TIDY_TAG_CONST(ISINDEX);
1940 TIDY_TAG_CONST(KBD);
1941 TIDY_TAG_CONST(KEYGEN);
1942 TIDY_TAG_CONST(LABEL);
1943 TIDY_TAG_CONST(LAYER);
1944 TIDY_TAG_CONST(LEGEND);
1945 TIDY_TAG_CONST(LI);
1946 TIDY_TAG_CONST(LINK);
1947 TIDY_TAG_CONST(LISTING);
1948 TIDY_TAG_CONST(MAP);
1949 TIDY_TAG_CONST(MARQUEE);
1950 TIDY_TAG_CONST(MENU);
1951 TIDY_TAG_CONST(META);
1952 TIDY_TAG_CONST(MULTICOL);
1953 TIDY_TAG_CONST(NOBR);
1954 TIDY_TAG_CONST(NOEMBED);
1955 TIDY_TAG_CONST(NOFRAMES);
1956 TIDY_TAG_CONST(NOLAYER);
1957 TIDY_TAG_CONST(NOSAVE);
1958 TIDY_TAG_CONST(NOSCRIPT);
1959 TIDY_TAG_CONST(OBJECT);
1960 TIDY_TAG_CONST(OL);
1961 TIDY_TAG_CONST(OPTGROUP);
1962 TIDY_TAG_CONST(OPTION);
1963 TIDY_TAG_CONST(P);
1964 TIDY_TAG_CONST(PARAM);
1965 TIDY_TAG_CONST(PLAINTEXT);
1966 TIDY_TAG_CONST(PRE);
1967 TIDY_TAG_CONST(Q);
1968 TIDY_TAG_CONST(RB);
1969 TIDY_TAG_CONST(RBC);
1970 TIDY_TAG_CONST(RP);
1971 TIDY_TAG_CONST(RT);
1972 TIDY_TAG_CONST(RTC);
1973 TIDY_TAG_CONST(RUBY);
1974 TIDY_TAG_CONST(S);
1975 TIDY_TAG_CONST(SAMP);
1976 TIDY_TAG_CONST(SCRIPT);
1977 TIDY_TAG_CONST(SELECT);
1978 TIDY_TAG_CONST(SERVER);
1979 TIDY_TAG_CONST(SERVLET);
1980 TIDY_TAG_CONST(SMALL);
1981 TIDY_TAG_CONST(SPACER);
1982 TIDY_TAG_CONST(SPAN);
1983 TIDY_TAG_CONST(STRIKE);
1984 TIDY_TAG_CONST(STRONG);
1985 TIDY_TAG_CONST(STYLE);
1986 TIDY_TAG_CONST(SUB);
1987 TIDY_TAG_CONST(SUP);
1988 TIDY_TAG_CONST(TABLE);
1989 TIDY_TAG_CONST(TBODY);
1990 TIDY_TAG_CONST(TD);
1991 TIDY_TAG_CONST(TEXTAREA);
1992 TIDY_TAG_CONST(TFOOT);
1993 TIDY_TAG_CONST(TH);
1994 TIDY_TAG_CONST(THEAD);
1995 TIDY_TAG_CONST(TITLE);
1996 TIDY_TAG_CONST(TR);
1997 TIDY_TAG_CONST(TT);
1998 TIDY_TAG_CONST(U);
1999 TIDY_TAG_CONST(UL);
2000 TIDY_TAG_CONST(VAR);
2001 TIDY_TAG_CONST(WBR);
2002 TIDY_TAG_CONST(XMP);
2003 }
2004
2005 #endif
2006
2007 /*
2008 * Local variables:
2009 * tab-width: 4
2010 * c-basic-offset: 4
2011 * End:
2012 * vim600: noet sw=4 ts=4 fdm=marker
2013 * vim<600: noet sw=4 ts=4
2014 */
2015
