Reviewed by Maciej.
[WebKit-https.git] / WebCore / xml / XSLTProcessor.cpp
1 /**
2  * This file is part of the XSL implementation.
3  *
4  * Copyright (C) 2004, 2005, 2006, 2007 Apple, Inc.
5  * Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@webkit.org>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24
25 #if ENABLE(XSLT)
26
27 #include "XSLTProcessor.h"
28
29 #include "CString.h"
30 #include "Cache.h"
31 #include "DOMImplementation.h"
32 #include "DocLoader.h"
33 #include "DocumentFragment.h"
34 #include "Frame.h"
35 #include "FrameLoader.h"
36 #include "FrameView.h"
37 #include "HTMLDocument.h"
38 #include "HTMLTokenizer.h"
39 #include "Page.h"
40 #include "ResourceHandle.h"
41 #include "ResourceRequest.h"
42 #include "ResourceResponse.h"
43 #include "Text.h"
44 #include "TextResourceDecoder.h"
45 #include "XMLTokenizer.h"
46 #include "XSLTExtensions.h"
47 #include "XSLTUnicodeSort.h"
48 #include "loader.h"
49 #include "markup.h"
50 #include <libxslt/imports.h>
51 #include <libxslt/variables.h>
52 #include <libxslt/xsltutils.h>
53 #include <wtf/Assertions.h>
54 #include <wtf/Platform.h>
55 #include <wtf/Vector.h>
56 #if PLATFORM(MAC)
57 #include "SoftLinking.h"
58 #endif
59
60 #if PLATFORM(MAC)
61 SOFT_LINK_LIBRARY(libxslt);
62 SOFT_LINK(libxslt, xsltFreeStylesheet, void, (xsltStylesheetPtr sheet), (sheet))
63 SOFT_LINK(libxslt, xsltFreeTransformContext, void, (xsltTransformContextPtr ctxt), (ctxt))
64 SOFT_LINK(libxslt, xsltNewTransformContext, xsltTransformContextPtr, (xsltStylesheetPtr style, xmlDocPtr doc), (style, doc))
65 SOFT_LINK(libxslt, xsltApplyStylesheetUser, xmlDocPtr, (xsltStylesheetPtr style, xmlDocPtr doc, const char** params, const char* output, FILE* profile, xsltTransformContextPtr userCtxt), (style, doc, params, output, profile, userCtxt))
66 SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char** params), (ctxt, params))
67 SOFT_LINK(libxslt, xsltSetCtxtSortFunc, void, (xsltTransformContextPtr ctxt, xsltSortFunc handler), (ctxt, handler))
68 SOFT_LINK(libxslt, xsltSetLoaderFunc, void, (xsltDocLoaderFunc f), (f))
69 SOFT_LINK(libxslt, xsltSaveResultTo, int, (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style), (buf, result, style))
70 SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style), (style))
71 #endif
72
73 namespace WebCore {
74
75 void XSLTProcessor::parseErrorFunc(void* userData, xmlError* error)
76 {
77     Chrome* chrome = static_cast<Chrome*>(userData);
78     if (!chrome)
79         return;
80
81     MessageLevel level;
82     switch (error->level) {
83         case XML_ERR_NONE:
84             level = TipMessageLevel;
85             break;
86         case XML_ERR_WARNING:
87             level = WarningMessageLevel;
88             break;
89         case XML_ERR_ERROR:
90         case XML_ERR_FATAL:
91         default:
92             level = ErrorMessageLevel;
93             break;
94     }
95
96     chrome->addMessageToConsole(XMLMessageSource, level, error->message, error->line, error->file);
97 }
98
99 // FIXME: There seems to be no way to control the ctxt pointer for loading here, thus we have globals.
100 static XSLTProcessor* globalProcessor = 0;
101 static DocLoader* globalDocLoader = 0;
102 static xmlDocPtr docLoaderFunc(const xmlChar* uri,
103                                     xmlDictPtr dict,
104                                     int options,
105                                     void* ctxt,
106                                     xsltLoadType type)
107 {
108     if (!globalProcessor)
109         return 0;
110     
111     switch (type) {
112         case XSLT_LOAD_DOCUMENT: {
113             xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
114             xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);
115             KURL url((const char*)base, (const char*)uri);
116             xmlFree(base);
117             ResourceError error;
118             ResourceResponse response;
119
120             Vector<char> data;
121
122             if (globalDocLoader->frame()) 
123                 globalDocLoader->frame()->loader()->loadResourceSynchronously(url, error, response, data);
124
125             Chrome* chrome = 0;
126             if (Page* page = globalProcessor->xslStylesheet()->ownerDocument()->page())
127                 chrome = page->chrome();
128             xmlSetStructuredErrorFunc(chrome, XSLTProcessor::parseErrorFunc);
129
130             // We don't specify an encoding here. Neither Gecko nor WinIE respects
131             // the encoding specified in the HTTP headers.
132             xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);
133
134             xmlSetStructuredErrorFunc(0, 0);
135
136             return doc;
137         }
138         case XSLT_LOAD_STYLESHEET:
139             return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);
140         default:
141             break;
142     }
143     
144     return 0;
145 }
146
147 static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor* processor, DocLoader* loader)
148 {
149     xsltSetLoaderFunc(func);
150     globalProcessor = processor;
151     globalDocLoader = loader;
152 }
153
154 static int writeToVector(void* context, const char* buffer, int len)
155 {
156     Vector<UChar>& resultOutput = *static_cast<Vector<UChar>*>(context);
157     String decodedChunk = String::fromUTF8(buffer, len);
158     resultOutput.append(decodedChunk.characters(), decodedChunk.length());
159     return len;
160 }
161
162 static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, String& resultString)
163 {
164     xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);
165     if (!outputBuf)
166         return false;
167
168     Vector<UChar> resultVector;
169     outputBuf->context = &resultVector;
170     outputBuf->writecallback = writeToVector;
171     
172     int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);
173     xmlOutputBufferClose(outputBuf);
174     if (retval < 0)
175         return false;
176
177     // Workaround for <http://bugzilla.gnome.org/show_bug.cgi?id=495668>: libxslt appends an extra line feed to the result.
178     if (resultVector.size() > 0 && resultVector[resultVector.size() - 1] == '\n')
179         resultVector.removeLast();
180
181     resultString = String::adopt(resultVector);
182
183     return true;
184 }
185
186 static inline void transformTextStringToXHTMLDocumentString(String& text)
187 {
188     // Modify the output so that it is a well-formed XHTML document with a <pre> tag enclosing the text.
189     text.replace('&', "&amp;");
190     text.replace('<', "&lt;");
191     text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
192         "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
193         "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
194         "<head><title/></head>\n"
195         "<body>\n"
196         "<pre>" + text + "</pre>\n"
197         "</body>\n"
198         "</html>\n";
199 }
200
201 static const char** xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
202 {
203     if (parameters.isEmpty())
204         return 0;
205
206     const char** parameterArray = (const char**)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char*));
207
208     XSLTProcessor::ParameterMap::iterator end = parameters.end();
209     unsigned index = 0;
210     for (XSLTProcessor::ParameterMap::iterator it = parameters.begin(); it != end; ++it) {
211         parameterArray[index++] = strdup(it->first.utf8().data());
212         parameterArray[index++] = strdup(it->second.utf8().data());
213     }
214     parameterArray[index] = 0;
215
216     return parameterArray;
217 }
218
219 static void freeXsltParamArray(const char** params)
220 {
221     const char** temp = params;
222     if (!params)
223         return;
224     
225     while (*temp) {
226         free((void*)*(temp++)); // strdup returns malloc'd blocks, so we have to use free() here
227         free((void*)*(temp++));
228     }
229     fastFree(params);
230 }
231
232
233 RefPtr<Document> XSLTProcessor::createDocumentFromSource(const String& sourceString,
234     const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame)
235 {
236     RefPtr<Document> ownerDocument = sourceNode->document();
237     bool sourceIsDocument = (sourceNode == ownerDocument.get());
238     String documentSource = sourceString;
239
240     RefPtr<Document> result;
241     if (sourceMIMEType == "text/plain") {
242         result = ownerDocument->implementation()->createDocument(frame);
243         transformTextStringToXHTMLDocumentString(documentSource);
244     } else
245         result = ownerDocument->implementation()->createDocument(sourceMIMEType, frame, false);
246     
247     // Before parsing, we need to save & detach the old document and get the new document
248     // in place. We have to do this only if we're rendering the result document.
249     if (frame) {
250         if (FrameView* view = frame->view())
251             view->clear();
252         result->setTransformSourceDocument(frame->document());
253         frame->setDocument(result);
254     }
255     
256     result->open();
257     if (sourceIsDocument) {
258         result->setURL(ownerDocument->URL());
259         result->setBaseURL(ownerDocument->baseURL());
260     }
261     result->determineParseMode(documentSource); // Make sure we parse in the correct mode.
262     
263     RefPtr<TextResourceDecoder> decoder = new TextResourceDecoder(sourceMIMEType);
264     decoder->setEncoding(sourceEncoding.isEmpty() ? UTF8Encoding() : TextEncoding(sourceEncoding), TextResourceDecoder::EncodingFromXMLHeader);
265     result->setDecoder(decoder.get());
266     
267     result->write(documentSource);
268     result->finishParsing();
269     result->close();
270
271     return result;
272 }
273
274 static inline RefPtr<DocumentFragment> createFragmentFromSource(String sourceString, String sourceMIMEType, Node* sourceNode, Document* outputDoc)
275 {
276     RefPtr<DocumentFragment> fragment = new DocumentFragment(outputDoc);
277     
278     if (sourceMIMEType == "text/html")
279         parseHTMLDocumentFragment(sourceString, fragment.get());
280     else if (sourceMIMEType == "text/plain")
281         fragment->addChild(new Text(outputDoc, sourceString));
282     else {
283         bool successfulParse = parseXMLDocumentFragment(sourceString, fragment.get(), outputDoc->documentElement());
284         if (!successfulParse)
285             return 0;
286     }
287     
288     // FIXME: Do we need to mess with URLs here?
289         
290     return fragment;
291 }
292
293 static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
294 {
295     if (!cachedStylesheet && stylesheetRootNode) {
296         cachedStylesheet = new XSLStyleSheet(stylesheetRootNode->parent() ? stylesheetRootNode->parent() : stylesheetRootNode, stylesheetRootNode->document()->URL());
297         cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
298     }
299     
300     if (!cachedStylesheet || !cachedStylesheet->document())
301         return 0;
302     
303     return cachedStylesheet->compileStyleSheet();
304 }
305
306 static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
307 {
308     RefPtr<Document> ownerDocument = sourceNode->document();
309     bool sourceIsDocument = (sourceNode == ownerDocument.get());
310     
311     xmlDocPtr sourceDoc = 0;
312     if (sourceIsDocument)
313         sourceDoc = (xmlDocPtr)ownerDocument->transformSource();
314     if (!sourceDoc) {
315         sourceDoc = (xmlDocPtr)xmlDocPtrForString(ownerDocument->docLoader(), createMarkup(sourceNode), sourceIsDocument ? ownerDocument->URL() : DeprecatedString());
316         shouldDelete = (sourceDoc != 0);
317     }
318     return sourceDoc;
319 }
320
321 static inline String resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
322 {
323     // There are three types of output we need to be able to deal with:
324     // HTML (create an HTML document), XML (create an XML document),
325     // and text (wrap in a <pre> and create an XML document).
326
327     const xmlChar* resultType = 0;
328     XSLT_GET_IMPORT_PTR(resultType, sheet, method);
329     if (resultType == 0 && resultDoc->type == XML_HTML_DOCUMENT_NODE)
330         resultType = (const xmlChar*)"html";
331     
332     if (xmlStrEqual(resultType, (const xmlChar*)"html"))
333         return "text/html";
334     else if (xmlStrEqual(resultType, (const xmlChar*)"text"))
335         return "text/plain";
336         
337     return "application/xml";
338 }
339
340 bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding)
341 {
342     RefPtr<Document> ownerDocument = sourceNode->document();
343     
344     setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->docLoader());
345     xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get());
346     if (!sheet) {
347         setXSLTLoadCallBack(0, 0, 0);
348         return false;
349     }
350     m_stylesheet->clearDocuments();
351
352     xmlChar* origMethod = sheet->method;
353     if (!origMethod && mimeType == "text/html")
354         sheet->method = (xmlChar*)"html";
355
356     bool success = false;
357     bool shouldFreeSourceDoc = false;
358     if (xmlDocPtr sourceDoc = xmlDocPtrFromNode(sourceNode, shouldFreeSourceDoc)) {
359         // The XML declaration would prevent parsing the result as a fragment, and it's not needed even for documents, 
360         // as the result of this function is always immediately parsed.
361         sheet->omitXmlDeclaration = true;
362
363         xsltTransformContextPtr transformContext = xsltNewTransformContext(sheet, sourceDoc);
364         registerXSLTExtensions(transformContext);
365 // FIXME: <rdar://5611712> Remove the PLATFORM(WIN) check once ICU on Windows has collation support.
366 #if USE(ICU_UNICODE) && !PLATFORM(WIN)
367         // <http://bugs.webkit.org/show_bug.cgi?id=16077>: XSLT processor <xsl:sort> algorithm only compares by code point
368         // Only implemented for ICU yet.
369         xsltSetCtxtSortFunc(transformContext, xsltUnicodeSortFunction);
370 #endif
371
372         // This is a workaround for a bug in libxslt. 
373         // The bug has been fixed in version 1.1.13, so once we ship that this can be removed.
374         if (transformContext->globalVars == NULL)
375            transformContext->globalVars = xmlHashCreate(20);
376
377         const char** params = xsltParamArrayFromParameterMap(m_parameters);
378         xsltQuoteUserParams(transformContext, params);
379         xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext);
380         
381         xsltFreeTransformContext(transformContext);        
382         freeXsltParamArray(params);
383         
384         if (shouldFreeSourceDoc)
385             xmlFreeDoc(sourceDoc);
386         
387         if (success = saveResultToString(resultDoc, sheet, resultString)) {
388             mimeType = resultMIMEType(resultDoc, sheet);
389             resultEncoding = (char*)resultDoc->encoding;
390         }
391         xmlFreeDoc(resultDoc);
392     }
393     
394     sheet->method = origMethod;
395     setXSLTLoadCallBack(0, 0, 0);
396     xsltFreeStylesheet(sheet);
397     m_stylesheet = 0;
398
399     return success;
400 }
401
402 RefPtr<Document> XSLTProcessor::transformToDocument(Node* sourceNode)
403 {
404     String resultMIMEType;
405     String resultString;
406     String resultEncoding;
407     if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
408         return 0;
409     return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
410 }
411
412 RefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
413 {
414     String resultMIMEType;
415     String resultString;
416     String resultEncoding;
417
418     // If the output document is HTML, default to HTML method.
419     if (outputDoc->isHTMLDocument())
420         resultMIMEType = "text/html";
421     
422     if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
423         return 0;
424     return createFragmentFromSource(resultString, resultMIMEType, sourceNode, outputDoc);
425 }
426
427 void XSLTProcessor::setParameter(const String& namespaceURI, const String& localName, const String& value)
428 {
429     // FIXME: namespace support?
430     // should make a QualifiedName here but we'd have to expose the impl
431     m_parameters.set(localName, value);
432 }
433
434 String XSLTProcessor::getParameter(const String& namespaceURI, const String& localName) const
435 {
436     // FIXME: namespace support?
437     // should make a QualifiedName here but we'd have to expose the impl
438     return m_parameters.get(localName);
439 }
440
441 void XSLTProcessor::removeParameter(const String& namespaceURI, const String& localName)
442 {
443     // FIXME: namespace support?
444     m_parameters.remove(localName);
445 }
446
447 } // namespace WebCore
448
449 #endif // ENABLE(XSLT)