/**

 * This file is part of the DOM implementation for KDE.

 *

 * Copyright (C) 2000 Peter Kelly (pmk@post.com)

 * Copyright (C) 2005, 2006 Apple Computer, Inc.

 * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)

 * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)

 * Copyright (C) 2007 Trolltech ASA

 *

 * 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.

 */

#include "config.h"

#include "XMLTokenizer.h"

#include "CDATASection.h"

#include "CString.h"

#include "Cache.h"

#include "CachedScript.h"

#include "Comment.h"

#include "DocLoader.h"

#include "Document.h"

#include "DocumentFragment.h"

#include "DocumentType.h"

#include "EventNames.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameView.h"

#include "HTMLNames.h"

#include "HTMLScriptElement.h"

#include "HTMLStyleElement.h"

#include "HTMLTableSectionElement.h"

#include "HTMLTokenizer.h"

#include "ProcessingInstruction.h"

#include "ResourceHandle.h"

#include "ResourceRequest.h"

#include "ResourceResponse.h"

#ifndef USE_QXMLSTREAM

#include <libxml/parser.h>

#include <libxml/parserInternals.h>

#else

#include <QDebug>

#endif

#include <wtf/Platform.h>

#include <wtf/Vector.h>

#if ENABLE(XSLT)

#include <libxslt/xslt.h>

#endif

#if ENABLE(SVG)

#include "SVGNames.h"

#include "SVGStyleElement.h"

#include "XLinkNames.h"

#endif

using namespace std;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

const int maxErrors = 25;

#ifndef USE_QXMLSTREAM

class PendingCallbacks {

public:

    PendingCallbacks()

    {

        m_callbacks.setAutoDelete(true);

    }

    void appendStartElementNSCallback(const xmlChar* xmlLocalName, const xmlChar* xmlPrefix, const xmlChar* xmlURI, int nb_namespaces,

                                      const xmlChar** namespaces, int nb_attributes, int nb_defaulted, const xmlChar** attributes)

    {

        PendingStartElementNSCallback* callback = new PendingStartElementNSCallback;

        callback->xmlLocalName = xmlStrdup(xmlLocalName);

        callback->xmlPrefix = xmlStrdup(xmlPrefix);

        callback->xmlURI = xmlStrdup(xmlURI);

        callback->nb_namespaces = nb_namespaces;

        callback->namespaces = reinterpret_cast<xmlChar**>(xmlMalloc(sizeof(xmlChar*) * nb_namespaces * 2));

        for (int i = 0; i < nb_namespaces * 2 ; i++)

            callback->namespaces[i] = xmlStrdup(namespaces[i]);

        callback->nb_attributes = nb_attributes;

        callback->nb_defaulted = nb_defaulted;

        callback->attributes =  reinterpret_cast<xmlChar**>(xmlMalloc(sizeof(xmlChar*) * nb_attributes * 5));

        for (int i = 0; i < nb_attributes; i++) {

            // Each attribute has 5 elements in the array:

            // name, prefix, uri, value and an end pointer.

            for (int j = 0; j < 3; j++)

                callback->attributes[i * 5 + j] = xmlStrdup(attributes[i * 5 + j]);

            int len = attributes[i * 5 + 4] - attributes[i * 5 + 3];

            callback->attributes[i * 5 + 3] = xmlStrndup(attributes[i * 5 + 3], len);

            callback->attributes[i * 5 + 4] = callback->attributes[i * 5 + 3] + len;

        }

        m_callbacks.append(callback);

    }

    void appendEndElementNSCallback()

    {

        PendingEndElementNSCallback* callback = new PendingEndElementNSCallback;

        m_callbacks.append(callback);

    }

    void appendCharactersCallback(const xmlChar* s, int len)

    {

        PendingCharactersCallback* callback = new PendingCharactersCallback;

        callback->s = xmlStrndup(s, len);

        callback->len = len;

        m_callbacks.append(callback);        

    }

    void appendProcessingInstructionCallback(const xmlChar* target, const xmlChar* data)

    {

        PendingProcessingInstructionCallback* callback = new PendingProcessingInstructionCallback;

        callback->target = xmlStrdup(target);

        callback->data = xmlStrdup(data);

        m_callbacks.append(callback);

    }

    void appendCDATABlockCallback(const xmlChar* s, int len)

    {

        PendingCDATABlockCallback* callback = new PendingCDATABlockCallback;

        callback->s = xmlStrndup(s, len);

        callback->len = len;

        m_callbacks.append(callback);        

    }

    void appendCommentCallback(const xmlChar* s)

    {

        PendingCommentCallback* callback = new PendingCommentCallback;

        callback->s = xmlStrdup(s);

        m_callbacks.append(callback);        

    }

    void appendInternalSubsetCallback(const xmlChar* name, const xmlChar* externalID, const xmlChar* systemID)

    {

        PendingInternalSubsetCallback* callback = new PendingInternalSubsetCallback;

        callback->name = xmlStrdup(name);

        callback->externalID = xmlStrdup(externalID);

        callback->systemID = xmlStrdup(systemID);

        m_callbacks.append(callback);        

    }

