* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include "precomp.h"
+#include "config.h"
+
+#define COBJMACROS
+
+#include <stdarg.h>
#ifdef HAVE_LIBXML2
+# include <libxml/parser.h>
+# include <libxml/parserInternals.h>
+# include <libxml/xmlerror.h>
# include <libxml/HTMLtree.h>
# ifdef SONAME_LIBXSLT
# ifdef HAVE_LIBXSLT_PATTERN_H
# include <libxslt/variables.h>
# include <libxslt/xsltutils.h>
# include <libxslt/xsltInternals.h>
+# include <libxslt/documents.h>
# endif
#endif
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winnls.h"
+#include "ole2.h"
+#include "msxml6.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
#ifdef HAVE_LIBXML2
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
#ifdef SONAME_LIBXSLT
extern void* libxslt_handle;
# define MAKE_FUNCPTR(f) extern typeof(f) * p##f
MAKE_FUNCPTR(xsltQuoteUserParams);
MAKE_FUNCPTR(xsltSaveResultTo);
# undef MAKE_FUNCPTR
+#else
+WINE_DECLARE_DEBUG_CHANNEL(winediag);
#endif
static const IID IID_xmlnode = {0x4f2f4ba2,0xb822,0x11df,{0x8b,0x8a,0x68,0x50,0xdf,0xd7,0x20,0x85}};
static int node_get_inst_cnt(xmlNodePtr node)
{
- int ret = *(LONG *)&node->_private;
+ int ret = *(LONG *)&node->_private & NODE_PRIV_REFCOUNT_MASK;
xmlNodePtr child;
/* add attribute counts */
return node_get_inst_cnt(node->node);
}
+/* _private field holds a number of COM instances spawned from this libxml2 node
+ * most significant bits are used to store information about ignorrable whitespace nodes */
+void xmlnode_add_ref(xmlNodePtr node)
+{
+ if (node->type == XML_DOCUMENT_NODE) return;
+ InterlockedIncrement((LONG*)&node->_private);
+}
+
+void xmlnode_release(xmlNodePtr node)
+{
+ if (node->type == XML_DOCUMENT_NODE) return;
+ InterlockedDecrement((LONG*)&node->_private);
+}
+
HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
IXMLDOMNode **ret)
{
xmlnode *before_node_obj = get_node_obj(before);
IXMLDOMNode_Release(before);
if(!before_node_obj) return E_FAIL;
+ }
- /* unlink from current parent first */
- if(node_obj->parent)
- {
- hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
- if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
- }
+ /* unlink from current parent first */
+ if(node_obj->parent)
+ {
+ hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
+ if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
+ }
+ doc = node_obj->node->doc;
- doc = node_obj->node->doc;
+ if(before)
+ {
+ xmlNodePtr new_node;
+ xmlnode *before_node_obj = get_node_obj(before);
/* refs count including subtree */
if (doc != before_node_obj->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(before_node_obj->node->doc, refcount);
- xmlAddPrevSibling(before_node_obj->node, node_obj->node);
+ new_node = xmlAddPrevSibling(before_node_obj->node, node_obj->node);
+ if (new_node != node_obj->node)
+ {
+ if (refcount != 1)
+ FIXME("referenced xmlNode was freed, expect crashes\n");
+ xmlnode_add_ref(new_node);
+ node_obj->node = new_node;
+ }
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->parent;
}
else
{
- /* unlink from current parent first */
- if(node_obj->parent)
- {
- hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
- if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
- }
- doc = node_obj->node->doc;
+ xmlNodePtr new_node;
if (doc != This->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(This->node->doc, refcount);
/* xmlAddChild doesn't unlink node from previous parent */
xmlUnlinkNode(node_obj->node);
- xmlAddChild(This->node, node_obj->node);
+ new_node = xmlAddChild(This->node, node_obj->node);
+ if (new_node != node_obj->node)
+ {
+ if (refcount != 1)
+ FIXME("referenced xmlNode was freed, expect crashes\n");
+ xmlnode_add_ref(new_node);
+ node_obj->node = new_node;
+ }
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->iface;
}
HRESULT node_get_owner_doc(const xmlnode *This, IXMLDOMDocument **doc)
{
+ if(!doc)
+ return E_INVALIDARG;
return get_domdoc_from_xmldoc(This->node->doc, (IXMLDOMDocument3**)doc);
}
return S_OK;
}
-static inline xmlChar* trim_whitespace(xmlChar* str)
-{
- xmlChar* ret = str;
- int len;
-
- if (!str)
- return NULL;
-
- while (*ret && isspace(*ret))
- ++ret;
- len = xmlStrlen(ret);
- if (len)
- while (isspace(ret[len-1])) --len;
-
- ret = xmlStrndup(ret, len);
- xmlFree(str);
- return ret;
-}
-
-static xmlChar* do_get_text(xmlNodePtr node)
+static xmlChar* do_get_text(xmlNodePtr node, BOOL trim, DWORD *first, DWORD *last, BOOL *trail_ig_ws)
{
xmlNodePtr child;
xmlChar* str;
BOOL preserving = is_preserving_whitespace(node);
+ *first = -1;
+ *last = 0;
+
if (!node->children)
{
str = xmlNodeGetContent(node);
+ *trail_ig_ws = *(DWORD*)&node->_private & NODE_PRIV_CHILD_IGNORABLE_WS;
}
else
{
- xmlElementType prev_type = XML_TEXT_NODE;
+ BOOL ig_ws = FALSE;
xmlChar* tmp;
+ DWORD pos = 0;
str = xmlStrdup(BAD_CAST "");
+
+ if (node->type != XML_DOCUMENT_NODE)
+ ig_ws = *(DWORD*)&node->_private & NODE_PRIV_CHILD_IGNORABLE_WS;
+ *trail_ig_ws = FALSE;
+
for (child = node->children; child != NULL; child = child->next)
{
switch (child->type)
{
- case XML_ELEMENT_NODE:
- tmp = do_get_text(child);
+ case XML_ELEMENT_NODE: {
+ DWORD node_first, node_last;
+
+ tmp = do_get_text(child, FALSE, &node_first, &node_last, trail_ig_ws);
+
+ if (node_first!=-1 && pos+node_first<*first)
+ *first = pos+node_first;
+ if (node_last && pos+node_last>*last)
+ *last = pos+node_last;
break;
+ }
case XML_TEXT_NODE:
+ tmp = xmlNodeGetContent(child);
+ if (!preserving && tmp[0])
+ {
+ xmlChar *beg;
+
+ for (beg = tmp; *beg; beg++)
+ if (!isspace(*beg)) break;
+
+ if (!*beg)
+ {
+ ig_ws = TRUE;
+ xmlFree(tmp);
+ tmp = NULL;
+ }
+ }
+ break;
case XML_CDATA_SECTION_NODE:
case XML_ENTITY_REF_NODE:
case XML_ENTITY_NODE:
break;
}
- if (tmp)
+ if ((tmp && *tmp) || child->type==XML_CDATA_SECTION_NODE)
{
- if (*tmp)
+ if (ig_ws && str[0])
{
- if (prev_type == XML_ELEMENT_NODE && child->type == XML_ELEMENT_NODE)
- str = xmlStrcat(str, BAD_CAST " ");
- str = xmlStrcat(str, tmp);
- prev_type = child->type;
+ str = xmlStrcat(str, BAD_CAST " ");
+ pos++;
}
- xmlFree(tmp);
+ if (tmp && *tmp) str = xmlStrcat(str, tmp);
+ if (child->type==XML_CDATA_SECTION_NODE && pos<*first)
+ *first = pos;
+ if (tmp && *tmp) pos += xmlStrlen(tmp);
+ if (child->type==XML_CDATA_SECTION_NODE && pos>*last)
+ *last = pos;
+ ig_ws = FALSE;
+ }
+ if (tmp) xmlFree(tmp);
+
+ if (!ig_ws)
+ {
+ ig_ws = *(DWORD*)&child->_private & NODE_PRIV_TRAILING_IGNORABLE_WS;
}
+ if (!ig_ws)
+ ig_ws = *trail_ig_ws;
+ *trail_ig_ws = FALSE;
}
+
+ *trail_ig_ws = ig_ws;
}
switch (node->type)
case XML_ENTITY_NODE:
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
- if (!preserving)
- str = trim_whitespace(str);
+ if (trim && !preserving)
+ {
+ xmlChar* ret;
+ int len;
+
+ if (!str)
+ break;
+
+ for (ret = str; *ret && isspace(*ret) && (*first)--; ret++)
+ if (*last) (*last)--;
+ for (len = xmlStrlen(ret)-1; len >= 0 && len >= *last; len--)
+ if(!isspace(ret[len])) break;
+
+ ret = xmlStrndup(ret, len+1);
+ xmlFree(str);
+ str = ret;
+ break;
+ }
break;
default:
break;
{
BSTR str = NULL;
xmlChar *content;
+ DWORD first, last;
+ BOOL tmp;
if (!text) return E_INVALIDARG;
- content = do_get_text(This->node);
+ content = do_get_text(This->node, TRUE, &first, &last, &tmp);
if (content)
{
str = bstr_from_xmlChar(content);
static int XMLCALL transform_to_stream_write(void *context, const char *buffer, int len)
{
DWORD written;
- HRESULT hr = IStream_Write((IStream*)context, buffer, len, &written);
+ HRESULT hr = ISequentialStream_Write((ISequentialStream *)context, buffer, len, &written);
return hr == S_OK ? written : -1;
}
htmlSetMetaEncoding(result, (const xmlChar *)encoding);
if (indent == -1)
indent = 1;
- htmldoc_dumpcontent(output, result, (const char*)encoding, indent);
+ htmldoc_dumpcontent(output, result, encoding, indent);
}
else if (method && xmlStrEqual(method, (const xmlChar *)"xhtml"))
{
return *str ? hr : E_OUTOFMEMORY;
}
-static HRESULT node_transform_write_to_stream(xsltStylesheetPtr style, xmlDocPtr result, IStream *stream)
+static HRESULT node_transform_write_to_stream(xsltStylesheetPtr style, xmlDocPtr result, ISequentialStream *stream)
{
static const xmlChar *utf16 = (const xmlChar*)"UTF-16";
xmlOutputBufferPtr output;
return hr;
}
-#endif
+struct import_buffer
+{
+ char *data;
+ int cur;
+ int len;
+};
+
+static int XMLCALL import_loader_io_read(void *context, char *out, int len)
+{
+ struct import_buffer *buffer = (struct import_buffer *)context;
+
+ TRACE("%p, %p, %d\n", context, out, len);
+
+ if (buffer->cur == buffer->len)
+ return 0;
+
+ len = min(len, buffer->len - buffer->cur);
+ memcpy(out, &buffer->data[buffer->cur], len);
+ buffer->cur += len;
+
+ TRACE("read %d\n", len);
+
+ return len;
+}
+
+static int XMLCALL import_loader_io_close(void * context)
+{
+ struct import_buffer *buffer = (struct import_buffer *)context;
+
+ TRACE("%p\n", context);
+
+ heap_free(buffer->data);
+ heap_free(buffer);
+ return 0;
+}
+
+static HRESULT import_loader_onDataAvailable(void *ctxt, char *ptr, DWORD len)
+{
+ xmlParserInputPtr *input = (xmlParserInputPtr *)ctxt;
+ xmlParserInputBufferPtr inputbuffer;
+ struct import_buffer *buffer;
+
+ buffer = heap_alloc(sizeof(*buffer));
+
+ buffer->data = heap_alloc(len);
+ memcpy(buffer->data, ptr, len);
+ buffer->cur = 0;
+ buffer->len = len;
+
+ inputbuffer = xmlParserInputBufferCreateIO(import_loader_io_read, import_loader_io_close, buffer,
+ XML_CHAR_ENCODING_NONE);
+ *input = xmlNewIOInputStream(ctxt, inputbuffer, XML_CHAR_ENCODING_NONE);
+ if (!*input)
+ xmlFreeParserInputBuffer(inputbuffer);
+
+ return *input ? S_OK : E_FAIL;
+}
+
+static HRESULT xslt_doc_get_uri(const xmlChar *uri, void *_ctxt, xsltLoadType type, IUri **doc_uri)
+{
+ xsltStylesheetPtr style = (xsltStylesheetPtr)_ctxt;
+ IUri *href_uri;
+ HRESULT hr;
+ BSTR uriW;
+
+ *doc_uri = NULL;
+
+ uriW = bstr_from_xmlChar(uri);
+ hr = CreateUri(uriW, Uri_CREATE_ALLOW_RELATIVE | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &href_uri);
+ SysFreeString(uriW);
+ if (FAILED(hr))
+ {
+ WARN("Failed to create href uri, %#x.\n", hr);
+ return hr;
+ }
+
+ if (type == XSLT_LOAD_STYLESHEET && style->doc && style->doc->name)
+ {
+ IUri *base_uri;
+ BSTR baseuriW;
+
+ baseuriW = bstr_from_xmlChar((xmlChar *)style->doc->name);
+ hr = CreateUri(baseuriW, Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &base_uri);
+ SysFreeString(baseuriW);
+ if (FAILED(hr))
+ {
+ WARN("Failed to create base uri, %#x.\n", hr);
+ return hr;
+ }
+
+ hr = CoInternetCombineIUri(base_uri, href_uri, 0, doc_uri, 0);
+ IUri_Release(base_uri);
+ if (FAILED(hr))
+ WARN("Failed to combine uris, %#x.\n", hr);
+ }
+ else
+ {
+ *doc_uri = href_uri;
+ IUri_AddRef(*doc_uri);
+ }
+
+ IUri_Release(href_uri);
+
+ return hr;
+}
+
+xmlDocPtr xslt_doc_default_loader(const xmlChar *uri, xmlDictPtr dict, int options,
+ void *_ctxt, xsltLoadType type)
+{
+ IUri *import_uri = NULL;
+ xmlParserInputPtr input;
+ xmlParserCtxtPtr pctxt;
+ xmlDocPtr doc = NULL;
+ IMoniker *moniker;
+ HRESULT hr;
+ bsc_t *bsc;
+ BSTR uriW;
+
+ TRACE("%s, %p, %#x, %p, %d\n", debugstr_a((const char *)uri), dict, options, _ctxt, type);
+
+ pctxt = xmlNewParserCtxt();
+ if (!pctxt)
+ return NULL;
+
+ if (dict && pctxt->dict)
+ {
+ xmlDictFree(pctxt->dict);
+ pctxt->dict = NULL;
+ }
+
+ if (dict)
+ {
+ pctxt->dict = dict;
+ xmlDictReference(pctxt->dict);
+ }
+
+ xmlCtxtUseOptions(pctxt, options);
+
+ hr = xslt_doc_get_uri(uri, _ctxt, type, &import_uri);
+ if (FAILED(hr))
+ goto failed;
+
+ hr = CreateURLMonikerEx2(NULL, import_uri, &moniker, 0);
+ if (FAILED(hr))
+ goto failed;
+
+ hr = bind_url(moniker, import_loader_onDataAvailable, &input, &bsc);
+ IMoniker_Release(moniker);
+ if (FAILED(hr))
+ goto failed;
+
+ if (FAILED(detach_bsc(bsc)))
+ goto failed;
+
+ if (!input)
+ goto failed;
+
+ inputPush(pctxt, input);
+ xmlParseDocument(pctxt);
+
+ if (pctxt->wellFormed)
+ {
+ doc = pctxt->myDoc;
+ /* Set imported uri, to give nested imports a chance. */
+ if (IUri_GetPropertyBSTR(import_uri, Uri_PROPERTY_ABSOLUTE_URI, &uriW, 0) == S_OK)
+ {
+ doc->name = (char *)xmlchar_from_wcharn(uriW, SysStringLen(uriW), TRUE);
+ SysFreeString(uriW);
+ }
+ }
+ else
+ {
+ doc = NULL;
+ xmlFreeDoc(pctxt->myDoc);
+ pctxt->myDoc = NULL;
+ }
+
+failed:
+ xmlFreeParserCtxt(pctxt);
+ if (import_uri)
+ IUri_Release(import_uri);
+
+ return doc;
+}
+
+#endif /* SONAME_LIBXSLT */
HRESULT node_transform_node_params(const xmlnode *This, IXMLDOMNode *stylesheet, BSTR *p,
- IStream *stream, const struct xslprocessor_params *params)
+ ISequentialStream *stream, const struct xslprocessor_params *params)
{
#ifdef SONAME_LIBXSLT
xsltStylesheetPtr xsltSS;
+ xmlDocPtr sheet_doc;
HRESULT hr = S_OK;
xmlnode *sheet;
sheet = get_node_obj(stylesheet);
if(!sheet) return E_FAIL;
- xsltSS = pxsltParseStylesheetDoc(sheet->node->doc);
- if(xsltSS)
+ sheet_doc = xmlCopyDoc(sheet->node->doc, 1);
+ xsltSS = pxsltParseStylesheetDoc(sheet_doc);
+ if (xsltSS)
{
const char **xslparams = NULL;
xmlDocPtr result;
hr = node_transform_write_to_bstr(xsltSS, result, p);
xmlFreeDoc(result);
}
- /* libxslt "helpfully" frees the XML document the stylesheet was
- generated from, too */
- xsltSS->doc = NULL;
+
pxsltFreeStylesheet(xsltSS);
}
+ else
+ xmlFreeDoc(sheet_doc);
if(!*p) *p = SysAllocStringLen(NULL, 0);
return hr;
#else
- FIXME("libxslt headers were not found at compile time\n");
+ ERR_(winediag)("libxslt headers were not found at compile time. Expect problems.\n");
+
return E_NOTIMPL;
#endif
}
return S_OK;
}
-/* _private field holds a number of COM instances spawned from this libxml2 node */
-static void xmlnode_add_ref(xmlNodePtr node)
-{
- if (node->type == XML_DOCUMENT_NODE) return;
- InterlockedIncrement((LONG*)&node->_private);
-}
-
-static void xmlnode_release(xmlNodePtr node)
-{
- if (node->type == XML_DOCUMENT_NODE) return;
- InterlockedDecrement((LONG*)&node->_private);
-}
-
void destroy_xmlnode(xmlnode *This)
{
if(This->node)
FIXME("(%p)->(%p)\n", This, domNodeType);
- *domNodeType = This->node.node->type;
+ switch (This->node.node->type)
+ {
+ case XML_ELEMENT_NODE:
+ case XML_ATTRIBUTE_NODE:
+ case XML_TEXT_NODE:
+ case XML_CDATA_SECTION_NODE:
+ case XML_ENTITY_REF_NODE:
+ case XML_ENTITY_NODE:
+ case XML_PI_NODE:
+ case XML_COMMENT_NODE:
+ case XML_DOCUMENT_NODE:
+ case XML_DOCUMENT_TYPE_NODE:
+ case XML_DOCUMENT_FRAG_NODE:
+ case XML_NOTATION_NODE:
+ /* we only care about this set of types, libxml2 type values are
+ exactly what we need */
+ *domNodeType = (DOMNodeType)This->node.node->type;
+ break;
+ default:
+ *domNodeType = NODE_INVALID;
+ break;
+ }
+
return S_OK;
}
pUnk = create_element( node );
break;
case XML_ATTRIBUTE_NODE:
- pUnk = create_attribute( node );
+ pUnk = create_attribute( node, FALSE );
break;
case XML_TEXT_NODE:
pUnk = create_text( node );
pUnk = create_doc_fragment( node );
break;
case XML_DTD_NODE:
+ case XML_DOCUMENT_TYPE_NODE:
pUnk = create_doc_type( node );
break;
- default: {
+ case XML_ENTITY_NODE:
+ case XML_NOTATION_NODE: {
unknode *new_node;
FIXME("only creating basic node for type %d\n", node->type);
new_node->ref = 1;
init_xmlnode(&new_node->node, node, &new_node->IXMLDOMNode_iface, NULL);
pUnk = (IUnknown*)&new_node->IXMLDOMNode_iface;
+ break;
}
+ default:
+ ERR("Called for unsupported node type %d\n", node->type);
+ return NULL;
}
hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);