tidy-ext 0.1.7

data/ext/tidy/fileio.c

@@ -0,0 +1,106 @@
+/* fileio.c -- does standard I/O
+
+  (c) 1998-2007 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+
+  CVS Info :
+
+    $Author: arnaud02 $ 
+    $Date: 2007/05/30 16:47:31 $ 
+    $Revision: 1.17 $ 
+
+  Default implementations of Tidy input sources
+  and output sinks based on standard C FILE*.
+
+*/
+
+#include <stdio.h>
+
+#include "forward.h"
+#include "fileio.h"
+#include "tidy.h"
+
+typedef struct _fp_input_source
+{
+    FILE*        fp;
+    TidyBuffer   unget;
+} FileSource;
+
+static int TIDY_CALL filesrc_getByte( void* sourceData )
+{
+  FileSource* fin = (FileSource*) sourceData;
+  int bv;
+  if ( fin->unget.size > 0 )
+    bv = tidyBufPopByte( &fin->unget );
+  else
+    bv = fgetc( fin->fp );
+  return bv;
+}
+
+static Bool TIDY_CALL filesrc_eof( void* sourceData )
+{
+  FileSource* fin = (FileSource*) sourceData;
+  Bool isEOF = ( fin->unget.size == 0 );
+  if ( isEOF )
+    isEOF = feof( fin->fp ) != 0;
+  return isEOF;
+}
+
+static void TIDY_CALL filesrc_ungetByte( void* sourceData, byte bv )
+{
+  FileSource* fin = (FileSource*) sourceData;
+  tidyBufPutByte( &fin->unget, bv );
+}
+
+#if SUPPORT_POSIX_MAPPED_FILES
+#define initFileSource initStdIOFileSource
+#define freeFileSource freeStdIOFileSource
+#endif
+int TY_(initFileSource)( TidyAllocator *allocator, TidyInputSource* inp, FILE* fp )
+{
+  FileSource* fin = NULL;
+
+  fin = (FileSource*) TidyAlloc( allocator, sizeof(FileSource) );
+  if ( !fin )
+      return -1;
+  TidyClearMemory( fin, sizeof(FileSource) );
+  fin->unget.allocator = allocator;
+  fin->fp = fp;
+
+  inp->getByte    = filesrc_getByte;
+  inp->eof        = filesrc_eof;
+  inp->ungetByte  = filesrc_ungetByte;
+  inp->sourceData = fin;
+
+  return 0;
+}
+
+void TY_(freeFileSource)( TidyInputSource* inp, Bool closeIt )
+{
+    FileSource* fin = (FileSource*) inp->sourceData;
+    if ( closeIt && fin && fin->fp )
+      fclose( fin->fp );
+    tidyBufFree( &fin->unget );
+    TidyFree( fin->unget.allocator, fin );
+}
+
+void TIDY_CALL TY_(filesink_putByte)( void* sinkData, byte bv )
+{
+  FILE* fout = (FILE*) sinkData;
+  fputc( bv, fout );
+}
+
+void TY_(initFileSink)( TidyOutputSink* outp, FILE* fp )
+{
+  outp->putByte  = TY_(filesink_putByte);
+  outp->sinkData = fp;
+}
+
+/*
+ * local variables:
+ * mode: c
+ * indent-tabs-mode: nil
+ * c-basic-offset: 4
+ * eval: (c-set-offset 'substatement-open 0)
+ * end:
+ */

data/ext/tidy/fileio.h

@@ -0,0 +1,46 @@
+#ifndef __FILEIO_H__
+#define __FILEIO_H__
+
+/** @file fileio.h - does standard C I/O
+
+  Implementation of a FILE* based TidyInputSource and 
+  TidyOutputSink.
+
+  (c) 1998-2007 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+
+  CVS Info:
+    $Author: arnaud02 $ 
+    $Date: 2007/05/30 16:47:31 $ 
+    $Revision: 1.8 $ 
+*/
+
+#include "buffio.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Allocate and initialize file input source */
+int TY_(initFileSource)( TidyAllocator *allocator, TidyInputSource* source, FILE* fp );
+
+/** Free file input source */
+void TY_(freeFileSource)( TidyInputSource* source, Bool closeIt );
+
+#if SUPPORT_POSIX_MAPPED_FILES
+/** Allocate and initialize file input source using Standard C I/O */
+int TY_(initStdIOFileSource)( TidyAllocator *allocator, TidyInputSource* source, FILE* fp );
+
+/** Free file input source using Standard C I/O */
+void TY_(freeStdIOFileSource)( TidyInputSource* source, Bool closeIt );
+#endif
+
+/** Initialize file output sink */
+void TY_(initFileSink)( TidyOutputSink* sink, FILE* fp );
+
+/* Needed for internal declarations */
+void TIDY_CALL TY_(filesink_putByte)( void* sinkData, byte bv );
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __FILEIO_H__ */