    void appendErrorCallback(XMLTokenizer::ErrorType type, const char* message, int lineNumber, int columnNumber)

    {

        PendingErrorCallback* callback = new PendingErrorCallback;

        callback->message = strdup(message);

        callback->type = type;

        callback->lineNumber = lineNumber;

        callback->columnNumber = columnNumber;

        m_callbacks.append(callback);

    }

    void callAndRemoveFirstCallback(XMLTokenizer* tokenizer)

    {

        PendingCallback* cb = m_callbacks.getFirst();

        cb->call(tokenizer);

        m_callbacks.removeFirst();

    }

    bool isEmpty() const { return m_callbacks.isEmpty(); }

private:    

    struct PendingCallback {        

        virtual ~PendingCallback() { } 

        virtual void call(XMLTokenizer* tokenizer) = 0;

    };  

    struct PendingStartElementNSCallback : public PendingCallback {        

        virtual ~PendingStartElementNSCallback() {

            xmlFree(xmlLocalName);

            xmlFree(xmlPrefix);

            xmlFree(xmlURI);

            for (int i = 0; i < nb_namespaces * 2; i++)

                xmlFree(namespaces[i]);

            xmlFree(namespaces);

            for (int i = 0; i < nb_attributes; i++)

                for (int j = 0; j < 4; j++) 

                    xmlFree(attributes[i * 5 + j]);

            xmlFree(attributes);

        }

        virtual void call(XMLTokenizer* tokenizer) {

            tokenizer->startElementNs(xmlLocalName, xmlPrefix, xmlURI, 

                                      nb_namespaces, (const xmlChar**)namespaces,

                                      nb_attributes, nb_defaulted, (const xmlChar**)(attributes));

        }

        xmlChar* xmlLocalName;

        xmlChar* xmlPrefix;

        xmlChar* xmlURI;

        int nb_namespaces;

        xmlChar** namespaces;

        int nb_attributes;

        int nb_defaulted;

        xmlChar** attributes;

    };

    struct PendingEndElementNSCallback : public PendingCallback {

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->endElementNs();

        }

    };

    struct PendingCharactersCallback : public PendingCallback {

        virtual ~PendingCharactersCallback() 

        {

            xmlFree(s);

        }

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->characters(s, len);

        }

        xmlChar* s;

        int len;

    };

    struct PendingProcessingInstructionCallback : public PendingCallback {

        virtual ~PendingProcessingInstructionCallback() 

        {

            xmlFree(target);

            xmlFree(data);

        }

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->processingInstruction(target, data);

        }

        xmlChar* target;

        xmlChar* data;

    };

    struct PendingCDATABlockCallback : public PendingCallback {

        virtual ~PendingCDATABlockCallback() 

        {

            xmlFree(s);

        }

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->cdataBlock(s, len);

        }

        xmlChar* s;

        int len;

    };

    struct PendingCommentCallback : public PendingCallback {

        virtual ~PendingCommentCallback() 

        {

            xmlFree(s);

        }

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->comment(s);

        }

        xmlChar* s;

    };

    struct PendingInternalSubsetCallback : public PendingCallback {

        virtual ~PendingInternalSubsetCallback() 

        {

            xmlFree(name);

            xmlFree(externalID);

            xmlFree(systemID);

        }

        virtual void call(XMLTokenizer* tokenizer)

        {

            tokenizer->internalSubset(name, externalID, systemID);

        }

        xmlChar* name;

        xmlChar* externalID;

        xmlChar* systemID;        

    };

    struct PendingErrorCallback: public PendingCallback {

        virtual ~PendingErrorCallback() 

        {

            free (message);

        }

        virtual void call(XMLTokenizer* tokenizer) 

        {

            tokenizer->handleError(type, message, lineNumber, columnNumber);

        }

        XMLTokenizer::ErrorType type;

        char* message;

        int lineNumber;

        int columnNumber;

    };

public:

    DeprecatedPtrList<PendingCallback> m_callbacks;

};

#endif

// --------------------------------

static int globalDescriptor = 0;

static int matchFunc(const char* uri)

{

    return 1; // Match everything.

}

static DocLoader* globalDocLoader = 0;

class OffsetBuffer {

public:

    OffsetBuffer(const Vector<char>& b) : m_buffer(b), m_currentOffset(0) { }

    int readOutBytes(char* outputBuffer, unsigned askedToRead) {

        unsigned bytesLeft = m_buffer.size() - m_currentOffset;

        unsigned lenToCopy = min(askedToRead, bytesLeft);

        if (lenToCopy) {

            memcpy(outputBuffer, m_buffer.data() + m_currentOffset, lenToCopy);

            m_currentOffset += lenToCopy;

        }

        return lenToCopy;

    }

private:

    Vector<char> m_buffer;

    unsigned m_currentOffset;

};

#ifndef USE_QXMLSTREAM

static bool shouldAllowExternalLoad(const char* inURI)

