2003-08-01 00:22:43 +00:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| PHP Version 4 |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Copyright (c) 1997-2003 The PHP Group |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| This source file is subject to version 3.0 of the PHP license, |
|
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
|
|
| available through the world-wide-web at the following url: |
|
|
|
|
| http://www.php.net/license/3_0.txt. |
|
|
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Author: John Coggeshall <john@php.net> |
|
2003-09-20 19:45:32 +00:00
|
|
|
| Ilia Alshanetsky <ilia@php.net> |
|
2003-08-01 00:22:43 +00:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* $Id$ */
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "php.h"
|
|
|
|
#include "php_ini.h"
|
|
|
|
#include "ext/standard/info.h"
|
|
|
|
#include "php_tidy.h"
|
|
|
|
#include "Zend/zend_API.h"
|
|
|
|
#include "Zend/zend_hash.h"
|
2003-09-14 00:45:51 +00:00
|
|
|
#include "safe_mode.h"
|
|
|
|
|
|
|
|
#ifdef ZEND_ENGINE_2
|
2003-08-01 09:12:35 +00:00
|
|
|
#include "zend_objects_API.h"
|
|
|
|
#include "zend_objects.h"
|
|
|
|
#include "zend_operators.h"
|
2003-09-14 00:45:51 +00:00
|
|
|
#endif
|
2003-08-01 00:22:43 +00:00
|
|
|
|
|
|
|
ZEND_DECLARE_MODULE_GLOBALS(tidy);
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/*
|
2003-08-01 00:22:43 +00:00
|
|
|
static int le_tidydoc;
|
|
|
|
#define le_tidydoc_name "Tidy Document"
|
2003-09-20 19:45:32 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define TIDY_PARSED_CHECK() \
|
|
|
|
if(!TG(tdoc)->parsed) { \
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "A document must be parsed before executing this function."); \
|
|
|
|
RETURN_FALSE; \
|
|
|
|
} \
|
|
|
|
|
|
|
|
#define TIDY_SAFE_MODE_CHECK(filename) \
|
|
|
|
if ((PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) || php_check_open_basedir(filename TSRMLS_CC)) { \
|
|
|
|
RETURN_FALSE; \
|
|
|
|
} \
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#ifdef ZEND_ENGINE_2
|
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
zend_class_entry *php_tidy_ce;
|
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
static zend_object_handlers php_tidy_object_handlers = {
|
|
|
|
ZEND_OBJECTS_STORE_HANDLERS,
|
|
|
|
tidy_property_read,
|
|
|
|
tidy_property_write,
|
|
|
|
tidy_read_dim,
|
|
|
|
tidy_write_dim,
|
|
|
|
tidy_property_get_ptr,
|
|
|
|
tidy_property_get_ptr,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
tidy_property_exists,
|
|
|
|
tidy_property_delete,
|
|
|
|
tidy_del_dim,
|
|
|
|
tidy_get_properties,
|
|
|
|
tidy_get_method,
|
|
|
|
tidy_call_method,
|
|
|
|
tidy_get_constructor,
|
|
|
|
tidy_get_class_entry,
|
|
|
|
tidy_get_class_name,
|
|
|
|
tidy_objects_compare,
|
|
|
|
tidy_object_cast
|
|
|
|
};
|
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#endif
|
2003-08-01 09:12:35 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
function_entry tidy_functions[] = {
|
2003-09-14 00:45:51 +00:00
|
|
|
PHP_FE(tidy_setopt, NULL)
|
|
|
|
PHP_FE(tidy_getopt, NULL)
|
|
|
|
PHP_FE(tidy_parse_string, NULL)
|
|
|
|
PHP_FE(tidy_parse_file, NULL)
|
|
|
|
PHP_FE(tidy_get_output, NULL)
|
|
|
|
PHP_FE(tidy_get_error_buffer, NULL)
|
|
|
|
PHP_FE(tidy_clean_repair, NULL)
|
|
|
|
PHP_FE(tidy_diagnose, NULL)
|
2003-09-20 19:45:32 +00:00
|
|
|
PHP_FE(tidy_get_release, NULL)
|
|
|
|
PHP_FE(tidy_get_config, NULL)
|
|
|
|
PHP_FE(tidy_get_status, NULL)
|
|
|
|
PHP_FE(tidy_get_html_ver, NULL)
|
|
|
|
PHP_FE(tidy_is_xhtml, NULL)
|
|
|
|
PHP_FE(tidy_is_xml, NULL)
|
|
|
|
PHP_FE(tidy_error_count, NULL)
|
|
|
|
PHP_FE(tidy_warning_count, NULL)
|
|
|
|
PHP_FE(tidy_access_count, NULL)
|
|
|
|
PHP_FE(tidy_config_count, NULL)
|
|
|
|
PHP_FE(tidy_load_config, NULL)
|
2003-09-14 00:45:51 +00:00
|
|
|
PHP_FE(tidy_load_config_enc, NULL)
|
2003-09-20 19:45:32 +00:00
|
|
|
PHP_FE(tidy_set_encoding, NULL)
|
|
|
|
PHP_FE(tidy_save_config, NULL)
|
2003-09-14 00:45:51 +00:00
|
|
|
|
|
|
|
#ifdef ZEND_ENGINE_2
|
2003-09-20 19:45:32 +00:00
|
|
|
PHP_FE(tidy_get_root, NULL)
|
|
|
|
PHP_FE(tidy_get_head, NULL)
|
|
|
|
PHP_FE(tidy_get_html, NULL)
|
|
|
|
PHP_FE(tidy_get_body, NULL)
|
2003-09-14 00:45:51 +00:00
|
|
|
#endif
|
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
{NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
zend_module_entry tidy_module_entry = {
|
|
|
|
#if ZEND_MODULE_API_NO >= 20010901
|
|
|
|
STANDARD_MODULE_HEADER,
|
|
|
|
#endif
|
2003-08-06 00:01:22 +00:00
|
|
|
"tidy",
|
2003-08-01 00:22:43 +00:00
|
|
|
tidy_functions,
|
|
|
|
PHP_MINIT(tidy),
|
|
|
|
PHP_MSHUTDOWN(tidy),
|
2003-09-20 19:45:32 +00:00
|
|
|
PHP_RINIT(tidy),
|
2003-08-01 00:22:43 +00:00
|
|
|
NULL,
|
|
|
|
PHP_MINFO(tidy),
|
|
|
|
#if ZEND_MODULE_API_NO >= 20010901
|
2003-09-14 00:45:51 +00:00
|
|
|
"0.6b",
|
2003-08-01 00:22:43 +00:00
|
|
|
#endif
|
|
|
|
STANDARD_MODULE_PROPERTIES
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef COMPILE_DL_TIDY
|
|
|
|
ZEND_GET_MODULE(tidy)
|
|
|
|
#endif
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ PHP_INI
|
|
|
|
*/
|
|
|
|
PHP_INI_BEGIN()
|
|
|
|
STD_PHP_INI_ENTRY("tidy.default_config", "", PHP_INI_SYSTEM, OnUpdateString, default_config, zend_tidy_globals, tidy_globals)
|
|
|
|
PHP_INI_END()
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
static void tidy_globals_ctor(zend_tidy_globals *g TSRMLS_DC)
|
|
|
|
{
|
|
|
|
g->used = 0;
|
|
|
|
g->tdoc = pemalloc(sizeof(PHPTidyDoc), 1);
|
|
|
|
g->tdoc->doc = tidyCreate();
|
|
|
|
g->tdoc->parsed = 0;
|
|
|
|
g->tdoc->errbuf = pemalloc(sizeof(TidyBuffer), 1);
|
|
|
|
tidyBufInit(g->tdoc->errbuf);
|
|
|
|
|
|
|
|
if(tidySetErrorBuffer(g->tdoc->doc, g->tdoc->errbuf) != 0) {
|
|
|
|
zend_error(E_ERROR, "Could not set Tidy error buffer");
|
|
|
|
}
|
|
|
|
|
|
|
|
tidyOptSetBool(g->tdoc->doc, TidyForceOutput, yes);
|
|
|
|
tidyOptSetBool(g->tdoc->doc, TidyMark, no);
|
|
|
|
|
|
|
|
/* remember settings so that we can restore them */
|
|
|
|
tidyOptSnapshot(g->tdoc->doc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tidy_globals_dtor(zend_tidy_globals *g TSRMLS_DC)
|
|
|
|
{
|
|
|
|
tidyBufFree(g->tdoc->errbuf);
|
|
|
|
pefree(g->tdoc->errbuf, 1);
|
|
|
|
tidyRelease(g->tdoc->doc);
|
|
|
|
pefree(g->tdoc, 1);
|
|
|
|
g->used = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *_php_tidy_get_opt_val(TidyOption opt, TidyOptionType *type)
|
|
|
|
{
|
|
|
|
*type = tidyOptGetType(opt);
|
|
|
|
|
|
|
|
switch (*type) {
|
|
|
|
case TidyString: {
|
|
|
|
char *val = (char *) tidyOptGetValue(TG(tdoc)->doc, tidyOptGetId(opt));
|
|
|
|
if (val) {
|
|
|
|
return (void *) estrdup(val);
|
|
|
|
} else {
|
|
|
|
return (void *) estrdup("");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyInteger:
|
|
|
|
return (void *) tidyOptGetInt(TG(tdoc)->doc, tidyOptGetId(opt));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyBoolean:
|
|
|
|
return (void *) tidyOptGetBool(TG(tdoc)->doc, tidyOptGetId(opt));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should not happen */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#ifdef ZEND_ENGINE_2
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
static inline PHPTidyObj *php_tidy_fetch_object(zval *object TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
return (PHPTidyObj *) zend_object_store_get_object(object TSRMLS_CC);
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
PHPTidyObj *php_tidy_new()
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *intern;
|
|
|
|
|
|
|
|
intern = emalloc(sizeof(PHPTidyObj));
|
|
|
|
intern->obj.ce = php_tidy_ce;
|
|
|
|
intern->obj.in_get = 0;
|
|
|
|
intern->obj.in_set = 0;
|
|
|
|
intern->node = NULL;
|
|
|
|
intern->attr = NULL;
|
|
|
|
intern->type = PHP_IS_TIDYUNDEF;
|
2003-08-06 00:01:22 +00:00
|
|
|
intern->parent = NULL;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
ALLOC_HASHTABLE(intern->obj.properties);
|
2003-08-01 09:12:35 +00:00
|
|
|
zend_hash_init(intern->obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return intern;
|
|
|
|
}
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
zval *_php_tidy_create_obj_zval(unsigned int objtype,
|
|
|
|
PHPTidyObj *parent,
|
|
|
|
void *data
|
2003-08-07 17:53:48 +00:00
|
|
|
TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 09:12:35 +00:00
|
|
|
zval *return_value;
|
|
|
|
MAKE_STD_ZVAL(return_value);
|
|
|
|
ZVAL_NULL(return_value);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
_php_tidy_create_obj(return_value, objtype, parent, data TSRMLS_CC);
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
void _php_tidy_create_obj(zval *return_value,
|
|
|
|
unsigned int objtype,
|
|
|
|
PHPTidyObj *parent,
|
|
|
|
void *data
|
2003-08-07 17:53:48 +00:00
|
|
|
TSRMLS_DC)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
PHPTidyObj *retobj, *t;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
retobj = php_tidy_new();
|
|
|
|
retobj->type = objtype;
|
|
|
|
retobj->refcount = 1;
|
2003-08-06 00:01:22 +00:00
|
|
|
retobj->parent = parent;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
t = retobj;
|
|
|
|
while((t = t->parent)) {
|
|
|
|
t->refcount++;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
parent->refcount++;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
switch(objtype) {
|
|
|
|
case PHP_IS_TIDYNODE:
|
|
|
|
retobj->node = (TidyNode)data;
|
|
|
|
break;
|
|
|
|
case PHP_IS_TIDYATTR:
|
|
|
|
retobj->node = parent->node;
|
|
|
|
retobj->attr = (TidyAttr)data;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retobj->node = NULL;
|
|
|
|
retobj->attr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return_value->type = IS_OBJECT;
|
|
|
|
return_value->value.obj = php_tidy_register_object(retobj TSRMLS_CC);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zend_object_value php_tidy_register_object(PHPTidyObj *intern TSRMLS_DC)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
zend_object_value retval;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
retval.handle = zend_objects_store_put(intern,
|
2003-08-06 00:01:22 +00:00
|
|
|
php_tidy_obj_dtor,
|
|
|
|
php_tidy_obj_clone TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
retval.handlers = (zend_object_handlers *) &php_tidy_object_handlers;
|
|
|
|
|
|
|
|
return retval;
|
2003-08-01 09:12:35 +00:00
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void php_tidy_obj_dtor(void *object, zend_object_handle handle TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 09:12:35 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *o = (PHPTidyObj *)object;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
do {
|
|
|
|
o->refcount--;
|
|
|
|
} while((o = o->parent));
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
o = (PHPTidyObj *)object;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
if(o->refcount <= 0) {
|
2003-08-01 09:12:35 +00:00
|
|
|
/* We don't free anything else here from
|
|
|
|
PHPTidyObj, they are all pointers
|
|
|
|
to internal TidyNode structs, which
|
|
|
|
get freed when the tidy resource is
|
|
|
|
destroied by TidyRelease()
|
|
|
|
*/
|
2003-08-06 00:01:22 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
/* zend_hash_destroy(o->obj.properties);
|
|
|
|
FREE_HASHTABLE(o->obj.properties); */
|
2003-08-06 00:01:22 +00:00
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
zend_objects_destroy_object(&o->obj, handle TSRMLS_CC);
|
2003-08-06 00:01:22 +00:00
|
|
|
|
|
|
|
o->node = NULL;
|
|
|
|
o->attr = NULL;
|
|
|
|
o->type = PHP_IS_TIDYUNDEF;
|
|
|
|
o->parent = NULL;
|
|
|
|
efree(o);
|
2003-08-01 09:12:35 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void php_tidy_obj_clone(void *object, void **object_clone TSRMLS_DC)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *intern = (PHPTidyObj *) object;
|
|
|
|
PHPTidyObj **intern_clone = (PHPTidyObj **) object_clone;
|
|
|
|
|
|
|
|
*intern_clone = emalloc(sizeof(PHPTidyObj));
|
|
|
|
(*intern_clone)->obj.ce = intern->obj.ce;
|
|
|
|
(*intern_clone)->obj.in_get = 0;
|
|
|
|
(*intern_clone)->obj.in_set = 0;
|
|
|
|
ALLOC_HASHTABLE((*intern_clone)->obj.properties);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
/* memcopy these.. */
|
|
|
|
memcpy((*intern_clone)->node, intern->node, sizeof(TidyNode));
|
|
|
|
memcpy((*intern_clone)->attr, intern->attr, sizeof(TidyAttr));
|
|
|
|
(*intern_clone)->type = intern->type;
|
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
}
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
#endif
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_MINIT_FUNCTION(tidy)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
REGISTER_INI_ENTRIES();
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#ifdef ZEND_ENGINE_2
|
2003-08-06 00:01:22 +00:00
|
|
|
zend_class_entry _tidy_entry;
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
INIT_CLASS_ENTRY(_tidy_entry, "TidyObject", NULL);
|
|
|
|
php_tidy_ce = zend_register_internal_class(&_tidy_entry TSRMLS_CC);
|
2003-09-14 00:45:51 +00:00
|
|
|
#endif
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
_php_tidy_register_tags(INIT_FUNC_ARGS_PASSTHRU);
|
|
|
|
_php_tidy_register_attributes(INIT_FUNC_ARGS_PASSTHRU);
|
2003-08-01 00:22:43 +00:00
|
|
|
_php_tidy_register_nodetypes(INIT_FUNC_ARGS_PASSTHRU);
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
ZEND_INIT_MODULE_GLOBALS(tidy, tidy_globals_ctor, tidy_globals_dtor);
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_MSHUTDOWN_FUNCTION(tidy)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
#ifndef ZTS
|
|
|
|
tidy_globals_dtor(&tidy_globals TSRMLS_CC);
|
|
|
|
#endif
|
|
|
|
return SUCCESS;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
PHP_RINIT_FUNCTION(tidy)
|
|
|
|
{
|
|
|
|
if (TG(used) && tidyOptDiffThanSnapshot((tidy_globals.tdoc)->doc)) {
|
|
|
|
tidyOptResetToSnapshot((tidy_globals.tdoc)->doc);
|
|
|
|
TG(used) = 0;
|
|
|
|
}
|
|
|
|
/* if a user provided a default configuration file, use it */
|
|
|
|
if (tidy_globals.default_config && tidy_globals.default_config[0]) {
|
|
|
|
if (tidyLoadConfig((tidy_globals.tdoc)->doc, tidy_globals.default_config) < 0) {
|
|
|
|
zend_error(E_ERROR, "Unable to load Tidy configuration file at '%s'.", tidy_globals.default_config);
|
|
|
|
}
|
|
|
|
TG(used) = 1;
|
|
|
|
}
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_MINFO_FUNCTION(tidy)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
TidyIterator itOpt = tidyGetOptionList(TG(tdoc)->doc);
|
|
|
|
void *opt_value;
|
|
|
|
TidyOptionType optt;
|
|
|
|
char buf[255];
|
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
php_info_print_table_start();
|
|
|
|
php_info_print_table_header(2, "Tidy support", "enabled");
|
2003-09-20 19:45:32 +00:00
|
|
|
php_info_print_table_row(2, "libTidy Build Date", (char *)tidyReleaseDate());
|
2003-08-01 00:22:43 +00:00
|
|
|
php_info_print_table_end();
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
DISPLAY_INI_ENTRIES();
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
php_info_print_table_start();
|
|
|
|
php_info_print_table_header(2, "Tidy Configuration Directive", "Value");
|
|
|
|
while (itOpt) {
|
|
|
|
TidyOption opt = tidyGetNextOption(TG(tdoc)->doc, &itOpt);
|
|
|
|
|
|
|
|
opt_value = _php_tidy_get_opt_val(opt, &optt);
|
|
|
|
switch (optt) {
|
|
|
|
case TidyString:
|
|
|
|
php_info_print_table_row(2, (char *)tidyOptGetName(opt), (char*)opt_value);
|
|
|
|
efree(opt_value);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyInteger:
|
|
|
|
sprintf(buf, "%d", (int)opt_value);
|
|
|
|
php_info_print_table_row(2, (char *)tidyOptGetName(opt), (char*)buf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyBoolean:
|
|
|
|
php_info_print_table_row(2, (char *)tidyOptGetName(opt), (opt_value ? "TRUE" : "FALSE"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
php_info_print_table_end();
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto bool tidy_parse_string(string input)
|
2003-08-01 00:22:43 +00:00
|
|
|
Parse a document stored in a string */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_parse_string)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
char *input;
|
|
|
|
int input_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &input, &input_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(tidyParseString(TG(tdoc)->doc, input) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "[Tidy error] %s", TG(tdoc)->errbuf->bp);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TG(tdoc)->parsed = TRUE;
|
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto string tidy_get_error_buffer([boolean detailed])
|
2003-08-01 00:22:43 +00:00
|
|
|
Return warnings and errors which occured parsing the specified document*/
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_error_buffer)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
zend_bool detailed = 0;
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &detailed) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
if (detailed) {
|
|
|
|
tidyErrorSummary(TG(tdoc)->doc);
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
RETVAL_STRING(TG(tdoc)->errbuf->bp, 1);
|
|
|
|
tidyBufClear(TG(tdoc)->errbuf);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto string tidy_get_output()
|
2003-08-01 00:22:43 +00:00
|
|
|
Return a string representing the parsed tidy markup */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_output)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
TidyBuffer output = {0};
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
tidySaveBuffer (TG(tdoc)->doc, &output);
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETVAL_STRING(output.bp, 1);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
tidyBufFree(&output);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_parse_file(string file)
|
2003-08-01 00:22:43 +00:00
|
|
|
Parse markup in file or URI */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_parse_file)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
char *inputfile;
|
|
|
|
int input_len;
|
|
|
|
php_stream *stream;
|
|
|
|
char *contents;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &inputfile, &input_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if (!(stream = php_stream_open_wrapper(inputfile, "rb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL))) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if (php_stream_copy_to_mem(stream, &contents, PHP_STREAM_COPY_ALL, 0) > 0) {
|
|
|
|
if(tidyParseString(TG(tdoc)->doc, contents) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "[Tidy error] %s", TG(tdoc)->errbuf->bp);
|
|
|
|
efree(contents);
|
|
|
|
php_stream_close(stream);
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
TG(tdoc)->parsed = TRUE;
|
|
|
|
efree(contents);
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
php_stream_close(stream);
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_clean_repair()
|
2003-08-01 00:22:43 +00:00
|
|
|
Execute configured cleanup and repair operations on parsed markup */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_clean_repair)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
if (tidyCleanAndRepair(TG(tdoc)->doc) >= 0) {
|
|
|
|
RETURN_TRUE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_diagnose()
|
2003-08-01 00:22:43 +00:00
|
|
|
Run configured diagnostics on parsed and repaired markup. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_diagnose)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
if (tidyRunDiagnostics(TG(tdoc)->doc) >= 0) {
|
|
|
|
RETURN_TRUE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto string tidy_get_release()
|
|
|
|
Get release date (version) for Tidy library */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_release)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_STRING((char *)tidyReleaseDate(), 1);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto string tidy_reset_config()
|
|
|
|
Restore Tidy configuration to default values */
|
|
|
|
PHP_FUNCTION(tidy_reset_config)
|
|
|
|
{
|
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_BOOL(tidyOptResetToSnapshot(TG(tdoc)->doc));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto array tidy_get_config()
|
|
|
|
Get current Tidy configuarion */
|
|
|
|
PHP_FUNCTION(tidy_get_config)
|
|
|
|
{
|
|
|
|
TidyIterator itOpt = tidyGetOptionList(TG(tdoc)->doc);
|
|
|
|
char *opt_name;
|
|
|
|
void *opt_value;
|
|
|
|
TidyOptionType optt;
|
|
|
|
|
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
array_init(return_value);
|
|
|
|
|
|
|
|
while (itOpt) {
|
|
|
|
TidyOption opt = tidyGetNextOption(TG(tdoc)->doc, &itOpt);
|
|
|
|
|
|
|
|
opt_name = (char *)tidyOptGetName(opt);
|
|
|
|
opt_value = _php_tidy_get_opt_val(opt, &optt);
|
|
|
|
switch (optt) {
|
|
|
|
case TidyString:
|
|
|
|
add_assoc_string(return_value, opt_name, (char*)opt_value, 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyInteger:
|
|
|
|
add_assoc_long(return_value, opt_name, (long)opt_value);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyBoolean:
|
|
|
|
add_assoc_bool(return_value, opt_name, (long)opt_value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ proto int tidy_get_status()
|
2003-08-01 00:22:43 +00:00
|
|
|
Get status of specfied document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_status)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
RETURN_LONG(tidyStatus(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto int tidy_get_html_ver()
|
2003-08-01 00:22:43 +00:00
|
|
|
Get the Detected HTML version for the specified document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_html_ver)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_LONG(tidyDetectedHtmlVersion(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_is_xhtml()
|
2003-08-01 00:22:43 +00:00
|
|
|
Indicates if the document is a XHTML document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_is_xhtml)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_BOOL(tidyDetectedXhtml(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_is_xhtml()
|
2003-08-01 00:22:43 +00:00
|
|
|
Indicates if the document is a generic (non HTML/XHTML) XML document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_is_xml)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_BOOL(tidyDetectedGenericXml(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto int tidy_error_count()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns the Number of Tidy errors encountered for specified document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_error_count)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_LONG(tidyErrorCount(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto int tidy_warning_count()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns the Number of Tidy warnings encountered for specified document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_warning_count)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_LONG(tidyWarningCount(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto int tidy_access_count()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns the Number of Tidy accessibility warnings encountered for specified document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_access_count)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_LONG(tidyAccessWarningCount(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto int tidy_config_count()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns the Number of Tidy configuration errors encountered for specified document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_config_count)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
RETURN_LONG(tidyConfigErrorCount(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto void tidy_load_config(string filename)
|
2003-08-06 00:01:22 +00:00
|
|
|
Load an ASCII Tidy configuration file */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_load_config)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
char *filename;
|
|
|
|
int filename_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_SAFE_MODE_CHECK(filename);
|
|
|
|
|
|
|
|
if(tidyLoadConfig(TG(tdoc)->doc, filename) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not load configuration file '%s'", filename);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto void tidy_load_config(string filename, string encoding)
|
2003-08-01 00:22:43 +00:00
|
|
|
Load an ASCII Tidy configuration file with the specified encoding */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_load_config_enc)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
char *filename, *encoding;
|
2003-08-06 00:01:22 +00:00
|
|
|
int enc_len, file_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &filename, &file_len, &encoding, &enc_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_SAFE_MODE_CHECK(filename);
|
|
|
|
|
|
|
|
if(tidyLoadConfigEnc(TG(tdoc)->doc, filename, encoding) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not load configuration file '%s' using encoding '%s'", filename, encoding);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_set_encoding(string encoding)
|
2003-08-01 00:22:43 +00:00
|
|
|
Set the input/output character encoding for parsing markup.
|
|
|
|
Values include: ascii, latin1, raw, utf8, iso2022, mac, win1252, utf16le,
|
|
|
|
utf16be, utf16, big5 and shiftjis. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_set_encoding)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
char *encoding;
|
|
|
|
int enc_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &encoding, &enc_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(tidySetCharEncoding(TG(tdoc)->doc, encoding) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not set encoding '%s'", encoding);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_save_config(string filename)
|
2003-08-01 00:22:43 +00:00
|
|
|
Save current settings to named file. Only non-default values are written. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_save_config)
|
|
|
|
{
|
2003-08-06 00:01:22 +00:00
|
|
|
char *filename;
|
|
|
|
int file_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &file_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_SAFE_MODE_CHECK(filename);
|
|
|
|
|
|
|
|
if(tidyOptSaveFile(TG(tdoc)->doc, filename) < 0) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not write tidy configuration file '%s'", filename);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_TRUE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto boolean tidy_setopt(string option, mixed newvalue)
|
2003-08-01 00:22:43 +00:00
|
|
|
Updates the configuration settings for the specified tidy document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_setopt)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
zval *value;
|
2003-08-06 00:01:22 +00:00
|
|
|
char *optname;
|
|
|
|
int optname_len;
|
|
|
|
TidyOption opt;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &optname, &optname_len, &value) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
opt = tidyGetOptionByName(TG(tdoc)->doc, optname);
|
|
|
|
if (!opt) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown Tidy Configuration Option '%s'", optname);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch(tidyOptGetType(opt)) {
|
2003-08-01 00:22:43 +00:00
|
|
|
case TidyString:
|
2003-09-20 19:45:32 +00:00
|
|
|
convert_to_string_ex(&value);
|
|
|
|
if(tidyOptSetValue(TG(tdoc)->doc, tidyOptGetId(opt), Z_STRVAL_P(value))) {
|
|
|
|
TG(used) = 1;
|
2003-08-01 00:22:43 +00:00
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyInteger:
|
2003-09-20 19:45:32 +00:00
|
|
|
convert_to_long_ex(&value);
|
|
|
|
if(tidyOptSetInt(TG(tdoc)->doc, tidyOptGetId(opt), Z_LVAL_P(value))) {
|
|
|
|
TG(used) = 1;
|
2003-08-01 00:22:43 +00:00
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyBoolean:
|
2003-09-20 19:45:32 +00:00
|
|
|
convert_to_long_ex(&value);
|
|
|
|
if(tidyOptSetBool(TG(tdoc)->doc, tidyOptGetId(opt), Z_LVAL_P(value))) {
|
|
|
|
TG(used) = 1;
|
2003-08-01 00:22:43 +00:00
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2003-09-20 19:45:32 +00:00
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to determine type of Tidy configuration constant to set");
|
|
|
|
break;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto mixed tidy_getopt(string option)
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns the value of the specified configuration option for the tidy document. */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_getopt)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
char *optname;
|
|
|
|
void *optval;
|
2003-08-06 00:01:22 +00:00
|
|
|
int optname_len;
|
2003-09-20 19:45:32 +00:00
|
|
|
TidyOption opt;
|
|
|
|
TidyOptionType optt;
|
2003-08-06 00:01:22 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &optname, &optname_len) == FAILURE) {
|
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
opt = tidyGetOptionByName(TG(tdoc)->doc, optname);
|
|
|
|
if (!opt) {
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown Tidy Configuration Option '%s'", optname);
|
|
|
|
RETURN_FALSE;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
optval = _php_tidy_get_opt_val(opt, &optt);
|
|
|
|
switch (optt) {
|
|
|
|
case TidyString:
|
|
|
|
RETVAL_STRING((char *)optval, 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyInteger:
|
|
|
|
RETURN_LONG((long)optval);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TidyBoolean:
|
|
|
|
if (optval) {
|
|
|
|
RETURN_TRUE;
|
|
|
|
} else {
|
|
|
|
RETURN_NULL();
|
|
|
|
}
|
|
|
|
break;
|
2003-08-06 00:01:22 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
default:
|
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to determine type of Tidy configuration constant to get");
|
|
|
|
break;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
RETURN_FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#ifdef ZEND_ENGINE_2
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto TidyNode tidy_get_root()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns a TidyNode Object representing the root of the tidy parse tree */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_root)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
PHPTidyObj *obj;
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
obj = php_tidy_new();
|
2003-09-20 19:45:32 +00:00
|
|
|
obj->node = tidyGetRoot(TG(tdoc)->doc);
|
2003-08-06 00:01:22 +00:00
|
|
|
obj->attr = NULL;
|
|
|
|
obj->type = PHP_IS_TIDYNODE;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
return_value->type = IS_OBJECT;
|
2003-08-01 00:22:43 +00:00
|
|
|
return_value->value.obj = php_tidy_register_object(obj TSRMLS_CC);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto TidyNode tidy_get_html()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns a TidyNode Object starting from the <HTML> tag of the tidy parse tree */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_html)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
PHPTidyObj *obj;
|
2003-08-06 00:01:22 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
obj = php_tidy_new();
|
2003-09-20 19:45:32 +00:00
|
|
|
obj->node = tidyGetHtml(TG(tdoc)->doc);
|
2003-08-06 00:01:22 +00:00
|
|
|
obj->attr = NULL;
|
|
|
|
obj->type = PHP_IS_TIDYNODE;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
return_value->type = IS_OBJECT;
|
2003-08-01 09:12:35 +00:00
|
|
|
return_value->value.obj = php_tidy_register_object(obj TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
/* {{{ proto TidyNode tidy_get_head()
|
2003-08-01 00:22:43 +00:00
|
|
|
Returns a TidyNode Object starting from the <HEAD> tag of the tidy parse tree */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_head)
|
|
|
|
{
|
2003-09-20 19:45:32 +00:00
|
|
|
PHPTidyObj *obj;
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
2003-08-06 00:01:22 +00:00
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
obj = php_tidy_new();
|
2003-09-20 19:45:32 +00:00
|
|
|
obj->node = tidyGetHead(TG(tdoc)->doc);
|
2003-08-06 00:01:22 +00:00
|
|
|
obj->attr = NULL;
|
|
|
|
obj->type = PHP_IS_TIDYNODE;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
return_value->type = IS_OBJECT;
|
2003-08-01 00:22:43 +00:00
|
|
|
return_value->value.obj = php_tidy_register_object(obj TSRMLS_CC);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto TidyNode tidy_get_body(resource tidy)
|
|
|
|
Returns a TidyNode Object starting from the <BODY> tag of the tidy parse tree */
|
2003-08-07 17:53:48 +00:00
|
|
|
PHP_FUNCTION(tidy_get_body)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *obj;
|
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
if(ZEND_NUM_ARGS()) {
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
TIDY_PARSED_CHECK();
|
|
|
|
|
|
|
|
obj = php_tidy_new();
|
|
|
|
obj->node = tidyGetBody(TG(tdoc)->doc);
|
|
|
|
obj->attr = NULL;
|
|
|
|
obj->type = PHP_IS_TIDYNODE;
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-09-20 19:45:32 +00:00
|
|
|
return_value->type = IS_OBJECT;
|
2003-08-01 00:22:43 +00:00
|
|
|
return_value->value.obj = php_tidy_register_object(obj TSRMLS_CC);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void tidy_property_delete(zval *obj, zval *member TSRMLS_DC) {}
|
|
|
|
void tidy_property_write(zval *obj, zval *member, zval *value TSRMLS_DC) {}
|
|
|
|
void tidy_object_cast(zval *readobj, zval *writeobj, int type, int should_free TSRMLS_DC) {}
|
|
|
|
void tidy_write_dim(zval *object, zval *offset, zval *value TSRMLS_DC) {}
|
|
|
|
void tidy_del_dim(zval *object, zval *offset TSRMLS_DC) {}
|
|
|
|
|
|
|
|
union _zend_function * tidy_get_constructor(zval *obj TSRMLS_DC)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
zval *tidy_read_dim(zval *object, zval *offset TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 09:12:35 +00:00
|
|
|
return EG(uninitialized_zval_ptr);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zend_class_entry * tidy_get_class_entry(zval *obj TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
return php_tidy_ce;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zval ** tidy_property_get_ptr(zval *obj, zval *member TSRMLS_DC)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
zval **p_ptr = NULL;
|
2003-08-01 00:22:43 +00:00
|
|
|
zval *p;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
p = tidy_property_read(obj, member, 0 TSRMLS_CC);
|
|
|
|
|
|
|
|
*p_ptr = p;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return p_ptr;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zval * tidy_property_read(zval *object, zval *member, zend_bool silent TSRMLS_DC)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
PHPTidyObj *obj = php_tidy_fetch_object(object TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
zval *return_value, *temp;
|
|
|
|
TidyBuffer buf;
|
|
|
|
TidyNode tempnode;
|
|
|
|
TidyAttr tempattr;
|
|
|
|
char *temp_str;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
char *name = Z_STRVAL_P(member);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
MAKE_STD_ZVAL(return_value);
|
|
|
|
ZVAL_NULL(return_value);
|
|
|
|
|
2003-08-01 09:12:35 +00:00
|
|
|
/* Seems to me the engine expects to simply recieve a pointer to
|
2003-09-20 19:45:32 +00:00
|
|
|
* an already-existing zval, not for one to be created and returned..
|
|
|
|
* Thus, it doesn't feel compelled to free the return value once it's
|
|
|
|
* done with it... this seems to compell it appropiately.
|
|
|
|
*/
|
2003-08-01 09:12:35 +00:00
|
|
|
return_value->refcount--;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
switch(obj->type) {
|
|
|
|
case PHP_IS_TIDYNODE:
|
|
|
|
if(!strcmp(name, "name")) {
|
|
|
|
temp_str = (char *)tidyNodeGetName(obj->node);
|
|
|
|
if(temp_str) {
|
|
|
|
ZVAL_STRING(return_value, temp_str, 1);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "value")) {
|
|
|
|
memset(&buf, 0, sizeof(buf));
|
2003-09-20 19:45:32 +00:00
|
|
|
tidyNodeGetText(TG(tdoc)->doc, obj->node, &buf);
|
2003-08-01 00:22:43 +00:00
|
|
|
ZVAL_STRING(return_value, (char *)buf.bp, 1);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
/* The buffer adds a newline at the end of the string */
|
|
|
|
REMOVE_NEWLINE(return_value);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
tidyBufFree(&buf);
|
|
|
|
} else if(!strcmp(name, "type")) {
|
|
|
|
ZVAL_LONG(return_value, tidyNodeGetType(obj->node));
|
|
|
|
|
|
|
|
} else if(!strcmp(name, "id")) {
|
|
|
|
if(tidyNodeGetName(obj->node)) {
|
|
|
|
ZVAL_LONG(return_value, tidyNodeGetId(obj->node));
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "attribs")) {
|
|
|
|
array_init(return_value);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
tempattr = tidyAttrFirst(obj->node);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
if(tempattr) {
|
2003-08-01 09:12:35 +00:00
|
|
|
temp = _php_tidy_create_obj_zval(PHP_IS_TIDYATTR, obj, tempattr TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
add_next_index_zval(return_value, temp);
|
|
|
|
while((tempattr = tidyAttrNext(tempattr))) {
|
2003-08-01 09:12:35 +00:00
|
|
|
temp = _php_tidy_create_obj_zval(PHP_IS_TIDYATTR, obj, tempattr TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
add_next_index_zval(return_value, temp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "children")) {
|
|
|
|
array_init(return_value);
|
|
|
|
tempnode = tidyGetChild(obj->node);
|
|
|
|
if(tempnode) {
|
2003-08-01 09:12:35 +00:00
|
|
|
temp = _php_tidy_create_obj_zval(PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
add_next_index_zval(return_value, temp);
|
|
|
|
while((tempnode = tidyGetNext(tempnode))) {
|
2003-08-06 00:01:22 +00:00
|
|
|
temp = _php_tidy_create_obj_zval(PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
2003-08-01 09:12:35 +00:00
|
|
|
add_next_index_zval(return_value, temp);
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "line")) {
|
|
|
|
ZVAL_LONG(return_value, tidyNodeLine(obj->node));
|
|
|
|
} else if(!strcmp(name, "column")) {
|
|
|
|
ZVAL_LONG(return_value, tidyNodeColumn(obj->node));
|
|
|
|
} else if(!strcmp(name, "html_ver")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
ZVAL_LONG(return_value, tidyDetectedHtmlVersion(TG(tdoc)->doc));
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
case PHP_IS_TIDYATTR:
|
|
|
|
if(!strcmp(name, "name")) {
|
|
|
|
temp_str = (char *)tidyAttrName(obj->attr);
|
|
|
|
if(temp_str) {
|
|
|
|
ZVAL_STRING(return_value, temp_str , 1);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "value")) {
|
|
|
|
temp_str = (char *)tidyAttrValue(obj->attr);
|
|
|
|
if(temp_str) {
|
|
|
|
ZVAL_STRING(return_value, temp_str , 1);
|
|
|
|
efree(temp_str);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(name, "id")) {
|
|
|
|
ZVAL_LONG(return_value, tidyAttrGetId(obj->attr));
|
|
|
|
}
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
default:
|
2003-09-20 19:45:32 +00:00
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Undefined Tidy object type.");
|
2003-08-01 00:22:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
int tidy_property_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
HashTable * tidy_get_properties(zval *object TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 09:12:35 +00:00
|
|
|
zend_object *zobj;
|
|
|
|
zobj = zend_objects_get_address(object TSRMLS_CC);
|
|
|
|
return zobj->properties;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
union _zend_function * tidy_get_method(zval *obj, char *method, int method_len TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
zend_internal_function *f;
|
|
|
|
|
|
|
|
f = emalloc(sizeof(zend_internal_function));
|
|
|
|
f->type = ZEND_OVERLOADED_FUNCTION;
|
2003-08-07 17:53:48 +00:00
|
|
|
/* f->arg_types = NULL; */
|
2003-08-01 00:22:43 +00:00
|
|
|
f->scope = php_tidy_ce;
|
|
|
|
f->fn_flags = 0;
|
2003-08-01 09:12:35 +00:00
|
|
|
f->function_name = estrndup(method, method_len);
|
2003-08-01 00:22:43 +00:00
|
|
|
|
|
|
|
return (union _zend_function *) f;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zend_bool _php_tidy_node_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
PHPTidyObj *obj = php_tidy_fetch_object(getThis() TSRMLS_CC);
|
2003-08-06 00:01:22 +00:00
|
|
|
zend_internal_function *func = (zend_internal_function *)EG(function_state_ptr)->function;
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *newobj;
|
|
|
|
TidyNode tempnode;
|
|
|
|
TidyAttr tempattr;
|
2003-08-06 00:01:22 +00:00
|
|
|
zend_bool retval = TRUE;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
int param;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
if(strstr(method, "has_")) {
|
|
|
|
if(!strcmp(method, "has_siblings")) {
|
|
|
|
if(tidyGetNext(obj->node) || tidyGetPrev(obj->node)) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "has_children")) {
|
|
|
|
if(tidyGetChild(obj->node)) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "has_parent")) {
|
|
|
|
if(tidyGetParent(obj->node)) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if(strstr(method, "is_")) {
|
|
|
|
if(!strcmp(method, "is_comment")) {
|
|
|
|
if(tidyNodeGetType(obj->node) == TidyNode_Comment) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_xhtml")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
if(tidyDetectedXhtml(TG(tdoc)->doc)) {
|
2003-08-01 00:22:43 +00:00
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_xml")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
if(tidyDetectedGenericXml(TG(tdoc)->doc)) {
|
2003-08-01 00:22:43 +00:00
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_text")) {
|
|
|
|
if(tidyNodeGetType(obj->node) == TidyNode_Text) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if(!strcmp(method, "is_jste")) {
|
|
|
|
if(tidyNodeGetType(obj->node) == TidyNode_Jste) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_asp")) {
|
|
|
|
if(tidyNodeGetType(obj->node) == TidyNode_Asp) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_php")) {
|
|
|
|
if(tidyNodeGetType(obj->node) == TidyNode_Php) {
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "is_html")) {
|
|
|
|
switch(tidyNodeGetType(obj->node)) {
|
|
|
|
case TidyNode_Start:
|
|
|
|
case TidyNode_End:
|
|
|
|
case TidyNode_StartEnd:
|
|
|
|
TIDY_RV_TRUE(return_value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if(!strcmp(method, "next")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
tempnode = tidyGetNext(obj->node);
|
|
|
|
if(tempnode) {
|
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
|
|
|
}
|
2003-08-06 00:01:22 +00:00
|
|
|
} else if(!strcmp(method, "prev")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
tempnode = tidyGetPrev(obj->node);
|
|
|
|
if(tempnode) {
|
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
} else if(!strcmp(method, "parent")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
tempnode = tidyGetParent(obj->node);
|
|
|
|
if(tempnode) {
|
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
} else if(!strcmp(method, "child")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
tempnode = tidyGetChild(obj->node);
|
|
|
|
if(tempnode) {
|
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYNODE, obj, tempnode TSRMLS_CC);
|
|
|
|
}
|
2003-08-01 00:22:43 +00:00
|
|
|
} else if(!strcmp(method, "get_attr_type")) {
|
2003-09-20 19:45:32 +00:00
|
|
|
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", ¶m) == FAILURE) {
|
2003-08-01 00:22:43 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
newobj = php_tidy_new();
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
for(tempattr = tidyAttrFirst(obj->node);
|
|
|
|
tempattr;
|
|
|
|
tempattr = tidyAttrNext(tempattr)) {
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
if(tidyAttrGetId(tempattr) == param) {
|
|
|
|
newobj->attr = tempattr;
|
|
|
|
newobj->type = PHP_IS_TIDYATTR;
|
2003-08-01 09:12:35 +00:00
|
|
|
obj->refcount++;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return_value->type = IS_OBJECT;
|
|
|
|
return_value->value.obj = php_tidy_register_object(newobj TSRMLS_CC);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2003-08-06 00:01:22 +00:00
|
|
|
retval = FALSE;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:01:22 +00:00
|
|
|
efree(func->function_name);
|
|
|
|
efree(func);
|
|
|
|
return retval;
|
2003-08-01 00:22:43 +00:00
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
zend_bool _php_tidy_attr_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
PHPTidyObj *obj = php_tidy_fetch_object(getThis() TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
TidyAttr tempattr;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
if(!strcmp(method, "next")) {
|
|
|
|
tempattr = tidyAttrNext(obj->attr);
|
|
|
|
if(tempattr) {
|
2003-08-01 09:12:35 +00:00
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYATTR, obj, tempattr TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
} else {
|
|
|
|
TIDY_RV_FALSE(return_value);
|
|
|
|
}
|
|
|
|
} else if(!strcmp(method, "tag")) {
|
2003-08-01 09:12:35 +00:00
|
|
|
_php_tidy_create_obj(return_value, PHP_IS_TIDYNODE, obj, obj->node TSRMLS_CC);
|
2003-08-01 00:22:43 +00:00
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
int tidy_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
PHPTidyObj *obj = php_tidy_fetch_object(getThis() TSRMLS_CC);
|
2003-08-01 09:12:35 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
switch(obj->type) {
|
|
|
|
case PHP_IS_TIDYNODE:
|
|
|
|
return _php_tidy_node_call_method(method, INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
case PHP_IS_TIDYATTR:
|
|
|
|
return _php_tidy_attr_call_method(method, INTERNAL_FUNCTION_PARAM_PASSTHRU);
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
default:
|
2003-09-20 19:45:32 +00:00
|
|
|
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Undefined Tidy object type.");
|
2003-08-01 00:22:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
int tidy_get_class_name(zval *obj, char **class_name, zend_uint *name_len, int parent TSRMLS_DC)
|
|
|
|
{
|
2003-08-06 00:19:31 +00:00
|
|
|
PHPTidyObj *object = php_tidy_fetch_object(obj TSRMLS_CC);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
switch(object->type) {
|
|
|
|
case PHP_IS_TIDYNODE:
|
|
|
|
*class_name = estrdup("Tidy_Node");
|
|
|
|
*name_len = sizeof("Tidy_Node");
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
case PHP_IS_TIDYATTR:
|
|
|
|
*class_name = estrdup("Tidy_Attribute");
|
|
|
|
*name_len = sizeof("Tidy_Attribute");
|
|
|
|
break;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
default:
|
|
|
|
*class_name = estrdup("Tidy_Unknown");
|
|
|
|
*name_len = sizeof("Tidy_Unknown");
|
|
|
|
break;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
int tidy_objects_compare(zval *obj_one, zval *obj_two TSRMLS_DC)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
PHPTidyObj *obj1, *obj2;
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-06 00:19:31 +00:00
|
|
|
obj1 = php_tidy_fetch_object(obj_one TSRMLS_CC);
|
|
|
|
obj2 = php_tidy_fetch_object(obj_two TSRMLS_CC);
|
2003-09-20 19:45:32 +00:00
|
|
|
|
|
|
|
if (((obj1->node == obj2->node) && (obj1->attr == obj2->attr) && (obj1->type == obj2->type)) {
|
2003-08-01 00:22:43 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
2003-09-20 19:45:32 +00:00
|
|
|
|
2003-08-01 00:22:43 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-09-14 00:45:51 +00:00
|
|
|
#endif
|
2003-08-01 00:22:43 +00:00
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void _php_tidy_register_nodetypes(INIT_FUNC_ARGS)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
|
|
|
|
TIDY_NODE_CONST(ROOT, Root);
|
|
|
|
TIDY_NODE_CONST(DOCTYPE, DocType);
|
|
|
|
TIDY_NODE_CONST(COMMENT, Comment);
|
|
|
|
TIDY_NODE_CONST(PROCINS, ProcIns);
|
|
|
|
TIDY_NODE_CONST(TEXT, Text);
|
|
|
|
TIDY_NODE_CONST(START, Start);
|
|
|
|
TIDY_NODE_CONST(END, End);
|
|
|
|
TIDY_NODE_CONST(STARTEND, StartEnd);
|
|
|
|
TIDY_NODE_CONST(CDATA, CDATA);
|
|
|
|
TIDY_NODE_CONST(SECTION, Section);
|
|
|
|
TIDY_NODE_CONST(ASP, Asp);
|
|
|
|
TIDY_NODE_CONST(JSTE, Jste);
|
|
|
|
TIDY_NODE_CONST(PHP, Php);
|
|
|
|
TIDY_NODE_CONST(XMLDECL, XmlDecl);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void _php_tidy_register_tags(INIT_FUNC_ARGS)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
|
|
|
|
TIDY_TAG_CONST(UNKNOWN);
|
|
|
|
TIDY_TAG_CONST(A);
|
|
|
|
TIDY_TAG_CONST(ABBR);
|
|
|
|
TIDY_TAG_CONST(ACRONYM);
|
|
|
|
TIDY_TAG_CONST(ADDRESS);
|
|
|
|
TIDY_TAG_CONST(ALIGN);
|
|
|
|
TIDY_TAG_CONST(APPLET);
|
|
|
|
TIDY_TAG_CONST(AREA);
|
|
|
|
TIDY_TAG_CONST(B);
|
|
|
|
TIDY_TAG_CONST(BASE);
|
|
|
|
TIDY_TAG_CONST(BASEFONT);
|
|
|
|
TIDY_TAG_CONST(BDO);
|
|
|
|
TIDY_TAG_CONST(BGSOUND);
|
|
|
|
TIDY_TAG_CONST(BIG);
|
|
|
|
TIDY_TAG_CONST(BLINK);
|
|
|
|
TIDY_TAG_CONST(BLOCKQUOTE);
|
|
|
|
TIDY_TAG_CONST(BODY);
|
|
|
|
TIDY_TAG_CONST(BR);
|
|
|
|
TIDY_TAG_CONST(BUTTON);
|
|
|
|
TIDY_TAG_CONST(CAPTION);
|
|
|
|
TIDY_TAG_CONST(CENTER);
|
|
|
|
TIDY_TAG_CONST(CITE);
|
|
|
|
TIDY_TAG_CONST(CODE);
|
|
|
|
TIDY_TAG_CONST(COL);
|
|
|
|
TIDY_TAG_CONST(COLGROUP);
|
|
|
|
TIDY_TAG_CONST(COMMENT);
|
|
|
|
TIDY_TAG_CONST(DD);
|
|
|
|
TIDY_TAG_CONST(DEL);
|
|
|
|
TIDY_TAG_CONST(DFN);
|
|
|
|
TIDY_TAG_CONST(DIR);
|
|
|
|
TIDY_TAG_CONST(DIV);
|
|
|
|
TIDY_TAG_CONST(DL);
|
|
|
|
TIDY_TAG_CONST(DT);
|
|
|
|
TIDY_TAG_CONST(EM);
|
|
|
|
TIDY_TAG_CONST(EMBED);
|
|
|
|
TIDY_TAG_CONST(FIELDSET);
|
|
|
|
TIDY_TAG_CONST(FONT);
|
|
|
|
TIDY_TAG_CONST(FORM);
|
|
|
|
TIDY_TAG_CONST(FRAME);
|
|
|
|
TIDY_TAG_CONST(FRAMESET);
|
|
|
|
TIDY_TAG_CONST(H1);
|
|
|
|
TIDY_TAG_CONST(H2);
|
|
|
|
TIDY_TAG_CONST(H3);
|
|
|
|
TIDY_TAG_CONST(H4);
|
|
|
|
TIDY_TAG_CONST(H5);
|
|
|
|
TIDY_TAG_CONST(H6);
|
|
|
|
TIDY_TAG_CONST(HEAD);
|
|
|
|
TIDY_TAG_CONST(HR);
|
|
|
|
TIDY_TAG_CONST(HTML);
|
|
|
|
TIDY_TAG_CONST(I);
|
|
|
|
TIDY_TAG_CONST(IFRAME);
|
|
|
|
TIDY_TAG_CONST(ILAYER);
|
|
|
|
TIDY_TAG_CONST(IMG);
|
|
|
|
TIDY_TAG_CONST(INPUT);
|
|
|
|
TIDY_TAG_CONST(INS);
|
|
|
|
TIDY_TAG_CONST(ISINDEX);
|
|
|
|
TIDY_TAG_CONST(KBD);
|
|
|
|
TIDY_TAG_CONST(KEYGEN);
|
|
|
|
TIDY_TAG_CONST(LABEL);
|
|
|
|
TIDY_TAG_CONST(LAYER);
|
|
|
|
TIDY_TAG_CONST(LEGEND);
|
|
|
|
TIDY_TAG_CONST(LI);
|
|
|
|
TIDY_TAG_CONST(LINK);
|
|
|
|
TIDY_TAG_CONST(LISTING);
|
|
|
|
TIDY_TAG_CONST(MAP);
|
|
|
|
TIDY_TAG_CONST(MARQUEE);
|
|
|
|
TIDY_TAG_CONST(MENU);
|
|
|
|
TIDY_TAG_CONST(META);
|
|
|
|
TIDY_TAG_CONST(MULTICOL);
|
|
|
|
TIDY_TAG_CONST(NOBR);
|
|
|
|
TIDY_TAG_CONST(NOEMBED);
|
|
|
|
TIDY_TAG_CONST(NOFRAMES);
|
|
|
|
TIDY_TAG_CONST(NOLAYER);
|
|
|
|
TIDY_TAG_CONST(NOSAVE);
|
|
|
|
TIDY_TAG_CONST(NOSCRIPT);
|
|
|
|
TIDY_TAG_CONST(OBJECT);
|
|
|
|
TIDY_TAG_CONST(OL);
|
|
|
|
TIDY_TAG_CONST(OPTGROUP);
|
|
|
|
TIDY_TAG_CONST(OPTION);
|
|
|
|
TIDY_TAG_CONST(P);
|
|
|
|
TIDY_TAG_CONST(PARAM);
|
|
|
|
TIDY_TAG_CONST(PLAINTEXT);
|
|
|
|
TIDY_TAG_CONST(PRE);
|
|
|
|
TIDY_TAG_CONST(Q);
|
|
|
|
TIDY_TAG_CONST(RB);
|
|
|
|
TIDY_TAG_CONST(RBC);
|
|
|
|
TIDY_TAG_CONST(RP);
|
|
|
|
TIDY_TAG_CONST(RT);
|
|
|
|
TIDY_TAG_CONST(RTC);
|
|
|
|
TIDY_TAG_CONST(RUBY);
|
|
|
|
TIDY_TAG_CONST(S);
|
|
|
|
TIDY_TAG_CONST(SAMP);
|
|
|
|
TIDY_TAG_CONST(SCRIPT);
|
|
|
|
TIDY_TAG_CONST(SELECT);
|
|
|
|
TIDY_TAG_CONST(SERVER);
|
|
|
|
TIDY_TAG_CONST(SERVLET);
|
|
|
|
TIDY_TAG_CONST(SMALL);
|
|
|
|
TIDY_TAG_CONST(SPACER);
|
|
|
|
TIDY_TAG_CONST(SPAN);
|
|
|
|
TIDY_TAG_CONST(STRIKE);
|
|
|
|
TIDY_TAG_CONST(STRONG);
|
|
|
|
TIDY_TAG_CONST(STYLE);
|
|
|
|
TIDY_TAG_CONST(SUB);
|
|
|
|
TIDY_TAG_CONST(SUP);
|
|
|
|
TIDY_TAG_CONST(TABLE);
|
|
|
|
TIDY_TAG_CONST(TBODY);
|
|
|
|
TIDY_TAG_CONST(TD);
|
|
|
|
TIDY_TAG_CONST(TEXTAREA);
|
|
|
|
TIDY_TAG_CONST(TFOOT);
|
|
|
|
TIDY_TAG_CONST(TH);
|
|
|
|
TIDY_TAG_CONST(THEAD);
|
|
|
|
TIDY_TAG_CONST(TITLE);
|
|
|
|
TIDY_TAG_CONST(TR);
|
|
|
|
TIDY_TAG_CONST(TT);
|
|
|
|
TIDY_TAG_CONST(U);
|
|
|
|
TIDY_TAG_CONST(UL);
|
|
|
|
TIDY_TAG_CONST(VAR);
|
|
|
|
TIDY_TAG_CONST(WBR);
|
|
|
|
TIDY_TAG_CONST(XMP);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-08-07 17:53:48 +00:00
|
|
|
void _php_tidy_register_attributes(INIT_FUNC_ARGS)
|
|
|
|
{
|
2003-08-01 00:22:43 +00:00
|
|
|
|
|
|
|
TIDY_ATTR_CONST(UNKNOWN);
|
|
|
|
TIDY_ATTR_CONST(ABBR);
|
|
|
|
TIDY_ATTR_CONST(ACCEPT);
|
|
|
|
TIDY_ATTR_CONST(ACCEPT_CHARSET);
|
|
|
|
TIDY_ATTR_CONST(ACCESSKEY);
|
|
|
|
TIDY_ATTR_CONST(ACTION);
|
|
|
|
TIDY_ATTR_CONST(ADD_DATE);
|
|
|
|
TIDY_ATTR_CONST(ALIGN);
|
|
|
|
TIDY_ATTR_CONST(ALINK);
|
|
|
|
TIDY_ATTR_CONST(ALT);
|
|
|
|
TIDY_ATTR_CONST(ARCHIVE);
|
|
|
|
TIDY_ATTR_CONST(AXIS);
|
|
|
|
TIDY_ATTR_CONST(BACKGROUND);
|
|
|
|
TIDY_ATTR_CONST(BGCOLOR);
|
|
|
|
TIDY_ATTR_CONST(BGPROPERTIES);
|
|
|
|
TIDY_ATTR_CONST(BORDER);
|
|
|
|
TIDY_ATTR_CONST(BORDERCOLOR);
|
|
|
|
TIDY_ATTR_CONST(BOTTOMMARGIN);
|
|
|
|
TIDY_ATTR_CONST(CELLPADDING);
|
|
|
|
TIDY_ATTR_CONST(CELLSPACING);
|
|
|
|
TIDY_ATTR_CONST(CHAR);
|
|
|
|
TIDY_ATTR_CONST(CHAROFF);
|
|
|
|
TIDY_ATTR_CONST(CHARSET);
|
|
|
|
TIDY_ATTR_CONST(CHECKED);
|
|
|
|
TIDY_ATTR_CONST(CITE);
|
|
|
|
TIDY_ATTR_CONST(CLASS);
|
|
|
|
TIDY_ATTR_CONST(CLASSID);
|
|
|
|
TIDY_ATTR_CONST(CLEAR);
|
|
|
|
TIDY_ATTR_CONST(CODE);
|
|
|
|
TIDY_ATTR_CONST(CODEBASE);
|
|
|
|
TIDY_ATTR_CONST(CODETYPE);
|
|
|
|
TIDY_ATTR_CONST(COLOR);
|
|
|
|
TIDY_ATTR_CONST(COLS);
|
|
|
|
TIDY_ATTR_CONST(COLSPAN);
|
|
|
|
TIDY_ATTR_CONST(COMPACT);
|
|
|
|
TIDY_ATTR_CONST(CONTENT);
|
|
|
|
TIDY_ATTR_CONST(COORDS);
|
|
|
|
TIDY_ATTR_CONST(DATA);
|
|
|
|
TIDY_ATTR_CONST(DATAFLD);
|
2003-08-07 17:53:48 +00:00
|
|
|
/* TIDY_ATTR_CONST(DATAFORMATSAS); */
|
2003-08-01 00:22:43 +00:00
|
|
|
TIDY_ATTR_CONST(DATAPAGESIZE);
|
|
|
|
TIDY_ATTR_CONST(DATASRC);
|
|
|
|
TIDY_ATTR_CONST(DATETIME);
|
|
|
|
TIDY_ATTR_CONST(DECLARE);
|
|
|
|
TIDY_ATTR_CONST(DEFER);
|
|
|
|
TIDY_ATTR_CONST(DIR);
|
|
|
|
TIDY_ATTR_CONST(DISABLED);
|
|
|
|
TIDY_ATTR_CONST(ENCODING);
|
|
|
|
TIDY_ATTR_CONST(ENCTYPE);
|
|
|
|
TIDY_ATTR_CONST(FACE);
|
|
|
|
TIDY_ATTR_CONST(FOR);
|
|
|
|
TIDY_ATTR_CONST(FRAME);
|
|
|
|
TIDY_ATTR_CONST(FRAMEBORDER);
|
|
|
|
TIDY_ATTR_CONST(FRAMESPACING);
|
|
|
|
TIDY_ATTR_CONST(GRIDX);
|
|
|
|
TIDY_ATTR_CONST(GRIDY);
|
|
|
|
TIDY_ATTR_CONST(HEADERS);
|
|
|
|
TIDY_ATTR_CONST(HEIGHT);
|
|
|
|
TIDY_ATTR_CONST(HREF);
|
|
|
|
TIDY_ATTR_CONST(HREFLANG);
|
|
|
|
TIDY_ATTR_CONST(HSPACE);
|
|
|
|
TIDY_ATTR_CONST(HTTP_EQUIV);
|
|
|
|
TIDY_ATTR_CONST(ID);
|
|
|
|
TIDY_ATTR_CONST(ISMAP);
|
|
|
|
TIDY_ATTR_CONST(LABEL);
|
|
|
|
TIDY_ATTR_CONST(LANG);
|
|
|
|
TIDY_ATTR_CONST(LANGUAGE);
|
|
|
|
TIDY_ATTR_CONST(LAST_MODIFIED);
|
|
|
|
TIDY_ATTR_CONST(LAST_VISIT);
|
|
|
|
TIDY_ATTR_CONST(LEFTMARGIN);
|
|
|
|
TIDY_ATTR_CONST(LINK);
|
|
|
|
TIDY_ATTR_CONST(LONGDESC);
|
|
|
|
TIDY_ATTR_CONST(LOWSRC);
|
|
|
|
TIDY_ATTR_CONST(MARGINHEIGHT);
|
|
|
|
TIDY_ATTR_CONST(MARGINWIDTH);
|
|
|
|
TIDY_ATTR_CONST(MAXLENGTH);
|
|
|
|
TIDY_ATTR_CONST(MEDIA);
|
|
|
|
TIDY_ATTR_CONST(METHOD);
|
|
|
|
TIDY_ATTR_CONST(MULTIPLE);
|
|
|
|
TIDY_ATTR_CONST(NAME);
|
|
|
|
TIDY_ATTR_CONST(NOHREF);
|
|
|
|
TIDY_ATTR_CONST(NORESIZE);
|
|
|
|
TIDY_ATTR_CONST(NOSHADE);
|
|
|
|
TIDY_ATTR_CONST(NOWRAP);
|
|
|
|
TIDY_ATTR_CONST(OBJECT);
|
|
|
|
TIDY_ATTR_CONST(OnAFTERUPDATE);
|
|
|
|
TIDY_ATTR_CONST(OnBEFOREUNLOAD);
|
|
|
|
TIDY_ATTR_CONST(OnBEFOREUPDATE);
|
|
|
|
TIDY_ATTR_CONST(OnBLUR);
|
|
|
|
TIDY_ATTR_CONST(OnCHANGE);
|
|
|
|
TIDY_ATTR_CONST(OnCLICK);
|
|
|
|
TIDY_ATTR_CONST(OnDATAAVAILABLE);
|
|
|
|
TIDY_ATTR_CONST(OnDATASETCHANGED);
|
|
|
|
TIDY_ATTR_CONST(OnDATASETCOMPLETE);
|
|
|
|
TIDY_ATTR_CONST(OnDBLCLICK);
|
|
|
|
TIDY_ATTR_CONST(OnERRORUPDATE);
|
|
|
|
TIDY_ATTR_CONST(OnFOCUS);
|
|
|
|
TIDY_ATTR_CONST(OnKEYDOWN);
|
|
|
|
TIDY_ATTR_CONST(OnKEYPRESS);
|
|
|
|
TIDY_ATTR_CONST(OnKEYUP);
|
|
|
|
TIDY_ATTR_CONST(OnLOAD);
|
|
|
|
TIDY_ATTR_CONST(OnMOUSEDOWN);
|
|
|
|
TIDY_ATTR_CONST(OnMOUSEMOVE);
|
|
|
|
TIDY_ATTR_CONST(OnMOUSEOUT);
|
|
|
|
TIDY_ATTR_CONST(OnMOUSEOVER);
|
|
|
|
TIDY_ATTR_CONST(OnMOUSEUP);
|
|
|
|
TIDY_ATTR_CONST(OnRESET);
|
|
|
|
TIDY_ATTR_CONST(OnROWENTER);
|
|
|
|
TIDY_ATTR_CONST(OnROWEXIT);
|
|
|
|
TIDY_ATTR_CONST(OnSELECT);
|
|
|
|
TIDY_ATTR_CONST(OnSUBMIT);
|
|
|
|
TIDY_ATTR_CONST(OnUNLOAD);
|
|
|
|
TIDY_ATTR_CONST(PROFILE);
|
|
|
|
TIDY_ATTR_CONST(PROMPT);
|
|
|
|
TIDY_ATTR_CONST(RBSPAN);
|
|
|
|
TIDY_ATTR_CONST(READONLY);
|
|
|
|
TIDY_ATTR_CONST(REL);
|
|
|
|
TIDY_ATTR_CONST(REV);
|
|
|
|
TIDY_ATTR_CONST(RIGHTMARGIN);
|
|
|
|
TIDY_ATTR_CONST(ROWS);
|
|
|
|
TIDY_ATTR_CONST(ROWSPAN);
|
|
|
|
TIDY_ATTR_CONST(RULES);
|
|
|
|
TIDY_ATTR_CONST(SCHEME);
|
|
|
|
TIDY_ATTR_CONST(SCOPE);
|
|
|
|
TIDY_ATTR_CONST(SCROLLING);
|
|
|
|
TIDY_ATTR_CONST(SELECTED);
|
|
|
|
TIDY_ATTR_CONST(SHAPE);
|
|
|
|
TIDY_ATTR_CONST(SHOWGRID);
|
|
|
|
TIDY_ATTR_CONST(SHOWGRIDX);
|
|
|
|
TIDY_ATTR_CONST(SHOWGRIDY);
|
|
|
|
TIDY_ATTR_CONST(SIZE);
|
|
|
|
TIDY_ATTR_CONST(SPAN);
|
|
|
|
TIDY_ATTR_CONST(SRC);
|
|
|
|
TIDY_ATTR_CONST(STANDBY);
|
|
|
|
TIDY_ATTR_CONST(START);
|
|
|
|
TIDY_ATTR_CONST(STYLE);
|
|
|
|
TIDY_ATTR_CONST(SUMMARY);
|
|
|
|
TIDY_ATTR_CONST(TABINDEX);
|
|
|
|
TIDY_ATTR_CONST(TARGET);
|
|
|
|
TIDY_ATTR_CONST(TEXT);
|
|
|
|
TIDY_ATTR_CONST(TITLE);
|
|
|
|
TIDY_ATTR_CONST(TOPMARGIN);
|
|
|
|
TIDY_ATTR_CONST(TYPE);
|
|
|
|
TIDY_ATTR_CONST(USEMAP);
|
|
|
|
TIDY_ATTR_CONST(VALIGN);
|
|
|
|
TIDY_ATTR_CONST(VALUE);
|
|
|
|
TIDY_ATTR_CONST(VALUETYPE);
|
|
|
|
TIDY_ATTR_CONST(VERSION);
|
|
|
|
TIDY_ATTR_CONST(VLINK);
|
|
|
|
TIDY_ATTR_CONST(VSPACE);
|
|
|
|
TIDY_ATTR_CONST(WIDTH);
|
|
|
|
TIDY_ATTR_CONST(WRAP);
|
|
|
|
TIDY_ATTR_CONST(XML_LANG);
|
|
|
|
TIDY_ATTR_CONST(XML_SPACE);
|
|
|
|
TIDY_ATTR_CONST(XMLNS);
|
|
|
|
|
|
|
|
}
|