elementtidy-1.0-20050212.orig/ 0000755 0000000 0000000 00000000000 10226463350 014224 5 ustar root root elementtidy-1.0-20050212.orig/README 0000644 0000000 0000000 00000011742 10226463350 015111 0 ustar root root $Id: README 2275 2005-02-03 18:20:56Z fredrik $
======================
The elementtidy module
======================
This module provides an ElementTree builder based on the HTML TidyLib
library. For more information, see:
http://effbot.org/zone/element-tidylib.htm
For more information on the ElementTree library, see:
http://effbot.org/zone/element-index.htm
This distribution includes a snapshot of the HTML Tidy sources. You
can get the latest version from:
http://tidy.sourceforge.net
Enjoy /F
fredrik@pythonware.com
http://www.pythonware.com
--------------------------------------------------------------------
Changes
--------------------------------------------------------------------
(1.0 final released)
- Improved error checking. The library may now raise IOError
exceptions if the underlying Tidy library fails.
(1.0 beta 1 released)
- Use 'ForceOutput' flag to force output even for badly malformed
HTML.
- Added source encoding support (based on code by Kevin Dangoor).
(1.0 alpha 3 released)
- Fixed core dump when pages are broken beyond repair (reported by
many, fix proposed by Brad Clements)
(1.0 alpha 2 released)
- Capture error output (available via the 'errlog' attribute on the
parser instance).
(1.0 alpha 1 released -- initial release)
--------------------------------------------------------------------
Software License
--------------------------------------------------------------------
The software components in this package are copyrighted, but can all
be used freely in all sorts of applications.
The _elementtree binding, and associated Python code, is
Copyright (c) 2003-2005 by Fredrik Lundh. All rights reserved.
By obtaining, using, and/or copying this software and/or its
associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:
Permission to use, copy, modify, and distribute this software and its
associated documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appears in all
copies, and that both that copyright notice and this permission notice
appear in supporting documentation, and that the name of Secret Labs
AB or the author not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--------------------------------------------------------------------
The TidyLib library is copyright (c) by 1998-2003 World Wide Web
Consortium. Software license:
HTML Tidy
HTML parser and pretty printer
Copyright (c) 1998-2003 World Wide Web Consortium
(Massachusetts Institute of Technology, European Research
Consortium for Informatics and Mathematics, Keio University).
All Rights Reserved.
This software and documentation is provided "as is," and
the copyright holders and contributing author(s) make no
representations or warranties, express or implied, including
but not limited to, warranties of merchantability or fitness
for any particular purpose or that the use of the software or
documentation will not infringe any third party patents,
copyrights, trademarks or other rights.
The copyright holders and contributing author(s) will not be held
liable for any direct, indirect, special or consequential damages
arising out of any use of the software or documentation, even if
advised of the possibility of such damage.
Permission is hereby granted to use, copy, modify, and distribute
this source code, or portions hereof, documentation and executables,
for any purpose, without fee, subject to the following restrictions:
1. The origin of this source code must not be misrepresented.
2. Altered versions must be plainly marked as such and must
not be misrepresented as being the original source.
3. This Copyright notice may not be removed or altered from any
source or altered source distribution.
The copyright holders and contributing author(s) specifically
permit, without fee, and encourage the use of this source code
as a component for supporting the Hypertext Markup Language in
commercial products. If you use this source code in a product,
acknowledgment is not required but would be appreciated.
(from http://tidy.sourceforge.net/license.html)
--------------------------------------------------------------------
elementtidy-1.0-20050212.orig/PKG-INFO 0000644 0000000 0000000 00000000454 10226463350 015324 0 ustar root root Metadata-Version: 1.0
Name: elementtidy
Version: 1.0-20050212
Summary: ElementTidy - a tidylib interface for ElementTree
Home-page: http://effbot.org/zone/element-tidylib.htm
Author: Fredrik Lundh
Author-email: fredrik@pythonware.com
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
elementtidy-1.0-20050212.orig/selftest.py 0000644 0000000 0000000 00000004006 10226463350 016427 0 ustar root root # $Id: selftest.py 1758 2004-03-28 17:36:59Z fredrik $
# -*- coding: iso-8859-1 -*-
# elementtidy selftest program (in progress)
from elementtree import ElementTree
def sanity():
"""
Make sure everything can be imported.
>>> import _elementtidy
>>> from elementtidy.TidyHTMLTreeBuilder import *
"""
HTML1 = "Foo- Foo!
- едц"
XML1 = """\
Foo
Foo!
åäö
"""
def check(a, b):
import re
a = ElementTree.tostring(ElementTree.XML(a))
a = re.sub("HTML Tidy[^\"]+", "TIDY", a)
a = re.sub("\r\n", "\n", a)
if a != b:
print a
print "Expected:"
print b
def testdriver():
"""
Check basic driver interface.
>>> import _elementtidy
>>> xml, errors = _elementtidy.fixup(HTML1)
>>> check(xml, XML1)
"""
def testencoding():
"""
Check basic driver interface.
>>> import _elementtidy
>>> xml, errors = _elementtidy.fixup(HTML1, 'ascii')
>>> check(xml, XML1)
>>> xml, errors = _elementtidy.fixup(HTML1, 'latin1')
>>> check(xml, XML1)
"""
def xmltoolkit35():
"""
@XMLTOOLKIT35
elementtidy crashes on really broken pages.
>>> import _elementtidy
>>> xml, errors = _elementtidy.fixup("")
>>> tree = ElementTree.XML(xml)
"""
def xmltoolkit48():
"""
@XMLTOOLKIT48
elementtidy gives up on some pages.
>>> import _elementtidy
>>> html = ""
>>> xml, errors = _elementtidy.fixup(html)
>>> tree = ElementTree.XML(xml)
"""
if __name__ == "__main__":
import doctest, selftest
failed, tested = doctest.testmod(selftest)
print tested - failed, "tests ok."
elementtidy-1.0-20050212.orig/tidylib/ 0000755 0000000 0000000 00000000000 10226463350 015664 5 ustar root root elementtidy-1.0-20050212.orig/tidylib/src/ 0000755 0000000 0000000 00000000000 10226463352 016455 5 ustar root root elementtidy-1.0-20050212.orig/tidylib/src/tidylib.c 0000644 0000000 0000000 00000115512 10226463352 020266 0 ustar root root /* tidylib.c -- internal library definitions
(c) 1998-2003 (W3C) MIT, ERCIM, Keio University
See tidy.h for the copyright notice.
CVS Info :
$LastChangedBy$
$LastChangedDate$
$LastChangedRevision$
Defines HTML Tidy API implemented by tidy library.
Very rough initial cut for discussion purposes.
Public interface is const-correct and doesn't explicitly depend
on any globals. Thus, thread-safety may be introduced w/out
changing the interface.
Looking ahead to a C++ wrapper, C functions always pass
this-equivalent as 1st arg.
Created 2001-05-20 by Charles Reitzel
*/
#include
#include "tidy-int.h"
#include "parser.h"
#include "clean.h"
#include "config.h"
#include "message.h"
#include "pprint.h"
#include "entities.h"
#include "tmbstr.h"
#include "utf8.h"
#ifdef TIDY_WIN32_MLANG_SUPPORT
#include "win32tc.h"
#endif
#ifdef NEVER
TidyDocImpl* tidyDocToImpl( TidyDoc tdoc )
{
return (TidyDocImpl*) tdoc;
}
TidyDoc tidyImplToDoc( TidyDocImpl* impl )
{
return (TidyDoc) impl;
}
Node* tidyNodeToImpl( TidyNode tnod )
{
return (Node*) tnod;
}
TidyNode tidyImplToNode( Node* node )
{
return (TidyNode) node;
}
AttVal* tidyAttrToImpl( TidyAttr tattr )
{
return (AttVal*) tattr;
}
TidyAttr tidyImplToAttr( AttVal* attval )
{
return (TidyAttr) attval;
}
const TidyOptionImpl* tidyOptionToImpl( TidyOption topt )
{
return (const TidyOptionImpl*) topt;
}
TidyOption tidyImplToOption( const TidyOptionImpl* option )
{
return (TidyOption) option;
}
#endif
/* Tidy public interface
**
** Most functions return an integer:
**
** 0 -> SUCCESS
** >0 -> WARNING
** <0 -> ERROR
**
*/
TidyDoc tidyCreate(void)
{
TidyDocImpl* impl = tidyDocCreate();
return tidyImplToDoc( impl );
}
void tidyRelease( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
tidyDocRelease( impl );
}
TidyDocImpl* tidyDocCreate(void)
{
TidyDocImpl* doc = MemAlloc( sizeof(TidyDocImpl) );
ClearMemory( doc, sizeof(*doc) );
InitMap();
InitTags( doc );
InitAttrs( doc );
InitConfig( doc );
InitPrintBuf( doc );
/* By default, wire tidy messages to standard error.
** Document input will be set by parsing routines.
** Document output will be set by pretty print routines.
** Config input will be set by config parsing routines.
** But we need to start off with a way to report errors.
*/
doc->errout = StdErrOutput();
return doc;
}
void tidyDocRelease( TidyDocImpl* doc )
{
/* doc in/out opened and closed by parse/print routines */
if ( doc )
{
assert( doc->docIn == NULL );
assert( doc->docOut == NULL );
ReleaseStreamOut( doc->errout );
doc->errout = NULL;
FreePrintBuf( doc );
FreeLexer( doc );
FreeNode(doc, &doc->root);
ClearMemory(&doc->root, sizeof(Node));
FreeNode( doc, doc->givenDoctype );
FreeConfig( doc );
FreeAttrTable( doc );
FreeTags( doc );
MemFree( doc );
}
}
/* Let application store a chunk of data w/ each Tidy tdocance.
** Useful for callbacks.
*/
void tidySetAppData( TidyDoc tdoc, ulong appData )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
impl->appData = appData;
}
ulong tidyGetAppData( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return impl->appData;
return 0;
}
ctmbstr tidyReleaseDate(void)
{
return ReleaseDate();
}
/* Get/set configuration options
*/
Bool tidySetOptionCallback( TidyDoc tdoc, TidyOptCallback pOptCallback )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
impl->pOptCallback = pOptCallback;
return yes;
}
return -EINVAL;
}
int tidyLoadConfig( TidyDoc tdoc, ctmbstr cfgfil )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ParseConfigFile( impl, cfgfil );
return -EINVAL;
}
int tidyLoadConfigEnc( TidyDoc tdoc, ctmbstr cfgfil, ctmbstr charenc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ParseConfigFileEnc( impl, cfgfil, charenc );
return -EINVAL;
}
int tidySetCharEncoding( TidyDoc tdoc, ctmbstr encnam )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
int enc = CharEncodingId( encnam );
if ( enc >= 0 && AdjustCharEncoding(impl, enc) )
return 0;
ReportBadArgument( impl, "char-encoding" );
}
return -EINVAL;
}
TidyOptionId tidyOptGetIdForName( ctmbstr optnam )
{
const TidyOptionImpl* option = lookupOption( optnam );
if ( option )
return option->id;
return N_TIDY_OPTIONS; /* Error */
}
TidyIterator tidyGetOptionList( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return getOptionList( impl );
return (TidyIterator) -1;
}
TidyOption tidyGetNextOption( TidyDoc tdoc, TidyIterator* pos )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
const TidyOptionImpl* option = NULL;
if ( impl )
option = getNextOption( impl, pos );
else if ( pos )
*pos = 0;
return tidyImplToOption( option );
}
TidyOption tidyGetOption( TidyDoc tdoc, TidyOptionId optId )
{
const TidyOptionImpl* option = getOption( optId );
return tidyImplToOption( option );
}
TidyOption tidyGetOptionByName( TidyDoc doc, ctmbstr optnam )
{
const TidyOptionImpl* option = lookupOption( optnam );
return tidyImplToOption( option );
}
TidyOptionId tidyOptGetId( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return option->id;
return N_TIDY_OPTIONS;
}
ctmbstr tidyOptGetName( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return option->name;
return NULL;
}
TidyOptionType tidyOptGetType( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return option->type;
return (TidyOptionType) -1;
}
TidyConfigCategory tidyOptGetCategory( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return option->category;
return (TidyConfigCategory) -1;
}
ctmbstr tidyOptGetDefault( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option && option->type == TidyString )
return (ctmbstr) option->dflt;
return NULL;
}
ulong tidyOptGetDefaultInt( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option && option->type != TidyString )
return option->dflt;
return ~0U;
}
Bool tidyOptGetDefaultBool( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option && option->type != TidyString )
return ( option->dflt ? yes : no );
return no;
}
Bool tidyOptIsReadOnly( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return ( option->parser == NULL );
return yes;
}
TidyIterator tidyOptGetPickList( TidyOption topt )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return getOptionPickList( option );
return (TidyIterator) -1;
}
ctmbstr tidyOptGetNextPick( TidyOption topt, TidyIterator* pos )
{
const TidyOptionImpl* option = tidyOptionToImpl( topt );
if ( option )
return getNextOptionPick( option, pos );
return NULL;
}
ctmbstr tidyOptGetValue( TidyDoc tdoc, TidyOptionId optId )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
ctmbstr optval = NULL;
if ( impl )
optval = cfgStr( impl, optId );
return optval;
}
Bool tidyOptSetValue( TidyDoc tdoc, TidyOptionId optId, ctmbstr val )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ParseConfigValue( impl, optId, val );
return no;
}
Bool tidyOptParseValue( TidyDoc tdoc, ctmbstr optnam, ctmbstr val )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ParseConfigOption( impl, optnam, val );
return no;
}
ulong tidyOptGetInt( TidyDoc tdoc, TidyOptionId optId )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
ulong opti = 0;
if ( impl )
opti = cfg( impl, optId );
return opti;
}
Bool tidyOptSetInt( TidyDoc tdoc, TidyOptionId optId, ulong val )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return SetOptionInt( impl, optId, val );
return no;
}
Bool tidyOptGetBool( TidyDoc tdoc, TidyOptionId optId )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
Bool optb = no;
if ( impl )
{
const TidyOptionImpl* option = getOption( optId );
if ( option )
{
optb = cfgBool( impl, optId );
}
}
return optb;
}
Bool tidyOptSetBool( TidyDoc tdoc, TidyOptionId optId, Bool val )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return SetOptionBool( impl, optId, val );
return no;
}
ctmbstr tidyOptGetEncName( TidyDoc tdoc, TidyOptionId optId )
{
uint enc = tidyOptGetInt( tdoc, optId );
return CharEncodingName( enc );
}
ctmbstr tidyOptGetCurrPick( TidyDoc tdoc, TidyOptionId optId )
{
const TidyOptionImpl* option = getOption( optId );
if ( option && option->pickList )
{
uint ix, pick = tidyOptGetInt( tdoc, optId );
const ctmbstr* pL = option->pickList;
for ( ix=0; *pL && ix < pick; ++ix )
++pL;
if ( *pL )
return *pL;
}
return NULL;
}
TidyIterator tidyOptGetDeclTagList( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
TidyIterator declIter = 0;
if ( impl )
declIter = GetDeclaredTagList( impl );
return declIter;
}
ctmbstr tidyOptGetNextDeclTag( TidyDoc tdoc, TidyOptionId optId,
TidyIterator* iter )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
ctmbstr tagnam = NULL;
if ( impl )
{
int tagtyp = 0;
if ( optId == TidyInlineTags )
tagtyp = tagtype_inline;
else if ( optId == TidyBlockTags )
tagtyp = tagtype_block;
else if ( optId == TidyEmptyTags )
tagtyp = tagtype_empty;
else if ( optId == TidyPreTags )
tagtyp = tagtype_pre;
if ( tagtyp )
tagnam = GetNextDeclaredTag( impl, tagtyp, iter );
}
return tagnam;
}
int tidyOptSaveFile( TidyDoc tdoc, ctmbstr cfgfil )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return SaveConfigFile( impl, cfgfil );
return -EINVAL;
}
int tidyOptSaveSink( TidyDoc tdoc, TidyOutputSink* sink )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return SaveConfigSink( impl, sink );
return -EINVAL;
}
Bool tidyOptSnapshot( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
TakeConfigSnapshot( impl );
return yes;
}
return no;
}
Bool tidyOptResetToSnapshot( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
ResetConfigToSnapshot( impl );
return yes;
}
return no;
}
Bool tidyOptResetAllToDefault( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
ResetConfigToDefault( impl );
return yes;
}
return no;
}
Bool tidyOptResetToDefault( TidyDoc tdoc, TidyOptionId optId )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ResetOptionToDefault( impl, optId );
return no;
}
Bool tidyOptDiffThanDefault( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ConfigDiffThanDefault( impl );
return no;
}
Bool tidyOptDiffThanSnapshot( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return ConfigDiffThanSnapshot( impl );
return no;
}
Bool tidyOptCopyConfig( TidyDoc to, TidyDoc from )
{
TidyDocImpl* docTo = tidyDocToImpl( to );
TidyDocImpl* docFrom = tidyDocToImpl( from );
if ( docTo && docFrom )
{
CopyConfig( docTo, docFrom );
return yes;
}
return no;
}
/* I/O and Message handling interface
**
** By default, Tidy will define, create and use
** tdocances of input and output handlers for
** standard C buffered I/O (i.e. FILE* stdin,
** FILE* stdout and FILE* stderr for content
** input, content output and diagnostic output,
** respectively. A FILE* cfgFile input handler
** will be used for config files. Command line
** options will just be set directly.
*/
/* Use TidyReportFilter to filter messages by diagnostic level:
** info, warning, etc. Just set diagnostic output
** handler to redirect all diagnostics output. Return true
** to proceed with output, false to cancel.
*/
Bool tidySetReportFilter( TidyDoc tdoc, TidyReportFilter filt )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
impl->mssgFilt = filt;
return yes;
}
return -EINVAL;
}
#if 0 /* Not yet */
int tidySetContentOutputSink( TidyDoc tdoc, TidyOutputSink* outp )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
impl->docOut = outp;
return 0;
}
return -EINVAL;
}
int tidySetDiagnosticOutputSink( TidyDoc tdoc, TidyOutputSink* outp )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
impl->msgOut = outp;
return 0;
}
return -EINVAL;
}
/* Library helpers
*/
cmbstr tidyLookupMessage( TidyDoc tdoc, int errorNo )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
cmbstr mssg = NULL;
if ( impl )
mssg = tidyMessage_Lookup( impl->messages, errorNo );
return mssg;
}
#endif
FILE* tidySetErrorFile( TidyDoc tdoc, ctmbstr errfilnam )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
FILE* errout = fopen( errfilnam, "wb" );
if ( errout )
{
uint outenc = cfg( impl, TidyOutCharEncoding );
uint nl = cfg( impl, TidyNewline );
ReleaseStreamOut( impl->errout );
impl->errout = FileOutput( errout, outenc, nl );
return errout;
}
else /* Emit message to current error sink */
FileError( impl, errfilnam, TidyError );
}
return NULL;
}
int tidySetErrorBuffer( TidyDoc tdoc, TidyBuffer* errbuf )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
uint outenc = cfg( impl, TidyOutCharEncoding );
uint nl = cfg( impl, TidyNewline );
ReleaseStreamOut( impl->errout );
impl->errout = BufferOutput( errbuf, outenc, nl );
return ( impl->errout ? 0 : -ENOMEM );
}
return -EINVAL;
}
int tidySetErrorSink( TidyDoc tdoc, TidyOutputSink* sink )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
{
uint outenc = cfg( impl, TidyOutCharEncoding );
uint nl = cfg( impl, TidyNewline );
ReleaseStreamOut( impl->errout );
impl->errout = UserOutput( sink, outenc, nl );
return ( impl->errout ? 0 : -ENOMEM );
}
return -EINVAL;
}
/* Document info */
int tidyStatus( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
int stat = -EINVAL;
if ( impl )
stat = tidyDocStatus( impl );
return stat;
}
int tidyDetectedHtmlVersion( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
return 0;
}
Bool tidyDetectedXhtml( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
return no;
}
Bool tidyDetectedGenericXml( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
return no;
}
uint tidyErrorCount( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
uint count = 0xFFFFFFFF;
if ( impl )
count = impl->errors;
return count;
}
uint tidyWarningCount( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
uint count = 0xFFFFFFFF;
if ( impl )
count = impl->warnings;
return count;
}
uint tidyAccessWarningCount( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
uint count = 0xFFFFFFFF;
if ( impl )
count = impl->accessErrors;
return count;
}
uint tidyConfigErrorCount( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
uint count = 0xFFFFFFFF;
if ( impl )
count = impl->optionErrors;
return count;
}
/* Error reporting functions
*/
void tidyErrorSummary( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
ErrorSummary( impl );
}
void tidyGeneralInfo( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
GeneralInfo( impl );
}
/* I/O Functions
**
** Initial version supports only whole-file operations.
** Do not expose Tidy StreamIn or Out data structures - yet.
*/
/* Parse/load Functions
**
** HTML/XHTML version determined from input.
*/
int tidyParseFile( TidyDoc tdoc, ctmbstr filnam )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocParseFile( doc, filnam );
}
int tidyParseStdin( TidyDoc tdoc )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocParseStdin( doc );
}
int tidyParseString( TidyDoc tdoc, ctmbstr content )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocParseString( doc, content );
}
int tidyParseBuffer( TidyDoc tdoc, TidyBuffer* inbuf )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocParseBuffer( doc, inbuf );
}
int tidyParseSource( TidyDoc tdoc, TidyInputSource* source )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocParseSource( doc, source );
}
int tidyDocParseFile( TidyDocImpl* doc, ctmbstr filnam )
{
int status = -ENOENT;
FILE* fin = fopen( filnam, "rb" );
#if PRESERVE_FILE_TIMES
struct stat sbuf = {0};
/* get last modified time */
ClearMemory( &doc->filetimes, sizeof(doc->filetimes) );
if ( fin && cfgBool(doc,TidyKeepFileTimes) &&
fstat(fileno(fin), &sbuf) != -1 )
{
doc->filetimes.actime = sbuf.st_atime;
doc->filetimes.modtime = sbuf.st_mtime;
}
#endif
if ( fin )
{
StreamIn* in = FileInput( doc, fin, cfg( doc, TidyInCharEncoding ));
status = tidyDocParseStream( doc, in );
freeFileSource(&in->source, yes);
MemFree(in);
}
else /* Error message! */
FileError( doc, filnam, TidyError );
return status;
}
int tidyDocParseStdin( TidyDocImpl* doc )
{
StreamIn* in = FileInput( doc, stdin, cfg( doc, TidyInCharEncoding ));
int status = tidyDocParseStream( doc, in );
MemFree( in );
return status;
}
int tidyDocParseBuffer( TidyDocImpl* doc, TidyBuffer* inbuf )
{
int status = -EINVAL;
if ( inbuf )
{
StreamIn* in = BufferInput( doc, inbuf, cfg( doc, TidyInCharEncoding ));
status = tidyDocParseStream( doc, in );
MemFree( in );
}
return status;
}
int tidyDocParseString( TidyDocImpl* doc, ctmbstr content )
{
int status = -EINVAL;
TidyBuffer inbuf = {0};
StreamIn* in = NULL;
if ( content )
{
tidyBufAttach( &inbuf, (void*)content, tmbstrlen(content)+1 );
in = BufferInput( doc, &inbuf, cfg( doc, TidyInCharEncoding ));
status = tidyDocParseStream( doc, in );
tidyBufDetach( &inbuf );
MemFree( in );
}
return status;
}
int tidyDocParseSource( TidyDocImpl* doc, TidyInputSource* source )
{
StreamIn* in = UserInput( doc, source, cfg( doc, TidyInCharEncoding ));
int status = tidyDocParseStream( doc, in );
MemFree( in );
return status;
}
/* Print/save Functions
**
*/
int tidySaveFile( TidyDoc tdoc, ctmbstr filnam )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveFile( doc, filnam );
}
int tidySaveStdout( TidyDoc tdoc )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveStdout( doc );
}
int tidySaveString( TidyDoc tdoc, tmbstr buffer, uint* buflen )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveString( doc, buffer, buflen );
}
int tidySaveBuffer( TidyDoc tdoc, TidyBuffer* outbuf )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveBuffer( doc, outbuf );
}
int tidySaveSink( TidyDoc tdoc, TidyOutputSink* sink )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
return tidyDocSaveSink( doc, sink );
}
int tidyDocSaveFile( TidyDocImpl* doc, ctmbstr filnam )
{
int status = -ENOENT;
FILE* fout = NULL;
/* Don't zap input file if no output */
if ( doc->errors > 0 &&
cfgBool(doc, TidyWriteBack) && !cfgBool(doc, TidyForceOutput) )
status = tidyDocStatus( doc );
else
fout = fopen( filnam, "wb" );
if ( fout )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = FileOutput( fout, outenc, nl );
status = tidyDocSaveStream( doc, out );
fclose( fout );
MemFree( out );
#if PRESERVE_FILE_TIMES
if ( doc->filetimes.actime )
{
/* set file last accessed/modified times to original values */
utime( filnam, &doc->filetimes );
ClearMemory( &doc->filetimes, sizeof(doc->filetimes) );
}
#endif /* PRESERVFILETIMES */
}
if ( status < 0 ) /* Error message! */
FileError( doc, filnam, TidyError );
return status;
}
/* Note, _setmode() does NOT work on Win2K Pro w/ VC++ 6.0 SP3.
** The code has been left in in case it works w/ other compilers
** or operating systems. If stdout is in Text mode, be aware that
** it will garble UTF16 documents. In text mode, when it encounters
** a single byte of value 10 (0xA), it will insert a single byte
** value 13 (0xD) just before it. This has the effect of garbling
** the entire document.
*/
#if !defined(NO_SETMODE_SUPPORT)
#if defined(_WIN32) || defined(OS2_OS)
#include
#include
#endif
#endif
int tidyDocSaveStdout( TidyDocImpl* doc )
{
int oldstdoutmode = -1, oldstderrmode = -1, status = 0;
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = FileOutput( stdout, outenc, nl );
#if !defined(NO_SETMODE_SUPPORT)
#if defined(_WIN32) || defined(OS2_OS)
oldstdoutmode = setmode( fileno(stdout), _O_BINARY );
oldstderrmode = setmode( fileno(stderr), _O_BINARY );
#if SUPPORT_UTF16_ENCODINGS && 0 /* fix for bug 723948 */
if ( out->encoding == UTF16 ||
out->encoding == UTF16LE ||
out->encoding == UTF16BE )
{
ReportError(doc, NULL, doc->root, ENCODING_IO_CONFLICT );
}
#endif
#endif
#endif
if ( 0 == status )
status = tidyDocSaveStream( doc, out );
fflush(stdout);
fflush(stderr);
#if !defined(NO_SETMODE_SUPPORT)
#if defined(_WIN32) || defined(OS2_OS)
if ( oldstdoutmode != -1 )
oldstdoutmode = setmode( fileno(stdout), oldstdoutmode );
if ( oldstderrmode != -1 )
oldstderrmode = setmode( fileno(stderr), oldstderrmode );
#endif
#endif
MemFree( out );
return status;
}
int tidyDocSaveString( TidyDocImpl* doc, tmbstr buffer, uint* buflen )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
TidyBuffer outbuf = {0};
StreamOut* out = BufferOutput( &outbuf, outenc, nl );
int status = tidyDocSaveStream( doc, out );
if ( outbuf.size > *buflen )
status = -ENOMEM;
else
memcpy( buffer, outbuf.bp, outbuf.size );
*buflen = outbuf.size;
tidyBufFree( &outbuf );
MemFree( out );
return status;
}
int tidyDocSaveBuffer( TidyDocImpl* doc, TidyBuffer* outbuf )
{
int status = -EINVAL;
if ( outbuf )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = BufferOutput( outbuf, outenc, nl );
status = tidyDocSaveStream( doc, out );
MemFree( out );
}
return status;
}
int tidyDocSaveSink( TidyDocImpl* doc, TidyOutputSink* sink )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = UserOutput( sink, outenc, nl );
int status = tidyDocSaveStream( doc, out );
MemFree( out );
return status;
}
int tidyDocStatus( TidyDocImpl* doc )
{
if ( doc->errors > 0 )
return 2;
if ( doc->warnings > 0 || doc->accessErrors > 0 )
return 1;
return 0;
}
int tidyCleanAndRepair( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return tidyDocCleanAndRepair( impl );
return -EINVAL;
}
int tidyRunDiagnostics( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
if ( impl )
return tidyDocRunDiagnostics( impl );
return -EINVAL;
}
/* Workhorse functions.
**
** Parse requires input source, all input config items
** and diagnostic sink to have all been set before calling.
**
** Emit likewise requires that document sink and all
** pretty printing options have been set.
*/
static ctmbstr integrity = "\nPanic - tree has lost its integrity\n";
int tidyDocParseStream( TidyDocImpl* doc, StreamIn* in )
{
int status = -EINVAL;
Bool xmlIn = cfgBool( doc, TidyXmlTags );
int bomEnc;
assert( doc != NULL && in != NULL );
assert( doc->docIn == NULL );
doc->docIn = in;
TakeConfigSnapshot( doc ); /* Save config state */
FreeLexer( doc );
FreeAnchors( doc );
FreeNode(doc, &doc->root);
ClearMemory(&doc->root, sizeof(Node));
FreeNode( doc, doc->givenDoctype );
doc->givenDoctype = NULL;
doc->lexer = NewLexer( doc );
/* doc->lexer->root = &doc->root; */
doc->root.line = doc->lexer->lines;
doc->root.column = doc->lexer->columns;
doc->inputHadBOM = no;
bomEnc = ReadBOMEncoding(in);
if (bomEnc != -1)
{
in->encoding = bomEnc;
SetOptionInt(doc, TidyInCharEncoding, bomEnc);
}
#ifdef TIDY_WIN32_MLANG_SUPPORT
if (in->encoding > WIN32MLANG)
Win32MLangInitInputTranscoder(in, in->encoding);
#endif /* TIDY_WIN32_MLANG_SUPPORT */
/* Tidy doesn't alter the doctype for generic XML docs */
if ( xmlIn )
{
ParseXMLDocument( doc );
if ( !CheckNodeIntegrity( &doc->root ) )
FatalError( integrity );
}
else
{
doc->warnings = 0;
ParseDocument( doc );
if ( !CheckNodeIntegrity( &doc->root ) )
FatalError( integrity );
}
#ifdef TIDY_WIN32_MLANG_SUPPORT
Win32MLangUninitInputTranscoder(in);
#endif /* TIDY_WIN32_MLANG_SUPPORT */
doc->docIn = NULL;
return tidyDocStatus( doc );
}
int tidyDocRunDiagnostics( TidyDocImpl* doc )
{
uint acclvl = cfg( doc, TidyAccessibilityCheckLevel );
Bool quiet = cfgBool( doc, TidyQuiet );
Bool force = cfgBool( doc, TidyForceOutput );
if ( !quiet )
{
ReportMarkupVersion( doc );
ReportNumWarnings( doc );
}
if ( doc->errors > 0 && !force )
NeedsAuthorIntervention( doc );
#if SUPPORT_ACCESSIBILITY_CHECKS
if ( acclvl > 0 )
AccessibilityChecks( doc );
#endif
return tidyDocStatus( doc );
}
int tidyDocCleanAndRepair( TidyDocImpl* doc )
{
Bool word2K = cfgBool( doc, TidyWord2000 );
Bool logical = cfgBool( doc, TidyLogicalEmphasis );
Bool clean = cfgBool( doc, TidyMakeClean );
Bool dropFont = cfgBool( doc, TidyDropFontTags );
Bool htmlOut = cfgBool( doc, TidyHtmlOut );
Bool xmlOut = cfgBool( doc, TidyXmlOut );
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
Bool xmlDecl = cfgBool( doc, TidyXmlDecl );
Bool tidyMark = cfgBool( doc, TidyMark );
/* simplifies ... ... etc. */
NestedEmphasis( doc, &doc->root );
/* cleans up indented text etc. */
List2BQ( doc, &doc->root );
BQ2Div( doc, &doc->root );
/* replaces i by em and b by strong */
if ( logical )
EmFromI( doc, &doc->root );
if ( word2K && IsWord2000(doc) )
{
/* prune Word2000's ... */
DropSections( doc, &doc->root );
/* drop style & class attributes and empty p, span elements */
CleanWord2000( doc, &doc->root );
}
/* replaces presentational markup by style rules */
if ( clean || dropFont )
CleanDocument( doc );
/* Move terminating
tags from out of paragraphs */
/*! Do we want to do this for all block-level elements? */
FixBrakes( doc, FindBody( doc ));
/* Reconcile http-equiv meta element with output encoding */
if (cfg( doc, TidyOutCharEncoding) != RAW
#ifndef NO_NATIVE_ISO2022_SUPPORT
&& cfg( doc, TidyOutCharEncoding) != ISO2022
#endif
)
VerifyHTTPEquiv( doc, FindHEAD( doc ));
if ( !CheckNodeIntegrity( &doc->root ) )
FatalError( integrity );
/* remember given doctype for reporting */
doc->givenDoctype = CloneNodeEx( doc, FindDocType(doc) );
if ( doc->root.content )
{
/* If we had XHTML input but want HTML output */
if ( htmlOut && doc->lexer->isvoyager )
{
Node* node = FindDocType( doc );
/* Remove reference, but do not free */
if ( node )
RemoveNode( node );
if ( node = FindHTML(doc) )
{
AttVal* av = AttrGetById( node, TidyAttr_XMLNS );
if ( av )
RemoveAttribute( node, av );
}
}
if ( xhtmlOut && !htmlOut )
SetXHTMLDocType( doc );
else
FixDocType( doc );
if ( tidyMark )
AddGenerator( doc );
}
/* ensure presence of initial */
if ( xmlOut && xmlDecl )
FixXmlDecl( doc );
return tidyDocStatus( doc );
}
int tidyDocSaveStream( TidyDocImpl* doc, StreamOut* out )
{
Bool showMarkup = cfgBool( doc, TidyShowMarkup );
Bool forceOutput = cfgBool( doc, TidyForceOutput );
#if SUPPORT_UTF16_ENCODINGS
Bool outputBOM = ( cfg(doc, TidyOutputBOM) == yes );
Bool smartBOM = ( cfg(doc, TidyOutputBOM) == TidyAutoState );
#endif
Bool xmlOut = cfgBool( doc, TidyXmlOut );
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
Bool bodyOnly = cfgBool( doc, TidyBodyOnly );
Bool dropComments = cfgBool(doc, TidyHideComments);
Bool makeClean = cfgBool(doc, TidyMakeClean);
Bool asciiChars = cfgBool(doc, TidyAsciiChars);
Bool makeBare = cfgBool(doc, TidyMakeBare);
Bool escapeCDATA = cfgBool(doc, TidyEscapeCdata);
if (escapeCDATA)
ConvertCDATANodes(doc, &doc->root);
if (dropComments)
DropComments(doc, &doc->root);
if (makeClean)
{
/* noop */
DropFontElements(doc, &doc->root, NULL);
WbrToSpace(doc, &doc->root);
}
if ((makeClean && asciiChars) || makeBare)
DowngradeTypography(doc, &doc->root);
if (makeBare)
/* Note: no longer replaces in */
/* attribute values / non-text tokens */
NormalizeSpaces(doc->lexer, &doc->root);
else
ReplacePreformattedSpaces(doc, &doc->root);
if ( showMarkup && (doc->errors == 0 || forceOutput) )
{
#if SUPPORT_UTF16_ENCODINGS
/* Output a Byte Order Mark if required */
if ( outputBOM || (doc->inputHadBOM && smartBOM) )
outBOM( out );
#endif
/* No longer necessary. No DOCTYPE == HTML 3.2,
** which gives you only the basic character entities,
** which are safe in any browser.
** if ( !FindDocType(doc) )
** SetOptionBool( doc, TidyNumEntities, yes );
*/
doc->docOut = out;
if ( xmlOut && !xhtmlOut )
PPrintXMLTree( doc, 0, 0, &doc->root );
else if ( bodyOnly )
PrintBody( doc );
else
PPrintTree( doc, 0, 0, &doc->root );
PFlushLine( doc, 0 );
doc->docOut = NULL;
}
ResetConfigToSnapshot( doc );
return tidyDocStatus( doc );
}
/* Tree traversal functions
**
** The big issue here is the degree to which we should mimic
** a DOM and/or SAX nodes.
**
** Is it 100% possible (and, if so, how difficult is it) to
** emit SAX events from this API? If SAX events are possible,
** is that 100% of data needed to build a DOM?
*/
TidyNode tidyGetRoot( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
return tidyImplToNode( &impl->root );
}
TidyNode tidyGetHtml( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
Node* node = NULL;
if ( impl )
node = FindHTML( impl );
return tidyImplToNode( node );
}
TidyNode tidyGetHead( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
Node* node = NULL;
if ( impl )
node = FindHEAD( impl );
return tidyImplToNode( node );
}
TidyNode tidyGetBody( TidyDoc tdoc )
{
TidyDocImpl* impl = tidyDocToImpl( tdoc );
Node* node = NULL;
if ( impl )
node = FindBody( impl );
return tidyImplToNode( node );
}
/* parent / child */
TidyNode tidyGetParent( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
return tidyImplToNode( nimp->parent );
}
TidyNode tidyGetChild( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
return tidyImplToNode( nimp->content );
}
/* siblings */
TidyNode tidyGetNext( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
return tidyImplToNode( nimp->next );
}
TidyNode tidyGetPrev( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
return tidyImplToNode( nimp->prev );
}
/* Node info */
TidyNodeType tidyNodeGetType( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
TidyNodeType ntyp = TidyNode_Root;
if ( nimp )
ntyp = (TidyNodeType) nimp->type;
return ntyp;
}
uint tidyNodeLine( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
uint line = 0;
if ( nimp )
line = nimp->line;
return line;
}
uint tidyNodeColumn( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
uint col = 0;
if ( nimp )
col = nimp->column;
return col;
}
ctmbstr tidyNodeGetName( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
ctmbstr nnam = NULL;
if ( nimp )
nnam = nimp->element;
return nnam;
}
Bool tidyNodeHasText( TidyDoc tdoc, TidyNode tnod )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
if ( doc )
return nodeHasText( doc, tidyNodeToImpl(tnod) );
return no;
}
Bool tidyNodeGetText( TidyDoc tdoc, TidyNode tnod, TidyBuffer* outbuf )
{
TidyDocImpl* doc = tidyDocToImpl( tdoc );
Node* nimp = tidyNodeToImpl( tnod );
if ( doc && nimp && outbuf )
{
uint outenc = cfg( doc, TidyOutCharEncoding );
uint nl = cfg( doc, TidyNewline );
StreamOut* out = BufferOutput( outbuf, outenc, nl );
Bool xmlOut = cfgBool( doc, TidyXmlOut );
Bool xhtmlOut = cfgBool( doc, TidyXhtmlOut );
doc->docOut = out;
if ( xmlOut && !xhtmlOut )
PPrintXMLTree( doc, 0, 0, nimp );
else
PPrintTree( doc, 0, 0, nimp );
PFlushLine( doc, 0 );
doc->docOut = NULL;
MemFree( out );
}
return no;
}
Bool tidyNodeIsProp( TidyDoc tdoc, TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
Bool isProprietary = yes;
if ( nimp )
{
switch ( nimp->type )
{
case RootNode:
case DocTypeTag:
case CommentTag:
case XmlDecl:
case ProcInsTag:
case TextNode:
case CDATATag:
isProprietary = no;
break;
case SectionTag:
case AspTag:
case JsteTag:
case PhpTag:
isProprietary = yes;
break;
case StartTag:
case EndTag:
case StartEndTag:
isProprietary = ( nimp->tag
? (nimp->tag->versions&VERS_PROPRIETARY)!=0
: yes );
break;
}
}
return isProprietary;
}
TidyTagId tidyNodeGetId( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
TidyTagId tagId = TidyTag_UNKNOWN;
if ( nimp )
tagId = nimp->tag->id;
return tagId;
}
/* Null for non-element nodes and all pure HTML
cmbstr tidyNodeNsLocal( TidyNode tnod )
{
}
cmbstr tidyNodeNsPrefix( TidyNode tnod )
{
}
cmbstr tidyNodeNsUri( TidyNode tnod )
{
}
*/
/* Iterate over attribute values */
TidyAttr tidyAttrFirst( TidyNode tnod )
{
Node* nimp = tidyNodeToImpl( tnod );
AttVal* attval = NULL;
if ( nimp )
attval = nimp->attributes;
return tidyImplToAttr( attval );
}
TidyAttr tidyAttrNext( TidyAttr tattr )
{
AttVal* attval = tidyAttrToImpl( tattr );
AttVal* nxtval = NULL;
if ( attval )
nxtval = attval->next;
return tidyImplToAttr( nxtval );
}
ctmbstr tidyAttrName( TidyAttr tattr )
{
AttVal* attval = tidyAttrToImpl( tattr );
ctmbstr anam = NULL;
if ( attval )
anam = attval->attribute;
return anam;
}
ctmbstr tidyAttrValue( TidyAttr tattr )
{
AttVal* attval = tidyAttrToImpl( tattr );
ctmbstr aval = NULL;
if ( attval )
aval = attval->value;
return aval;
}
/* Null for pure HTML
ctmbstr tidyAttrNsLocal( TidyAttr tattr )
{
}
ctmbstr tidyAttrNsPrefix( TidyAttr tattr )
{
}
ctmbstr tidyAttrNsUri( TidyAttr tattr )
{
}
*/
TidyAttrId tidyAttrGetId( TidyAttr tattr )
{
AttVal* attval = tidyAttrToImpl( tattr );
TidyAttrId attrId = TidyAttr_UNKNOWN;
if ( attval && attval->dict )
attrId = attval->dict->id;
return attrId;
}
Bool tidyAttrIsProp( TidyAttr tattr )
{
AttVal* attval = tidyAttrToImpl( tattr );
Bool isProprietary = yes;
if ( attval )
isProprietary = ( attval->dict
? (attval->dict->versions & VERS_PROPRIETARY) != 0
: yes );
return isProprietary;
}
elementtidy-1.0-20050212.orig/tidylib/src/attrask.c 0000644 0000000 0000000 00000011334 10226463351 020273 0 ustar root root /* attrask.c -- Interrogate attribute type
(c) 1998-2003 (W3C) MIT, ERCIM, Keio University
See tidy.h for the copyright notice.
CVS Info:
$LastChangedBy$
$LastChangedDate$
$LastChangedRevision$
*/
#include "tidy-int.h"
#include "tidy.h"
#include "attrs.h"
Bool tidyAttrIsHREF( TidyAttr tattr )
{
return attrIsHREF( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsSRC( TidyAttr tattr )
{
return attrIsSRC( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsID( TidyAttr tattr )
{
return attrIsID( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsNAME( TidyAttr tattr )
{
return attrIsNAME( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsSUMMARY( TidyAttr tattr )
{
return attrIsSUMMARY( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsALT( TidyAttr tattr )
{
return attrIsALT( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsLONGDESC( TidyAttr tattr )
{
return attrIsLONGDESC( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsUSEMAP( TidyAttr tattr )
{
return attrIsUSEMAP( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsISMAP( TidyAttr tattr )
{
return attrIsISMAP( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsLANGUAGE( TidyAttr tattr )
{
return attrIsLANGUAGE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsTYPE( TidyAttr tattr )
{
return attrIsTYPE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsVALUE( TidyAttr tattr )
{
return attrIsVALUE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsCONTENT( TidyAttr tattr )
{
return attrIsCONTENT( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsTITLE( TidyAttr tattr )
{
return attrIsTITLE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsXMLNS( TidyAttr tattr )
{
return attrIsXMLNS( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsDATAFLD( TidyAttr tattr )
{
return attrIsDATAFLD( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsWIDTH( TidyAttr tattr )
{
return attrIsWIDTH( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsHEIGHT( TidyAttr tattr )
{
return attrIsHEIGHT( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsFOR( TidyAttr tattr )
{
return attrIsFOR( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsSELECTED( TidyAttr tattr )
{
return attrIsSELECTED( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsCHECKED( TidyAttr tattr )
{
return attrIsCHECKED( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsLANG( TidyAttr tattr )
{
return attrIsLANG( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsTARGET( TidyAttr tattr )
{
return attrIsTARGET( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsHTTP_EQUIV( TidyAttr tattr )
{
return attrIsHTTP_EQUIV( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsREL( TidyAttr tattr )
{
return attrIsREL( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsEvent( TidyAttr tattr )
{
return attrIsEvent( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnMOUSEMOVE( TidyAttr tattr )
{
return attrIsOnMOUSEMOVE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnMOUSEDOWN( TidyAttr tattr )
{
return attrIsOnMOUSEDOWN( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnMOUSEUP( TidyAttr tattr )
{
return attrIsOnMOUSEUP( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnCLICK( TidyAttr tattr )
{
return attrIsOnCLICK( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnMOUSEOVER( TidyAttr tattr )
{
return attrIsOnMOUSEOVER( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnMOUSEOUT( TidyAttr tattr )
{
return attrIsOnMOUSEOUT( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnKEYDOWN( TidyAttr tattr )
{
return attrIsOnKEYDOWN( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnKEYUP( TidyAttr tattr )
{
return attrIsOnKEYUP( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnKEYPRESS( TidyAttr tattr )
{
return attrIsOnKEYPRESS( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnFOCUS( TidyAttr tattr )
{
return attrIsOnFOCUS( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsOnBLUR( TidyAttr tattr )
{
return attrIsOnBLUR( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsBGCOLOR( TidyAttr tattr )
{
return attrIsBGCOLOR( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsLINK( TidyAttr tattr )
{
return attrIsLINK( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsALINK( TidyAttr tattr )
{
return attrIsALINK( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsVLINK( TidyAttr tattr )
{
return attrIsVLINK( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsTEXT( TidyAttr tattr )
{
return attrIsTEXT( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsSTYLE( TidyAttr tattr )
{
return attrIsSTYLE( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsABBR( TidyAttr tattr )
{
return attrIsABBR( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsCOLSPAN( TidyAttr tattr )
{
return attrIsCOLSPAN( tidyAttrToImpl(tattr) );
}
Bool tidyAttrIsROWSPAN( TidyAttr tattr )
{
return attrIsROWSPAN( tidyAttrToImpl(tattr) );
}
elementtidy-1.0-20050212.orig/tidylib/src/attrget.c 0000644 0000000 0000000 00000013165 10226463351 020300 0 ustar root root /* attrget.c -- Locate attribute value by type
(c) 1998-2003 (W3C) MIT, ERCIM, Keio University
See tidy.h for the copyright notice.
CVS Info:
$LastChangedBy$
$LastChangedDate$
$LastChangedRevision$
*/
#include "tidy-int.h"
#include "tags.h"
#include "attrs.h"
#include "tidy.h"
TidyAttr tidyAttrGetHREF( TidyNode tnod )
{
return tidyImplToAttr( attrGetHREF( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetSRC( TidyNode tnod )
{
return tidyImplToAttr( attrGetSRC( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetID( TidyNode tnod )
{
return tidyImplToAttr( attrGetID( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetNAME( TidyNode tnod )
{
return tidyImplToAttr( attrGetNAME( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetSUMMARY( TidyNode tnod )
{
return tidyImplToAttr( attrGetSUMMARY( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetALT( TidyNode tnod )
{
return tidyImplToAttr( attrGetALT( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetLONGDESC( TidyNode tnod )
{
return tidyImplToAttr( attrGetLONGDESC( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetUSEMAP( TidyNode tnod )
{
return tidyImplToAttr( attrGetUSEMAP( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetISMAP( TidyNode tnod )
{
return tidyImplToAttr( attrGetISMAP( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetLANGUAGE( TidyNode tnod )
{
return tidyImplToAttr( attrGetLANGUAGE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetTYPE( TidyNode tnod )
{
return tidyImplToAttr( attrGetTYPE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetVALUE( TidyNode tnod )
{
return tidyImplToAttr( attrGetVALUE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetCONTENT( TidyNode tnod )
{
return tidyImplToAttr( attrGetCONTENT( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetTITLE( TidyNode tnod )
{
return tidyImplToAttr( attrGetTITLE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetXMLNS( TidyNode tnod )
{
return tidyImplToAttr( attrGetXMLNS( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetDATAFLD( TidyNode tnod )
{
return tidyImplToAttr( attrGetDATAFLD( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetWIDTH( TidyNode tnod )
{
return tidyImplToAttr( attrGetWIDTH( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetHEIGHT( TidyNode tnod )
{
return tidyImplToAttr( attrGetHEIGHT( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetFOR( TidyNode tnod )
{
return tidyImplToAttr( attrGetFOR( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetSELECTED( TidyNode tnod )
{
return tidyImplToAttr( attrGetSELECTED( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetCHECKED( TidyNode tnod )
{
return tidyImplToAttr( attrGetCHECKED( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetLANG( TidyNode tnod )
{
return tidyImplToAttr( attrGetLANG( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetTARGET( TidyNode tnod )
{
return tidyImplToAttr( attrGetTARGET( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetHTTP_EQUIV( TidyNode tnod )
{
return tidyImplToAttr( attrGetHTTP_EQUIV( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetREL( TidyNode tnod )
{
return tidyImplToAttr( attrGetREL( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnMOUSEMOVE( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnMOUSEMOVE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnMOUSEDOWN( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnMOUSEDOWN( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnMOUSEUP( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnMOUSEUP( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnCLICK( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnCLICK( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnMOUSEOVER( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnMOUSEOVER( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnMOUSEOUT( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnMOUSEOUT( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnKEYDOWN( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnKEYDOWN( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnKEYUP( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnKEYUP( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnKEYPRESS( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnKEYPRESS( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnFOCUS( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnFOCUS( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetOnBLUR( TidyNode tnod )
{
return tidyImplToAttr( attrGetOnBLUR( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetBGCOLOR( TidyNode tnod )
{
return tidyImplToAttr( attrGetBGCOLOR( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetLINK( TidyNode tnod )
{
return tidyImplToAttr( attrGetLINK( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetALINK( TidyNode tnod )
{
return tidyImplToAttr( attrGetALINK( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetVLINK( TidyNode tnod )
{
return tidyImplToAttr( attrGetVLINK( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetTEXT( TidyNode tnod )
{
return tidyImplToAttr( attrGetTEXT( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetSTYLE( TidyNode tnod )
{
return tidyImplToAttr( attrGetSTYLE( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetABBR( TidyNode tnod )
{
return tidyImplToAttr( attrGetABBR( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetCOLSPAN( TidyNode tnod )
{
return tidyImplToAttr( attrGetCOLSPAN( tidyNodeToImpl(tnod) ) );
}
TidyAttr tidyAttrGetROWSPAN( TidyNode tnod )
{
return tidyImplToAttr( attrGetROWSPAN( tidyNodeToImpl(tnod) ) );
}
elementtidy-1.0-20050212.orig/tidylib/src/lexer.c 0000644 0000000 0000000 00000321742 10226463352 017751 0 ustar root root /* lexer.c -- Lexer for html parser
(c) 1998-2003 (W3C) MIT, ERCIM, Keio University
See tidy.h for the copyright notice.
CVS Info :
$LastChangedBy$
$LastChangedDate$
$LastChangedRevision$
*/
/*
Given a file stream fp it returns a sequence of tokens.
GetToken(fp) gets the next token
UngetToken(fp) provides one level undo
The tags include an attribute list:
- linked list of attribute/value nodes
- each node has 2 NULL-terminated strings.
- entities are replaced in attribute values
white space is compacted if not in preformatted mode
If not in preformatted mode then leading white space
is discarded and subsequent white space sequences
compacted to single space characters.
If XmlTags is no then Tag names are folded to upper
case and attribute names to lower case.
Not yet done:
- Doctype subset and marked sections
*/
#include "tidy-int.h"
#include "lexer.h"
#include "parser.h"
#include "entities.h"
#include "streamio.h"
#include "message.h"
#include "tmbstr.h"
#include "clean.h"
#include "utf8.h"
#include "streamio.h"
/* Forward references
*/
/* swallows closing '>' */
AttVal *ParseAttrs( TidyDocImpl* doc, Bool *isempty );
Node *CommentToken( Lexer *lexer);
static tmbstr ParseAttribute( TidyDocImpl* doc, Bool* isempty,
Node **asp, Node **php );
static tmbstr ParseValue( TidyDocImpl* doc, ctmbstr name, Bool foldCase,
Bool *isempty, int *pdelim );
static Node *ParseDocTypeDecl(TidyDocImpl* doc);
static void AddAttrToList( AttVal** list, AttVal* av );
/* used to classify characters for lexical purposes */
#define MAP(c) ((unsigned)c < 128 ? lexmap[(unsigned)c] : 0)
uint lexmap[128];
#define IsValidXMLAttrName(name) IsValidXMLID(name)
struct _doctypes
{
uint score;
uint vers;
ctmbstr name;
ctmbstr fpi;
ctmbstr si;
} const W3C_Doctypes[] =
{
{ 2, HT20, "HTML 2.0", "-//IETF//DTD HTML 2.0//EN", NULL, },
{ 2, HT20, "HTML 2.0", "-//IETF//DTD HTML//EN", NULL, },
{ 2, HT20, "HTML 2.0", "-//W3C//DTD HTML 2.0//EN", NULL, },
{ 1, HT32, "HTML 3.2", "-//W3C//DTD HTML 3.2//EN", NULL, },
{ 1, HT32, "HTML 3.2", "-//W3C//DTD HTML 3.2 Final//EN", NULL, },
{ 1, HT32, "HTML 3.2", "-//W3C//DTD HTML 3.2 Draft//EN", NULL, },
{ 6, H40S, "HTML 4.0 Strict", "-//W3C//DTD HTML 4.0//EN", "http://www.w3.org/TR/REC-html40/strict.dtd" },
{ 8, H40T, "HTML 4.0 Transitional", "-//W3C//DTD HTML 4.0 Transitional//EN", "http://www.w3.org/TR/REC-html40/loose.dtd" },
{ 7, H40F, "HTML 4.0 Frameset", "-//W3C//DTD HTML 4.0 Frameset//EN", "http://www.w3.org/TR/REC-html40/frameset.dtd" },
{ 3, H41S, "HTML 4.01 Strict", "-//W3C//DTD HTML 4.01//EN", "http://www.w3.org/TR/html4/strict.dtd" },
{ 5, H41T, "HTML 4.01 Transitional", "-//W3C//DTD HTML 4.01 Transitional//EN", "http://www.w3.org/TR/html4/loose.dtd" },
{ 4, H41F, "HTML 4.01 Frameset", "-//W3C//DTD HTML 4.01 Frameset//EN", "http://www.w3.org/TR/html4/frameset.dtd" },
{ 9, X10S, "XHTML 1.0 Strict", "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" },
{ 11, X10T, "XHTML 1.0 Transitional", "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" },
{ 10, X10F, "XHTML 1.0 Frameset", "-//W3C//DTD XHTML 1.0 Frameset//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd" },
{ 12, XH11, "XHTML 1.1", "-//W3C//DTD XHTML 1.1//EN", "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" },
{ 13, XB10, "XHTML Basic 1.0", "-//W3C//DTD XHTML Basic 1.0//EN", "http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd" },
/* final entry */
{ 0, 0, NULL, NULL, NULL }
};
int HTMLVersion(TidyDocImpl* doc)
{
uint i;
uint j = 0;
uint score = 0;
uint vers = doc->lexer->versions;
uint dtver = doc->lexer->doctype;
TidyDoctypeModes dtmode = cfg(doc, TidyDoctypeMode);
Bool xhtml = (cfgBool(doc, TidyXmlOut) || doc->lexer->isvoyager) &&
!cfgBool(doc, TidyHtmlOut);
Bool html4 = dtmode == TidyDoctypeStrict || dtmode == TidyDoctypeLoose || VERS_FROM40 & dtver;
for (i = 0; W3C_Doctypes[i].name; ++i)
{
if ((xhtml && !(VERS_XHTML & W3C_Doctypes[i].vers)) ||
(html4 && !(VERS_FROM40 & W3C_Doctypes[i].vers)))
continue;
if (vers & W3C_Doctypes[i].vers &&
(W3C_Doctypes[i].score < score || !score))
{
score = W3C_Doctypes[i].score;
j = i;
}
}
if (score)
return W3C_Doctypes[j].vers;
return VERS_UNKNOWN;
}
ctmbstr GetFPIFromVers(uint vers)
{
uint i;
for (i = 0; W3C_Doctypes[i].name; ++i)
if (W3C_Doctypes[i].vers == vers)
return W3C_Doctypes[i].fpi;
return NULL;
}
ctmbstr GetSIFromVers(uint vers)
{
uint i;
for (i = 0; W3C_Doctypes[i].name; ++i)
if (W3C_Doctypes[i].vers == vers)
return W3C_Doctypes[i].si;
return NULL;
}
ctmbstr GetNameFromVers(uint vers)
{
uint i;
for (i = 0; W3C_Doctypes[i].name; ++i)
if (W3C_Doctypes[i].vers == vers)
return W3C_Doctypes[i].name;
return NULL;
}
uint GetVersFromFPI(ctmbstr fpi)
{
uint i;
for (i = 0; W3C_Doctypes[i].name; ++i)
if (tmbstrcasecmp(W3C_Doctypes[i].fpi, fpi) == 0)
return W3C_Doctypes[i].vers;
return 0;
}
/* everything is allowed in proprietary version of HTML */
/* this is handled here rather than in the tag/attr dicts */
void ConstrainVersion(TidyDocImpl* doc, uint vers)
{
doc->lexer->versions &= (vers | VERS_PROPRIETARY);
}
Bool IsWhite(uint c)
{
uint map = MAP(c);
return (Bool)(map & white);
}
Bool IsNewline(uint c)
{
uint map = MAP(c);
return (Bool)(map & newline);
}
Bool IsDigit(uint c)
{
uint map;
map = MAP(c);
return (Bool)(map & digit);
}
Bool IsLetter(uint c)
{
uint map;
map = MAP(c);
return (Bool)(map & letter);
}
Bool IsNamechar(uint c)
{
uint map = MAP(c);
return (Bool)(map & namechar);
}
Bool IsXMLLetter(uint c)
{
return ((c >= 0x41 && c <= 0x5a) ||
(c >= 0x61 && c <= 0x7a) ||
(c >= 0xc0 && c <= 0xd6) ||
(c >= 0xd8 && c <= 0xf6) ||
(c >= 0xf8 && c <= 0xff) ||
(c >= 0x100 && c <= 0x131) ||
(c >= 0x134 && c <= 0x13e) ||
(c >= 0x141 && c <= 0x148) ||
(c >= 0x14a && c <= 0x17e) ||
(c >= 0x180 && c <= 0x1c3) ||
(c >= 0x1cd && c <= 0x1f0) ||
(c >= 0x1f4 && c <= 0x1f5) ||
(c >= 0x1fa && c <= 0x217) ||
(c >= 0x250 && c <= 0x2a8) ||
(c >= 0x2bb && c <= 0x2c1) ||
c == 0x386 ||
(c >= 0x388 && c <= 0x38a) ||
c == 0x38c ||
(c >= 0x38e && c <= 0x3a1) ||
(c >= 0x3a3 && c <= 0x3ce) ||
(c >= 0x3d0 && c <= 0x3d6) ||
c == 0x3da ||
c == 0x3dc ||
c == 0x3de ||
c == 0x3e0 ||
(c >= 0x3e2 && c <= 0x3f3) ||
(c >= 0x401 && c <= 0x40c) ||
(c >= 0x40e && c <= 0x44f) ||
(c >= 0x451 && c <= 0x45c) ||
(c >= 0x45e && c <= 0x481) ||
(c >= 0x490 && c <= 0x4c4) ||
(c >= 0x4c7 && c <= 0x4c8) ||
(c >= 0x4cb && c <= 0x4cc) ||
(c >= 0x4d0 && c <= 0x4eb) ||
(c >= 0x4ee && c <= 0x4f5) ||
(c >= 0x4f8 && c <= 0x4f9) ||
(c >= 0x531 && c <= 0x556) ||
c == 0x559 ||
(c >= 0x561 && c <= 0x586) ||
(c >= 0x5d0 && c <= 0x5ea) ||
(c >= 0x5f0 && c <= 0x5f2) ||
(c >= 0x621 && c <= 0x63a) ||
(c >= 0x641 && c <= 0x64a) ||
(c >= 0x671 && c <= 0x6b7) ||
(c >= 0x6ba && c <= 0x6be) ||
(c >= 0x6c0 && c <= 0x6ce) ||
(c >= 0x6d0 && c <= 0x6d3) ||
c == 0x6d5 ||
(c >= 0x6e5 && c <= 0x6e6) ||
(c >= 0x905 && c <= 0x939) ||
c == 0x93d ||
(c >= 0x958 && c <= 0x961) ||
(c >= 0x985 && c <= 0x98c) ||
(c >= 0x98f && c <= 0x990) ||
(c >= 0x993 && c <= 0x9a8) ||
(c >= 0x9aa && c <= 0x9b0) ||
c == 0x9b2 ||
(c >= 0x9b6 && c <= 0x9b9) ||
(c >= 0x9dc && c <= 0x9dd) ||
(c >= 0x9df && c <= 0x9e1) ||
(c >= 0x9f0 && c <= 0x9f1) ||
(c >= 0xa05 && c <= 0xa0a) ||
(c >= 0xa0f && c <= 0xa10) ||
(c >= 0xa13 && c <= 0xa28) ||
(c >= 0xa2a && c <= 0xa30) ||
(c >= 0xa32 && c <= 0xa33) ||
(c >= 0xa35 && c <= 0xa36) ||
(c >= 0xa38 && c <= 0xa39) ||
(c >= 0xa59 && c <= 0xa5c) ||
c == 0xa5e ||
(c >= 0xa72 && c <= 0xa74) ||
(c >= 0xa85 && c <= 0xa8b) ||
c == 0xa8d ||
(c >= 0xa8f && c <= 0xa91) ||
(c >= 0xa93 && c <= 0xaa8) ||
(c >= 0xaaa && c <= 0xab0) ||
(c >= 0xab2 && c <= 0xab3) ||
(c >= 0xab5 && c <= 0xab9) ||
c == 0xabd ||
c == 0xae0 ||
(c >= 0xb05 && c <= 0xb0c) ||
(c >= 0xb0f && c <= 0xb10) ||
(c >= 0xb13 && c <= 0xb28) ||
(c >= 0xb2a && c <= 0xb30) ||
(c >= 0xb32 && c <= 0xb33) ||
(c >= 0xb36 && c <= 0xb39) ||
c == 0xb3d ||
(c >= 0xb5c && c <= 0xb5d) ||
(c >= 0xb5f && c <= 0xb61) ||
(c >= 0xb85 && c <= 0xb8a) ||
(c >= 0xb8e && c <= 0xb90) ||
(c >= 0xb92 && c <= 0xb95) ||
(c >= 0xb99 && c <= 0xb9a) ||
c == 0xb9c ||
(c >= 0xb9e && c <= 0xb9f) ||
(c >= 0xba3 && c <= 0xba4) ||
(c >= 0xba8 && c <= 0xbaa) ||
(c >= 0xbae && c <= 0xbb5) ||
(c >= 0xbb7 && c <= 0xbb9) ||
(c >= 0xc05 && c <= 0xc0c) ||
(c >= 0xc0e && c <= 0xc10) ||
(c >= 0xc12 && c <= 0xc28) ||
(c >= 0xc2a && c <= 0xc33) ||
(c >= 0xc35 && c <= 0xc39) ||
(c >= 0xc60 && c <= 0xc61) ||
(c >= 0xc85 && c <= 0xc8c) ||
(c >= 0xc8e && c <= 0xc90) ||
(c >= 0xc92 && c <= 0xca8) ||
(c >= 0xcaa && c <= 0xcb3) ||
(c >= 0xcb5 && c <= 0xcb9) ||
c == 0xcde ||
(c >= 0xce0 && c <= 0xce1) ||
(c >= 0xd05 && c <= 0xd0c) ||
(c >= 0xd0e && c <= 0xd10) ||
(c >= 0xd12 && c <= 0xd28) ||
(c >= 0xd2a && c <= 0xd39) ||
(c >= 0xd60 && c <= 0xd61) ||
(c >= 0xe01 && c <= 0xe2e) ||
c == 0xe30 ||
(c >= 0xe32 && c <= 0xe33) ||
(c >= 0xe40 && c <= 0xe45) ||
(c >= 0xe81 && c <= 0xe82) ||
c == 0xe84 ||
(c >= 0xe87 && c <= 0xe88) ||
c == 0xe8a ||
c == 0xe8d ||
(c >= 0xe94 && c <= 0xe97) ||
(c >= 0xe99 && c <= 0xe9f) ||
(c >= 0xea1 && c <= 0xea3) ||
c == 0xea5 ||
c == 0xea7 ||
(c >= 0xeaa && c <= 0xeab) ||
(c >= 0xead && c <= 0xeae) ||
c == 0xeb0 ||
(c >= 0xeb2 && c <= 0xeb3) ||
c == 0xebd ||
(c >= 0xec0 && c <= 0xec4) ||
(c >= 0xf40 && c <= 0xf47) ||
(c >= 0xf49 && c <= 0xf69) ||
(c >= 0x10a0 && c <= 0x10c5) ||
(c >= 0x10d0 && c <= 0x10f6) ||
c == 0x1100 ||
(c >= 0x1102 && c <= 0x1103) ||
(c >= 0x1105 && c <= 0x1107) ||
c == 0x1109 ||
(c >= 0x110b && c <= 0x110c) ||
(c >= 0x110e && c <= 0x1112) ||
c == 0x113c ||
c == 0x113e ||
c == 0x1140 ||
c == 0x114c ||
c == 0x114e ||
c == 0x1150 ||
(c >= 0x1154 && c <= 0x1155) ||
c == 0x1159 ||
(c >= 0x115f && c <= 0x1161) ||
c == 0x1163 ||
c == 0x1165 ||
c == 0x1167 ||
c == 0x1169 ||
(c >= 0x116d && c <= 0x116e) ||
(c >= 0x1172 && c <= 0x1173) ||
c == 0x1175 ||
c == 0x119e ||
c == 0x11a8 ||
c == 0x11ab ||
(c >= 0x11ae && c <= 0x11af) ||
(c >= 0x11b7 && c <= 0x11b8) ||
c == 0x11ba ||
(c >= 0x11bc && c <= 0x11c2) ||
c == 0x11eb ||
c == 0x11f0 ||
c == 0x11f9 ||
(c >= 0x1e00 && c <= 0x1e9b) ||
(c >= 0x1ea0 && c <= 0x1ef9) ||
(c >= 0x1f00 && c <= 0x1f15) ||
(c >= 0x1f18 && c <= 0x1f1d) ||
(c >= 0x1f20 && c <= 0x1f45) ||
(c >= 0x1f48 && c <= 0x1f4d) ||
(c >= 0x1f50 && c <= 0x1f57) ||
c == 0x1f59 ||
c == 0x1f5b ||
c == 0x1f5d ||
(c >= 0x1f5f && c <= 0x1f7d) ||
(c >= 0x1f80 && c <= 0x1fb4) ||
(c >= 0x1fb6 && c <= 0x1fbc) ||
c == 0x1fbe ||
(c >= 0x1fc2 && c <= 0x1fc4) ||
(c >= 0x1fc6 && c <= 0x1fcc) ||
(c >= 0x1fd0 && c <= 0x1fd3) ||
(c >= 0x1fd6 && c <= 0x1fdb) ||
(c >= 0x1fe0 && c <= 0x1fec) ||
(c >= 0x1ff2 && c <= 0x1ff4) ||
(c >= 0x1ff6 && c <= 0x1ffc) ||
c == 0x2126 ||
(c >= 0x212a && c <= 0x212b) ||
c == 0x212e ||
(c >= 0x2180 && c <= 0x2182) ||
(c >= 0x3041 && c <= 0x3094) ||
(c >= 0x30a1 && c <= 0x30fa) ||
(c >= 0x3105 && c <= 0x312c) ||
(c >= 0xac00 && c <= 0xd7a3) ||
(c >= 0x4e00 && c <= 0x9fa5) ||
c == 0x3007 ||
(c >= 0x3021 && c <= 0x3029) ||
(c >= 0x4e00 && c <= 0x9fa5) ||
c == 0x3007 ||
(c >= 0x3021 && c <= 0x3029));
}
Bool IsXMLNamechar(uint c)
{
return (IsXMLLetter(c) ||
c == '.' || c == '_' ||
c == ':' || c == '-' ||
(c >= 0x300 && c <= 0x345) ||
(c >= 0x360 && c <= 0x361) ||
(c >= 0x483 && c <= 0x486) ||
(c >= 0x591 && c <= 0x5a1) ||
(c >= 0x5a3 && c <= 0x5b9) ||
(c >= 0x5bb && c <= 0x5bd) ||
c == 0x5bf ||
(c >= 0x5c1 && c <= 0x5c2) ||
c == 0x5c4 ||
(c >= 0x64b && c <= 0x652) ||
c == 0x670 ||
(c >= 0x6d6 && c <= 0x6dc) ||
(c >= 0x6dd && c <= 0x6df) ||
(c >= 0x6e0 && c <= 0x6e4) ||
(c >= 0x6e7 && c <= 0x6e8) ||
(c >= 0x6ea && c <= 0x6ed) ||
(c >= 0x901 && c <= 0x903) ||
c == 0x93c ||
(c >= 0x93e && c <= 0x94c) ||
c == 0x94d ||
(c >= 0x951 && c <= 0x954) ||
(c >= 0x962 && c <= 0x963) ||
(c >= 0x981 && c <= 0x983) ||
c == 0x9bc ||
c == 0x9be ||
c == 0x9bf ||
(c >= 0x9c0 && c <= 0x9c4) ||
(c >= 0x9c7 && c <= 0x9c8) ||
(c >= 0x9cb && c <= 0x9cd) ||
c == 0x9d7 ||
(c >= 0x9e2 && c <= 0x9e3) ||
c == 0xa02 ||
c == 0xa3c ||
c == 0xa3e ||
c == 0xa3f ||
(c >= 0xa40 && c <= 0xa42) ||
(c >= 0xa47 && c <= 0xa48) ||
(c >= 0xa4b && c <= 0xa4d) ||
(c >= 0xa70 && c <= 0xa71) ||
(c >= 0xa81 && c <= 0xa83) ||
c == 0xabc ||
(c >= 0xabe && c <= 0xac5) ||
(c >= 0xac7 && c <= 0xac9) ||
(c >= 0xacb && c <= 0xacd) ||
(c >= 0xb01 && c <= 0xb03) ||
c == 0xb3c ||
(c >= 0xb3e && c <= 0xb43) ||
(c >= 0xb47 && c <= 0xb48) ||
(c >= 0xb4b && c <= 0xb4d) ||
(c >= 0xb56 && c <= 0xb57) ||
(c >= 0xb82 && c <= 0xb83) ||
(c >= 0xbbe && c <= 0xbc2) ||
(c >= 0xbc6 && c <= 0xbc8) ||
(c >= 0xbca && c <= 0xbcd) ||
c == 0xbd7 ||
(c >= 0xc01 && c <= 0xc03) ||
(c >= 0xc3e && c <= 0xc44) ||
(c >= 0xc46 && c <= 0xc48) ||
(c >= 0xc4a && c <= 0xc4d) ||
(c >= 0xc55 && c <= 0xc56) ||
(c >= 0xc82 && c <= 0xc83) ||
(c >= 0xcbe && c <= 0xcc4) ||
(c >= 0xcc6 && c <= 0xcc8) ||
(c >= 0xcca && c <= 0xccd) ||
(c >= 0xcd5 && c <= 0xcd6) ||
(c >= 0xd02 && c <= 0xd03) ||
(c >= 0xd3e && c <= 0xd43) ||
(c >= 0xd46 && c <= 0xd48) ||
(c >= 0xd4a && c <= 0xd4d) ||
c == 0xd57 ||
c == 0xe31 ||
(c >= 0xe34 && c <= 0xe3a) ||
(c >= 0xe47 && c <= 0xe4e) ||
c == 0xeb1 ||
(c >= 0xeb4 && c <= 0xeb9) ||
(c >= 0xebb && c <= 0xebc) ||
(c >= 0xec8 && c <= 0xecd) ||
(c >= 0xf18 && c <= 0xf19) ||
c == 0xf35 ||
c == 0xf37 ||
c == 0xf39 ||
c == 0xf3e ||
c == 0xf3f ||
(c >= 0xf71 && c <= 0xf84) ||
(c >= 0xf86 && c <= 0xf8b) ||
(c >= 0xf90 && c <= 0xf95) ||
c == 0xf97 ||
(c >= 0xf99 && c <= 0xfad) ||
(c >= 0xfb1 && c <= 0xfb7) ||
c == 0xfb9 ||
(c >= 0x20d0 && c <= 0x20dc) ||
c == 0x20e1 ||
(c >= 0x302a && c <= 0x302f) ||
c == 0x3099 ||
c == 0x309a ||
(c >= 0x30 && c <= 0x39) ||
(c >= 0x660 && c <= 0x669) ||
(c >= 0x6f0 && c <= 0x6f9) ||
(c >= 0x966 && c <= 0x96f) ||
(c >= 0x9e6 && c <= 0x9ef) ||
(c >= 0xa66 && c <= 0xa6f) ||
(c >= 0xae6 && c <= 0xaef) ||
(c >= 0xb66 && c <= 0xb6f) ||
(c >= 0xbe7 && c <= 0xbef) ||
(c >= 0xc66 && c <= 0xc6f) ||
(c >= 0xce6 && c <= 0xcef) ||
(c >= 0xd66 && c <= 0xd6f) ||
(c >= 0xe50 && c <= 0xe59) ||
(c >= 0xed0 && c <= 0xed9) ||
(c >= 0xf20 && c <= 0xf29) ||
c == 0xb7 ||
c == 0x2d0 ||
c == 0x2d1 ||
c == 0x387 ||
c == 0x640 ||
c == 0xe46 ||
c == 0xec6 ||
c == 0x3005 ||
(c >= 0x3031 && c <= 0x3035) ||
(c >= 0x309d && c <= 0x309e) ||
(c >= 0x30fc && c <= 0x30fe));
}
Bool IsLower(uint c)
{
uint map = MAP(c);
return (Bool)(map & lowercase);
}
Bool IsUpper(uint c)
{
uint map = MAP(c);
return (Bool)(map & uppercase);
}
uint ToLower(uint c)
{
uint map = MAP(c);
if (map & uppercase)
c += 'a' - 'A';
return c;
}
uint ToUpper(uint c)
{
uint map = MAP(c);
if (map & lowercase)
c += (uint) ('A' - 'a' );
return c;
}
char FoldCase( TidyDocImpl* doc, tmbchar c, Bool tocaps )
{
if ( !cfgBool(doc, TidyXmlTags) )
{
if ( tocaps )
{
c = (tmbchar) ToUpper(c);
}
else /* force to lower case */
{
c = (tmbchar) ToLower(c);
}
}
return c;
}
/*
return last character in string
this is useful when trailing quotemark
is missing on an attribute
*/
static tmbchar LastChar( tmbstr str )
{
if ( str && *str )
{
int n = tmbstrlen(str);
return str[n-1];
}
return 0;
}
/*
node->type is one of these:
#define TextNode 1
#define StartTag 2
#define EndTag 3
#define StartEndTag 4
*/
Lexer* NewLexer( TidyDocImpl* doc )
{
Lexer* lexer = (Lexer*) MemAlloc( sizeof(Lexer) );
if ( lexer != NULL )
{
ClearMemory( lexer, sizeof(Lexer) );
lexer->lines = 1;
lexer->columns = 1;
lexer->state = LEX_CONTENT;
lexer->versions = (VERS_ALL|VERS_PROPRIETARY);
lexer->doctype = VERS_UNKNOWN;
lexer->root = &doc->root;
}
return lexer;
}
Bool EndOfInput( TidyDocImpl* doc )
{
assert( doc->docIn != NULL );
return ( !doc->docIn->pushed && IsEOF(doc->docIn) );
}
void FreeLexer( TidyDocImpl* doc )
{
Lexer *lexer = doc->lexer;
if ( lexer )
{
FreeStyles( doc );
while ( lexer->istacksize > 0 )
PopInline( doc, NULL );
MemFree( lexer->istack );
MemFree( lexer->lexbuf );
MemFree( lexer );
doc->lexer = NULL;
}
/*
Moved to tidylib.c, as an object really should not be freeing
resources it doesn't "own"
FreeNode( doc, doc->root );
doc->root = NULL;
FreeNode( doc, doc->givenDoctype );
doc->givenDoctype = NULL;
*/
}
/* Lexer uses bigger memory chunks than pprint as
** it must hold the entire input document. not just
** the last line or three.
*/
void AddByte( Lexer *lexer, tmbchar ch )
{
if ( lexer->lexsize + 1 >= lexer->lexlength )
{
tmbstr buf = NULL;
uint allocAmt = lexer->lexlength;
while ( lexer->lexsize + 1 >= allocAmt )
{
if ( allocAmt == 0 )
allocAmt = 8192;
else
allocAmt *= 2;
}
buf = (tmbstr) MemRealloc( lexer->lexbuf, allocAmt );
if ( buf )
{
ClearMemory( buf + lexer->lexlength,
allocAmt - lexer->lexlength );
lexer->lexbuf = buf;
lexer->lexlength = allocAmt;
}
}
lexer->lexbuf[ lexer->lexsize++ ] = ch;
lexer->lexbuf[ lexer->lexsize ] = '\0'; /* debug */
}
static void ChangeChar( Lexer *lexer, tmbchar c )
{
if ( lexer->lexsize > 0 )
{
lexer->lexbuf[ lexer->lexsize-1 ] = c;
}
}
/* store character c as UTF-8 encoded byte stream */
void AddCharToLexer( Lexer *lexer, uint c )
{
int i, err, count = 0;
tmbchar buf[10] = {0};
err = EncodeCharToUTF8Bytes( c, buf, NULL, &count );
if (err)
{
#if 0 && defined(_DEBUG)
fprintf( stderr, "lexer UTF-8 encoding error for U+%x : ", c );
#endif
/* replacement character 0xFFFD encoded as UTF-8 */
buf[0] = (byte) 0xEF;
buf[1] = (byte) 0xBF;
buf[2] = (byte) 0xBD;
count = 3;
}
for ( i = 0; i < count; ++i )
AddByte( lexer, buf[i] );
}
static void AddStringToLexer( Lexer *lexer, ctmbstr str )
{
uint c;
/* Many (all?) compilers will sign-extend signed chars (the default) when
** converting them to unsigned integer values. We must cast our char to
** unsigned char before assigning it to prevent this from happening.
*/
while( 0 != (c = (unsigned char) *str++ ))
AddCharToLexer( lexer, c );
}
/*
No longer attempts to insert missing ';' for unknown
enitities unless one was present already, since this
gives unexpected results.
For example:
was tidied to:
rather than:
My thanks for Maurice Buxton for spotting this.
Also Randy Waki pointed out the following case for the
04 Aug 00 version (bug #433012):
For example:
was tidied to:
rather than:
where "lang" is a known entity (#9001), but browsers would
misinterpret "⟨" because it had a value > 256.
So the case of an apparently known entity with a value > 256 and
missing a semicolon is handled specially.
"ParseEntity" is also a bit of a misnomer - it handles entities and
numeric character references. Invalid NCR's are now reported.
*/
static void ParseEntity( TidyDocImpl* doc, int mode )
{
uint start;
Bool first = yes, semicolon = no, found = no;
Bool isXml = cfgBool( doc, TidyXmlTags );
uint c, ch, startcol, entver = 0;
Lexer* lexer = doc->lexer;
start = lexer->lexsize - 1; /* to start at "&" */
startcol = doc->docIn->curcol - 1;
while ( (c = ReadChar(doc->docIn)) != EndOfStream )
{
if ( c == ';' )
{
semicolon = yes;
break;
}
if (first && c == '#')
{
#if SUPPORT_ASIAN_ENCODINGS
if ( !cfgBool(doc, TidyNCR) ||
cfg(doc, TidyInCharEncoding) == BIG5 ||
cfg(doc, TidyInCharEncoding) == SHIFTJIS )
{
UngetChar('#', doc->docIn);
return;
}
#endif
AddCharToLexer( lexer, c );
first = no;
continue;
}
first = no;
if ( IsNamechar(c) )
{
AddCharToLexer( lexer, c );
continue;
}
/* otherwise put it back */
UngetChar( c, doc->docIn );
break;
}
/* make sure entity is NULL terminated */
lexer->lexbuf[lexer->lexsize] = '\0';
/* Should contrain version to XML/XHTML if '
** is encountered. But this is not possible with
** Tidy's content model bit mask.
*/
if ( tmbstrcmp(lexer->lexbuf+start, "&apos") == 0
&& !cfgBool(doc, TidyXmlOut)
&& !lexer->isvoyager
&& !cfgBool(doc, TidyXhtmlOut) )
ReportEntityError( doc, APOS_UNDEFINED, lexer->lexbuf+start, 39 );
/* Lookup entity code and version
*/
found = EntityInfo( lexer->lexbuf+start, isXml, &ch, &entver );
/* deal with unrecognized or invalid entities */
/* #433012 - fix by Randy Waki 17 Feb 01 */
/* report invalid NCR's - Terry Teague 01 Sep 01 */
if ( !found || (ch >= 128 && ch <= 159) || (ch >= 256 && c != ';') )
{
/* set error position just before offending character */
lexer->lines = doc->docIn->curline;
lexer->columns = startcol;
if (lexer->lexsize > start + 1)
{
if (ch >= 128 && ch <= 159)
{
/* invalid numeric character reference */
int c1 = 0, replaceMode = DISCARDED_CHAR;
if ( ReplacementCharEncoding == WIN1252 )
c1 = DecodeWin1252( ch );
else if ( ReplacementCharEncoding == MACROMAN )
c1 = DecodeMacRoman( ch );
if ( c1 )
replaceMode = REPLACED_CHAR;
if ( c != ';' ) /* issue warning if not terminated by ';' */
ReportEntityError( doc, MISSING_SEMICOLON_NCR,
lexer->lexbuf+start, c );
ReportEncodingError(doc, INVALID_NCR, ch, replaceMode == DISCARDED_CHAR);
if ( c1 )
{
/* make the replacement */
lexer->lexsize = start;
AddCharToLexer( lexer, c1 );
semicolon = no;
}
else
{
/* discard */
lexer->lexsize = start;
semicolon = no;
}
}
else
ReportEntityError( doc, UNKNOWN_ENTITY,
lexer->lexbuf+start, ch );
if (semicolon)
AddCharToLexer( lexer, ';' );
}
else /* naked & */
ReportEntityError( doc, UNESCAPED_AMPERSAND,
lexer->lexbuf+start, ch );
}
else
{
if ( c != ';' ) /* issue warning if not terminated by ';' */
{
/* set error position just before offending chararcter */
lexer->lines = doc->docIn->curline;
lexer->columns = startcol;
ReportEntityError( doc, MISSING_SEMICOLON, lexer->lexbuf+start, c );
}
lexer->lexsize = start;
if ( ch == 160 && (mode & Preformatted) )
ch = ' ';
AddCharToLexer( lexer, ch );
if ( ch == '&' && !cfgBool(doc, TidyQuoteAmpersand) )
AddStringToLexer( lexer, "amp;" );
/* Detect extended vs. basic entities */
ConstrainVersion( doc, entver );
}
}
static tmbchar ParseTagName( TidyDocImpl* doc )
{
Lexer *lexer = doc->lexer;
uint c = lexer->lexbuf[ lexer->txtstart ];
Bool xml = cfgBool(doc, TidyXmlTags);
/* fold case of first character in buffer */
if (!xml && IsUpper(c))
lexer->lexbuf[lexer->txtstart] = (tmbchar) ToLower(c);
while ((c = ReadChar(doc->docIn)) != EndOfStream)
{
if ((!xml && !IsNamechar(c)) ||
(xml && !IsXMLNamechar(c)))
break;
/* fold case of subsequent characters */
if (!xml && IsUpper(c))
c = ToLower(c);
AddCharToLexer(lexer, c);
}
lexer->txtend = lexer->lexsize;
return (tmbchar) c;
}
/*
Used for elements and text nodes
element name is NULL for text nodes
start and end are offsets into lexbuf
which contains the textual content of
all elements in the parse tree.
parent and content allow traversal
of the parse tree in any direction.
attributes are represented as a linked
list of AttVal nodes which hold the
strings for attribute/value pairs.
*/
Node *NewNode(Lexer *lexer)
{
Node* node = (Node*) MemAlloc( sizeof(Node) );
ClearMemory( node, sizeof(Node) );
if ( lexer )
{
node->line = lexer->lines;
node->column = lexer->columns;
}
node->type = TextNode;
return node;
}
/* used to clone heading nodes when split by an
*/
Node *CloneNode( TidyDocImpl* doc, Node *element )
{
Lexer* lexer = doc->lexer;
Node *node = NewNode( lexer );
node->start = lexer->lexsize;
node->end = lexer->lexsize;
if ( element )
{
node->parent = element->parent;
node->type = element->type;
node->closed = element->closed;
node->implicit = element->implicit;
node->tag = element->tag;
node->element = tmbstrdup( element->element );
node->attributes = DupAttrs( doc, element->attributes );
}
return node;
}
/* Just like CloneNode but also copies node->start */
/* and node->end; note that it does not clone the */
/* lexbuf pointed to by these values */
Node *CloneNodeEx( TidyDocImpl* doc, Node *element )
{
Node *node = NULL;
if ( element )
{
node = NewNode( doc->lexer );
node->parent = element->parent;
node->start = element->start;
node->end = element->end;
node->type = element->type;
node->closed = element->closed;
node->implicit = element->implicit;
node->tag = element->tag;
node->element = tmbstrdup( element->element );
node->attributes = DupAttrs( doc, element->attributes );
}
return node;
}
/* free node's attributes */
void FreeAttrs( TidyDocImpl* doc, Node *node )
{
while ( node->attributes )
{
AttVal *av = node->attributes;
if ( av->attribute )
{
if ((attrIsID(av) || attrIsNAME(av)) &&
IsAnchorElement(doc, node) )
{
RemoveAnchorByNode( doc, node );
}
MemFree( av->attribute );
}
MemFree( av->value );
FreeNode( doc, av->asp );
FreeNode( doc, av->php );
node->attributes = av->next;
MemFree(av);
}
}
/* doesn't repair attribute list linkage */
void FreeAttribute( AttVal *av )
{
MemFree( av->attribute );
MemFree( av->value );
MemFree( av );
}
/* remove attribute from node then free it
*/
void RemoveAttribute( Node *node, AttVal *attr )
{
AttVal *av, *prev = NULL;
for ( av = node->attributes; av; av = av->next )
{
if ( av == attr )
{
if ( prev )
prev->next = attr->next;
else
node->attributes = attr->next;
break;
}
prev = av;
}
FreeAttribute( attr );
}
/*
Free document nodes by iterating through peers and recursing
through children. Set next to NULL before calling FreeNode()
to avoid freeing peer nodes. Doesn't patch up prev/next links.
*/
void FreeNode( TidyDocImpl* doc, Node *node )
{
while ( node )
{
Node* next = node->next;
MemFree( node->element );
FreeAttrs( doc, node );
FreeNode( doc, node->content );
/* node->content = NULL; */
if (RootNode != node->type)
MemFree( node );
node = next;
}
}
Node* TextToken( Lexer *lexer )
{
Node *node = NewNode( lexer );
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
/* used for creating preformatted text from Word2000 */
Node *NewLineNode( Lexer *lexer )
{
Node *node = NewNode( lexer );
node->start = lexer->lexsize;
AddCharToLexer( lexer, (uint)'\n' );
node->end = lexer->lexsize;
return node;
}
/* used for adding a for Word2000 */
Node* NewLiteralTextNode( Lexer *lexer, ctmbstr txt )
{
Node *node = NewNode( lexer );
node->start = lexer->lexsize;
AddStringToLexer( lexer, txt );
node->end = lexer->lexsize;
return node;
}
static Node* TagToken( TidyDocImpl* doc, uint type )
{
Lexer* lexer = doc->lexer;
Node* node = NewNode( lexer );
node->type = type;
node->element = tmbstrndup( lexer->lexbuf + lexer->txtstart,
lexer->txtend - lexer->txtstart );
node->start = lexer->txtstart;
node->end = lexer->txtstart;
if ( type == StartTag || type == StartEndTag || type == EndTag )
FindTag(doc, node);
return node;
}
Node* CommentToken(Lexer *lexer)
{
Node* node = NewNode( lexer );
node->type = CommentTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
static Node* DocTypeToken(Lexer *lexer)
{
Node* node = NewNode( lexer );
node->type = DocTypeTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
static Node *PIToken(Lexer *lexer)
{
Node *node = NewNode(lexer);
node->type = ProcInsTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
static Node *AspToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = AspTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
static Node *JsteToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = JsteTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
/* Added by Baruch Even - handle PHP code too. */
static Node *PhpToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = PhpTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
/* XML Declaration */
static Node *XmlDeclToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = XmlDecl;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
/* Word2000 uses and */
static Node *SectionToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = SectionTag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
/* CDATA uses */
static Node *CDATAToken(Lexer *lexer)
{
Node* node = NewNode(lexer);
node->type = CDATATag;
node->start = lexer->txtstart;
node->end = lexer->txtend;
return node;
}
void AddStringLiteral( Lexer* lexer, ctmbstr str )
{
byte c;
while( c = *str++ )
AddCharToLexer( lexer, c );
}
void AddStringLiteralLen( Lexer* lexer, ctmbstr str, int len )
{
byte c;
int ix;
for ( ix=0; ix < len && (c = *str++); ++ix )
AddCharToLexer(lexer, c);
}
/* find doctype element */
Node *FindDocType( TidyDocImpl* doc )
{
Node* node;
for ( node = (doc ? doc->root.content : NULL);
node && node->type != DocTypeTag;
node = node->next )
/**/;
return node;
}
/* find parent container element */
Node* FindContainer( Node* node )
{
for ( node = (node ? node->parent : NULL);
node && nodeHasCM(node, CM_INLINE);
node = node->parent )
/**/;
return node;
}
/* find html element */
Node *FindHTML( TidyDocImpl* doc )
{
Node *node;
for ( node = (doc ? doc->root.content : NULL);
node && !nodeIsHTML(node);
node = node->next )
/**/;
return node;
}
/* find XML Declaration */
Node *FindXmlDecl(TidyDocImpl* doc)
{
Node *node;
for ( node = (doc ? doc->root.content : NULL);
node && !(node->type == XmlDecl);
node = node->next )
/**/;
return node;
}
Node *FindHEAD( TidyDocImpl* doc )
{
Node *node = FindHTML( doc );
if ( node )
{
for ( node = node->content;
node && !nodeIsHEAD(node);
node = node->next )
/**/;
}
return node;
}
Node *FindTITLE(TidyDocImpl* doc)
{
Node *node = FindHEAD(doc);
if (node)
for (node = node->content;
node && !nodeIsTITLE(node);
node = node->next);
return node;
}
Node *FindBody( TidyDocImpl* doc )
{
Node *node = ( doc ? doc->root.content : NULL );
while ( node && !nodeIsHTML(node) )
node = node->next;
if (node == NULL)
return NULL;
node = node->content;
while ( node && !nodeIsBODY(node) && !nodeIsFRAMESET(node) )
node = node->next;
if ( node && nodeIsFRAMESET(node) )
{
node = node->content;
while ( node && !nodeIsNOFRAMES(node) )
node = node->next;
if ( node )
{
node = node->content;
while ( node && !nodeIsBODY(node) )
node = node->next;
}
}
return node;
}
/* add meta element for Tidy */
Bool AddGenerator( TidyDocImpl* doc )
{
AttVal *attval;
Node *node;
Node *head = FindHEAD( doc );
tmbchar buf[256];
if (head)
{
#ifdef PLATFORM_NAME
sprintf( buf, "HTML Tidy for "PLATFORM_NAME" (vers %s), see www.w3.org",
tidyReleaseDate() );
#else
sprintf( buf, "HTML Tidy (vers %s), see www.w3.org", tidyReleaseDate() );
#endif
for ( node = head->content; node; node = node->next )
{
if ( nodeIsMETA(node) )
{
attval = AttrGetById(node, TidyAttr_NAME);
if ( attval && attval->value &&
tmbstrcasecmp(attval->value, "generator") == 0 )
{
attval = AttrGetById(node, TidyAttr_CONTENT);
if ( attval && attval->value &&
tmbstrncasecmp(attval->value, "HTML Tidy", 9) == 0 )
{
/* update the existing content to reflect the */
/* actual version of Tidy currently being used */
MemFree(attval->value);
attval->value = tmbstrdup(buf);
return no;
}
}
}
}
if ( cfg(doc, TidyAccessibilityCheckLevel) == 0 )
{
node = InferredTag( doc, "meta" );
AddAttribute( doc, node, "name", "generator" );
AddAttribute( doc, node, "content", buf );
InsertNodeAtStart( head, node );
return yes;
}
}
return no;
}
/* examine to identify version */
int FindGivenVersion( TidyDocImpl* doc, Node* doctype )
{
AttVal * fpi = GetAttrByName(doctype, "PUBLIC");
uint vers;
if (!fpi || !fpi->value)
return 0;
vers = GetVersFromFPI(fpi->value);
if (VERS_XHTML & vers)
{
SetOptionBool(doc, TidyXmlOut, yes);
SetOptionBool(doc, TidyXhtmlOut, yes);
doc->lexer->isvoyager = yes;
}
/* todo: add a warning if case does not match? */
MemFree(fpi->value);
fpi->value = tmbstrdup(GetFPIFromVers(vers));
return vers;
}
ctmbstr HTMLVersionNameFromCode( uint vers, Bool isXhtml )
{
ctmbstr name = GetNameFromVers(vers);
if (!name)
name = "HTML Proprietary";
return name;
}
static void FixHTMLNameSpace( TidyDocImpl* doc, ctmbstr profile )
{
Node* node = FindHTML( doc );
if ( node )
{
AttVal *attr = AttrGetById(node, TidyAttr_XMLNS);
if ( attr )
{
if ( tmbstrcmp(attr->value, profile) != 0 )
{
ReportError(doc, node, NULL, INCONSISTENT_NAMESPACE );
MemFree( attr->value );
attr->value = tmbstrdup( profile );
}
}
else
{
attr = NewAttribute();
attr->delim = '"';
attr->attribute = tmbstrdup("xmlns");
attr->value = tmbstrdup(profile);
attr->dict = FindAttribute( doc, attr );
attr->next = node->attributes;
node->attributes = attr;
}
}
}
/* Put DOCTYPE declaration between the
** declaration, if any,
** and the tag. Should also work for any comments,
** etc. that may precede the tag.
*/
static Node* NewDocTypeNode( TidyDocImpl* doc )
{
Node* doctype = NULL;
Node* html = FindHTML( doc );
Node* root = &doc->root;
if ( !html )
return NULL;
doctype = NewNode( NULL );
doctype->type = DocTypeTag;
doctype->next = html;
doctype->parent = root;
if ( html == root->content )
{
/* No declaration. */
root->content->prev = doctype;
root->content = doctype;
doctype->prev = NULL;
}
else
{
/* we have an declaration. */
doctype->prev = html->prev;
doctype->prev->next = doctype;
}
html->prev = doctype;
return doctype;
}
Bool SetXHTMLDocType( TidyDocImpl* doc )
{
Lexer *lexer = doc->lexer;
Node *doctype = FindDocType( doc );
uint dtmode = cfg(doc, TidyDoctypeMode);
ctmbstr pub = "PUBLIC";
ctmbstr sys = "SYSTEM";
FixHTMLNameSpace(doc, XHTML_NAMESPACE);
if (dtmode == TidyDoctypeOmit)
{
if (doctype)
DiscardElement(doc, doctype);
return yes;
}
if (dtmode == TidyDoctypeUser && !cfgStr(doc, TidyDoctype))
return no;
if (!doctype)
{
doctype = NewDocTypeNode(doc);
doctype->element = tmbstrdup("html");
}
else
{
doctype->element = tmbstrtolower(doctype->element);
}
switch(dtmode)
{
case TidyDoctypeStrict:
/* XHTML 1.0 Strict */
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(X10S));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(X10S));
break;
case TidyDoctypeLoose:
/* XHTML 1.0 Transitional */
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(X10T));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(X10T));
break;
case TidyDoctypeUser:
/* user defined document type declaration */
RepairAttrValue(doc, doctype, pub, cfgStr(doc, TidyDoctype));
RepairAttrValue(doc, doctype, sys, "");
break;
case TidyDoctypeAuto:
if (lexer->versions & XH11 && lexer->doctype == XH11)
{
if (!GetAttrByName(doctype, sys))
RepairAttrValue(doc, doctype, sys, GetSIFromVers(XH11));
return yes;
}
else if (lexer->versions & XH11 && !(lexer->versions & VERS_HTML40))
{
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(XH11));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(XH11));
}
else if (lexer->versions & XB10 && lexer->doctype == XB10)
{
if (!GetAttrByName(doctype, sys))
RepairAttrValue(doc, doctype, sys, GetSIFromVers(XB10));
return yes;
}
else if (lexer->versions & VERS_HTML40_STRICT)
{
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(X10S));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(X10S));
}
else if (lexer->versions & VERS_FRAMESET)
{
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(X10F));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(X10F));
}
else if (lexer->versions & VERS_LOOSE)
{
RepairAttrValue(doc, doctype, pub, GetFPIFromVers(X10T));
RepairAttrValue(doc, doctype, sys, GetSIFromVers(X10T));
}
else
{
if (doctype)
DiscardElement(doc, doctype);
return no;
}
break;
}
return no;
}
/* fixup doctype if missing */
Bool FixDocType( TidyDocImpl* doc )
{
Lexer* lexer = doc->lexer;
Node* doctype = FindDocType( doc );
uint dtmode = cfg( doc, TidyDoctypeMode );
uint guessed = VERS_UNKNOWN;
Bool hadSI = no;
if (dtmode == TidyDoctypeAuto &&
lexer->versions & lexer->doctype &&
!(VERS_XHTML & lexer->doctype && !lexer->isvoyager)
&& FindDocType(doc))
return yes;
if (dtmode == TidyDoctypeOmit)
{
if (doctype)
DiscardElement( doc, doctype );
return yes;
}
if (cfgBool(doc, TidyXmlOut))
return yes;
if (doctype)
hadSI = GetAttrByName(doctype, "SYSTEM") != NULL;
if ((dtmode == TidyDoctypeStrict ||
dtmode == TidyDoctypeLoose) && doctype)
{
DiscardElement(doc, doctype);
doctype = NULL;
}
switch (dtmode)
{
case TidyDoctypeStrict:
guessed = H41S;
break;
case TidyDoctypeLoose:
guessed = H41T;
break;
case TidyDoctypeAuto:
guessed = HTMLVersion(doc);
break;
}
if (guessed == VERS_UNKNOWN)
return no;
if (doctype)
{
doctype->element = tmbstrtolower(doctype->element);
}
else
{
doctype = NewDocTypeNode(doc);
doctype->element = tmbstrdup("html");
}
RepairAttrValue(doc, doctype, "PUBLIC", GetFPIFromVers(guessed));
if (hadSI)
RepairAttrValue(doc, doctype, "SYSTEM", GetSIFromVers(guessed));
return yes;
}
/* ensure XML document starts with */
/* add encoding attribute if not using ASCII or UTF-8 output */
Bool FixXmlDecl( TidyDocImpl* doc )
{
Node* xml;
AttVal *version, *encoding;
Lexer*lexer = doc->lexer;
Node* root = &doc->root;
if ( root->content && root->content->type == XmlDecl )
{
xml = root->content;
}
else
{
xml = NewNode(lexer);
xml->type = XmlDecl;
xml->next = root->content;
if ( root->content )
{
root->content->prev = xml;
xml->next = root->content;
}
root->content = xml;
}
version = GetAttrByName(xml, "version");
encoding = GetAttrByName(xml, "encoding");
/*
We need to insert a check if declared encoding
and output encoding mismatch and fix the XML
declaration accordingly!!!
*/
if ( encoding == NULL && cfg(doc, TidyOutCharEncoding) != UTF8 )
{
ctmbstr enc = GetEncodingNameFromTidyId(cfg(doc, TidyOutCharEncoding));
if ( enc )
AddAttribute( doc, xml, "encoding", tmbstrdup(enc) );
}
if ( version == NULL )
AddAttribute( doc, xml, "version", "1.0" );
return yes;
}
Node* InferredTag( TidyDocImpl* doc, ctmbstr name )
{
Lexer *lexer = doc->lexer;
Node *node = NewNode( lexer );
node->type = StartTag;
node->implicit = yes;
node->element = tmbstrdup(name);
node->start = lexer->txtstart;
node->end = lexer->txtend;
FindTag( doc, node );
return node;
}
Bool ExpectsContent(Node *node)
{
if (node->type != StartTag)
return no;
/* unknown element? */
if (node->tag == NULL)
return yes;
if (node->tag->model & CM_EMPTY)
return no;
return yes;
}
/*
create a text node for the contents of
a CDATA element like style or script
which ends with for some foo.
*/
#define CDATA_INTERMEDIATE 1
#define CDATA_STARTTAG 2
#define CDATA_ENDTAG 3
Node *GetCDATA( TidyDocImpl* doc, Node *container )
{
Lexer* lexer = doc->lexer;
int start = 0;
int nested = 0;
int state = CDATA_INTERMEDIATE;
int i;
Bool isEmpty = yes;
Bool matches = no;
uint c;
Bool hasSrc = AttrGetById(container, TidyAttr_SRC) != NULL;
lexer->lines = doc->docIn->curline;
lexer->columns = doc->docIn->curcol;
lexer->waswhite = no;
lexer->txtstart = lexer->txtend = lexer->lexsize;
/* seen start tag, look for matching end tag */
while ((c = ReadChar(doc->docIn)) != EndOfStream)
{
AddCharToLexer(lexer, (uint)c);
lexer->txtend = lexer->lexsize;
if (state == CDATA_INTERMEDIATE)
{
if (c != '<')
{
if (isEmpty && !IsWhite(c))
isEmpty = no;
continue;
}
c = ReadChar(doc->docIn);
if (IsLetter(c))
{
/*