PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/tidy - tidy.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 675 810 83.3 %
Date: 2019-05-06 Functions: 62 68 91.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Mon, 06 May 2019 17:58:30 +0000 (992 days ago)

Copyright © 2005-2022 The PHP Group
All rights reserved.