Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1733 insertions, 0 deletions

diff --git a/khtml/html/htmlparser.cpp b/khtml/html/htmlparser.cpp
new file mode 100644
index 000000000..1fe79f9e0
--- /dev/null
+++ b/khtml/html/htmlparser.cpp
@@ -0,0 +1,1733 @@
+/*
+    This file is part of the KDE libraries
+
+    Copyright (C) 1997 Martin Jones (mjones@kde.org)
+              (C) 1997 Torben Weis (weis@kde.org)
+              (C) 1999,2001 Lars Knoll (knoll@kde.org)
+              (C) 2000,2001 Dirk Mueller (mueller@kde.org)
+              (C) 2003 Apple Computer, Inc.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+//----------------------------------------------------------------------------
+//
+// KDE HTML Widget -- HTML Parser
+// #define PARSER_DEBUG
+
+#include "dom/dom_exception.h"
+
+#include "html/html_baseimpl.h"
+#include "html/html_blockimpl.h"
+#include "html/html_documentimpl.h"
+#include "html/html_elementimpl.h"
+#include "html/html_formimpl.h"
+#include "html/html_headimpl.h"
+#include "html/html_imageimpl.h"
+#include "html/html_inlineimpl.h"
+#include "html/html_listimpl.h"
+#include "html/html_miscimpl.h"
+#include "html/html_tableimpl.h"
+#include "html/html_objectimpl.h"
+#include "xml/dom_textimpl.h"
+#include "xml/dom_nodeimpl.h"
+#include "misc/htmlhashes.h"
+#include "html/htmltokenizer.h"
+#include "khtmlview.h"
+#include "khtml_part.h"
+#include "khtml_factory.h"
+#include "css/cssproperties.h"
+#include "css/cssvalues.h"
+#include "css/csshelper.h"
+
+#include "rendering/render_object.h"
+
+#include "html/htmlparser.h"
+#include <kdebug.h>
+#include <klocale.h>
+
+using namespace DOM;
+using namespace khtml;
+
+//----------------------------------------------------------------------------
+
+/**
+ * @internal
+ */
+class HTMLStackElem
+{
+public:
+    HTMLStackElem( int _id,
+                   int _level,
+                   DOM::NodeImpl *_node,
+		   bool _inline,
+                   HTMLStackElem * _next )
+        :
+        id(_id),
+        level(_level),
+        strayTableContent(false),
+	m_inline(_inline),
+        node(_node),
+        next(_next)
+        { node->ref(); }
+
+    ~HTMLStackElem()
+        { node->deref(); }
+
+    void setNode(NodeImpl* newNode)
+    {
+        newNode->ref();
+        node->deref();
+        node = newNode;
+    }
+
+    int       id;
+    int       level;
+    bool      strayTableContent;
+    bool m_inline;
+    NodeImpl *node;
+    HTMLStackElem *next;
+};
+
+/**
+ * @internal
+ *
+ * The parser parses tokenized input into the document, building up the
+ * document tree. If the document is wellformed, parsing it is
+ * straightforward.
+ * Unfortunately, people can't write wellformed HTML documents, so the parser
+ * has to be tolerant about errors.
+ *
+ * We have to take care of the following error conditions:
+ * 1. The element being added is explicitly forbidden inside some outer tag.
+ *    In this case we should close all tags up to the one, which forbids
+ *    the element, and add it afterwards.
+ * 2. We are not allowed to add the element directly. It could be, that
+ *    the person writing the document forgot some tag inbetween (or that the
+ *    tag inbetween is optional...) This could be the case with the following
+ *    tags: HTML HEAD BODY TBODY TR TD LI (did I forget any?)
+ * 3. We wan't to add a block element inside to an inline element. Close all
+ *    inline elements up to the next higher block element.
+ * 4. If this doesn't help close elements, until we are allowed to add the
+ *    element or ignore the tag.
+ *
+ */
+
+KHTMLParser::KHTMLParser( KHTMLView *_parent, DocumentImpl *doc)
+{
+    //kdDebug( 6035 ) << "parser constructor" << endl;
+#if SPEED_DEBUG > 0
+    qt.start();
+#endif
+
+    HTMLWidget    = _parent;
+    document      = doc;
+
+    blockStack = 0;
+    current = 0;
+
+    // ID_CLOSE_TAG == Num of tags
+    forbiddenTag = new ushort[ID_CLOSE_TAG+1];
+
+    reset();
+}
+
+KHTMLParser::KHTMLParser( DOM::DocumentFragmentImpl *i, DocumentImpl *doc )
+{
+    HTMLWidget = 0;
+    document = doc;
+
+    forbiddenTag = new ushort[ID_CLOSE_TAG+1];
+
+    blockStack = 0;
+    current = 0;
+
+    reset();
+
+    setCurrent(i);
+
+    inBody = true;
+}
+
+KHTMLParser::~KHTMLParser()
+{
+#if SPEED_DEBUG > 0
+    kdDebug( ) << "TIME: parsing time was = " << qt.elapsed() << endl;
+#endif
+
+    freeBlock();
+
+    if (current) current->deref();
+
+    delete [] forbiddenTag;
+    delete isindex;
+}
+
+void KHTMLParser::reset()
+{
+    setCurrent ( document );
+
+    freeBlock();
+
+    // before parsing no tags are forbidden...
+    memset(forbiddenTag, 0, (ID_CLOSE_TAG+1)*sizeof(ushort));
+
+    inBody = false;
+    haveFrameSet = false;
+    haveContent = false;
+    haveBody = false;
+    haveTitle = false;
+    inSelect = false;
+    inStrayTableContent = 0;
+    m_inline = false;
+
+    form = 0;
+    map = 0;
+    head = 0;
+    end = false;
+    isindex = 0;
+
+    discard_until = 0;
+}
+
+void KHTMLParser::parseToken(Token *t)
+{
+    if (t->tid > 2*ID_CLOSE_TAG)
+    {
+      kdDebug( 6035 ) << "Unknown tag!! tagID = " << t->tid << endl;
+      return;
+    }
+    if(discard_until) {
+        if(t->tid == discard_until)
+            discard_until = 0;
+
+        // do not skip </iframe>
+        if ( discard_until || current->id() + ID_CLOSE_TAG != t->tid )
+            return;
+    }
+
+#ifdef PARSER_DEBUG
+    kdDebug( 6035 ) << "\n\n==> parser: processing token " << getTagName(t->tid) << "(" << t->tid << ")"
+                    << " current = " << getTagName(current->id()) << "(" << current->id() << ")" << endl;
+    kdDebug(6035) << "inline=" << m_inline << " inBody=" << inBody << " haveFrameSet=" << haveFrameSet << " haveContent=" << haveContent << endl;
+#endif
+
+    // holy shit. apparently some sites use </br> instead of <br>
+    // be compatible with IE and NS
+    if(t->tid == ID_BR+ID_CLOSE_TAG && document->inCompatMode())
+        t->tid -= ID_CLOSE_TAG;
+
+    if(t->tid > ID_CLOSE_TAG)
+    {
+        processCloseTag(t);
+        return;
+    }
+
+    // ignore spaces, if we're not inside a paragraph or other inline code
+    if( t->tid == ID_TEXT && t->text ) {
+        if(inBody && !skipMode() &&
+           current->id() != ID_STYLE && current->id() != ID_TITLE &&
+           current->id() != ID_SCRIPT &&
+           !t->text->containsOnlyWhitespace()) haveContent = true;
+#ifdef PARSER_DEBUG
+        kdDebug(6035) << "length="<< t->text->l << " text='" << QConstString(t->text->s, t->text->l).string() << "'" << endl;
+#endif
+    }
+
+    NodeImpl *n = getElement(t);
+    // just to be sure, and to catch currently unimplemented stuff
+    if(!n)
+        return;
+
+    // set attributes
+    if(n->isElementNode() && t->tid != ID_ISINDEX)
+    {
+        ElementImpl *e = static_cast<ElementImpl *>(n);
+        e->setAttributeMap(t->attrs);
+
+        // take care of optional close tags
+        if(endTag[e->id()] == DOM::OPTIONAL)
+            popBlock(t->tid);
+    }
+
+    // if this tag is forbidden inside the current context, pop
+    // blocks until we are allowed to add it...
+    while(blockStack && forbiddenTag[t->tid]) {
+#ifdef PARSER_DEBUG
+        kdDebug( 6035 ) << "t->id: " << t->tid << " is forbidden :-( " << endl;
+#endif
+        popOneBlock();
+    }
+
+    // sometimes flat doesn't make sense
+    switch(t->tid) {
+    case ID_SELECT:
+    case ID_OPTION:
+        t->flat = false;
+    }
+
+    // the tokenizer needs the feedback for space discarding
+    if ( tagPriority[t->tid] == 0 )
+	t->flat = true;
+
+    if ( !insertNode(n, t->flat) ) {
+        // we couldn't insert the node...
+#ifdef PARSER_DEBUG
+        kdDebug( 6035 ) << "insertNode failed current=" << current->id() << ", new=" << n->id() << "!" << endl;
+#endif
+        if (map == n)
+        {
+#ifdef PARSER_DEBUG
+            kdDebug( 6035 ) << "  --> resetting map!" << endl;
+#endif
+            map = 0;
+        }
+        if (form == n)
+        {
+#ifdef PARSER_DEBUG
+            kdDebug( 6035 ) << "   --> resetting form!" << endl;
+#endif
+            form = 0;
+        }
+        delete n;
+    }
+}
+
+static bool isTableRelatedTag(int id)
+{
+    return (id == ID_TR || id == ID_TD || id == ID_TABLE || id == ID_TBODY || id == ID_TFOOT || id == ID_THEAD ||
+            id == ID_TH);
+}
+
+bool KHTMLParser::insertNode(NodeImpl *n, bool flat)
+{
+    int id = n->id();
+
+    // let's be stupid and just try to insert it.
+    // this should work if the document is wellformed
+#ifdef PARSER_DEBUG
+    NodeImpl *tmp = current;
+#endif
+    NodeImpl *newNode = current->addChild(n);
+    if ( newNode ) {
+#ifdef PARSER_DEBUG
+        kdDebug( 6035 ) << "added " << n->nodeName().string() << " to " << tmp->nodeName().string() << ", new current=" << newNode->nodeName().string() << endl;
+#endif
+        // We allow TABLE > FORM in dtd.cpp, but do not allow the form have children in this case
+        if (current->id() == ID_TABLE && id == ID_FORM) {
+            flat = true;
+            static_cast<HTMLFormElementImpl*>(n)->setMalformed(true);
+        }
+
+	// don't push elements without end tag on the stack
+        if(tagPriority[id] != 0 && !flat) {
+#if SPEED_DEBUG < 2
+            if(!n->attached() && HTMLWidget )
+                n->attach();
+#endif
+	    if(n->isInline()) m_inline = true;
+            pushBlock(id, tagPriority[id]);
+            setCurrent( newNode );
+        } else {
+#if SPEED_DEBUG < 2
+            if(!n->attached() && HTMLWidget)
+                n->attach();
+            if (n->maintainsState()) {
+                document->registerMaintainsState(n);
+                QString state(document->nextState());
+                if (!state.isNull()) n->restoreState(state);
+            }
+            n->close();
+#endif
+	    if(n->isInline()) m_inline = true;
+        }
+
+
+#if SPEED_DEBUG < 1
+        if(tagPriority[id] == 0 && n->renderer())
+            n->renderer()->calcMinMaxWidth();
+#endif
+        return true;
+    } else {
+#ifdef PARSER_DEBUG
+        kdDebug( 6035 ) << "ADDING NODE FAILED!!!! current = " << current->nodeName().string() << ", new = " << n->nodeName().string() << endl;
+#endif
+        // error handling...
+        HTMLElementImpl *e;
+        bool handled = false;
+
+        // first switch on current element for elements with optional end-tag and inline-only content
+        switch(current->id())
+        {
+        case ID_P:
+        case ID_DT:
+            if(!n->isInline())
+            {
+                popBlock(current->id());
+                return insertNode(n);
+            }
+            break;
+        default:
+            break;
+        }
+
+        // switch according to the element to insert
+        switch(id)
+        {
+        case ID_TR:
+        case ID_TH:
+        case ID_TD:
+            if (inStrayTableContent && !isTableRelatedTag(current->id())) {
+                // pop out to the nearest enclosing table-related tag.
+                while (blockStack && !isTableRelatedTag(current->id()))
+                    popOneBlock();
+                return insertNode(n);
+            }
+            break;
+        case ID_COMMENT:
+            break;
+        case ID_HEAD:
+            // ### allow not having <HTML> in at all, as per HTML spec
+            if (!current->isDocumentNode() && current->id() != ID_HTML )
+                return false;
+            break;
+        case ID_META:
+        case ID_LINK:
+        case ID_ISINDEX:
+        case ID_BASE:
+            if( !head )
+                createHead();
+            if( head ) {
+                if ( head->addChild(n) ) {
+#if SPEED_DEBUG < 2
+                    if(!n->attached() && HTMLWidget)
+                        n->attach();
+#endif
+                }
+
+                return true;
+            }
+
+            break;
+        case ID_HTML:
+            if (!current->isDocumentNode() ) {
+		if ( doc()->firstChild()->id() == ID_HTML) {
+		    // we have another <HTML> element.... apply attributes to existing one
+		    // make sure we don't overwrite already existing attributes
+		    NamedAttrMapImpl *map = static_cast<ElementImpl*>(n)->attributes(true);
+		    NamedAttrMapImpl *bmap = static_cast<ElementImpl*>(doc()->firstChild())->attributes(false);
+		    bool changed = false;
+		    for (unsigned long l = 0; map && l < map->length(); ++l) {
+			NodeImpl::Id attrId = map->idAt(l);
+			DOMStringImpl *attrValue = map->valueAt(l);
+			changed = !bmap->getValue(attrId);
+			bmap->setValue(attrId,attrValue);
+		    }
+		    if ( changed )
+			doc()->recalcStyle( NodeImpl::Inherit );
+		}
+                return false;
+	    }
+            break;
+        case ID_TITLE:
+        case ID_STYLE:
+            if ( !head )
+                createHead();
+            if ( head ) {
+                DOM::NodeImpl *newNode = head->addChild(n);
+                if ( newNode ) {
+                    pushBlock(id, tagPriority[id]);
+                    setCurrent ( newNode );
+#if SPEED_DEBUG < 2
+		    if(!n->attached() && HTMLWidget)
+                        n->attach();
+#endif
+                } else {
+#ifdef PARSER_DEBUG
+                    kdDebug( 6035 ) << "adding style before to body failed!!!!" << endl;
+#endif
+                    discard_until = ID_STYLE + ID_CLOSE_TAG;
+                    return false;
+                }
+                return true;
+            } else if(inBody) {
+                discard_until = id + ID_CLOSE_TAG;
+                return false;
+            }
+            break;
+        case ID_SCRIPT:
+            // if we failed to insert it, go into skip mode
+            discard_until = id + ID_CLOSE_TAG;
+            break;
+        case ID_BODY:
+            if(inBody && doc()->body()) {
+                // we have another <BODY> element.... apply attributes to existing one
+                // make sure we don't overwrite already existing attributes
+                // some sites use <body bgcolor=rightcolor>...<body bgcolor=wrongcolor>
+                NamedAttrMapImpl *map = static_cast<ElementImpl*>(n)->attributes(true);
+                NamedAttrMapImpl *bmap = doc()->body()->attributes(false);
+                bool changed = false;
+                for (unsigned long l = 0; map && l < map->length(); ++l) {
+                    NodeImpl::Id attrId = map->idAt(l);
+                    DOMStringImpl *attrValue = map->valueAt(l);
+                    if ( !bmap->getValue(attrId) ) {
+                        bmap->setValue(attrId,attrValue);
+                        changed = true;
+                    }
+                }
+                if ( changed )
+                    doc()->recalcStyle( NodeImpl::Inherit );
+            } else if ( current->isDocumentNode() )
+                break;
+            return false;
+            break;
+
+            // the following is a hack to move non rendered elements
+            // outside of tables.
+            // needed for broken constructs like <table><form ...><tr>....
+        case ID_INPUT:
+        {
+            ElementImpl *e = static_cast<ElementImpl *>(n);
+            DOMString type = e->getAttribute(ATTR_TYPE);
+
+            if ( strcasecmp( type, "hidden" ) != 0 )
+                break;
+            // Fall through!
+        }
+        case ID_TEXT:
+        {
+            // Don't try to fit random white-space anywhere
+            TextImpl *t = static_cast<TextImpl *>(n);
+            if (t->containsOnlyWhitespace())
+                return false;
+            // ignore text inside the following elements.
+            switch(current->id())
+            {
+            case ID_SELECT:
+                return false;
+            default:
+                ;
+                // fall through!!
+            };
+            break;
+        }
+        case ID_DL:
+            popBlock( ID_DT );
+            if ( current->id() == ID_DL ) {
+                e = new HTMLGenericElementImpl( document, ID_DD );
+                insertNode( e );
+                handled = true;
+            }
+            break;
+        case ID_DT:
+            e = new HTMLDListElementImpl(document);
+            if ( insertNode(e) ) {
+                insertNode(n);
+                return true;
+            }
+            break;
+        case ID_AREA:
+        {
+            if(map)
+            {
+                map->addChild(n);
+#if SPEED_DEBUG < 2
+                if(!n->attached() && HTMLWidget)
+		    n->attach();
+#endif
+                handled = true;
+                return true;
+            }
+            else
+                return false;
+        }
+        case ID_CAPTION: {
+            switch (current->id()) {
+                case ID_THEAD:
+                case ID_TBODY:
+                case ID_TFOOT:
+                case ID_TR:
+                case ID_TH:
+                case ID_TD: {
+                    NodeImpl* tsection = current;
+                    if (current->id() == ID_TR)
+                        tsection = current->parent();
+                    else if (current->id() == ID_TD || current->id() == ID_TH)
+                        tsection = current->parent()->parent();
+                    NodeImpl* table = tsection->parent();
+                    int exceptioncode = 0;
+                    table->insertBefore(n, tsection, exceptioncode);
+                    pushBlock(id, tagPriority[id]);
+                    setCurrent(n);
+                    inStrayTableContent++;
+                    blockStack->strayTableContent = true;
+                    return true;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+
+        case ID_THEAD:
+        case ID_TBODY:
+        case ID_TFOOT:
+        case ID_COLGROUP: {
+            if (isTableRelatedTag(current->id())) {
+                while (blockStack && current->id() != ID_TABLE && isTableRelatedTag(current->id()))
+                    popOneBlock();
+                return insertNode(n);
+            }
+        }
+        default:
+            break;
+        }
+
+        // switch on the currently active element
+        switch(current->id())
+        {
+        case ID_HTML:
+            switch(id)
+            {
+            case ID_SCRIPT:
+            case ID_STYLE:
+            case ID_META:
+            case ID_LINK:
+            case ID_OBJECT:
+            case ID_EMBED:
+            case ID_TITLE:
+            case ID_ISINDEX:
+            case ID_BASE:
+                if(!head) {
+                    head = new HTMLHeadElementImpl(document);
+                    e = head;
+                    insertNode(e);
+                    handled = true;
+                }
+                break;
+            case ID_TEXT: {
+                TextImpl *t = static_cast<TextImpl *>(n);
+                if (t->containsOnlyWhitespace())
+                    return false;
+                /* Fall through to default */
+            }
+            default:
+                if ( haveFrameSet ) break;
+                e = new HTMLBodyElementImpl(document);
+                startBody();
+                insertNode(e);
+                handled = true;
+                break;
+            }
+            break;
+        case ID_HEAD:
+            // we can get here only if the element is not allowed in head.
+            if (id == ID_HTML)
+                return false;
+            else {
+                // This means the body starts here...
+                if ( haveFrameSet ) break;
+                popBlock(ID_HEAD);
+                e = new HTMLBodyElementImpl(document);
+                startBody();
+                insertNode(e);
+                handled = true;
+            }
+            break;
+        case ID_BODY:
+            break;
+        case ID_CAPTION:
+            // Illegal content in a caption. Close the caption and try again.
+            popBlock(ID_CAPTION);
+            switch( id ) {
+            case ID_THEAD:
+            case ID_TFOOT:
+            case ID_TBODY:
+            case ID_TR:
+            case ID_TD:
+            case ID_TH:
+                return insertNode(n, flat);
+            }
+            break;
+        case ID_TABLE:
+        case ID_THEAD:
+        case ID_TFOOT:
+        case ID_TBODY:
+        case ID_TR:
+            switch(id)
+            {
+            case ID_TABLE:
+                popBlock(ID_TABLE); // end the table
+                handled = checkChild( current->id(), id, !doc()->inCompatMode());
+                break;
+            default:
+            {
+                NodeImpl *node = current;
+                NodeImpl *parent = node->parentNode();
+                // A script may have removed the current node's parent from the DOM
+                // http://bugzilla.opendarwin.org/show_bug.cgi?id=7137
+                // FIXME: we should do real recovery here and re-parent with the correct node.
+                if (!parent)
+                    return false;
+                NodeImpl *parentparent = parent->parentNode();
+
+                if (n->isTextNode() ||
+                    ( node->id() == ID_TR &&
+                     ( parent->id() == ID_THEAD ||
+                       parent->id() == ID_TBODY ||
+                       parent->id() == ID_TFOOT ) && parentparent->id() == ID_TABLE ) ||
+                   ( !checkChild( ID_TR, id ) && ( node->id() == ID_THEAD || node->id() == ID_TBODY || node->id() == ID_TFOOT ) &&
+                     parent->id() == ID_TABLE ) )
+                {
+                    node = (node->id() == ID_TABLE) ? node :
+                           ((node->id() == ID_TR ) ? parentparent : parent);
+                    NodeImpl *parent = node->parentNode();
+                    if (!parent)
+                        return false;
+                    int exceptioncode = 0;
+#ifdef PARSER_DEBUG
+                    kdDebug( 6035 ) << "calling insertBefore(" << n->nodeName().string() << "," << node->nodeName().string() << ")" << endl;
+#endif
+                    parent->insertBefore(n, node, exceptioncode);
+                    if (exceptioncode) {
+#ifndef PARSER_DEBUG
+                        if (!n->isTextNode())
+#endif
+                            kdDebug(6035) << "adding content before table failed.." << endl;
+                        break;
+                    }
+                    if ( n->isElementNode() && tagPriority[id] != 0 &&
+                         !flat && endTag[id] != DOM::FORBIDDEN ) {
+
+                        pushBlock(id, tagPriority[id]);
+                        setCurrent ( n );
+                        inStrayTableContent++;
+                        blockStack->strayTableContent = true;
+                    }
+                    return true;
+                }
+
+                if ( current->id() == ID_TR )
+                    e = new HTMLTableCellElementImpl(document, ID_TD);
+                else if ( current->id() == ID_TABLE )
+                    e = new HTMLTableSectionElementImpl( document, ID_TBODY, true /* implicit */ );
+                else
+                    e = new HTMLTableRowElementImpl( document );
+
+                insertNode(e);
+                handled = true;
+                break;
+            } // end default
+            } // end switch
+            break;
+        case ID_OBJECT:
+            discard_until = id + ID_CLOSE_TAG;
+            return false;
+        case ID_UL:
+        case ID_OL:
+        case ID_DIR:
+        case ID_MENU:
+            e = new HTMLLIElementImpl(document);
+            e->addCSSProperty(CSS_PROP_LIST_STYLE_TYPE, CSS_VAL_NONE);
+            insertNode(e);
+            handled = true;
+            break;
+        case ID_DL:
+            popBlock(ID_DL);
+            handled = true;
+            break;
+        case ID_DT:
+            popBlock(ID_DT);
+            handled = true;
+            break;
+        case ID_FORM:
+            popBlock(ID_FORM);
+            handled = true;
+            break;
+        case ID_SELECT:
+            if( n->isInline() )
+                return false;
+            break;
+        case ID_P:
+        case ID_H1:
+        case ID_H2:
+        case ID_H3:
+        case ID_H4:
+        case ID_H5:
+        case ID_H6:
+            if(!n->isInline())
+            {
+                popBlock(current->id());
+                handled = true;
+            }
+            break;
+        case ID_OPTION:
+        case ID_OPTGROUP:
+            if (id == ID_OPTGROUP)
+            {
+                popBlock(current->id());
+                handled = true;
+            }
+            else if(id == ID_SELECT)
+            {
+                // IE treats a nested select as </select>. Let's do the same
+                popBlock( ID_SELECT );
+                break;
+            }
+            break;
+            // head elements in the body should be ignored.
+
+        case ID_ADDRESS:
+        case ID_COLGROUP:
+        case ID_FONT:
+            popBlock(current->id());
+            handled = true;
+            break;
+        default:
+            if(current->isDocumentNode())
+            {
+                if(current->firstChild() == 0) {
+                    e = new HTMLHtmlElementImpl(document);
+                    insertNode(e);
+                    handled = true;
+                }
+            }
+            else if(current->isInline())
+            {
+                popInlineBlocks();
+                handled = true;
+            }
+        }
+
+        // if we couldn't handle the error, just rethrow the exception...
+        if(!handled)
+        {
+            //kdDebug( 6035 ) << "Exception handler failed in HTMLPArser::insertNode()" << endl;
+            return false;
+        }
+
+        return insertNode(n);
+    }
+}
+
+
+NodeImpl *KHTMLParser::getElement(Token* t)
+{
+    NodeImpl *n = 0;
+
+    switch(t->tid)
+    {
+    case ID_HTML:
+        n = new HTMLHtmlElementImpl(document);
+        break;
+    case ID_HEAD:
+        if(!head && current->id() == ID_HTML) {
+            head = new HTMLHeadElementImpl(document);
+            n = head;
+        }
+        break;
+    case ID_BODY:
+        // body no longer allowed if we have a frameset
+        if(haveFrameSet) break;
+        popBlock(ID_HEAD);
+        n = new HTMLBodyElementImpl(document);
+        haveBody =  true;
+        startBody();
+        break;
+
+// head elements
+    case ID_BASE:
+        n = new HTMLBaseElementImpl(document);
+        break;
+    case ID_LINK:
+        n = new HTMLLinkElementImpl(document);
+        break;
+    case ID_META:
+        n = new HTMLMetaElementImpl(document);
+        break;
+    case ID_STYLE:
+        n = new HTMLStyleElementImpl(document);
+        break;
+    case ID_TITLE:
+        // only one non-empty <title> allowed
+        if (haveTitle) {
+            discard_until = ID_TITLE+ID_CLOSE_TAG;
+            break;
+        }
+        n = new HTMLTitleElementImpl(document);
+        // we'll set haveTitle when closing the tag
+        break;
+
+// frames
+    case ID_FRAME:
+        n = new HTMLFrameElementImpl(document);
+        break;
+    case ID_FRAMESET:
+        popBlock(ID_HEAD);
+        if ( inBody && !haveFrameSet && !haveContent && !haveBody) {
+            popBlock( ID_BODY );
+            // ### actually for IE document.body returns the now hidden "body" element
+            // we can't implement that behavior now because it could cause too many
+            // regressions and the headaches are not worth the work as long as there is
+            // no site actually relying on that detail (Dirk)
+            if (static_cast<HTMLDocumentImpl*>(document)->body())
+                static_cast<HTMLDocumentImpl*>(document)->body()
+                    ->addCSSProperty(CSS_PROP_DISPLAY, CSS_VAL_NONE);
+            inBody = false;
+        }
+        if ( (haveBody || haveContent || haveFrameSet) && current->id() == ID_HTML)
+            break;
+        n = new HTMLFrameSetElementImpl(document);
+        haveFrameSet = true;
+        startBody();
+        break;
+        // a bit a special case, since the frame is inlined...
+    case ID_IFRAME:
+        n = new HTMLIFrameElementImpl(document);
+        if (!t->flat) discard_until = ID_IFRAME+ID_CLOSE_TAG;
+        break;
+
+// form elements
+    case ID_FORM:
+        // thou shall not nest <form> - NS/IE quirk
+        if (form) break;
+        n = form = new HTMLFormElementImpl(document, false);
+        break;
+    case ID_BUTTON:
+        n = new HTMLButtonElementImpl(document, form);
+        break;
+    case ID_FIELDSET:
+        n = new HTMLFieldSetElementImpl(document, form);
+        break;
+    case ID_INPUT:
+        if ( t->attrs &&
+             KHTMLFactory::defaultHTMLSettings()->isAdFilterEnabled() &&
+             KHTMLFactory::defaultHTMLSettings()->isHideAdsEnabled() &&
+             !strcasecmp( t->attrs->getValue( ATTR_TYPE ), "image" ) )
+        {
+            if (KHTMLFactory::defaultHTMLSettings()->isAdFiltered( doc()->completeURL( khtml::parseURL(t->attrs->getValue(ATTR_SRC)).string() ) ))
+                return 0;
+        }
+        n = new HTMLInputElementImpl(document, form);
+        break;
+    case ID_ISINDEX:
+        n = handleIsindex(t);
+        if( !inBody ) {
+            isindex = n;
+            n = 0;
+        } else
+            t->flat = true;
+        break;
+    case ID_KEYGEN:
+        n = new HTMLKeygenElementImpl(document, form);
+        break;
+    case ID_LABEL:
+        n = new HTMLLabelElementImpl(document);
+        break;
+    case ID_LEGEND:
+        n = new HTMLLegendElementImpl(document, form);
+        break;
+    case ID_OPTGROUP:
+        n = new HTMLOptGroupElementImpl(document, form);
+        break;
+    case ID_OPTION:
+        n = new HTMLOptionElementImpl(document, form);
+        break;
+    case ID_SELECT:
+        inSelect = true;
+        n = new HTMLSelectElementImpl(document, form);
+        break;
+    case ID_TEXTAREA:
+        n = new HTMLTextAreaElementImpl(document, form);
+        break;
+
+// lists
+    case ID_DL:
+        n = new HTMLDListElementImpl(document);
+        break;
+    case ID_DD:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        popBlock(ID_DT);
+        popBlock(ID_DD);
+        break;
+    case ID_DT:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        popBlock(ID_DD);
+        popBlock(ID_DT);
+        break;
+    case ID_UL:
+    {
+        n = new HTMLUListElementImpl(document);
+        break;
+    }
+    case ID_OL:
+    {
+        n = new HTMLOListElementImpl(document);
+        break;
+    }
+    case ID_DIR:
+        n = new HTMLDirectoryElementImpl(document);
+        break;
+    case ID_MENU:
+        n = new HTMLMenuElementImpl(document);
+        break;
+    case ID_LI:
+        popBlock(ID_LI);
+        n = new HTMLLIElementImpl(document);
+        break;
+// formatting elements (block)
+    case ID_BLOCKQUOTE:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+    case ID_LAYER:
+    case ID_ILAYER:
+        n = new HTMLLayerElementImpl(document, t->tid);
+        break;
+    case ID_P:
+    case ID_DIV:
+        n = new HTMLDivElementImpl(document, t->tid);
+        break;
+    case ID_H1:
+    case ID_H2:
+    case ID_H3:
+    case ID_H4:
+    case ID_H5:
+    case ID_H6:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+    case ID_HR:
+        n = new HTMLHRElementImpl(document);
+        break;
+    case ID_PRE:
+    case ID_XMP:
+    case ID_PLAINTEXT:
+        n = new HTMLPreElementImpl(document, t->tid);
+        break;
+
+// font stuff
+    case ID_BASEFONT:
+        n = new HTMLBaseFontElementImpl(document);
+        break;
+    case ID_FONT:
+        n = new HTMLFontElementImpl(document);
+        break;
+
+// ins/del
+    case ID_DEL:
+    case ID_INS:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+
+// anchor
+    case ID_A:
+        popBlock(ID_A);
+
+        n = new HTMLAnchorElementImpl(document);
+        break;
+
+// images
+    case ID_IMG:
+        if (t->attrs&&
+            KHTMLFactory::defaultHTMLSettings()->isAdFilterEnabled()&&
+            KHTMLFactory::defaultHTMLSettings()->isHideAdsEnabled())
+        {
+            QString url = doc()->completeURL( khtml::parseURL(t->attrs->getValue(ATTR_SRC)).string() );
+            if (KHTMLFactory::defaultHTMLSettings()->isAdFiltered(url))
+                return 0;
+        }
+        n = new HTMLImageElementImpl(document, form);
+        break;
+
+    case ID_MAP:
+        map = new HTMLMapElementImpl(document);
+        n = map;
+        break;
+    case ID_AREA:
+        n = new HTMLAreaElementImpl(document);
+        break;
+
+// objects, applets and scripts
+    case ID_APPLET:
+        n = new HTMLAppletElementImpl(document);
+        break;
+    case ID_EMBED:
+        n = new HTMLEmbedElementImpl(document);
+        break;
+    case ID_OBJECT:
+        n = new HTMLObjectElementImpl(document);
+        break;
+    case ID_PARAM:
+        n = new HTMLParamElementImpl(document);
+        break;
+    case ID_SCRIPT:
+    {
+        HTMLScriptElementImpl *scriptElement = new HTMLScriptElementImpl(document);
+        scriptElement->setCreatedByParser(true);
+        n = scriptElement;
+        break;
+    }
+
+// tables
+    case ID_TABLE:
+        n = new HTMLTableElementImpl(document);
+        break;
+    case ID_CAPTION:
+        n = new HTMLTableCaptionElementImpl(document);
+        break;
+    case ID_COLGROUP:
+    case ID_COL:
+        n = new HTMLTableColElementImpl(document, t->tid);
+        break;
+    case ID_TR:
+        popBlock(ID_TR);
+        n = new HTMLTableRowElementImpl(document);
+        break;
+    case ID_TD:
+    case ID_TH:
+        popBlock(ID_TH);
+        popBlock(ID_TD);
+        n = new HTMLTableCellElementImpl(document, t->tid);
+        break;
+    case ID_TBODY:
+    case ID_THEAD:
+    case ID_TFOOT:
+        popBlock( ID_THEAD );
+        popBlock( ID_TBODY );
+        popBlock( ID_TFOOT );
+        n = new HTMLTableSectionElementImpl(document, t->tid, false);
+        break;
+
+// inline elements
+    case ID_BR:
+        n = new HTMLBRElementImpl(document);
+        break;
+    case ID_Q:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+
+// elements with no special representation in the DOM
+
+// block:
+    case ID_ADDRESS:
+    case ID_CENTER:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+// inline
+        // %fontstyle
+    case ID_TT:
+    case ID_U:
+    case ID_B:
+    case ID_I:
+    case ID_S:
+    case ID_STRIKE:
+    case ID_BIG:
+    case ID_SMALL:
+
+        // %phrase
+    case ID_EM:
+    case ID_STRONG:
+    case ID_DFN:
+    case ID_CODE:
+    case ID_SAMP:
+    case ID_KBD:
+    case ID_VAR:
+    case ID_CITE:
+    case ID_ABBR:
+    case ID_ACRONYM:
+
+        // %special
+    case ID_SUB:
+    case ID_SUP:
+    case ID_SPAN:
+    case ID_WBR:
+    case ID_NOBR:
+        if ( t->tid == ID_NOBR || t->tid == ID_WBR )
+            popBlock( t->tid );
+    case ID_BDO:
+        n = new HTMLGenericElementImpl(document, t->tid);
+        break;
+
+        // these are special, and normally not rendered
+    case ID_NOEMBED:
+        if (!t->flat) {
+            n = new HTMLGenericElementImpl(document, t->tid);
+            discard_until = ID_NOEMBED + ID_CLOSE_TAG;
+        }
+        return n;
+    case ID_NOFRAMES:
+        if (!t->flat) {
+            n = new HTMLGenericElementImpl(document, t->tid);
+            discard_until = ID_NOFRAMES + ID_CLOSE_TAG;
+        }
+        return n;
+    case ID_NOSCRIPT:
+        if (!t->flat) {
+            n = new HTMLGenericElementImpl(document, t->tid);
+            if(HTMLWidget && HTMLWidget->part()->jScriptEnabled())
+                discard_until = ID_NOSCRIPT + ID_CLOSE_TAG;
+        }
+        return n;
+    case ID_NOLAYER:
+//        discard_until = ID_NOLAYER + ID_CLOSE_TAG;
+        return 0;
+        break;
+    case ID_MARQUEE:
+        n = new HTMLMarqueeElementImpl(document);
+        break;
+// text
+    case ID_TEXT:
+//        kdDebug(6035) << "ID_TEXT: \"" << DOMString(t->text).string() << "\"" << endl;
+        n = new TextImpl(document, t->text);
+        break;
+    case ID_COMMENT:
+#ifdef COMMENTS_IN_DOM
+        n = new CommentImpl(document, t->text);
+#endif
+        break;
+    default:
+        kdDebug( 6035 ) << "Unknown tag " << t->tid << "!" << endl;
+    }
+    return n;
+}
+
+void KHTMLParser::processCloseTag(Token *t)
+{
+    // support for really broken html. Can't believe I'm supporting such crap (lars)
+    switch(t->tid)
+    {
+    case ID_HTML+ID_CLOSE_TAG:
+    case ID_BODY+ID_CLOSE_TAG:
+        // we never trust those close tags, since stupid webpages close
+        // them prematurely
+        return;
+    case ID_FORM+ID_CLOSE_TAG:
+        form = 0;
+        // this one is to get the right style on the body element
+        break;
+    case ID_MAP+ID_CLOSE_TAG:
+        map = 0;
+        break;
+    case ID_SELECT+ID_CLOSE_TAG:
+        inSelect = false;
+        break;
+    case ID_TITLE+ID_CLOSE_TAG:
+        // Set haveTitle only if <title> isn't empty
+        if ( current->firstChild() )
+            haveTitle = true;
+        break;
+    default:
+        break;
+    }
+
+#ifdef PARSER_DEBUG
+    kdDebug( 6035 ) << "added the following children to " << current->nodeName().string() << endl;
+    NodeImpl *child = current->firstChild();
+    while(child != 0)
+    {
+        kdDebug( 6035 ) << "    " << child->nodeName().string() << endl;
+        child = child->nextSibling();
+    }
+#endif
+    popBlock(t->tid-ID_CLOSE_TAG);
+#ifdef PARSER_DEBUG
+    kdDebug( 6035 ) << "closeTag --> current = " << current->nodeName().string() << endl;
+#endif
+}
+
+bool KHTMLParser::isResidualStyleTag(int _id)
+{
+    switch (_id) {
+        case ID_A:
+        case ID_FONT:
+        case ID_TT:
+        case ID_U:
+        case ID_B:
+        case ID_I:
+        case ID_S:
+        case ID_STRIKE:
+        case ID_BIG:
+        case ID_SMALL:
+        case ID_EM:
+        case ID_STRONG:
+        case ID_DFN:
+        case ID_CODE:
+        case ID_SAMP:
+        case ID_KBD:
+        case ID_VAR:
+        case ID_DEL:
+        case ID_INS:
+        case ID_WBR:
+        case ID_NOBR:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool KHTMLParser::isAffectedByResidualStyle(int _id)
+{
+    if (isResidualStyleTag(_id))
+        return true;
+
+    switch (_id) {
+        case ID_P:
+        case ID_DIV:
+        case ID_BLOCKQUOTE:
+        case ID_ADDRESS:
+        case ID_H1:
+        case ID_H2:
+        case ID_H3:
+        case ID_H4:
+        case ID_H5:
+        case ID_H6:
+        case ID_CENTER:
+        case ID_UL:
+        case ID_OL:
+        case ID_LI:
+        case ID_DL:
+        case ID_DT:
+        case ID_DD:
+        case ID_PRE:
+            return true;
+        default:
+            return false;
+    }
+}
+
+void KHTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
+{
+    // Find the element that crosses over to a higher level.
+    // ### For now, if there is more than one, we will only make sure we close the residual style.
+    int exceptionCode = 0;
+    HTMLStackElem* curr = blockStack;
+    HTMLStackElem* maxElem = 0;
+    HTMLStackElem* endElem = 0;
+    HTMLStackElem* prev = 0;
+    HTMLStackElem* prevMaxElem = 0;
+    bool advancedResidual = false; // ### if set we only close the residual style
+    while (curr && curr != elem) {
+        if (curr->level > elem->level) {
+            if (!isAffectedByResidualStyle(curr->id)) return;
+            if (maxElem) advancedResidual = true;
+            else
+                endElem = curr;
+            maxElem = curr;
+            prevMaxElem = prev;
+        }
+
+        prev = curr;
+        curr = curr->next;
+    }
+
+    if (!curr || !maxElem ) return;
+
+    NodeImpl* residualElem = prev->node;
+    NodeImpl* blockElem = prevMaxElem ? prevMaxElem->node : current;
+    NodeImpl* parentElem = elem->node;
+
+    // Check to see if the reparenting that is going to occur is allowed according to the DOM.
+    // FIXME: We should either always allow it or perform an additional fixup instead of
+    // just bailing here.
+    // Example: <p><font><center>blah</font></center></p> isn't doing a fixup right now.
+    if (!parentElem->childAllowed(blockElem))
+        return;
+
+    if (maxElem->node->parentNode() != elem->node && !advancedResidual) {
+        // Walk the stack and remove any elements that aren't residual style tags.  These
+        // are basically just being closed up.  Example:
+        // <font><span>Moo<p>Goo</font></p>.
+        // In the above example, the <span> doesn't need to be reopened.  It can just close.
+        HTMLStackElem* currElem = maxElem->next;
+        HTMLStackElem* prevElem = maxElem;
+        while (currElem != elem) {
+            HTMLStackElem* nextElem = currElem->next;
+            if (!isResidualStyleTag(currElem->id)) {
+                prevElem->next = nextElem;
+                prevElem->setNode(currElem->node);
+                delete currElem;
+            }
+            else
+               prevElem = currElem;
+            currElem = nextElem;
+        }
+
+        // We have to reopen residual tags in between maxElem and elem.  An example of this case s:
+        // <font><i>Moo<p>Foo</font>.
+        // In this case, we need to transform the part before the <p> into:
+        // <font><i>Moo</i></font><i>
+        // so that the <i> will remain open.  This involves the modification of elements
+        // in the block stack.
+        // This will also affect how we ultimately reparent the block, since we want it to end up
+        // under the reopened residual tags (e.g., the <i> in the above example.)
+        NodeImpl* prevNode = 0;
+        NodeImpl* currNode = 0;
+        currElem = maxElem;
+        while (currElem->node != residualElem) {
+            if (isResidualStyleTag(currElem->node->id())) {
+                // Create a clone of this element.
+                currNode = currElem->node->cloneNode(false);
+                currElem->node->close();
+                removeForbidden(currElem->id, forbiddenTag);
+
+                // Change the stack element's node to point to the clone.
+                currElem->setNode(currNode);
+
+                // Attach the previous node as a child of this new node.
+                if (prevNode)
+                    currNode->appendChild(prevNode, exceptionCode);
+                else // The new parent for the block element is going to be the innermost clone.
+                    parentElem = currNode;
+
+                prevNode = currNode;
+            }
+
+            currElem = currElem->next;
+        }
+
+        // Now append the chain of new residual style elements if one exists.
+        if (prevNode)
+            elem->node->appendChild(prevNode, exceptionCode);
+    }
+
+    // We need to make a clone of |residualElem| and place it just inside |blockElem|.
+    // All content of |blockElem| is reparented to be under this clone.  We then
+    // reparent |blockElem| using real DOM calls so that attachment/detachment will
+    // be performed to fix up the rendering tree.
+    // So for this example: <b>...<p>Foo</b>Goo</p>
+    // The end result will be: <b>...</b><p><b>Foo</b>Goo</p>
+    //
+    // Step 1: Remove |blockElem| from its parent, doing a batch detach of all the kids.
+    SharedPtr<NodeImpl> guard(blockElem);
+    blockElem->parentNode()->removeChild(blockElem, exceptionCode);
+
+    if (!advancedResidual) {
+    // Step 2: Clone |residualElem|.
+    NodeImpl* newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.
+
+    // Step 3: Place |blockElem|'s children under |newNode|.  Remove all of the children of |blockElem|
+    // before we've put |newElem| into the document.  That way we'll only do one attachment of all
+    // the new content (instead of a bunch of individual attachments).
+    NodeImpl* currNode = blockElem->firstChild();
+    while (currNode) {
+        NodeImpl* nextNode = currNode->nextSibling();
+        SharedPtr<NodeImpl> guard(currNode); //Protect from deletion while moving
+        blockElem->removeChild(currNode, exceptionCode);
+        newNode->appendChild(currNode, exceptionCode);
+        currNode = nextNode;
+
+ // TODO - To be replaced.
+        // Re-register form elements with currently active form, step 1 will have removed them
+        if (form && currNode && currNode->isGenericFormElement())
+        {
+            HTMLGenericFormElementImpl *e = static_cast<HTMLGenericFormElementImpl *>(currNode);
+            form->registerFormElement(e);
+        }
+    }
+
+    // Step 4: Place |newNode| under |blockElem|.  |blockElem| is still out of the document, so no
+    // attachment can occur yet.
+    blockElem->appendChild(newNode, exceptionCode);
+    }
+
+    // Step 5: Reparent |blockElem|.  Now the full attachment of the fixed up tree takes place.
+    parentElem->appendChild(blockElem, exceptionCode);
+
+    // Step 6: Elide |elem|, since it is effectively no longer open.  Also update
+    // the node associated with the previous stack element so that when it gets popped,
+    // it doesn't make the residual element the next current node.
+    HTMLStackElem* currElem = maxElem;
+    HTMLStackElem* prevElem = 0;
+    while (currElem != elem) {
+        prevElem = currElem;
+        currElem = currElem->next;
+    }
+    prevElem->next = elem->next;
+    prevElem->setNode(elem->node);
+    delete elem;
+
+    // Step 7: Reopen intermediate inlines, e.g., <b><p><i>Foo</b>Goo</p>.
+    // In the above example, Goo should stay italic.
+    curr = blockStack;
+    HTMLStackElem* residualStyleStack = 0;
+    while (curr && curr != endElem) {
+        // We will actually schedule this tag for reopening
+        // after we complete the close of this entire block.
+        NodeImpl* currNode = current;
+        if (isResidualStyleTag(curr->id)) {
+            // We've overloaded the use of stack elements and are just reusing the
+            // struct with a slightly different meaning to the variables.  Instead of chaining
+            // from innermost to outermost, we build up a list of all the tags we need to reopen
+            // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
+            // to the outermost tag we need to reopen.
+            // We also set curr->node to be the actual element that corresponds to the ID stored in
+            // curr->id rather than the node that you should pop to when the element gets pulled off
+            // the stack.
+            popOneBlock(false);
+            curr->setNode(currNode);
+            curr->next = residualStyleStack;
+            residualStyleStack = curr;
+        }
+        else
+            popOneBlock();
+
+        curr = blockStack;
+    }
+
+    reopenResidualStyleTags(residualStyleStack, 0); // FIXME: Deal with stray table content some day
+                                                    // if it becomes necessary to do so.
+}
+
+void KHTMLParser::reopenResidualStyleTags(HTMLStackElem* elem, DOM::NodeImpl* malformedTableParent)
+{
+    // Loop for each tag that needs to be reopened.
+    while (elem) {
+        // Create a shallow clone of the DOM node for this element.
+        NodeImpl* newNode = elem->node->cloneNode(false);
+
+        // Append the new node. In the malformed table case, we need to insert before the table,
+        // which will be the last child.
+        int exceptionCode = 0;
+        if (malformedTableParent)
+            malformedTableParent->insertBefore(newNode, malformedTableParent->lastChild(), exceptionCode);
+        else
+            current->appendChild(newNode, exceptionCode);
+        // FIXME: Is it really OK to ignore the exceptions here?
+
+        // Now push a new stack element for this node we just created.
+        pushBlock(elem->id, elem->level);
+
+        // Set our strayTableContent boolean if needed, so that the reopened tag also knows
+        // that it is inside a malformed table.
+        blockStack->strayTableContent = malformedTableParent != 0;
+        if (blockStack->strayTableContent)
+            inStrayTableContent++;
+
+        // Clear our malformed table parent variable.
+        malformedTableParent = 0;
+
+        // Update |current| manually to point to the new node.
+        setCurrent(newNode);
+
+        // Advance to the next tag that needs to be reopened.
+        HTMLStackElem* next = elem->next;
+        delete elem;
+        elem = next;
+    }
+}
+
+void KHTMLParser::pushBlock(int _id, int _level)
+{
+    HTMLStackElem *Elem = new HTMLStackElem(_id, _level, current, m_inline, blockStack);
+
+    blockStack = Elem;
+    addForbidden(_id, forbiddenTag);
+}
+
+void KHTMLParser::popBlock( int _id )
+{
+    HTMLStackElem *Elem = blockStack;
+    int maxLevel = 0;
+
+#ifdef PARSER_DEBUG
+    kdDebug( 6035 ) << "popBlock(" << getTagName(_id) << ")" << endl;
+    while(Elem) {
+        kdDebug( 6035) << "   > " << getTagName(Elem->id) << endl;
+        Elem = Elem->next;
+    }
+    Elem = blockStack;
+#endif
+
+    while( Elem && (Elem->id != _id))
+    {
+        if (maxLevel < Elem->level)
+        {
+            maxLevel = Elem->level;
+        }
+        Elem = Elem->next;
+    }
+    if (!Elem)
+        return;
+
+    if (maxLevel > Elem->level) {
+        // We didn't match because the tag is in a different scope, e.g.,
+        // <b><p>Foo</b>.  Try to correct the problem.
+        if (!isResidualStyleTag(_id))
+            return;
+        return handleResidualStyleCloseTagAcrossBlocks(Elem);
+    }
+
+    bool isAffectedByStyle = isAffectedByResidualStyle(Elem->id);
+    HTMLStackElem* residualStyleStack = 0;
+    NodeImpl* malformedTableParent = 0;
+
+    Elem = blockStack;
+
+    while (Elem)
+    {
+        if (Elem->id == _id)
+        {
+            int strayTable = inStrayTableContent;
+            popOneBlock();
+            Elem = 0;
+
+            // This element was the root of some malformed content just inside an implicit or
+            // explicit <tbody> or <tr>.
+            // If we end up needing to reopen residual style tags, the root of the reopened chain
+            // must also know that it is the root of malformed content inside a <tbody>/<tr>.
+            if (strayTable && (inStrayTableContent < strayTable) && residualStyleStack) {
+                NodeImpl* curr = current;
+                while (curr && curr->id() != ID_TABLE)
+                    curr = curr->parentNode();
+                malformedTableParent = curr ? curr->parentNode() : 0;
+            }
+        }
+        else
+        {
+            // Schedule this tag for reopening
+            // after we complete the close of this entire block.
+            NodeImpl* currNode = current;
+            if (isAffectedByStyle && isResidualStyleTag(Elem->id)) {
+                // We've overloaded the use of stack elements and are just reusing the
+                // struct with a slightly different meaning to the variables.  Instead of chaining
+                // from innermost to outermost, we build up a list of all the tags we need to reopen
+                // from the outermost to the innermost, i.e., residualStyleStack will end up pointing
+                // to the outermost tag we need to reopen.
+                // We also set Elem->node to be the actual element that corresponds to the ID stored in
+                // Elem->id rather than the node that you should pop to when the element gets pulled off
+                // the stack.
+                popOneBlock(false);
+                Elem->next = residualStyleStack;
+                Elem->setNode(currNode);
+                residualStyleStack = Elem;
+            }
+            else
+                popOneBlock();
+            Elem = blockStack;
+        }
+    }
+
+    reopenResidualStyleTags(residualStyleStack, malformedTableParent);
+}
+
+void KHTMLParser::popOneBlock(bool delBlock)
+{
+    HTMLStackElem *Elem = blockStack;
+
+    // we should never get here, but some bad html might cause it.
+#ifndef PARSER_DEBUG
+    if(!Elem) return;
+#else
+    kdDebug( 6035 ) << "popping block: " << getTagName(Elem->id) << "(" << Elem->id << ")" << endl;
+#endif
+
+#if SPEED_DEBUG < 1
+    if((Elem->node != current)) {
+        if (current->maintainsState() && document){
+            document->registerMaintainsState(current);
+            QString state(document->nextState());
+            if (!state.isNull()) current->restoreState(state);
+        }
+        current->close();
+    }
+#endif
+
+    removeForbidden(Elem->id, forbiddenTag);
+
+    blockStack = Elem->next;
+    // we only set inline to false, if the element we close is a block level element.
+    // This helps getting cases as <p><b>bla</b> <b>bla</b> right.
+
+    m_inline = Elem->m_inline;
+
+    if (current->id() == ID_FORM && form && inStrayTableContent)
+        form->setMalformed(true);
+
+    setCurrent( Elem->node );
+
+    if (Elem->strayTableContent)
+        inStrayTableContent--;
+
+    if (delBlock)
+        delete Elem;
+}
+
+void KHTMLParser::popInlineBlocks()
+{
+    while(blockStack && current->isInline() && current->id() != ID_FONT)
+        popOneBlock();
+}
+
+void KHTMLParser::freeBlock()
+{
+    while (blockStack)
+        popOneBlock();
+    blockStack = 0;
+}
+
+void KHTMLParser::createHead()
+{
+    if(head || !doc()->firstChild())
+        return;
+
+    head = new HTMLHeadElementImpl(document);
+    HTMLElementImpl *body = doc()->body();
+    int exceptioncode = 0;
+    doc()->firstChild()->insertBefore(head, body, exceptioncode);
+    if ( exceptioncode ) {
+#ifdef PARSER_DEBUG
+        kdDebug( 6035 ) << "creation of head failed!!!!" << endl;
+#endif
+        delete head;
+        head = 0;
+    }
+}
+
+NodeImpl *KHTMLParser::handleIsindex( Token *t )
+{
+    NodeImpl *n;
+    HTMLFormElementImpl *myform = form;
+    if ( !myform ) {
+        myform = new HTMLFormElementImpl(document, true);
+        n = myform;
+    } else
+        n = new HTMLDivElementImpl( document, ID_DIV );
+    NodeImpl *child = new HTMLHRElementImpl( document );
+    n->addChild( child );
+    DOMStringImpl* a = t->attrs ? t->attrs->getValue(ATTR_PROMPT) : 0;
+    DOMString text = i18n("This is a searchable index. Enter search keywords: ");
+    if (a)
+        text = a;
+    child = new TextImpl(document, text.implementation());
+    n->addChild( child );
+    child = new HTMLIsIndexElementImpl(document, myform);
+    static_cast<ElementImpl *>(child)->setAttribute(ATTR_TYPE, "khtml_isindex");
+    n->addChild( child );
+    child = new HTMLHRElementImpl( document );
+    n->addChild( child );
+
+    return n;
+}
+
+void KHTMLParser::startBody()
+{
+    if(inBody) return;
+
+    inBody = true;
+
+    if( isindex ) {
+        insertNode( isindex, true /* don't decend into this node */ );
+        isindex = 0;
+    }
+}