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: 635 751 84.6 %
Date: 2014-04-08 Functions: 58 64 90.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Tue, 08 Apr 2014 11:59:47 +0000 (9 days ago)

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