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