55720c9f62c8d6cba9e98c82ab601d08f8a91f75
[WebKit-https.git] / WebCore / dom / xml_tokenizer.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
5  * Copyright (C) 2005, 2006 Apple Computer, Inc.
6  * Copyright (C) 2006 Alexey Proskuryakov
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., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 #include "config.h"
25 #include "xml_tokenizer.h"
26
27 #include "CDATASection.h"
28 #include "Cache.h"
29 #include "CachedScript.h"
30 #include "Comment.h"
31 #include "DocLoader.h"
32 #include "Document.h"
33 #include "DocumentFragment.h"
34 #include "DocumentType.h"
35 #include "Frame.h"
36 #include "HTMLNames.h"
37 #include "HTMLScriptElement.h"
38 #include "HTMLTableSectionElement.h"
39 #include "HTMLTokenizer.h"
40 #include "KWQLoader.h"
41 #include "ProcessingInstruction.h"
42 #include "TransferJob.h"
43 #include <libxml/parser.h>
44 #include <libxml/parserInternals.h>
45 #include <wtf/Vector.h>
46
47 #if SVG_SUPPORT
48 #include "SVGNames.h"
49 #include "XLinkNames.h"
50 #endif
51
52 using namespace std;
53
54 namespace WebCore {
55
56 using namespace HTMLNames;
57
58 const int maxErrors = 25;
59
60 typedef HashMap<StringImpl *, StringImpl *> PrefixForNamespaceMap;
61
62 class XMLTokenizer : public Tokenizer, public CachedObjectClient
63 {
64 public:
65     XMLTokenizer(Document *, FrameView * = 0);
66     XMLTokenizer(DocumentFragment *, Element *);
67     ~XMLTokenizer();
68
69     enum ErrorType { warning, nonFatal, fatal };
70
71     // from Tokenizer
72     virtual bool write(const SegmentedString &str, bool);
73     virtual void finish();
74     virtual bool isWaitingForScripts() const;
75     virtual void stopParsing();
76
77     void setIsXHTMLDocument(bool isXHTML) { m_isXHTMLDocument = isXHTML; }
78     bool isXHTMLDocument() const { return m_isXHTMLDocument; }
79
80     // from CachedObjectClient
81     virtual void notifyFinished(CachedObject *finishedObj);
82
83     // callbacks from parser SAX
84     void error(ErrorType, const char *message, va_list args);
85     void startElementNs(const xmlChar *xmlLocalName, const xmlChar *xmlPrefix, const xmlChar *xmlURI, int nb_namespaces, const xmlChar **namespaces, int nb_attributes, int nb_defaulted, const xmlChar **libxmlAttributes);
86     void endElementNs();
87     void characters(const xmlChar *s, int len);
88     void processingInstruction(const xmlChar *target, const xmlChar *data);
89     void cdataBlock(const xmlChar *s, int len);
90     void comment(const xmlChar *s);
91     void internalSubset(const xmlChar *name, const xmlChar *externalID, const xmlChar *systemID);
92
93 private:
94     void initializeParserContext();
95     void setCurrentNode(Node*);
96
97     int lineNumber() const;
98     int columnNumber() const;
99
100     void insertErrorMessageBlock();
101
102     void executeScripts();
103     void addScripts(Node *n);
104
105     bool enterText();
106     void exitText();
107
108     Document *m_doc;
109     FrameView *m_view;
110     
111     DeprecatedString m_originalSourceForTransform;
112
113     xmlParserCtxtPtr m_context;
114     Node *m_currentNode;
115     bool m_currentNodeIsReferenced;
116
117     bool m_sawError;
118     bool m_sawXSLTransform;
119     bool m_sawFirstElement;
120     bool m_isXHTMLDocument;
121     
122     int m_errorCount;
123     int m_lastErrorLine;
124     int m_lastErrorColumn;
125     String m_errorMessages;
126
127     DeprecatedPtrList<Element> m_scripts;
128     DeprecatedPtrListIterator<Element> *m_scriptsIt;
129     CachedScript *m_cachedScript;
130     
131     bool m_parsingFragment;
132     String m_defaultNamespaceURI;
133     PrefixForNamespaceMap m_prefixToNamespaceMap;
134 };
135
136 // --------------------------------
137
138 static int globalDescriptor = 0;
139
140 static int matchFunc(const char* uri)
141 {
142     return 1; // Match everything.
143 }
144
145 static WebCore::DocLoader *globalDocLoader = 0;
146
147 class OffsetBuffer {
148 public:
149     OffsetBuffer(const Vector<char>& b) : m_buffer(b), m_currentOffset(0) { }
150     
151     int readOutBytes(char *outputBuffer, unsigned askedToRead) {
152         unsigned bytesLeft = m_buffer.size() - m_currentOffset;
153         unsigned lenToCopy = min(askedToRead, bytesLeft);
154         if (lenToCopy) {
155             memcpy(outputBuffer, m_buffer.data() + m_currentOffset, lenToCopy);
156             m_currentOffset += lenToCopy;
157         }
158         return lenToCopy;
159     }
160
161 private:
162     Vector<char> m_buffer;
163     unsigned m_currentOffset;
164 };
165
166 static bool shouldAllowExternalLoad(const char* inURI)
167 {
168     DeprecatedString url(inURI);
169     if (url.contains("/etc/catalog")
170         || url.startsWith("http://www.w3.org/Graphics/SVG")
171         || url.startsWith("http://www.w3.org/TR/xhtml"))
172         return false;
173     return true;
174 }
175
176 static void* openFunc(const char* uri)
177 {
178     if (!globalDocLoader || !shouldAllowExternalLoad(uri))
179         return &globalDescriptor;
180
181     KURL finalURL;
182     TransferJob* job = new TransferJob(0, "GET", uri);
183     DeprecatedString headers;
184     Vector<char> data = KWQServeSynchronousRequest(Cache::loader(), globalDocLoader, job, finalURL, headers);
185     
186     return new OffsetBuffer(data);
187 }
188
189 static int readFunc(void* context, char* buffer, int len)
190 {
191     // Do 0-byte reads in case of a null descriptor
192     if (context == &globalDescriptor)
193         return 0;
194         
195     OffsetBuffer *data = static_cast<OffsetBuffer *>(context);
196     return data->readOutBytes(buffer, len);
197 }
198
199 static int writeFunc(void* context, const char* buffer, int len)
200 {
201     // Always just do 0-byte writes
202     return 0;
203 }
204
205 static int closeFunc(void * context)
206 {
207     if (context != &globalDescriptor) {
208         OffsetBuffer *data = static_cast<OffsetBuffer *>(context);
209         delete data;
210     }
211     return 0;
212 }
213
214 void setLoaderForLibXMLCallbacks(DocLoader *docLoader)
215 {
216     globalDocLoader = docLoader;
217 }
218
219 static xmlParserCtxtPtr createQStringParser(xmlSAXHandlerPtr handlers, void *userData)
220 {
221     static bool didInit = false;
222     if (!didInit) {
223         xmlInitParser();
224         xmlRegisterInputCallbacks(matchFunc, openFunc, readFunc, closeFunc);
225         xmlRegisterOutputCallbacks(matchFunc, openFunc, writeFunc, closeFunc);
226         didInit = true;
227     }
228
229     xmlParserCtxtPtr parser = xmlCreatePushParserCtxt(handlers, 0, 0, 0, 0);
230     parser->_private = userData;
231     parser->replaceEntities = true;
232     const QChar BOM(0xFEFF);
233     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char *>(&BOM);
234     xmlSwitchEncoding(parser, BOMHighByte == 0xFF ? XML_CHAR_ENCODING_UTF16LE : XML_CHAR_ENCODING_UTF16BE);
235     return parser;
236 }
237
238 // --------------------------------
239
240 XMLTokenizer::XMLTokenizer(Document *_doc, FrameView *_view)
241     : m_doc(_doc)
242     , m_view(_view)
243     , m_context(0)
244     , m_currentNode(_doc)
245     , m_currentNodeIsReferenced(false)
246     , m_sawError(false)
247     , m_sawXSLTransform(false)
248     , m_sawFirstElement(false)
249     , m_isXHTMLDocument(false)
250     , m_errorCount(0)
251     , m_lastErrorLine(0)
252     , m_lastErrorColumn(0)
253     , m_scriptsIt(0)
254     , m_cachedScript(0)
255     , m_parsingFragment(false)
256 {
257 }
258
259 XMLTokenizer::XMLTokenizer(DocumentFragment *fragment, Element *parentElement)
260     : m_doc(fragment->document())
261     , m_view(0)
262     , m_context(0)
263     , m_currentNode(fragment)
264     , m_currentNodeIsReferenced(fragment)
265     , m_sawError(false)
266     , m_sawXSLTransform(false)
267     , m_sawFirstElement(false)
268     , m_isXHTMLDocument(false)
269     , m_errorCount(0)
270     , m_lastErrorLine(0)
271     , m_lastErrorColumn(0)
272     , m_scriptsIt(0)
273     , m_cachedScript(0)
274     , m_parsingFragment(true)
275 {
276     if (fragment)
277         fragment->ref();
278     if (m_doc)
279         m_doc->ref();
280           
281     // Add namespaces based on the parent node
282     Vector<Element*> elemStack;
283     while (parentElement) {
284         elemStack.append(parentElement);
285         
286         Node *n = parentElement->parentNode();
287         if (!n || !n->isElementNode())
288             break;
289         parentElement = static_cast<Element *>(n);
290     }
291     for (Element *element = elemStack.last(); !elemStack.isEmpty(); elemStack.removeLast()) {
292         if (NamedAttrMap *attrs = element->attributes()) {
293             for (unsigned i = 0; i < attrs->length(); i++) {
294                 Attribute *attr = attrs->attributeItem(i);
295                 if (attr->localName() == "xmlns")
296                     m_defaultNamespaceURI = attr->value();
297                 else if (attr->prefix() == "xmlns")
298                     m_prefixToNamespaceMap.set(attr->localName().impl(), attr->value().impl());
299             }
300         }
301     }
302 }
303
304 XMLTokenizer::~XMLTokenizer()
305 {
306     setCurrentNode(0);
307     if (m_parsingFragment && m_doc)
308         m_doc->deref();
309     delete m_scriptsIt;
310     if (m_cachedScript)
311         m_cachedScript->deref(this);
312 }
313
314 void XMLTokenizer::setCurrentNode(Node* n)
315 {
316     bool nodeNeedsReference = n && n != m_doc;
317     if (nodeNeedsReference)
318         n->ref(); 
319     if (m_currentNodeIsReferenced) 
320         m_currentNode->deref(); 
321     m_currentNode = n;
322     m_currentNodeIsReferenced = nodeNeedsReference;
323 }
324
325 bool XMLTokenizer::write(const SegmentedString &s, bool /*appendData*/ )
326 {
327     DeprecatedString parseString = s.toString();
328     if (m_sawXSLTransform || !m_sawFirstElement)
329         m_originalSourceForTransform += parseString;
330
331     if (m_parserStopped || m_sawXSLTransform)
332         return false;
333     if (!m_context)
334         initializeParserContext();
335     
336     // Hack around libxml2's lack of encoding overide support by manually
337     // resetting the encoding to UTF-16 before every chunk.  Otherwise libxml
338     // will detect <?xml version="1.0" encoding="<encoding name>"?> blocks 
339     // and switch encodings, causing the parse to fail.
340     const QChar BOM(0xFEFF);
341     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char *>(&BOM);
342     xmlSwitchEncoding(m_context, BOMHighByte == 0xFF ? XML_CHAR_ENCODING_UTF16LE : XML_CHAR_ENCODING_UTF16BE);
343     
344     xmlParseChunk(m_context, reinterpret_cast<const char *>(parseString.unicode()), sizeof(QChar) * parseString.length(), 0);
345     
346     return false;
347 }
348
349 inline DeprecatedString toQString(const xmlChar *str, unsigned int len)
350 {
351     return DeprecatedString::fromUtf8(reinterpret_cast<const char *>(str), len);
352 }
353
354 inline DeprecatedString toQString(const xmlChar *str)
355 {
356     return DeprecatedString::fromUtf8(str ? reinterpret_cast<const char *>(str) : "");
357 }
358
359 inline String toString(const xmlChar* str, unsigned int len)
360 {
361     return DeprecatedString::fromUtf8(reinterpret_cast<const char *>(str), len);
362 }
363
364 inline String toString(const xmlChar* str)
365 {
366     return DeprecatedString::fromUtf8(str ? reinterpret_cast<const char *>(str) : "");
367 }
368
369 struct _xmlSAX2Namespace {
370     const xmlChar *prefix;
371     const xmlChar *uri;
372 };
373 typedef struct _xmlSAX2Namespace xmlSAX2Namespace;
374
375 static inline void handleElementNamespaces(Element *newElement, const xmlChar **libxmlNamespaces, int nb_namespaces, ExceptionCode& ec)
376 {
377     xmlSAX2Namespace *namespaces = reinterpret_cast<xmlSAX2Namespace *>(libxmlNamespaces);
378     for(int i = 0; i < nb_namespaces; i++) {
379         String namespaceQName = "xmlns";
380         String namespaceURI = toString(namespaces[i].uri);
381         if (namespaces[i].prefix)
382             namespaceQName = "xmlns:" + toString(namespaces[i].prefix);
383         newElement->setAttributeNS("http://www.w3.org/2000/xmlns/", namespaceQName, namespaceURI, ec);
384         if (ec) // exception setting attributes
385             return;
386     }
387 }
388
389 struct _xmlSAX2Attributes {
390     const xmlChar *localname;
391     const xmlChar *prefix;
392     const xmlChar *uri;
393     const xmlChar *value;
394     const xmlChar *end;
395 };
396 typedef struct _xmlSAX2Attributes xmlSAX2Attributes;
397
398 static inline void handleElementAttributes(Element *newElement, const xmlChar **libxmlAttributes, int nb_attributes, ExceptionCode& ec)
399 {
400     xmlSAX2Attributes *attributes = reinterpret_cast<xmlSAX2Attributes *>(libxmlAttributes);
401     for(int i = 0; i < nb_attributes; i++) {
402         String attrLocalName = toQString(attributes[i].localname);
403         int valueLength = (int) (attributes[i].end - attributes[i].value);
404         String attrValue = toQString(attributes[i].value, valueLength);
405         String attrPrefix = toQString(attributes[i].prefix);
406         String attrURI = attrPrefix.isEmpty() ? String() : toQString(attributes[i].uri);
407         String attrQName = attrPrefix.isEmpty() ? attrLocalName : attrPrefix + ":" + attrLocalName;
408         
409         newElement->setAttributeNS(attrURI, attrQName, attrValue, ec);
410         if (ec) // exception setting attributes
411             return;
412     }
413 }
414
415 void XMLTokenizer::startElementNs(const xmlChar *xmlLocalName, const xmlChar *xmlPrefix, const xmlChar *xmlURI, int nb_namespaces, const xmlChar **libxmlNamespaces, int nb_attributes, int nb_defaulted, const xmlChar **libxmlAttributes)
416 {
417     if (m_parserStopped)
418         return;
419     
420     m_sawFirstElement = true;
421
422     exitText();
423
424     String localName = toQString(xmlLocalName);
425     String uri = toQString(xmlURI);
426     String prefix = toQString(xmlPrefix);
427     String qName = prefix.isEmpty() ? localName : prefix + ":" + localName;
428     
429     if (m_parsingFragment && uri.isEmpty()) {
430         if (!prefix.isEmpty())
431             uri = String(m_prefixToNamespaceMap.get(prefix.impl()));
432         else
433             uri = m_defaultNamespaceURI;
434     }
435
436     ExceptionCode ec = 0;
437     RefPtr<Element> newElement = m_doc->createElementNS(uri, qName, ec);
438     if (!newElement) {
439         stopParsing();
440         return;
441     }
442     
443     handleElementNamespaces(newElement.get(), libxmlNamespaces, nb_namespaces, ec);
444     if (ec) {
445         stopParsing();
446         return;
447     }
448     
449     handleElementAttributes(newElement.get(), libxmlAttributes, nb_attributes, ec);
450     if (ec) {
451         stopParsing();
452         return;
453     }
454
455     // FIXME: This hack ensures implicit table bodies get constructed in XHTML and XML files.
456     // We want to consolidate this with the HTML parser and HTML DOM code at some point.
457     // For now, it's too risky to rip that code up.
458     if (m_currentNode->hasTagName(tableTag) && newElement->hasTagName(trTag)) {
459         RefPtr<Node> implicitTBody = new HTMLTableSectionElement(tbodyTag, m_doc, true /* implicit */);
460         m_currentNode->addChild(implicitTBody.get());
461         setCurrentNode(implicitTBody.get());
462         if (m_view && !implicitTBody->attached())
463             implicitTBody->attach();
464     }
465
466     if (newElement->hasTagName(scriptTag))
467         static_cast<HTMLScriptElement *>(newElement.get())->setCreatedByParser(true);
468
469     if (!m_currentNode->addChild(newElement.get())) {
470         stopParsing();
471         return;
472     }
473     
474     setCurrentNode(newElement.get());
475     if (m_view && !newElement->attached())
476         newElement->attach();
477 }
478
479 void XMLTokenizer::endElementNs()
480 {
481     if (m_parserStopped)
482         return;
483
484     exitText();
485
486     Node *n = m_currentNode;
487     while (n->implicitNode())
488         n = n->parentNode();
489     RefPtr<Node> parent = n->parentNode();
490     n->closeRenderer();
491     setCurrentNode(parent.get());
492 }
493
494 void XMLTokenizer::characters(const xmlChar *s, int len)
495 {
496     if (m_parserStopped)
497         return;
498     
499     if (m_currentNode->isTextNode() || enterText()) {
500         ExceptionCode ec = 0;
501         static_cast<Text*>(m_currentNode)->appendData(toQString(s, len), ec);
502     }
503 }
504
505 bool XMLTokenizer::enterText()
506 {
507     RefPtr<Node> newNode = new Text(m_doc, "");
508     if (!m_currentNode->addChild(newNode.get()))
509         return false;
510     setCurrentNode(newNode.get());
511     return true;
512 }
513
514 void XMLTokenizer::exitText()
515 {
516     if (m_parserStopped)
517         return;
518
519     if (!m_currentNode || !m_currentNode->isTextNode())
520         return;
521
522     if (m_view && m_currentNode && !m_currentNode->attached())
523         m_currentNode->attach();
524
525     // FIXME: What's the right thing to do if the parent is really 0?
526     // Just leaving the current node set to the text node doesn't make much sense.
527     if (Node* par = m_currentNode->parentNode())
528         setCurrentNode(par);
529 }
530
531 void XMLTokenizer::error(ErrorType type, const char *message, va_list args)
532 {
533     if (m_parserStopped)
534         return;
535
536     if (type == fatal || (m_errorCount < maxErrors && m_lastErrorLine != lineNumber() && m_lastErrorColumn != columnNumber())) {
537 #if WIN32
538         char m[1024];
539         vsnprintf(m, sizeof(m) - 1, message, args);
540 #else
541         char *m;
542         vasprintf(&m, message, args);
543 #endif
544         switch (type) {
545             case warning:
546                 m_errorMessages += String::sprintf("warning on line %d at column %d: %s", lineNumber(), columnNumber(), m);
547                 break;
548             case fatal:
549             case nonFatal:
550                 m_errorMessages += String::sprintf("error on line %d at column %d: %s", lineNumber(), columnNumber(), m);
551         }
552 #if !WIN32
553         free(m);
554 #endif
555
556         m_lastErrorLine = lineNumber();
557         m_lastErrorColumn = columnNumber();
558         ++m_errorCount;
559     }
560
561     if (type != warning)
562         m_sawError = true;
563
564     if (type == fatal)
565         stopParsing();
566 }
567
568 void XMLTokenizer::processingInstruction(const xmlChar *target, const xmlChar *data)
569 {
570     if (m_parserStopped)
571         return;
572
573     exitText();
574
575     // ### handle exceptions
576     int exception = 0;
577     RefPtr<ProcessingInstruction> pi = m_doc->createProcessingInstruction(
578         toQString(target), toQString(data), exception);
579     if (exception)
580         return;
581
582     if (!m_currentNode->addChild(pi.get()))
583         return;
584     if (m_view && !pi->attached())
585         pi->attach();
586
587     // don't load stylesheets for standalone documents
588     if (m_doc->frame()) {
589         m_sawXSLTransform = !m_sawFirstElement && !pi->checkStyleSheet();
590 #ifdef KHTML_XSLT
591         // Pretend we didn't see this PI if we're the result of a transform.
592         if (m_sawXSLTransform && !m_doc->transformSourceDocument())
593 #else
594         if (m_sawXSLTransform)
595 #endif
596             // Stop the SAX parser.
597             stopParsing();
598     }
599 }
600
601 void XMLTokenizer::cdataBlock(const xmlChar *s, int len)
602 {
603     if (m_parserStopped)
604         return;
605
606     exitText();
607
608     RefPtr<Node> newNode = new CDATASection(m_doc, toQString(s, len));
609     if (!m_currentNode->addChild(newNode.get()))
610         return;
611     if (m_view && !newNode->attached())
612         newNode->attach();
613 }
614
615 void XMLTokenizer::comment(const xmlChar *s)
616 {
617     if (m_parserStopped)
618         return;
619
620     exitText();
621
622     RefPtr<Node> newNode = new Comment(m_doc, toQString(s));
623     m_currentNode->addChild(newNode.get());
624     if (m_view && !newNode->attached())
625         newNode->attach();
626 }
627
628 void XMLTokenizer::internalSubset(const xmlChar *name, const xmlChar *externalID, const xmlChar *systemID)
629 {
630     if (m_parserStopped)
631         return;
632
633     Document *doc = m_doc;
634     if (!doc)
635         return;
636
637     doc->setDocType(new DocumentType(doc, toQString(name), toQString(externalID), toQString(systemID)));
638 }
639
640 inline XMLTokenizer *getTokenizer(void *closure)
641 {
642     xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(closure);
643     return static_cast<XMLTokenizer *>(ctxt->_private);
644 }
645
646 static void startElementNsHandler(void *closure, const xmlChar *localname, const xmlChar *prefix, const xmlChar *uri, int nb_namespaces, const xmlChar **namespaces, int nb_attributes, int nb_defaulted, const xmlChar **libxmlAttributes)
647 {
648     getTokenizer(closure)->startElementNs(localname, prefix, uri, nb_namespaces, namespaces, nb_attributes, nb_defaulted, libxmlAttributes);
649 }
650
651 static void endElementNsHandler(void *closure, const xmlChar *localname, const xmlChar *prefix, const xmlChar *uri)
652 {
653     getTokenizer(closure)->endElementNs();
654 }
655
656 static void charactersHandler(void *closure, const xmlChar *s, int len)
657 {
658     getTokenizer(closure)->characters(s, len);
659 }
660
661 static void processingInstructionHandler(void *closure, const xmlChar *target, const xmlChar *data)
662 {
663     getTokenizer(closure)->processingInstruction(target, data);
664 }
665
666 static void cdataBlockHandler(void *closure, const xmlChar *s, int len)
667 {
668     getTokenizer(closure)->cdataBlock(s, len);
669 }
670
671 static void commentHandler(void *closure, const xmlChar *comment)
672 {
673     getTokenizer(closure)->comment(comment);
674 }
675
676 static void warningHandler(void *closure, const char *message, ...)
677 {
678     va_list args;
679     va_start(args, message);
680     getTokenizer(closure)->error(XMLTokenizer::warning, message, args);
681     va_end(args);
682 }
683
684 static void fatalErrorHandler(void *closure, const char *message, ...)
685 {
686     va_list args;
687     va_start(args, message);
688     getTokenizer(closure)->error(XMLTokenizer::fatal, message, args);
689     va_end(args);
690 }
691
692 static void normalErrorHandler(void *closure, const char *message, ...)
693 {
694     va_list args;
695     va_start(args, message);
696     getTokenizer(closure)->error(XMLTokenizer::nonFatal, message, args);
697     va_end(args);
698 }
699
700 // Using a global variable entity and marking it XML_INTERNAL_PREDEFINED_ENTITY is
701 // a hack to avoid malloc/free. Using a global variable like this could cause trouble
702 // if libxml implementation details were to change
703 static xmlChar sharedXHTMLEntityResult[5] = {0,0,0,0,0};
704 static xmlEntity sharedXHTMLEntity = {
705     0, XML_ENTITY_DECL, 0, 0, 0, 0, 0, 0, 0, 
706     sharedXHTMLEntityResult, sharedXHTMLEntityResult, 0,
707     XML_INTERNAL_PREDEFINED_ENTITY, 0, 0, 0, 0, 0
708 };
709
710 static xmlEntityPtr getXHTMLEntity(const xmlChar* name)
711 {
712     unsigned short c = decodeNamedEntity(reinterpret_cast<const char*>(name));
713     if (!c)
714         return 0;
715
716     DeprecatedCString value = DeprecatedString(QChar(c)).utf8();
717     assert(value.length() < 5);
718     sharedXHTMLEntity.length = value.length();
719     sharedXHTMLEntity.name = name;
720     memcpy(sharedXHTMLEntityResult, value.data(), sharedXHTMLEntity.length);
721
722     return &sharedXHTMLEntity;
723 }
724
725 static xmlEntityPtr getEntityHandler(void *closure, const xmlChar *name)
726 {
727     xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(closure);
728     xmlEntityPtr ent = xmlGetPredefinedEntity(name);
729     if (ent)
730         return ent;
731
732     ent = xmlGetDocEntity(ctxt->myDoc, name);
733     if (!ent && getTokenizer(closure)->isXHTMLDocument())
734         ent = getXHTMLEntity(name);
735
736     // Work around a libxml SAX2 bug that causes charactersHandler to be called twice.
737     if (ent)
738         ctxt->replaceEntities = (ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) || (ent->etype != XML_INTERNAL_GENERAL_ENTITY);
739     
740     return ent;
741 }
742
743 static void internalSubsetHandler(void *closure, const xmlChar *name, const xmlChar *externalID, const xmlChar *systemID)
744 {
745     getTokenizer(closure)->internalSubset(name, externalID, systemID);
746     xmlSAX2InternalSubset(closure, name, externalID, systemID);
747 }
748
749 static void externalSubsetHandler(void *closure, const xmlChar *name, const xmlChar *externalId, const xmlChar *systemId)
750 {
751     DeprecatedString extId = toQString(externalId);
752     if ((extId == "-//W3C//DTD XHTML 1.0 Transitional//EN")
753         || (extId == "-//W3C//DTD XHTML 1.1//EN")
754         || (extId == "-//W3C//DTD XHTML 1.0 Strict//EN")
755         || (extId == "-//W3C//DTD XHTML 1.0 Frameset//EN")
756         || (extId == "-//W3C//DTD XHTML Basic 1.0//EN")
757         || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN")
758         || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN")
759         || (extId == "-//WAPFORUM//DTD XHTML Mobile 1.0//EN"))
760         getTokenizer(closure)->setIsXHTMLDocument(true); // controls if we replace entities or not.
761 }
762
763 static void ignorableWhitespaceHandler(void *ctx, const xmlChar *ch, int len)
764 {
765     // nothing to do, but we need this to work around a crasher
766     // http://bugzilla.gnome.org/show_bug.cgi?id=172255
767     // http://bugzilla.opendarwin.org/show_bug.cgi?id=5792
768 }
769
770 void XMLTokenizer::initializeParserContext()
771 {
772     xmlSAXHandler sax;
773     memset(&sax, 0, sizeof(sax));
774     sax.error = normalErrorHandler;
775     sax.fatalError = fatalErrorHandler;
776     sax.characters = charactersHandler;
777     sax.processingInstruction = processingInstructionHandler;
778     sax.cdataBlock = cdataBlockHandler;
779     sax.comment = commentHandler;
780     sax.warning = warningHandler;
781     sax.startElementNs = startElementNsHandler;
782     sax.endElementNs = endElementNsHandler;
783     sax.getEntity = getEntityHandler;
784     sax.startDocument = xmlSAX2StartDocument;
785     sax.internalSubset = internalSubsetHandler;
786     sax.externalSubset = externalSubsetHandler;
787     sax.ignorableWhitespace = ignorableWhitespaceHandler;
788     sax.entityDecl = xmlSAX2EntityDecl;
789     sax.initialized = XML_SAX2_MAGIC;
790     
791     m_parserStopped = false;
792     m_sawError = false;
793     m_sawXSLTransform = false;
794     m_sawFirstElement = false;
795     m_context = createQStringParser(&sax, this);
796 }
797
798 void XMLTokenizer::finish()
799 {
800     if (m_sawXSLTransform) {
801         m_doc->setTransformSource(xmlDocPtrForString(m_originalSourceForTransform, m_doc->URL()));
802         
803         m_doc->setParsing(false); // Make the doc think it's done, so it will apply xsl sheets.
804         m_doc->updateStyleSelector();
805         m_doc->setParsing(true);
806         m_parserStopped = true;
807     }
808     
809     if (m_context) {
810         // Tell libxml we're done.
811         xmlParseChunk(m_context, 0, 0, 1);
812         
813         if (m_context->myDoc)
814             xmlFreeDoc(m_context->myDoc);
815         xmlFreeParserCtxt(m_context);
816         m_context = 0;
817     }
818     
819     if (m_sawError)
820         insertErrorMessageBlock();
821     else {
822         // Parsing was successful. Now locate all html <script> tags in the document and execute them
823         // one by one.
824         exitText();
825         addScripts(m_doc);
826         m_scriptsIt = new DeprecatedPtrListIterator<Element>(m_scripts);
827         executeScripts();
828     }
829
830     setCurrentNode(0);
831     m_doc->finishedParsing();
832 }
833
834 static inline RefPtr<Element> createXHTMLParserErrorHeader(Document* doc, const String& errorMessages) 
835 {
836     ExceptionCode ec = 0;
837     RefPtr<Element> reportElement = doc->createElementNS(xhtmlNamespaceURI, "parsererror", ec);
838     reportElement->setAttribute(styleAttr, "white-space: pre; border: 2px solid #c77; padding: 0 1em 0 1em; margin: 1em; background-color: #fdd; color: black");
839     
840     RefPtr<Element> h3 = doc->createElementNS(xhtmlNamespaceURI, "h3", ec);
841     reportElement->appendChild(h3.get(), ec);
842     h3->appendChild(doc->createTextNode("This page contains the following errors:"), ec);
843     
844     RefPtr<Element> fixed = doc->createElementNS(xhtmlNamespaceURI, "div", ec);
845     reportElement->appendChild(fixed.get(), ec);
846     fixed->setAttribute(styleAttr, "font-family:monospace;font-size:12px");
847     fixed->appendChild(doc->createTextNode(errorMessages), ec);
848     
849     h3 = doc->createElementNS(xhtmlNamespaceURI, "h3", ec);
850     reportElement->appendChild(h3.get(), ec);
851     h3->appendChild(doc->createTextNode("Below is a rendering of the page up to the first error."), ec);
852     
853     return reportElement;
854 }
855
856 void XMLTokenizer::insertErrorMessageBlock()
857 {
858     // One or more errors occurred during parsing of the code. Display an error block to the user above
859     // the normal content (the DOM tree is created manually and includes line/col info regarding 
860     // where the errors are located)
861
862     // Create elements for display
863     ExceptionCode ec = 0;
864     Document *doc = m_doc;
865     Node* documentElement = doc->documentElement();
866     if (!documentElement) {
867         RefPtr<Node> rootElement = doc->createElementNS(xhtmlNamespaceURI, "html", ec);
868         doc->appendChild(rootElement, ec);
869         RefPtr<Node> body = doc->createElementNS(xhtmlNamespaceURI, "body", ec);
870         rootElement->appendChild(body, ec);
871         documentElement = body.get();
872     }
873 #if SVG_SUPPORT
874     else if (documentElement->namespaceURI() == WebCore::SVGNames::svgNamespaceURI) {
875         // Until our SVG implementation has text support, it is best if we 
876         // wrap the erroneous SVG document in an xhtml document and render
877         // the combined document with error messages.
878         RefPtr<Node> rootElement = doc->createElementNS(xhtmlNamespaceURI, "html", ec);
879         RefPtr<Node> body = doc->createElementNS(xhtmlNamespaceURI, "body", ec);
880         rootElement->appendChild(body, ec);
881         body->appendChild(documentElement, ec);
882         doc->appendChild(rootElement.get(), ec);
883         documentElement = body.get();
884     }
885 #endif
886
887     RefPtr<Element> reportElement = createXHTMLParserErrorHeader(doc, m_errorMessages);
888     documentElement->insertBefore(reportElement, documentElement->firstChild(), ec);
889 #ifdef KHTML_XSLT
890     if (doc->transformSourceDocument()) {
891         RefPtr<Element> par = doc->createElementNS(xhtmlNamespaceURI, "p", ec);
892         reportElement->appendChild(par, ec);
893         par->setAttribute(styleAttr, "white-space: normal");
894         par->appendChild(doc->createTextNode("This document was created as the result of an XSL transformation. The line and column numbers given are from the transformed result."), ec);
895     }
896 #endif
897     doc->updateRendering();
898 }
899
900 void XMLTokenizer::addScripts(Node *n)
901 {
902     // Recursively go through the entire document tree, looking for html <script> tags. For each of these
903     // that is found, add it to the m_scripts list from which they will be executed
904     if (n->hasTagName(scriptTag)
905 #if SVG_SUPPORT
906         || n->hasTagName(WebCore::SVGNames::scriptTag)
907 #endif
908         )
909         m_scripts.append(static_cast<Element*>(n));
910
911     Node *child;
912     for (child = n->firstChild(); child; child = child->nextSibling())
913         addScripts(child);
914 }
915
916 void XMLTokenizer::executeScripts()
917 {
918     // Iterate through all of the html <script> tags in the document. For those that have a src attribute,
919     // start loading the script and return (executeScripts() will be called again once the script is loaded
920     // and continue where it left off). For scripts that don't have a src attribute, execute the code
921     // inside the tag
922     while (Element *scriptElement = m_scriptsIt->current()) {
923         ++(*m_scriptsIt);
924         String scriptHref = scriptElement->getAttribute(srcAttr);
925 #if SVG_SUPPORT
926         if (scriptElement->hasTagName(WebCore::SVGNames::scriptTag))
927             scriptHref = scriptElement->getAttribute(XLinkNames::hrefAttr);
928 #endif
929         // don't load external scripts for standalone documents (for now)
930         if (!scriptHref.isEmpty() && m_doc->frame()) {
931             // we have a src attribute
932             DeprecatedString charset = scriptElement->getAttribute(charsetAttr).deprecatedString();
933             m_cachedScript = m_doc->docLoader()->requestScript(scriptHref, charset);
934             m_cachedScript->ref(this); // will call executeScripts() again if already cached
935             return;
936         } else {
937             // no src attribute - execute from contents of tag
938             DeprecatedString scriptCode = "";
939             for (Node *child = scriptElement->firstChild(); child; child = child->nextSibling()) {
940                 if (child->isTextNode() || child->nodeType() == Node::CDATA_SECTION_NODE)
941                     scriptCode += static_cast<CharacterData*>(child)->data().deprecatedString();
942             }
943             // the script cannot do document.write until we support incremental parsing
944             // ### handle the case where the script deletes the node or redirects to
945             // another page, etc. (also in notifyFinished())
946             // ### the script may add another script node after this one which should be executed
947             if (m_view)
948                 m_view->frame()->executeScript(0, scriptCode);
949         }
950     }
951
952     // All scripts have finished executing, so calculate the style for the document and close
953     // the last element
954     m_doc->updateStyleSelector();
955 }
956
957 void XMLTokenizer::notifyFinished(CachedObject *finishedObj)
958 {
959     // This is called when a script has finished loading that was requested from executeScripts(). We execute
960     // the script, and then call executeScripts() again to continue iterating through the list of scripts in
961     // the document
962     if (finishedObj == m_cachedScript) {
963         String scriptSource = m_cachedScript->script();
964         m_cachedScript->deref(this);
965         m_cachedScript = 0;
966         m_view->frame()->executeScript(0, scriptSource.deprecatedString());
967         executeScripts();
968     }
969 }
970
971 bool XMLTokenizer::isWaitingForScripts() const
972 {
973     return m_cachedScript != 0;
974 }
975
976 #ifdef KHTML_XSLT
977 void *xmlDocPtrForString(const DeprecatedString &source, const DeprecatedString &url)
978 {
979     if (source.isEmpty())
980             return 0;
981     // Parse in a single chunk into an xmlDocPtr
982     // FIXME: Hook up error handlers so that a failure to parse the main document results in
983     // good error messages.
984     const QChar BOM(0xFEFF);
985     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char *>(&BOM);
986     xmlDocPtr sourceDoc = xmlReadMemory(reinterpret_cast<const char *>(source.unicode()),
987                                         source.length() * sizeof(QChar),
988                                         url.ascii(),
989                                         BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE", 
990                                         XML_PARSE_NOCDATA|XML_PARSE_DTDATTR|XML_PARSE_NOENT);
991     return sourceDoc;
992 }
993 #endif
994
995 Tokenizer *newXMLTokenizer(Document *d, FrameView *v)
996 {
997     return new XMLTokenizer(d, v);
998 }
999
1000 int XMLTokenizer::lineNumber() const
1001 {
1002     return m_context->input->line;
1003 }
1004
1005 int XMLTokenizer::columnNumber() const
1006 {
1007     return m_context->input->col;
1008 }
1009
1010 void XMLTokenizer::stopParsing()
1011 {
1012     Tokenizer::stopParsing();
1013     xmlStopParser(m_context);
1014 }
1015
1016 static void balancedStartElementNsHandler(void *closure, const xmlChar *localname, const xmlChar *prefix, const xmlChar *uri, int nb_namespaces, const xmlChar **namespaces, int nb_attributes, int nb_defaulted, const xmlChar **libxmlAttributes)
1017 {
1018    static_cast<XMLTokenizer *>(closure)->startElementNs(localname, prefix, uri, nb_namespaces, namespaces, nb_attributes, nb_defaulted, libxmlAttributes);
1019 }
1020
1021 static void balancedEndElementNsHandler(void *closure, const xmlChar *localname, const xmlChar *prefix, const xmlChar *uri)
1022 {
1023     static_cast<XMLTokenizer *>(closure)->endElementNs();
1024 }
1025
1026 static void balancedCharactersHandler(void *closure, const xmlChar *s, int len)
1027 {
1028     static_cast<XMLTokenizer *>(closure)->characters(s, len);
1029 }
1030
1031 static void balancedProcessingInstructionHandler(void *closure, const xmlChar *target, const xmlChar *data)
1032 {
1033     static_cast<XMLTokenizer *>(closure)->processingInstruction(target, data);
1034 }
1035
1036 static void balancedCdataBlockHandler(void *closure, const xmlChar *s, int len)
1037 {
1038     static_cast<XMLTokenizer *>(closure)->cdataBlock(s, len);
1039 }
1040
1041 static void balancedCommentHandler(void *closure, const xmlChar *comment)
1042 {
1043     static_cast<XMLTokenizer *>(closure)->comment(comment);
1044 }
1045
1046 static void balancedWarningHandler(void *closure, const char *message, ...)
1047 {
1048     va_list args;
1049     va_start(args, message);
1050     static_cast<XMLTokenizer *>(closure)->error(XMLTokenizer::warning, message, args);
1051     va_end(args);
1052 }
1053
1054 bool parseXMLDocumentFragment(const String &string, DocumentFragment *fragment, Element *parent)
1055 {
1056     XMLTokenizer tokenizer(fragment, parent);
1057     
1058     xmlSAXHandler sax;
1059     memset(&sax, 0, sizeof(sax));
1060
1061     sax.characters = balancedCharactersHandler;
1062     sax.processingInstruction = balancedProcessingInstructionHandler;
1063     sax.startElementNs = balancedStartElementNsHandler;
1064     sax.endElementNs = balancedEndElementNsHandler;
1065     sax.cdataBlock = balancedCdataBlockHandler;
1066     sax.ignorableWhitespace = balancedCdataBlockHandler;
1067     sax.comment = balancedCommentHandler;
1068     sax.warning = balancedWarningHandler;
1069     sax.initialized = XML_SAX2_MAGIC;
1070     
1071     int result = xmlParseBalancedChunkMemory(0, &sax, &tokenizer, 0, 
1072                                             (const xmlChar*)(const char*)(string.deprecatedString().utf8()), 0);
1073     return result == 0;
1074 }
1075
1076 // --------------------------------
1077
1078 struct AttributeParseState {
1079     HashMap<String, String> attributes;
1080     bool gotAttributes;
1081 };
1082
1083
1084 static void attributesStartElementNsHandler(void *closure, const xmlChar *xmlLocalName, const xmlChar *xmlPrefix, const xmlChar *xmlURI, int nb_namespaces, const xmlChar **namespaces, int nb_attributes, int nb_defaulted, const xmlChar **libxmlAttributes)
1085 {
1086     if (strcmp(reinterpret_cast<const char *>(xmlLocalName), "attrs") != 0)
1087         return;
1088     
1089     xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(closure);
1090     AttributeParseState *state = static_cast<AttributeParseState *>(ctxt->_private);
1091     
1092     state->gotAttributes = true;
1093     
1094     xmlSAX2Attributes *attributes = reinterpret_cast<xmlSAX2Attributes *>(libxmlAttributes);
1095     for(int i = 0; i < nb_attributes; i++) {
1096         DeprecatedString attrLocalName = toQString(attributes[i].localname);
1097         int valueLength = (int) (attributes[i].end - attributes[i].value);
1098         String attrValue = toString(attributes[i].value, valueLength);
1099         String attrPrefix = toString(attributes[i].prefix);
1100         String attrQName = attrPrefix.isEmpty() ? attrLocalName : attrPrefix + ":" + attrLocalName;
1101         
1102         state->attributes.set(attrQName, attrValue);
1103     }
1104 }
1105
1106 HashMap<String, String> parseAttributes(const String& string, bool& attrsOK)
1107 {
1108     AttributeParseState state;
1109     state.gotAttributes = false;
1110
1111     xmlSAXHandler sax;
1112     memset(&sax, 0, sizeof(sax));
1113     sax.startElementNs = attributesStartElementNsHandler;
1114     sax.initialized = XML_SAX2_MAGIC;
1115     xmlParserCtxtPtr parser = createQStringParser(&sax, &state);
1116     DeprecatedString parseString = "<?xml version=\"1.0\"?><attrs " + string.deprecatedString() + " />";
1117     xmlParseChunk(parser, reinterpret_cast<const char *>(parseString.unicode()), parseString.length() * sizeof(QChar), 1);
1118     if (parser->myDoc)
1119         xmlFreeDoc(parser->myDoc);
1120     xmlFreeParserCtxt(parser);
1121
1122     attrsOK = state.gotAttributes;
1123     return state.attributes;
1124 }
1125
1126 }