{

    if (strstr(inURI, "/etc/xml/catalog")

            || strstr(inURI, "http://www.w3.org/Graphics/SVG") == inURI

            || strstr(inURI, "http://www.w3.org/TR/xhtml") == inURI)

        return false;

    return true;

}

static void* openFunc(const char* uri)

{

    if (!globalDocLoader || !shouldAllowExternalLoad(uri))

        return &globalDescriptor;

    ResourceError error;

    ResourceResponse response;

    Vector<char> data;

    if (globalDocLoader->frame()) 

        globalDocLoader->frame()->loader()->loadResourceSynchronously(KURL(uri), error, response, data);

    return new OffsetBuffer(data);

}

static int readFunc(void* context, char* buffer, int len)

{

    // Do 0-byte reads in case of a null descriptor

    if (context == &globalDescriptor)

        return 0;

    OffsetBuffer* data = static_cast<OffsetBuffer*>(context);

    return data->readOutBytes(buffer, len);

}

static int writeFunc(void* context, const char* buffer, int len)

{

    // Always just do 0-byte writes

    return 0;

}

static int closeFunc(void* context)

{

    if (context != &globalDescriptor) {

        OffsetBuffer* data = static_cast<OffsetBuffer*>(context);

        delete data;

    }

    return 0;

}

static void errorFunc(void*, const char*, ...)

{

    // FIXME: It would be nice to display error messages somewhere.

}

void setLoaderForLibXMLCallbacks(DocLoader* docLoader)

{

    globalDocLoader = docLoader;

}

static xmlParserCtxtPtr createStringParser(xmlSAXHandlerPtr handlers, void* userData)

{

    static bool didInit = false;

    if (!didInit) {

        xmlInitParser();

        xmlRegisterInputCallbacks(matchFunc, openFunc, readFunc, closeFunc);

        xmlRegisterOutputCallbacks(matchFunc, openFunc, writeFunc, closeFunc);

        didInit = true;

    }

    xmlParserCtxtPtr parser = xmlCreatePushParserCtxt(handlers, 0, 0, 0, 0);

    parser->_private = userData;

    parser->replaceEntities = true;

    const UChar BOM = 0xFEFF;

    const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);

    xmlSwitchEncoding(parser, BOMHighByte == 0xFF ? XML_CHAR_ENCODING_UTF16LE : XML_CHAR_ENCODING_UTF16BE);

    return parser;

}

#endif

// --------------------------------

XMLTokenizer::XMLTokenizer(Document* _doc, FrameView* _view)

    : m_doc(_doc)

    , m_view(_view)

#ifndef USE_QXMLSTREAM

    , m_context(0)

#endif

    , m_currentNode(_doc)

    , m_currentNodeIsReferenced(false)

    , m_sawError(false)

    , m_sawXSLTransform(false)

    , m_sawFirstElement(false)

    , m_isXHTMLDocument(false)

    , m_parserPaused(false)

    , m_requestingScript(false)

    , m_finishCalled(false)

    , m_errorCount(0)

    , m_lastErrorLine(0)

    , m_lastErrorColumn(0)

    , m_pendingScript(0)

    , m_scriptStartLine(0)

    , m_parsingFragment(false)

#ifndef USE_QXMLSTREAM

    , m_pendingCallbacks(new PendingCallbacks)

#endif

{

}

XMLTokenizer::XMLTokenizer(DocumentFragment* fragment, Element* parentElement)

    : m_doc(fragment->document())

    , m_view(0)

#ifndef USE_QXMLSTREAM

    , m_context(0)

#endif

    , m_currentNode(fragment)

    , m_currentNodeIsReferenced(fragment)

    , m_sawError(false)

    , m_sawXSLTransform(false)

    , m_sawFirstElement(false)

    , m_isXHTMLDocument(false)

    , m_parserPaused(false)

    , m_requestingScript(false)

    , m_finishCalled(false)

    , m_errorCount(0)

    , m_lastErrorLine(0)

    , m_lastErrorColumn(0)

    , m_pendingScript(0)

    , m_scriptStartLine(0)

    , m_parsingFragment(true)

#ifndef USE_QXMLSTREAM

    , m_pendingCallbacks(new PendingCallbacks)

#endif

{

    if (fragment)

        fragment->ref();

    if (m_doc)

        m_doc->ref();

    // Add namespaces based on the parent node

    Vector<Element*> elemStack;

    while (parentElement) {

        elemStack.append(parentElement);

        Node* n = parentElement->parentNode();

        if (!n || !n->isElementNode())

            break;

        parentElement = static_cast<Element*>(n);

    }

    if (elemStack.isEmpty())

        return;

    for (Element* element = elemStack.last(); !elemStack.isEmpty(); elemStack.removeLast()) {

        if (NamedAttrMap* attrs = element->attributes()) {

            for (unsigned i = 0; i < attrs->length(); i++) {

                Attribute* attr = attrs->attributeItem(i);

                if (attr->localName() == "xmlns")

                    m_defaultNamespaceURI = attr->value();