data/ext/tidy/forward.h

@@ -0,0 +1,69 @@
+#ifndef __FORWARD_H__
+#define __FORWARD_H__
+
+/* forward.h -- Forward declarations for major Tidy structures
+
+  (c) 1998-2007 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+
+  CVS Info :
+
+    $Author: arnaud02 $ 
+    $Date: 2007/02/11 09:45:52 $ 
+    $Revision: 1.7 $ 
+
+  Avoids many include file circular dependencies.
+
+  Try to keep this file down to the minimum to avoid
+  cross-talk between modules.
+
+  Header files include this file.  C files include tidy-int.h.
+
+*/
+
+#include "platform.h"
+#include "tidy.h"
+
+/* Internal symbols are prefixed to avoid clashes with other libraries */
+#define TYDYAPPEND(str1,str2) str1##str2
+#define TY_(str) TYDYAPPEND(prvTidy,str)
+
+struct _StreamIn;
+typedef struct _StreamIn StreamIn;
+
+struct _StreamOut;
+typedef struct _StreamOut StreamOut;
+
+struct _TidyDocImpl;
+typedef struct _TidyDocImpl TidyDocImpl;
+
+
+struct _Dict;
+typedef struct _Dict Dict;
+
+struct _Attribute;
+typedef struct _Attribute Attribute;
+
+struct _AttVal;
+typedef struct _AttVal AttVal;
+
+struct _Node;
+typedef struct _Node Node;
+
+struct _IStack;
+typedef struct _IStack IStack;
+
+struct _Lexer;
+typedef struct _Lexer Lexer;
+
+extern TidyAllocator TY_(g_default_allocator);
+
+/** Wrappers for easy memory allocation using an allocator */
+#define TidyAlloc(allocator, size) ((allocator)->vtbl->alloc((allocator), (size)))
+#define TidyRealloc(allocator, block, size) ((allocator)->vtbl->realloc((allocator), (block), (size)))
+#define TidyFree(allocator, block) ((allocator)->vtbl->free((allocator), (block)))
+#define TidyPanic(allocator, msg) ((allocator)->vtbl->panic((allocator), (msg)))
+#define TidyClearMemory(block, size) memset((block), 0, (size))
+ 
+
+#endif /* __FORWARD_H__ */

data/ext/tidy/iconvtc.c

@@ -0,0 +1,105 @@
+/* iconvtc.c -- Interface to iconv transcoding routines
+
+  (c) 1998-2008 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+
+  $Id: iconvtc.c,v 1.2 2008/08/09 11:55:27 hoehrmann Exp $
+*/
+
+#include "tidy.h"
+#include "forward.h"
+#include "streamio.h"
+
+#ifdef TIDY_ICONV_SUPPORT
+
+#include <iconv.h>
+
+/* maximum number of bytes for a single character */
+#define TC_INBUFSIZE  16
+
+/* maximum number of characters per byte sequence */
+#define TC_OUTBUFSIZE 16
+
+Bool IconvInitInputTranscoder(void)
+{
+    return no;
+}
+
+void IconvUninitInputTranscoder(void)
+{
+    return;
+}
+
+int IconvGetChar(byte firstByte, StreamIn * in, uint * bytesRead)
+{
+    iconv_t cd;
+    TidyInputSource * source;
+    char inbuf[TC_INBUFSIZE] = { 0 };
+    char outbuf[TC_OUTBUFSIZE] = { 0 };
+    size_t inbufsize = 0;
+
+    assert( in != NULL );
+    assert( &in->source != NULL );
+    assert( bytesRead != NULL );
+    assert( in->iconvptr != 0 );
+
+    cd = (iconv_t)in->iconvptr;
+    source = &in->source;
+
+    inbuf[inbufsize++] = (char)firstByte;
+    
+    while(inbufsize < TC_INBUFSIZE)
+    {
+        char * outbufptr = (char*)outbuf;
+        char * inbufptr = (char*)inbuf;
+        size_t readNow = inbufsize;
+        size_t writeNow = TC_OUTBUFSIZE;
+        size_t result = 0;
+        int iconv_errno = 0;
+        int nextByte = EndOfStream;
+
+        result = iconv(cd, (const char**)&inbufptr, &readNow, (char**)&outbufptr, &writeNow);
+        iconv_errno = errno;
+
+        if (result != (size_t)(-1))
+        {
+            int c;
+
+            /* create codepoint from UTF-32LE octets */
+            c = (unsigned char)outbuf[0];
+            c += (unsigned char)outbuf[1] << 8;
+            c += (unsigned char)outbuf[2] << 16;
+            c += (unsigned char)outbuf[3] << 32;
+
+            /* set number of read bytes */
+            *bytesRead = inbufsize;
+
+            return c;
+        }
+
+        assert( iconv_errno != EILSEQ ); /* broken multibyte sequence */
+        assert( iconv_errno != E2BIG );  /* not enough memory         */
+        assert( iconv_errno == EINVAL ); /* incomplete sequence       */
+
+        /* we need more bytes */
+        nextByte = source->getByte(source->sourceData);
+
+        if (nextByte == EndOfStream)
+        {
+            /* todo: error message for broken stream? */
+
+            *bytesRead = inbufsize;
+            return EndOfStream;
+        }
+
+        inbuf[inbufsize++] = (char)nextByte;
+    }
+
+    /* No full character found after reading TC_INBUFSIZE bytes, */
+    /* give up to read this stream, it's obviously unreadable.   */
+
+    /* todo: error message for broken stream? */
+    return EndOfStream;
+}
+
+#endif /* TIDY_ICONV_SUPPORT */

