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

Generated by: LCOV version 1.10

Generated at Wed, 22 Oct 2014 07:25:00 +0000 (2 days ago)

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