1/*
2 * Copyright (C) 2000 Peter Kelly (pmk@post.com)
3 * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
4 * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
5 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
6 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public License
19 * along with this library; see the file COPYING.LIB.  If not, write to
20 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 *
23 */
24
25#ifndef XMLDocumentParser_h
26#define XMLDocumentParser_h
27
28#include "core/dom/ParserContentPolicy.h"
29#include "core/dom/ScriptableDocumentParser.h"
30#include "core/loader/cache/ResourceClient.h"
31#include "core/loader/cache/ResourcePtr.h"
32#include "core/platform/text/SegmentedString.h"
33#include "core/xml/XMLErrors.h"
34#include <libxml/tree.h>
35#include <wtf/HashMap.h>
36#include <wtf/OwnPtr.h>
37#include <wtf/text/CString.h>
38#include <wtf/text/StringHash.h>
39
40namespace WebCore {
41
42class ContainerNode;
43class ScriptResource;
44class ResourceFetcher;
45class DocumentFragment;
46class Document;
47class Element;
48class FrameView;
49class Text;
50
51    class XMLParserContext : public RefCounted<XMLParserContext> {
52    public:
53        static PassRefPtr<XMLParserContext> createMemoryParser(xmlSAXHandlerPtr, void* userData, const CString& chunk);
54        static PassRefPtr<XMLParserContext> createStringParser(xmlSAXHandlerPtr, void* userData);
55        ~XMLParserContext();
56        xmlParserCtxtPtr context() const { return m_context; }
57
58    private:
59        XMLParserContext(xmlParserCtxtPtr context)
60            : m_context(context)
61        {
62        }
63        xmlParserCtxtPtr m_context;
64    };
65
66    class XMLDocumentParser : public ScriptableDocumentParser, public ResourceClient {
67        WTF_MAKE_FAST_ALLOCATED;
68    public:
69        static PassRefPtr<XMLDocumentParser> create(Document* document, FrameView* view)
70        {
71            return adoptRef(new XMLDocumentParser(document, view));
72        }
73        static PassRefPtr<XMLDocumentParser> create(DocumentFragment* fragment, Element* element, ParserContentPolicy parserContentPolicy)
74        {
75            return adoptRef(new XMLDocumentParser(fragment, element, parserContentPolicy));
76        }
77
78        ~XMLDocumentParser();
79
80        // Exposed for callbacks:
81        void handleError(XMLErrors::ErrorType, const char* message, TextPosition);
82
83        void setIsXHTMLDocument(bool isXHTML) { m_isXHTMLDocument = isXHTML; }
84        bool isXHTMLDocument() const { return m_isXHTMLDocument; }
85
86        bool isCurrentlyParsing8BitChunk() { return m_isCurrentlyParsing8BitChunk; }
87
88        static bool parseDocumentFragment(const String&, DocumentFragment*, Element* parent = 0, ParserContentPolicy = AllowScriptingContent);
89
90        // Used by the XMLHttpRequest to check if the responseXML was well formed.
91        virtual bool wellFormed() const { return !m_sawError; }
92
93        TextPosition textPosition() const;
94
95        static bool supportsXMLVersion(const String&);
96
97        class PendingCallback {
98        public:
99            virtual ~PendingCallback() { }
100            virtual void call(XMLDocumentParser*) = 0;
101        };
102
103    private:
104        XMLDocumentParser(Document*, FrameView* = 0);
105        XMLDocumentParser(DocumentFragment*, Element*, ParserContentPolicy);
106
107        // From DocumentParser
108        virtual void insert(const SegmentedString&);
109        virtual void append(PassRefPtr<StringImpl>);
110        virtual void finish();
111        virtual bool isWaitingForScripts() const;
112        virtual void stopParsing();
113        virtual void detach();
114        virtual OrdinalNumber lineNumber() const;
115        OrdinalNumber columnNumber() const;
116
117        // from ResourceClient
118        virtual void notifyFinished(Resource*);
119
120        void end();
121
122        void pauseParsing();
123        void resumeParsing();
124
125        bool appendFragmentSource(const String&);
126
127    public:
128        // callbacks from parser SAX
129        void error(XMLErrors::ErrorType, const char* message, va_list args) WTF_ATTRIBUTE_PRINTF(3, 0);
130        void startElementNs(const AtomicString& localName, const AtomicString& prefix, const AtomicString& uri, int nb_namespaces,
131                            const xmlChar** namespaces, int nb_attributes, int nb_defaulted, const xmlChar** libxmlAttributes);
132        void endElementNs();
133        void characters(const xmlChar* chars, int length);
134        void processingInstruction(const String& target, const String& data);
135        void cdataBlock(const String&);
136        void comment(const String&);
137        void startDocument(const String& version, const String& encoding, int standalone);
138        void internalSubset(const String& name, const String& externalID, const String& systemID);
139        void endDocument();
140
141    private:
142        void initializeParserContext(const CString& chunk = CString());
143
144        void pushCurrentNode(ContainerNode*);
145        void popCurrentNode();
146        void clearCurrentNodeStack();
147
148        void insertErrorMessageBlock();
149
150        void enterText();
151        void exitText();
152
153        void doWrite(const String&);
154        void doEnd();
155
156        FrameView* m_view;
157
158        SegmentedString m_originalSourceForTransform;
159
160        xmlParserCtxtPtr context() const { return m_context ? m_context->context() : 0; };
161        RefPtr<XMLParserContext> m_context;
162        Deque<OwnPtr<PendingCallback> > m_pendingCallbacks;
163        Vector<xmlChar> m_bufferedText;
164
165        ContainerNode* m_currentNode;
166        Vector<ContainerNode*> m_currentNodeStack;
167
168        RefPtr<Text> m_leafTextNode;
169
170        bool m_isCurrentlyParsing8BitChunk;
171        bool m_sawError;
172        bool m_sawCSS;
173        bool m_sawXSLTransform;
174        bool m_sawFirstElement;
175        bool m_isXHTMLDocument;
176        bool m_parserPaused;
177        bool m_requestingScript;
178        bool m_finishCalled;
179
180        XMLErrors m_xmlErrors;
181
182        ResourcePtr<ScriptResource> m_pendingScript;
183        RefPtr<Element> m_scriptElement;
184        TextPosition m_scriptStartPosition;
185
186        bool m_parsingFragment;
187        AtomicString m_defaultNamespaceURI;
188
189        typedef HashMap<AtomicString, AtomicString> PrefixForNamespaceMap;
190        PrefixForNamespaceMap m_prefixToNamespaceMap;
191        SegmentedString m_pendingSrc;
192    };
193
194xmlDocPtr xmlDocPtrForString(ResourceFetcher*, const String& source, const String& url);
195
196HashMap<String, String> parseAttributes(const String&, bool& attrsOK);
197
198} // namespace WebCore
199
200#endif // XMLDocumentParser_h
201