data/ext/tidy/iconvtc.h

@@ -0,0 +1,15 @@
+#ifndef __ICONVTC_H__
+#define __ICONVTC_H__
+#ifdef TIDY_ICONV_SUPPORT
+
+/* iconvtc.h -- Interface to iconv transcoding routines
+
+  (c) 1998-2003 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+
+  $Id: iconvtc.h,v 1.1 2003/04/28 22:59:41 hoehrmann Exp $
+*/
+
+
+#endif /* TIDY_ICONV_SUPPORT */
+#endif /* __ICONVTC_H__ */

data/ext/tidy/istack.c

@@ -0,0 +1,373 @@
+/* istack.c -- inline stack for compatibility with Mosaic
+
+  (c) 1998-2006 (W3C) MIT, ERCIM, Keio University
+  See tidy.h for the copyright notice.
+  
+  CVS Info :
+
+    $Author: arnaud02 $ 
+    $Date: 2006/12/29 16:31:08 $ 
+    $Revision: 1.21 $ 
+
+*/
+
+#include "tidy-int.h"
+#include "lexer.h"
+#include "attrs.h"
+#include "streamio.h"
+#include "tmbstr.h"
+
+/* duplicate attributes */
+AttVal *TY_(DupAttrs)( TidyDocImpl* doc, AttVal *attrs)
+{
+    AttVal *newattrs;
+
+    if (attrs == NULL)
+        return attrs;
+
+    newattrs = TY_(NewAttribute)(doc);
+    *newattrs = *attrs;
+    newattrs->next = TY_(DupAttrs)( doc, attrs->next );
+    newattrs->attribute = TY_(tmbstrdup)(doc->allocator, attrs->attribute);
+    newattrs->value = TY_(tmbstrdup)(doc->allocator, attrs->value);
+    newattrs->dict = TY_(FindAttribute)(doc, newattrs);
+    newattrs->asp = attrs->asp ? TY_(CloneNode)(doc, attrs->asp) : NULL;
+    newattrs->php = attrs->php ? TY_(CloneNode)(doc, attrs->php) : NULL;
+    return newattrs;
+}
+
+static Bool IsNodePushable( Node *node )
+{
+    if (node->tag == NULL)
+        return no;
+
+    if (!(node->tag->model & CM_INLINE))
+        return no;
+
+    if (node->tag->model & CM_OBJECT)
+        return no;
+
+    return yes;
+}
+
+/*
+  push a copy of an inline node onto stack
+  but don't push if implicit or OBJECT or APPLET
+  (implicit tags are ones generated from the istack)
+
+  One issue arises with pushing inlines when
+  the tag is already pushed. For instance:
+
+      <p><em>text
+      <p><em>more text
+
+  Shouldn't be mapped to
+
+      <p><em>text</em></p>
+      <p><em><em>more text</em></em>
+*/
+void TY_(PushInline)( TidyDocImpl* doc, Node *node )
+{
+    Lexer* lexer = doc->lexer;
+    IStack *istack;
+
+    if (node->implicit)
+        return;
+
+    if ( !IsNodePushable(node) )
+        return;
+
+    if ( !nodeIsFONT(node) && TY_(IsPushed)(doc, node) )
+        return;
+
+    /* make sure there is enough space for the stack */
+    if (lexer->istacksize + 1 > lexer->istacklength)
+    {
+        if (lexer->istacklength == 0)
+            lexer->istacklength = 6;   /* this is perhaps excessive */
+
+        lexer->istacklength = lexer->istacklength * 2;
+        lexer->istack = (IStack *)TidyDocRealloc(doc, lexer->istack,
+                            sizeof(IStack)*(lexer->istacklength));
+    }
+
+    istack = &(lexer->istack[lexer->istacksize]);
+    istack->tag = node->tag;
+
+    istack->element = TY_(tmbstrdup)(doc->allocator, node->element);
+    istack->attributes = TY_(DupAttrs)( doc, node->attributes );
+    ++(lexer->istacksize);
+}
+
+static void PopIStack( TidyDocImpl* doc )
+{
+    Lexer* lexer = doc->lexer;
+    IStack *istack;
+    AttVal *av;
+
+    --(lexer->istacksize);
+    istack = &(lexer->istack[lexer->istacksize]);
+
+    while (istack->attributes)
+    {
+        av = istack->attributes;
+        istack->attributes = av->next;
+        TY_(FreeAttribute)( doc, av );
+    }
+    TidyDocFree(doc, istack->element);
+}
+
+static void PopIStackUntil( TidyDocImpl* doc, TidyTagId tid )
+{
+    Lexer* lexer = doc->lexer;
+    IStack *istack;
+
+    while (lexer->istacksize > 0)
+    {
+        PopIStack( doc );
+        istack = &(lexer->istack[lexer->istacksize]);
+        if ( istack->tag->id == tid )
+            break;
+    }
+}
+
+/* pop inline stack */
+void TY_(PopInline)( TidyDocImpl* doc, Node *node )
+{
+    Lexer* lexer = doc->lexer;
+
+    if (node)
+    {
+        if ( !IsNodePushable(node) )
+            return;
+
+        /* if node is </a> then pop until we find an <a> */
+        if ( nodeIsA(node) )
+        {
+            PopIStackUntil( doc, TidyTag_A );
+            return;
+        }
+    }
+
+    if (lexer->istacksize > 0)
+    {
+        PopIStack( doc );
+
+        /* #427822 - fix by Randy Waki 7 Aug 00 */
+        if (lexer->insert >= lexer->istack + lexer->istacksize)
+            lexer->insert = NULL;
+    }
+}
+
+Bool TY_(IsPushed)( TidyDocImpl* doc, Node *node )
+{
+    Lexer* lexer = doc->lexer;
+    int i;
+
+    for (i = lexer->istacksize - 1; i >= 0; --i)
+    {
+        if (lexer->istack[i].tag == node->tag)
+            return yes;
+    }
+
+    return no;
+}
+
+/*
+   Test whether the last element on the stack has the same type than "node".
+*/
+Bool TY_(IsPushedLast)( TidyDocImpl* doc, Node *element, Node *node )
+{
+    Lexer* lexer = doc->lexer;
+
+    if ( element && !IsNodePushable(element) )
+        return no;
+
+    if (lexer->istacksize > 0) {
+        if (lexer->istack[lexer->istacksize - 1].tag == node->tag) {
+            return yes;
+        }
+    }
+
+    return no;
+}
+
+/*
+  This has the effect of inserting "missing" inline
+  elements around the contents of blocklevel elements
+  such as P, TD, TH, DIV, PRE etc. This procedure is
+  called at the start of ParseBlock. when the inline
+  stack is not empty, as will be the case in:
+
+    <i><h1>italic heading</h1></i>
+
+  which is then treated as equivalent to
+
+    <h1><i>italic heading</i></h1>
+
+  This is implemented by setting the lexer into a mode
+  where it gets tokens from the inline stack rather than
+  from the input stream.
+*/
+int TY_(InlineDup)( TidyDocImpl* doc, Node* node )
+{
+    Lexer* lexer = doc->lexer;
+    int n;
+
+    if ((n = lexer->istacksize - lexer->istackbase) > 0)
+    {
+        lexer->insert = &(lexer->istack[lexer->istackbase]);
+        lexer->inode = node;
+    }
+
+    return n;
+}
+
+/*
+ defer duplicates when entering a table or other
+ element where the inlines shouldn't be duplicated
+*/
+void TY_(DeferDup)( TidyDocImpl* doc )
+{
+    doc->lexer->insert = NULL;
+    doc->lexer->inode = NULL;
+}
+
+Node *TY_(InsertedToken)( TidyDocImpl* doc )
+{
+    Lexer* lexer = doc->lexer;
+    Node *node;
+    IStack *istack;
+    uint n;
+
+    /* this will only be NULL if inode != NULL */
+    if (lexer->insert == NULL)
+    {
+        node = lexer->inode;
+        lexer->inode = NULL;
+        return node;
+    }
+
+    /*
+      If this is the "latest" node then update
+      the position, otherwise use current values
+    */
+
+    if (lexer->inode == NULL)
+    {
+        lexer->lines = doc->docIn->curline;
+        lexer->columns = doc->docIn->curcol;
+    }
+
+    node = TY_(NewNode)(doc->allocator, lexer);
+    node->type = StartTag;
+    node->implicit = yes;
+    node->start = lexer->txtstart;
+    /* #431734 [JTidy bug #226261 (was 126261)] - fix by Gary Peskin 20 Dec 00 */ 
+    node->end = lexer->txtend; /* was : lexer->txtstart; */
+    istack = lexer->insert;
+
+#if 0 && defined(_DEBUG)
+    if ( lexer->istacksize == 0 )
+        fprintf( stderr, "0-size istack!\n" );
+#endif
+
+    node->element = TY_(tmbstrdup)(doc->allocator, istack->element);
+    node->tag = istack->tag;
+    node->attributes = TY_(DupAttrs)( doc, istack->attributes );
+
+    /* advance lexer to next item on the stack */
+    n = (uint)(lexer->insert - &(lexer->istack[0]));
+
+    /* and recover state if we have reached the end */
+    if (++n < lexer->istacksize)
+        lexer->insert = &(lexer->istack[n]);
+    else
+        lexer->insert = NULL;
+
+    return node;
+}
+
+
+/*
+   We have two CM_INLINE elements pushed ... the first is closing,
+   but, like the browser, the second should be retained ...
+   Like <b>bold <i>bold and italics</b> italics only</i>
+   This function switches the tag positions on the stack,
+   returning 'yes' if both were found in the expected order.
+*/
+Bool TY_(SwitchInline)( TidyDocImpl* doc, Node* element, Node* node )
+{
+    Lexer* lexer = doc->lexer;
+    if ( lexer
+         && element && element->tag
+         && node && node->tag
+         && TY_(IsPushed)( doc, element )
+         && TY_(IsPushed)( doc, node ) 
+         && ((lexer->istacksize - lexer->istackbase) >= 2) )
+    {
+        /* we have a chance of succeeding ... */
+        int i;
+        for (i = (lexer->istacksize - lexer->istackbase - 1); i >= 0; --i)
+        {
+            if (lexer->istack[i].tag == element->tag) {
+                /* found the element tag - phew */
+                IStack *istack1 = &lexer->istack[i];
+                IStack *istack2 = NULL;
+                --i; /* back one more, and continue */
+                for ( ; i >= 0; --i)
+                {
+                    if (lexer->istack[i].tag == node->tag)
+                    {
+                        /* found the element tag - phew */
+                        istack2 = &lexer->istack[i];
+                        break;
+                    }
+                }
+                if ( istack2 )
+                {
+                    /* perform the swap */
+                    IStack tmp_istack = *istack2;
+                    *istack2 = *istack1;
+                    *istack1 = tmp_istack;
+                    return yes;
+                }
+            }
+        }
+    }
+    return no;
+}
+
+/*
+  We want to push a specific a specific element on the stack,
+  but it may not be the last element, which InlineDup()
+  would handle. Return yes, if found and inserted.
+*/
+Bool TY_(InlineDup1)( TidyDocImpl* doc, Node* node, Node* element )
+{
+    Lexer* lexer = doc->lexer;
+    int n, i;
+    if ( element
+         && (element->tag != NULL)
+         && ((n = lexer->istacksize - lexer->istackbase) > 0) )
+    {
+        for ( i = n - 1; i >=0; --i ) {
+            if (lexer->istack[i].tag == element->tag) {
+                /* found our element tag - insert it */
+                lexer->insert = &(lexer->istack[i]);
+                lexer->inode = node;
+                return yes;
+            }
+        }
+    }
+    return no;
+}
+
+/*
+ * local variables:
+ * mode: c
+ * indent-tabs-mode: nil
+ * c-basic-offset: 4
+ * eval: (c-set-offset 'substatement-open 0)
+ * end:
+ */