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: 658 775 84.9 %
Date: 2014-07-15 Functions: 61 67 91.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Tue, 15 Jul 2014 20:53:33 +0000 (9 days ago)

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