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