Annotation of embedaddon/php/ext/tidy/tidy.c, revision 1.1.1.2

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>