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: 650 775 83.9 %
Date: 2016-08-24 Functions: 62 68 91.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Wed, 24 Aug 2016 12:20:33 +0000 (2 days ago)

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