?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msxml3: libxml2 error/warning callback functions.
[wine.git] / dlls / msxml3 / domdoc.c
blob8a214023bdaa802f1e73f1ef319c538ccc764dac
1 /*
2 * DOM Document implementation
3 *
4 * Copyright 2005 Mike McCormack
5 * Copyright 2010 Adam Martinson for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 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 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include "config.h"
26
27 #include <stdarg.h>
28 #include <assert.h>
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "ole2.h"
34 #include "olectl.h"
35 #include "msxml6.h"
36 #include "wininet.h"
37 #include "winreg.h"
38 #include "shlwapi.h"
39 #include "ocidl.h"
40 #include "objsafe.h"
41 #include "dispex.h"
42
43 #include "wine/debug.h"
44 #include "wine/list.h"
45
46 #include "msxml_private.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
49
50 #ifdef HAVE_LIBXML2
51
52 #include <libxml/xpathInternals.h>
53 #include <libxml/xmlsave.h>
54 #include <libxml/SAX2.h>
55 #include <libxml/parserInternals.h>
56
57 /* not defined in older versions */
58 #define XML_SAVE_FORMAT 1
59 #define XML_SAVE_NO_DECL 2
60 #define XML_SAVE_NO_EMPTY 4
61 #define XML_SAVE_NO_XHTML 8
62 #define XML_SAVE_XHTML 16
63 #define XML_SAVE_AS_XML 32
64 #define XML_SAVE_AS_HTML 64
65
66 static const WCHAR PropertySelectionLanguageW[] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0};
67 static const WCHAR PropertySelectionNamespacesW[] = {'S','e','l','e','c','t','i','o','n','N','a','m','e','s','p','a','c','e','s',0};
68 static const WCHAR PropertyProhibitDTDW[] = {'P','r','o','h','i','b','i','t','D','T','D',0};
69 static const WCHAR PropertyNewParserW[] = {'N','e','w','P','a','r','s','e','r',0};
70 static const WCHAR PropValueXPathW[] = {'X','P','a','t','h',0};
71 static const WCHAR PropValueXSLPatternW[] = {'X','S','L','P','a','t','t','e','r','n',0};
72
73 /* Data used by domdoc_getProperty()/domdoc_setProperty().
74 * We need to preserve this when reloading a document,
75 * and also need access to it from the libxml backend. */
76 typedef struct _domdoc_properties {
77 struct list selectNsList;
78 xmlChar const* selectNsStr;
79 LONG selectNsStr_len;
80 BOOL XPath;
81 } domdoc_properties;
82
83 typedef struct ConnectionPoint ConnectionPoint;
84 typedef struct domdoc domdoc;
85
86 struct ConnectionPoint
87 {
88 const IConnectionPointVtbl *lpVtblConnectionPoint;
89 const IID *iid;
90
91 ConnectionPoint *next;
92 IConnectionPointContainer *container;
93 domdoc *doc;
94
95 union
96 {
97 IUnknown *unk;
98 IDispatch *disp;
99 IPropertyNotifySink *propnotif;
100 } *sinks;
101 DWORD sinks_size;
102 };
103
104 struct domdoc
105 {
106 xmlnode node;
107 const struct IXMLDOMDocument3Vtbl *lpVtbl;
108 const struct IPersistStreamInitVtbl *lpvtblIPersistStreamInit;
109 const struct IObjectWithSiteVtbl *lpvtblIObjectWithSite;
110 const struct IObjectSafetyVtbl *lpvtblIObjectSafety;
111 const struct ISupportErrorInfoVtbl *lpvtblISupportErrorInfo;
112 const struct IConnectionPointContainerVtbl *lpVtblConnectionPointContainer;
113 LONG ref;
114 VARIANT_BOOL async;
115 VARIANT_BOOL validating;
116 VARIANT_BOOL resolving;
117 VARIANT_BOOL preserving;
118 domdoc_properties* properties;
119 IXMLDOMSchemaCollection *schema;
120 bsc_t *bsc;
121 HRESULT error;
122
123 /* IPersistStream */
124 IStream *stream;
125
126 /* IObjectWithSite*/
127 IUnknown *site;
128
129 /* IObjectSafety */
130 DWORD safeopt;
131
132 /* connection list */
133 ConnectionPoint *cp_list;
134 ConnectionPoint cp_domdocevents;
135 ConnectionPoint cp_propnotif;
136 ConnectionPoint cp_dispatch;
137 };
138
139 static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface)
140 {
141 return (ConnectionPoint *)((char*)iface - FIELD_OFFSET(ConnectionPoint, lpVtblConnectionPoint));
142 }
143
144 /*
145 In native windows, the whole lifetime management of XMLDOMNodes is
146 managed automatically using reference counts. Wine emulates that by
147 maintaining a reference count to the document that is increased for
148 each IXMLDOMNode pointer passed out for this document. If all these
149 pointers are gone, the document is unreachable and gets freed, that
150 is, all nodes in the tree of the document get freed.
151
152 You are able to create nodes that are associated to a document (in
153 fact, in msxml's XMLDOM model, all nodes are associated to a document),
154 but not in the tree of that document, for example using the createFoo
155 functions from IXMLDOMDocument. These nodes do not get cleaned up
156 by libxml, so we have to do it ourselves.
157
158 To catch these nodes, a list of "orphan nodes" is introduced.
159 It contains pointers to all roots of node trees that are
160 associated with the document without being part of the document
161 tree. All nodes with parent==NULL (except for the document root nodes)
162 should be in the orphan node list of their document. All orphan nodes
163 get freed together with the document itself.
164 */
165
166 typedef struct _xmldoc_priv {
167 LONG refs;
168 struct list orphans;
169 domdoc_properties* properties;
170 } xmldoc_priv;
171
172 typedef struct _orphan_entry {
173 struct list entry;
174 xmlNode * node;
175 } orphan_entry;
176
177 typedef struct _select_ns_entry {
178 struct list entry;
179 xmlChar const* prefix;
180 xmlChar prefix_end;
181 xmlChar const* href;
182 xmlChar href_end;
183 } select_ns_entry;
184
185 static inline xmldoc_priv * priv_from_xmlDocPtr(const xmlDocPtr doc)
186 {
187 return doc->_private;
188 }
189
190 static inline domdoc_properties * properties_from_xmlDocPtr(xmlDocPtr doc)
191 {
192 return priv_from_xmlDocPtr(doc)->properties;
193 }
194
195 BOOL is_xpathmode(const xmlDocPtr doc)
196 {
197 return properties_from_xmlDocPtr(doc)->XPath;
198 }
199
200 int registerNamespaces(xmlXPathContextPtr ctxt)
201 {
202 int n = 0;
203 const select_ns_entry* ns = NULL;
204 const struct list* pNsList = &properties_from_xmlDocPtr(ctxt->doc)->selectNsList;
205
206 TRACE("(%p)\n", ctxt);
207
208 LIST_FOR_EACH_ENTRY( ns, pNsList, select_ns_entry, entry )
209 {
210 xmlXPathRegisterNs(ctxt, ns->prefix, ns->href);
211 ++n;
212 }
213
214 return n;
215 }
216
217 static inline void clear_selectNsList(struct list* pNsList)
218 {
219 select_ns_entry *ns, *ns2;
220 LIST_FOR_EACH_ENTRY_SAFE( ns, ns2, pNsList, select_ns_entry, entry )
221 {
222 heap_free( ns );
223 }
224 list_init(pNsList);
225 }
226
227 static xmldoc_priv * create_priv(void)
228 {
229 xmldoc_priv *priv;
230 priv = heap_alloc( sizeof (*priv) );
231
232 if (priv)
233 {
234 priv->refs = 0;
235 list_init( &priv->orphans );
236 priv->properties = NULL;
237 }
238
239 return priv;
240 }
241
242 static domdoc_properties * create_properties(const GUID *clsid)
243 {
244 domdoc_properties *properties = heap_alloc(sizeof(domdoc_properties));
245
246 list_init( &properties->selectNsList );
247 properties->selectNsStr = heap_alloc_zero(sizeof(xmlChar));
248 properties->selectNsStr_len = 0;
249 properties->XPath = FALSE;
250
251 /* properties that are dependent on object versions */
252 if (IsEqualCLSID( clsid, &CLSID_DOMDocument40 ) ||
253 IsEqualCLSID( clsid, &CLSID_DOMDocument60 ))
254 {
255 properties->XPath = TRUE;
256 }
257
258 return properties;
259 }
260
261 static domdoc_properties* copy_properties(domdoc_properties const* properties)
262 {
263 domdoc_properties* pcopy = heap_alloc(sizeof(domdoc_properties));
264 select_ns_entry const* ns = NULL;
265 select_ns_entry* new_ns = NULL;
266 int len = (properties->selectNsStr_len+1)*sizeof(xmlChar);
267 ptrdiff_t offset;
268
269 if (pcopy)
270 {
271 pcopy->XPath = properties->XPath;
272 pcopy->selectNsStr_len = properties->selectNsStr_len;
273 list_init( &pcopy->selectNsList );
274 pcopy->selectNsStr = heap_alloc(len);
275 memcpy((xmlChar*)pcopy->selectNsStr, properties->selectNsStr, len);
276 offset = pcopy->selectNsStr - properties->selectNsStr;
277
278 LIST_FOR_EACH_ENTRY( ns, (&properties->selectNsList), select_ns_entry, entry )
279 {
280 new_ns = heap_alloc(sizeof(select_ns_entry));
281 memcpy(new_ns, ns, sizeof(select_ns_entry));
282 new_ns->href += offset;
283 new_ns->prefix += offset;
284 list_add_tail(&pcopy->selectNsList, &new_ns->entry);
285 }
286
287 }
288
289 return pcopy;
290 }
291
292 static void free_properties(domdoc_properties* properties)
293 {
294 if (properties)
295 {
296 clear_selectNsList(&properties->selectNsList);
297 heap_free((xmlChar*)properties->selectNsStr);
298 heap_free(properties);
299 }
300 }
301
302 /* links a "<?xml" node as a first child */
303 void xmldoc_link_xmldecl(xmlDocPtr doc, xmlNodePtr node)
304 {
305 assert(doc != NULL);
306 if (doc->standalone != -1) xmlAddPrevSibling( doc->children, node );
307 }
308
309 /* unlinks a first "<?xml" child if it was created */
310 xmlNodePtr xmldoc_unlink_xmldecl(xmlDocPtr doc)
311 {
312 xmlNodePtr node;
313
314 assert(doc != NULL);
315
316 if (doc->standalone != -1)
317 {
318 node = doc->children;
319 xmlUnlinkNode( node );
320 }
321 else
322 node = NULL;
323
324 return node;
325 }
326
327 static inline BOOL strn_isspace(xmlChar const* str, int len)
328 {
329 for (; str && len > 0 && *str; ++str, --len)
330 if (!isspace(*str))
331 break;
332
333 return len == 0;
334 }
335
336 static void sax_characters(void *ctx, const xmlChar *ch, int len)
337 {
338 xmlParserCtxtPtr pctx;
339 domdoc const* This;
340
341 pctx = (xmlParserCtxtPtr) ctx;
342 This = (domdoc const*) pctx->_private;
343
344 if (!This->preserving)
345 {
346 xmlChar* ws = xmlGetNsProp(pctx->node, BAD_CAST "space", XML_XML_NAMESPACE);
347 if ((!ws || xmlStrcmp(ws, BAD_CAST "preserve") != 0) &&
348 strn_isspace(ch, len))
349 {
350 xmlFree(ws);
351 return;
352 }
353 xmlFree(ws);
354 }
355
356 xmlSAX2Characters(ctx, ch, len);
357 }
358
359 static void LIBXML2_LOG_CALLBACK sax_error(void* ctx, char const* msg, ...)
360 {
361 va_list ap;
362 va_start(ap, msg);
363 LIBXML2_CALLBACK_ERR(doparse, msg, ap);
364 va_end(ap);
365 }
366
367 static void LIBXML2_LOG_CALLBACK sax_warning(void* ctx, char const* msg, ...)
368 {
369 va_list ap;
370 va_start(ap, msg);
371 LIBXML2_CALLBACK_WARN(doparse, msg, ap);
372 va_end(ap);
373 }
374
375 static void sax_serror(void* ctx, xmlErrorPtr err)
376 {
377 LIBXML2_CALLBACK_SERROR(doparse, err);
378 }
379
380 static xmlDocPtr doparse(domdoc* This, char *ptr, int len, xmlChar const* encoding)
381 {
382 xmlDocPtr doc = NULL;
383 xmlParserCtxtPtr pctx;
384 static xmlSAXHandler sax_handler = {
385 xmlSAX2InternalSubset, /* internalSubset */
386 xmlSAX2IsStandalone, /* isStandalone */
387 xmlSAX2HasInternalSubset, /* hasInternalSubset */
388 xmlSAX2HasExternalSubset, /* hasExternalSubset */
389 xmlSAX2ResolveEntity, /* resolveEntity */
390 xmlSAX2GetEntity, /* getEntity */
391 xmlSAX2EntityDecl, /* entityDecl */
392 xmlSAX2NotationDecl, /* notationDecl */
393 xmlSAX2AttributeDecl, /* attributeDecl */
394 xmlSAX2ElementDecl, /* elementDecl */
395 xmlSAX2UnparsedEntityDecl, /* unparsedEntityDecl */
396 xmlSAX2SetDocumentLocator, /* setDocumentLocator */
397 xmlSAX2StartDocument, /* startDocument */
398 xmlSAX2EndDocument, /* endDocument */
399 xmlSAX2StartElement, /* startElement */
400 xmlSAX2EndElement, /* endElement */
401 xmlSAX2Reference, /* reference */
402 sax_characters, /* characters */
403 sax_characters, /* ignorableWhitespace */
404 xmlSAX2ProcessingInstruction, /* processingInstruction */
405 xmlSAX2Comment, /* comment */
406 sax_warning, /* warning */
407 sax_error, /* error */
408 sax_error, /* fatalError */
409 xmlSAX2GetParameterEntity, /* getParameterEntity */
410 xmlSAX2CDataBlock, /* cdataBlock */
411 xmlSAX2ExternalSubset, /* externalSubset */
412 0, /* initialized */
413 NULL, /* _private */
414 xmlSAX2StartElementNs, /* startElementNs */
415 xmlSAX2EndElementNs, /* endElementNs */
416 sax_serror /* serror */
417 };
418 xmlInitParser();
419
420 pctx = xmlCreateMemoryParserCtxt(ptr, len);
421 if (!pctx)
422 {
423 ERR("Failed to create parser context\n");
424 return NULL;
425 }
426
427 if (pctx->sax) xmlFree(pctx->sax);
428 pctx->sax = &sax_handler;
429 pctx->_private = This;
430 pctx->recovery = 0;
431 pctx->encoding = xmlStrdup(encoding);
432 xmlParseDocument(pctx);
433
434 if (pctx->wellFormed)
435 {
436 doc = pctx->myDoc;
437 }
438 else
439 {
440 xmlFreeDoc(pctx->myDoc);
441 pctx->myDoc = NULL;
442 }
443 pctx->sax = NULL;
444 xmlFreeParserCtxt(pctx);
445
446 /* TODO: put this in one of the SAX callbacks */
447 /* create first child as a <?xml...?> */
448 if (doc && doc->standalone != -1)
449 {
450 xmlNodePtr node;
451 char buff[30];
452 xmlChar *xmlbuff = (xmlChar*)buff;
453
454 node = xmlNewDocPI( doc, (xmlChar*)"xml", NULL );
455
456 /* version attribute can't be omitted */
457 sprintf(buff, "version=\"%s\"", doc->version ? (char*)doc->version : "1.0");
458 xmlNodeAddContent( node, xmlbuff );
459
460 if (doc->encoding)
461 {
462 sprintf(buff, " encoding=\"%s\"", doc->encoding);
463 xmlNodeAddContent( node, xmlbuff );
464 }
465
466 if (doc->standalone != -2)
467 {
468 sprintf(buff, " standalone=\"%s\"", doc->standalone == 0 ? "no" : "yes");
469 xmlNodeAddContent( node, xmlbuff );
470 }
471
472 xmldoc_link_xmldecl( doc, node );
473 }
474
475 return doc;
476 }
477
478 void xmldoc_init(xmlDocPtr doc, const GUID *clsid)
479 {
480 doc->_private = create_priv();
481 priv_from_xmlDocPtr(doc)->properties = create_properties(clsid);
482 }
483
484 LONG xmldoc_add_ref(xmlDocPtr doc)
485 {
486 LONG ref = InterlockedIncrement(&priv_from_xmlDocPtr(doc)->refs);
487 TRACE("(%p)->(%d)\n", doc, ref);
488 return ref;
489 }
490
491 LONG xmldoc_release(xmlDocPtr doc)
492 {
493 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
494 LONG ref = InterlockedDecrement(&priv->refs);
495 TRACE("(%p)->(%d)\n", doc, ref);
496 if(ref == 0)
497 {
498 orphan_entry *orphan, *orphan2;
499 TRACE("freeing docptr %p\n", doc);
500
501 LIST_FOR_EACH_ENTRY_SAFE( orphan, orphan2, &priv->orphans, orphan_entry, entry )
502 {
503 xmlFreeNode( orphan->node );
504 heap_free( orphan );
505 }
506 free_properties(priv->properties);
507 heap_free(doc->_private);
508
509 xmlFreeDoc(doc);
510 }
511
512 return ref;
513 }
514
515 HRESULT xmldoc_add_orphan(xmlDocPtr doc, xmlNodePtr node)
516 {
517 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
518 orphan_entry *entry;
519
520 entry = heap_alloc( sizeof (*entry) );
521 if(!entry)
522 return E_OUTOFMEMORY;
523
524 entry->node = node;
525 list_add_head( &priv->orphans, &entry->entry );
526 return S_OK;
527 }
528
529 HRESULT xmldoc_remove_orphan(xmlDocPtr doc, xmlNodePtr node)
530 {
531 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
532 orphan_entry *entry, *entry2;
533
534 LIST_FOR_EACH_ENTRY_SAFE( entry, entry2, &priv->orphans, orphan_entry, entry )
535 {
536 if( entry->node == node )
537 {
538 list_remove( &entry->entry );
539 heap_free( entry );
540 return S_OK;
541 }
542 }
543
544 return S_FALSE;
545 }
546
547 static inline xmlDocPtr get_doc( domdoc *This )
548 {
549 return (xmlDocPtr)This->node.node;
550 }
551
552 static HRESULT attach_xmldoc(domdoc *This, xmlDocPtr xml )
553 {
554 if(This->node.node)
555 {
556 priv_from_xmlDocPtr(get_doc(This))->properties = NULL;
557 if (xmldoc_release(get_doc(This)) != 0)
558 priv_from_xmlDocPtr(get_doc(This))->properties =
559 copy_properties(This->properties);
560 }
561
562 This->node.node = (xmlNodePtr) xml;
563
564 if(This->node.node)
565 {
566 xmldoc_add_ref(get_doc(This));
567 priv_from_xmlDocPtr(get_doc(This))->properties = This->properties;
568 }
569
570 return S_OK;
571 }
572
573 static inline domdoc *impl_from_IXMLDOMDocument3( IXMLDOMDocument3 *iface )
574 {
575 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtbl));
576 }
577
578 static inline domdoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
579 {
580 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIPersistStreamInit));
581 }
582
583 static inline domdoc *impl_from_IObjectWithSite(IObjectWithSite *iface)
584 {
585 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectWithSite));
586 }
587
588 static inline domdoc *impl_from_IObjectSafety(IObjectSafety *iface)
589 {
590 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectSafety));
591 }
592
593 static inline domdoc *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
594 {
595 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblISupportErrorInfo));
596 }
597
598 static inline domdoc *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
599 {
600 return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtblConnectionPointContainer));
601 }
602
603 /************************************************************************
604 * domdoc implementation of IPersistStream.
605 */
606 static HRESULT WINAPI domdoc_IPersistStreamInit_QueryInterface(
607 IPersistStreamInit *iface, REFIID riid, void **ppvObj)
608 {
609 domdoc *this = impl_from_IPersistStreamInit(iface);
610 return IXMLDOMDocument2_QueryInterface((IXMLDOMDocument2 *)this, riid, ppvObj);
611 }
612
613 static ULONG WINAPI domdoc_IPersistStreamInit_AddRef(
614 IPersistStreamInit *iface)
615 {
616 domdoc *this = impl_from_IPersistStreamInit(iface);
617 return IXMLDOMDocument2_AddRef((IXMLDOMDocument2 *)this);
618 }
619
620 static ULONG WINAPI domdoc_IPersistStreamInit_Release(
621 IPersistStreamInit *iface)
622 {
623 domdoc *this = impl_from_IPersistStreamInit(iface);
624 return IXMLDOMDocument2_Release((IXMLDOMDocument2 *)this);
625 }
626
627 static HRESULT WINAPI domdoc_IPersistStreamInit_GetClassID(
628 IPersistStreamInit *iface, CLSID *classid)
629 {
630 TRACE("(%p,%p): stub!\n", iface, classid);
631
632 if(!classid)
633 return E_POINTER;
634
635 *classid = CLSID_DOMDocument2;
636
637 return S_OK;
638 }
639
640 static HRESULT WINAPI domdoc_IPersistStreamInit_IsDirty(
641 IPersistStreamInit *iface)
642 {
643 domdoc *This = impl_from_IPersistStreamInit(iface);
644 FIXME("(%p): stub!\n", This);
645 return S_FALSE;
646 }
647
648 static HRESULT WINAPI domdoc_IPersistStreamInit_Load(
649 IPersistStreamInit *iface, LPSTREAM pStm)
650 {
651 domdoc *This = impl_from_IPersistStreamInit(iface);
652 HRESULT hr;
653 HGLOBAL hglobal;
654 DWORD read, written, len;
655 BYTE buf[4096];
656 char *ptr;
657 xmlDocPtr xmldoc = NULL;
658
659 TRACE("(%p)->(%p)\n", This, pStm);
660
661 if (!pStm)
662 return E_INVALIDARG;
663
664 hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
665 if (FAILED(hr))
666 return hr;
667
668 do
669 {
670 IStream_Read(pStm, buf, sizeof(buf), &read);
671 hr = IStream_Write(This->stream, buf, read, &written);
672 } while(SUCCEEDED(hr) && written != 0 && read != 0);
673
674 if (FAILED(hr))
675 {
676 ERR("Failed to copy stream\n");
677 return hr;
678 }
679
680 hr = GetHGlobalFromStream(This->stream, &hglobal);
681 if (FAILED(hr))
682 return hr;
683
684 len = GlobalSize(hglobal);
685 ptr = GlobalLock(hglobal);
686 if (len != 0)
687 xmldoc = doparse(This, ptr, len, NULL);
688 GlobalUnlock(hglobal);
689
690 if (!xmldoc)
691 {
692 ERR("Failed to parse xml\n");
693 return E_FAIL;
694 }
695
696 xmldoc->_private = create_priv();
697
698 return attach_xmldoc(This, xmldoc);
699 }
700
701 static HRESULT WINAPI domdoc_IPersistStreamInit_Save(
702 IPersistStreamInit *iface, IStream *stream, BOOL clr_dirty)
703 {
704 domdoc *This = impl_from_IPersistStreamInit(iface);
705 BSTR xmlString;
706 HRESULT hr;
707
708 TRACE("(%p)->(%p %d)\n", This, stream, clr_dirty);
709
710 hr = IXMLDOMDocument3_get_xml( (IXMLDOMDocument3*)&This->lpVtbl, &xmlString );
711 if(hr == S_OK)
712 {
713 DWORD len = SysStringLen(xmlString) * sizeof(WCHAR);
714
715 hr = IStream_Write( stream, xmlString, len, NULL );
716 SysFreeString(xmlString);
717 }
718
719 TRACE("ret 0x%08x\n", hr);
720
721 return hr;
722 }
723
724 static HRESULT WINAPI domdoc_IPersistStreamInit_GetSizeMax(
725 IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
726 {
727 domdoc *This = impl_from_IPersistStreamInit(iface);
728 TRACE("(%p)->(%p): stub!\n", This, pcbSize);
729 return E_NOTIMPL;
730 }
731
732 static HRESULT WINAPI domdoc_IPersistStreamInit_InitNew(
733 IPersistStreamInit *iface)
734 {
735 domdoc *This = impl_from_IPersistStreamInit(iface);
736 TRACE("(%p)\n", This);
737 return S_OK;
738 }
739
740 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
741 {
742 domdoc_IPersistStreamInit_QueryInterface,
743 domdoc_IPersistStreamInit_AddRef,
744 domdoc_IPersistStreamInit_Release,
745 domdoc_IPersistStreamInit_GetClassID,
746 domdoc_IPersistStreamInit_IsDirty,
747 domdoc_IPersistStreamInit_Load,
748 domdoc_IPersistStreamInit_Save,
749 domdoc_IPersistStreamInit_GetSizeMax,
750 domdoc_IPersistStreamInit_InitNew
751 };
752
753 /* ISupportErrorInfo interface */
754 static HRESULT WINAPI support_error_QueryInterface(
755 ISupportErrorInfo *iface,
756 REFIID riid, void** ppvObj )
757 {
758 domdoc *This = impl_from_ISupportErrorInfo(iface);
759 return IXMLDOMDocument3_QueryInterface((IXMLDOMDocument3 *)This, riid, ppvObj);
760 }
761
762 static ULONG WINAPI support_error_AddRef(
763 ISupportErrorInfo *iface )
764 {
765 domdoc *This = impl_from_ISupportErrorInfo(iface);
766 return IXMLDOMDocument3_AddRef((IXMLDOMDocument3 *)This);
767 }
768
769 static ULONG WINAPI support_error_Release(
770 ISupportErrorInfo *iface )
771 {
772 domdoc *This = impl_from_ISupportErrorInfo(iface);
773 return IXMLDOMDocument3_Release((IXMLDOMDocument3 *)This);
774 }
775
776 static HRESULT WINAPI support_error_InterfaceSupportsErrorInfo(
777 ISupportErrorInfo *iface,
778 REFIID riid )
779 {
780 FIXME("(%p)->(%s)\n", iface, debugstr_guid(riid));
781 return S_FALSE;
782 }
783
784 static const struct ISupportErrorInfoVtbl support_error_vtbl =
785 {
786 support_error_QueryInterface,
787 support_error_AddRef,
788 support_error_Release,
789 support_error_InterfaceSupportsErrorInfo
790 };
791
792 /* IXMLDOMDocument2 interface */
793 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument3 *iface, REFIID riid, void** ppvObject )
794 {
795 domdoc *This = impl_from_IXMLDOMDocument3( iface );
796
797 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppvObject );
798
799 *ppvObject = NULL;
800
801 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
802 IsEqualGUID( riid, &IID_IDispatch ) ||
803 IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
804 IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
805 IsEqualGUID( riid, &IID_IXMLDOMDocument2 )||
806 IsEqualGUID( riid, &IID_IXMLDOMDocument3 ))
807 {
808 *ppvObject = iface;
809 }
810 else if (IsEqualGUID(&IID_IPersistStream, riid) ||
811 IsEqualGUID(&IID_IPersistStreamInit, riid))
812 {
813 *ppvObject = &(This->lpvtblIPersistStreamInit);
814 }
815 else if (IsEqualGUID(&IID_IObjectWithSite, riid))
816 {
817 *ppvObject = &(This->lpvtblIObjectWithSite);
818 }
819 else if (IsEqualGUID(&IID_IObjectSafety, riid))
820 {
821 *ppvObject = &(This->lpvtblIObjectSafety);
822 }
823 else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
824 {
825 *ppvObject = &This->lpvtblISupportErrorInfo;
826 }
827 else if(node_query_interface(&This->node, riid, ppvObject))
828 {
829 return *ppvObject ? S_OK : E_NOINTERFACE;
830 }
831 else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
832 {
833 *ppvObject = &This->lpVtblConnectionPointContainer;
834 }
835 else if(IsEqualGUID(&IID_IRunnableObject, riid))
836 {
837 TRACE("IID_IRunnableObject not supported returning NULL\n");
838 return E_NOINTERFACE;
839 }
840 else
841 {
842 FIXME("interface %s not implemented\n", debugstr_guid(riid));
843 return E_NOINTERFACE;
844 }
845
846 IUnknown_AddRef((IUnknown*)*ppvObject);
847
848 return S_OK;
849 }
850
851
852 static ULONG WINAPI domdoc_AddRef(
853 IXMLDOMDocument3 *iface )
854 {
855 domdoc *This = impl_from_IXMLDOMDocument3( iface );
856 TRACE("%p\n", This );
857 return InterlockedIncrement( &This->ref );
858 }
859
860
861 static ULONG WINAPI domdoc_Release(
862 IXMLDOMDocument3 *iface )
863 {
864 domdoc *This = impl_from_IXMLDOMDocument3( iface );
865 LONG ref;
866
867 TRACE("%p\n", This );
868
869 ref = InterlockedDecrement( &This->ref );
870 if ( ref == 0 )
871 {
872 if(This->bsc)
873 detach_bsc(This->bsc);
874
875 if (This->site)
876 IUnknown_Release( This->site );
877 destroy_xmlnode(&This->node);
878 if(This->schema) IXMLDOMSchemaCollection_Release( This->schema );
879 if (This->stream) IStream_Release(This->stream);
880 HeapFree( GetProcessHeap(), 0, This );
881 }
882
883 return ref;
884 }
885
886 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument3 *iface, UINT* pctinfo )
887 {
888 domdoc *This = impl_from_IXMLDOMDocument3( iface );
889
890 TRACE("(%p)->(%p)\n", This, pctinfo);
891
892 *pctinfo = 1;
893
894 return S_OK;
895 }
896
897 static HRESULT WINAPI domdoc_GetTypeInfo(
898 IXMLDOMDocument3 *iface,
899 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
900 {
901 domdoc *This = impl_from_IXMLDOMDocument3( iface );
902 HRESULT hr;
903
904 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
905
906 hr = get_typeinfo(IXMLDOMDocument2_tid, ppTInfo);
907
908 return hr;
909 }
910
911 static HRESULT WINAPI domdoc_GetIDsOfNames(
912 IXMLDOMDocument3 *iface,
913 REFIID riid,
914 LPOLESTR* rgszNames,
915 UINT cNames,
916 LCID lcid,
917 DISPID* rgDispId)
918 {
919 domdoc *This = impl_from_IXMLDOMDocument3( iface );
920 ITypeInfo *typeinfo;
921 HRESULT hr;
922
923 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
924 lcid, rgDispId);
925
926 if(!rgszNames || cNames == 0 || !rgDispId)
927 return E_INVALIDARG;
928
929 hr = get_typeinfo(IXMLDOMDocument2_tid, &typeinfo);
930 if(SUCCEEDED(hr))
931 {
932 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
933 ITypeInfo_Release(typeinfo);
934 }
935
936 return hr;
937 }
938
939
940 static HRESULT WINAPI domdoc_Invoke(
941 IXMLDOMDocument3 *iface,
942 DISPID dispIdMember,
943 REFIID riid,
944 LCID lcid,
945 WORD wFlags,
946 DISPPARAMS* pDispParams,
947 VARIANT* pVarResult,
948 EXCEPINFO* pExcepInfo,
949 UINT* puArgErr)
950 {
951 domdoc *This = impl_from_IXMLDOMDocument3( iface );
952 ITypeInfo *typeinfo;
953 HRESULT hr;
954
955 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
956 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
957
958 hr = get_typeinfo(IXMLDOMDocument2_tid, &typeinfo);
959 if(SUCCEEDED(hr))
960 {
961 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
962 pVarResult, pExcepInfo, puArgErr);
963 ITypeInfo_Release(typeinfo);
964 }
965
966 return hr;
967 }
968
969
970 static HRESULT WINAPI domdoc_get_nodeName(
971 IXMLDOMDocument3 *iface,
972 BSTR* name )
973 {
974 domdoc *This = impl_from_IXMLDOMDocument3( iface );
975
976 static const WCHAR documentW[] = {'#','d','o','c','u','m','e','n','t',0};
977
978 TRACE("(%p)->(%p)\n", This, name);
979
980 return return_bstr(documentW, name);
981 }
982
983
984 static HRESULT WINAPI domdoc_get_nodeValue(
985 IXMLDOMDocument3 *iface,
986 VARIANT* value )
987 {
988 domdoc *This = impl_from_IXMLDOMDocument3( iface );
989
990 TRACE("(%p)->(%p)\n", This, value);
991
992 if(!value)
993 return E_INVALIDARG;
994
995 V_VT(value) = VT_NULL;
996 V_BSTR(value) = NULL; /* tests show that we should do this */
997 return S_FALSE;
998 }
999
1000
1001 static HRESULT WINAPI domdoc_put_nodeValue(
1002 IXMLDOMDocument3 *iface,
1003 VARIANT value)
1004 {
1005 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1006 FIXME("(%p)->(v%d)\n", This, V_VT(&value));
1007 return E_FAIL;
1008 }
1009
1010
1011 static HRESULT WINAPI domdoc_get_nodeType(
1012 IXMLDOMDocument3 *iface,
1013 DOMNodeType* type )
1014 {
1015 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1016
1017 TRACE("(%p)->(%p)\n", This, type);
1018
1019 *type = NODE_DOCUMENT;
1020 return S_OK;
1021 }
1022
1023
1024 static HRESULT WINAPI domdoc_get_parentNode(
1025 IXMLDOMDocument3 *iface,
1026 IXMLDOMNode** parent )
1027 {
1028 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1029
1030 TRACE("(%p)->(%p)\n", This, parent);
1031
1032 return node_get_parent(&This->node, parent);
1033 }
1034
1035
1036 static HRESULT WINAPI domdoc_get_childNodes(
1037 IXMLDOMDocument3 *iface,
1038 IXMLDOMNodeList** childList )
1039 {
1040 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1041
1042 TRACE("(%p)->(%p)\n", This, childList);
1043
1044 return node_get_child_nodes(&This->node, childList);
1045 }
1046
1047
1048 static HRESULT WINAPI domdoc_get_firstChild(
1049 IXMLDOMDocument3 *iface,
1050 IXMLDOMNode** firstChild )
1051 {
1052 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1053
1054 TRACE("(%p)->(%p)\n", This, firstChild);
1055
1056 return node_get_first_child(&This->node, firstChild);
1057 }
1058
1059
1060 static HRESULT WINAPI domdoc_get_lastChild(
1061 IXMLDOMDocument3 *iface,
1062 IXMLDOMNode** lastChild )
1063 {
1064 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1065
1066 TRACE("(%p)->(%p)\n", This, lastChild);
1067
1068 return node_get_last_child(&This->node, lastChild);
1069 }
1070
1071
1072 static HRESULT WINAPI domdoc_get_previousSibling(
1073 IXMLDOMDocument3 *iface,
1074 IXMLDOMNode** previousSibling )
1075 {
1076 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1077
1078 TRACE("(%p)->(%p)\n", This, previousSibling);
1079
1080 return return_null_node(previousSibling);
1081 }
1082
1083
1084 static HRESULT WINAPI domdoc_get_nextSibling(
1085 IXMLDOMDocument3 *iface,
1086 IXMLDOMNode** nextSibling )
1087 {
1088 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1089
1090 TRACE("(%p)->(%p)\n", This, nextSibling);
1091
1092 return return_null_node(nextSibling);
1093 }
1094
1095
1096 static HRESULT WINAPI domdoc_get_attributes(
1097 IXMLDOMDocument3 *iface,
1098 IXMLDOMNamedNodeMap** attributeMap )
1099 {
1100 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1101
1102 TRACE("(%p)->(%p)\n", This, attributeMap);
1103
1104 return return_null_ptr((void**)attributeMap);
1105 }
1106
1107
1108 static HRESULT WINAPI domdoc_insertBefore(
1109 IXMLDOMDocument3 *iface,
1110 IXMLDOMNode* newChild,
1111 VARIANT refChild,
1112 IXMLDOMNode** outNewChild )
1113 {
1114 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1115
1116 TRACE("(%p)->(%p x%d %p)\n", This, newChild, V_VT(&refChild), outNewChild);
1117
1118 return node_insert_before(&This->node, newChild, &refChild, outNewChild);
1119 }
1120
1121
1122 static HRESULT WINAPI domdoc_replaceChild(
1123 IXMLDOMDocument3 *iface,
1124 IXMLDOMNode* newChild,
1125 IXMLDOMNode* oldChild,
1126 IXMLDOMNode** outOldChild)
1127 {
1128 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1129
1130 TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, outOldChild);
1131
1132 return node_replace_child(&This->node, newChild, oldChild, outOldChild);
1133 }
1134
1135
1136 static HRESULT WINAPI domdoc_removeChild(
1137 IXMLDOMDocument3 *iface,
1138 IXMLDOMNode* childNode,
1139 IXMLDOMNode** oldChild)
1140 {
1141 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1142 return IXMLDOMNode_removeChild( IXMLDOMNode_from_impl(&This->node), childNode, oldChild );
1143 }
1144
1145
1146 static HRESULT WINAPI domdoc_appendChild(
1147 IXMLDOMDocument3 *iface,
1148 IXMLDOMNode* newChild,
1149 IXMLDOMNode** outNewChild)
1150 {
1151 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1152 return IXMLDOMNode_appendChild( IXMLDOMNode_from_impl(&This->node), newChild, outNewChild );
1153 }
1154
1155
1156 static HRESULT WINAPI domdoc_hasChildNodes(
1157 IXMLDOMDocument3 *iface,
1158 VARIANT_BOOL* hasChild)
1159 {
1160 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1161 return IXMLDOMNode_hasChildNodes( IXMLDOMNode_from_impl(&This->node), hasChild );
1162 }
1163
1164
1165 static HRESULT WINAPI domdoc_get_ownerDocument(
1166 IXMLDOMDocument3 *iface,
1167 IXMLDOMDocument** DOMDocument)
1168 {
1169 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1170 return IXMLDOMNode_get_ownerDocument( IXMLDOMNode_from_impl(&This->node), DOMDocument );
1171 }
1172
1173
1174 static HRESULT WINAPI domdoc_cloneNode(
1175 IXMLDOMDocument3 *iface,
1176 VARIANT_BOOL deep,
1177 IXMLDOMNode** cloneRoot)
1178 {
1179 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1180 return IXMLDOMNode_cloneNode( IXMLDOMNode_from_impl(&This->node), deep, cloneRoot );
1181 }
1182
1183
1184 static HRESULT WINAPI domdoc_get_nodeTypeString(
1185 IXMLDOMDocument3 *iface,
1186 BSTR* nodeType )
1187 {
1188 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1189 return IXMLDOMNode_get_nodeTypeString( IXMLDOMNode_from_impl(&This->node), nodeType );
1190 }
1191
1192
1193 static HRESULT WINAPI domdoc_get_text(
1194 IXMLDOMDocument3 *iface,
1195 BSTR* text )
1196 {
1197 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1198 return IXMLDOMNode_get_text( IXMLDOMNode_from_impl(&This->node), text );
1199 }
1200
1201
1202 static HRESULT WINAPI domdoc_put_text(
1203 IXMLDOMDocument3 *iface,
1204 BSTR text )
1205 {
1206 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1207 TRACE("(%p)->(%s)\n", This, debugstr_w(text));
1208 return E_FAIL;
1209 }
1210
1211
1212 static HRESULT WINAPI domdoc_get_specified(
1213 IXMLDOMDocument3 *iface,
1214 VARIANT_BOOL* isSpecified )
1215 {
1216 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1217 FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1218 *isSpecified = VARIANT_TRUE;
1219 return S_OK;
1220 }
1221
1222
1223 static HRESULT WINAPI domdoc_get_definition(
1224 IXMLDOMDocument3 *iface,
1225 IXMLDOMNode** definitionNode )
1226 {
1227 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1228 FIXME("(%p)->(%p)\n", This, definitionNode);
1229 return E_NOTIMPL;
1230 }
1231
1232
1233 static HRESULT WINAPI domdoc_get_nodeTypedValue(
1234 IXMLDOMDocument3 *iface,
1235 VARIANT* typedValue )
1236 {
1237 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1238 return IXMLDOMNode_get_nodeTypedValue( IXMLDOMNode_from_impl(&This->node), typedValue );
1239 }
1240
1241 static HRESULT WINAPI domdoc_put_nodeTypedValue(
1242 IXMLDOMDocument3 *iface,
1243 VARIANT typedValue )
1244 {
1245 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1246 return IXMLDOMNode_put_nodeTypedValue( IXMLDOMNode_from_impl(&This->node), typedValue );
1247 }
1248
1249
1250 static HRESULT WINAPI domdoc_get_dataType(
1251 IXMLDOMDocument3 *iface,
1252 VARIANT* typename )
1253 {
1254 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1255 TRACE("(%p)->(%p)\n", This, typename);
1256 return return_null_var( typename );
1257 }
1258
1259
1260 static HRESULT WINAPI domdoc_put_dataType(
1261 IXMLDOMDocument3 *iface,
1262 BSTR dataTypeName )
1263 {
1264 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1265 return IXMLDOMNode_put_dataType( IXMLDOMNode_from_impl(&This->node), dataTypeName );
1266 }
1267
1268
1269 static HRESULT WINAPI domdoc_get_xml(
1270 IXMLDOMDocument3 *iface,
1271 BSTR* xmlString )
1272 {
1273 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1274 return IXMLDOMNode_get_xml( IXMLDOMNode_from_impl(&This->node), xmlString );
1275 }
1276
1277
1278 static HRESULT WINAPI domdoc_transformNode(
1279 IXMLDOMDocument3 *iface,
1280 IXMLDOMNode* styleSheet,
1281 BSTR* xmlString )
1282 {
1283 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1284 return IXMLDOMNode_transformNode( IXMLDOMNode_from_impl(&This->node), styleSheet, xmlString );
1285 }
1286
1287
1288 static HRESULT WINAPI domdoc_selectNodes(
1289 IXMLDOMDocument3 *iface,
1290 BSTR queryString,
1291 IXMLDOMNodeList** resultList )
1292 {
1293 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1294 return IXMLDOMNode_selectNodes( IXMLDOMNode_from_impl(&This->node), queryString, resultList );
1295 }
1296
1297
1298 static HRESULT WINAPI domdoc_selectSingleNode(
1299 IXMLDOMDocument3 *iface,
1300 BSTR queryString,
1301 IXMLDOMNode** resultNode )
1302 {
1303 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1304 return IXMLDOMNode_selectSingleNode( IXMLDOMNode_from_impl(&This->node), queryString, resultNode );
1305 }
1306
1307
1308 static HRESULT WINAPI domdoc_get_parsed(
1309 IXMLDOMDocument3 *iface,
1310 VARIANT_BOOL* isParsed )
1311 {
1312 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1313 FIXME("(%p)->(%p) stub!\n", This, isParsed);
1314 *isParsed = VARIANT_TRUE;
1315 return S_OK;
1316 }
1317
1318
1319 static HRESULT WINAPI domdoc_get_namespaceURI(
1320 IXMLDOMDocument3 *iface,
1321 BSTR* namespaceURI )
1322 {
1323 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1324 return IXMLDOMNode_get_namespaceURI( IXMLDOMNode_from_impl(&This->node), namespaceURI );
1325 }
1326
1327
1328 static HRESULT WINAPI domdoc_get_prefix(
1329 IXMLDOMDocument3 *iface,
1330 BSTR* prefixString )
1331 {
1332 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1333 return IXMLDOMNode_get_prefix( IXMLDOMNode_from_impl(&This->node), prefixString );
1334 }
1335
1336
1337 static HRESULT WINAPI domdoc_get_baseName(
1338 IXMLDOMDocument3 *iface,
1339 BSTR* nameString )
1340 {
1341 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1342 return IXMLDOMNode_get_baseName( IXMLDOMNode_from_impl(&This->node), nameString );
1343 }
1344
1345
1346 static HRESULT WINAPI domdoc_transformNodeToObject(
1347 IXMLDOMDocument3 *iface,
1348 IXMLDOMNode* stylesheet,
1349 VARIANT outputObject)
1350 {
1351 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1352 return IXMLDOMNode_transformNodeToObject( IXMLDOMNode_from_impl(&This->node), stylesheet, outputObject );
1353 }
1354
1355
1356 static HRESULT WINAPI domdoc_get_doctype(
1357 IXMLDOMDocument3 *iface,
1358 IXMLDOMDocumentType** documentType )
1359 {
1360 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1361 FIXME("(%p)\n", This);
1362 return E_NOTIMPL;
1363 }
1364
1365
1366 static HRESULT WINAPI domdoc_get_implementation(
1367 IXMLDOMDocument3 *iface,
1368 IXMLDOMImplementation** impl )
1369 {
1370 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1371
1372 TRACE("(%p)->(%p)\n", This, impl);
1373
1374 if(!impl)
1375 return E_INVALIDARG;
1376
1377 *impl = (IXMLDOMImplementation*)create_doc_Implementation();
1378
1379 return S_OK;
1380 }
1381
1382 static HRESULT WINAPI domdoc_get_documentElement(
1383 IXMLDOMDocument3 *iface,
1384 IXMLDOMElement** DOMElement )
1385 {
1386 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1387 IXMLDOMNode *element_node;
1388 xmlNodePtr root;
1389 HRESULT hr;
1390
1391 TRACE("(%p)->(%p)\n", This, DOMElement);
1392
1393 if(!DOMElement)
1394 return E_INVALIDARG;
1395
1396 *DOMElement = NULL;
1397
1398 root = xmlDocGetRootElement( get_doc(This) );
1399 if ( !root )
1400 return S_FALSE;
1401
1402 element_node = create_node( root );
1403 if(!element_node) return S_FALSE;
1404
1405 hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (void**)DOMElement);
1406 IXMLDOMNode_Release(element_node);
1407
1408 return hr;
1409 }
1410
1411
1412 static HRESULT WINAPI domdoc_put_documentElement(
1413 IXMLDOMDocument3 *iface,
1414 IXMLDOMElement* DOMElement )
1415 {
1416 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1417 IXMLDOMNode *elementNode;
1418 xmlNodePtr oldRoot;
1419 xmlnode *xmlNode;
1420 HRESULT hr;
1421
1422 TRACE("(%p)->(%p)\n", This, DOMElement);
1423
1424 hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode );
1425 if(FAILED(hr))
1426 return hr;
1427
1428 xmlNode = get_node_obj( elementNode );
1429 if(!xmlNode) {
1430 FIXME("elementNode is not our object\n");
1431 return E_FAIL;
1432 }
1433
1434 if(!xmlNode->node->parent)
1435 if(xmldoc_remove_orphan(xmlNode->node->doc, xmlNode->node) != S_OK)
1436 WARN("%p is not an orphan of %p\n", xmlNode->node->doc, xmlNode->node);
1437
1438 oldRoot = xmlDocSetRootElement( get_doc(This), xmlNode->node);
1439 IXMLDOMNode_Release( elementNode );
1440
1441 if(oldRoot)
1442 xmldoc_add_orphan(oldRoot->doc, oldRoot);
1443
1444 return S_OK;
1445 }
1446
1447
1448 static HRESULT WINAPI domdoc_createElement(
1449 IXMLDOMDocument3 *iface,
1450 BSTR tagname,
1451 IXMLDOMElement** element )
1452 {
1453 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1454 IXMLDOMNode *node;
1455 VARIANT type;
1456 HRESULT hr;
1457
1458 TRACE("(%p)->(%s %p)\n", This, debugstr_w(tagname), element);
1459
1460 if (!element || !tagname) return E_INVALIDARG;
1461
1462 V_VT(&type) = VT_I1;
1463 V_I1(&type) = NODE_ELEMENT;
1464
1465 hr = IXMLDOMDocument3_createNode(iface, type, tagname, NULL, &node);
1466 if (hr == S_OK)
1467 {
1468 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)element);
1469 IXMLDOMNode_Release(node);
1470 }
1471
1472 return hr;
1473 }
1474
1475
1476 static HRESULT WINAPI domdoc_createDocumentFragment(
1477 IXMLDOMDocument3 *iface,
1478 IXMLDOMDocumentFragment** frag )
1479 {
1480 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1481 IXMLDOMNode *node;
1482 VARIANT type;
1483 HRESULT hr;
1484
1485 TRACE("(%p)->(%p)\n", This, frag);
1486
1487 if (!frag) return E_INVALIDARG;
1488
1489 *frag = NULL;
1490
1491 V_VT(&type) = VT_I1;
1492 V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
1493
1494 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1495 if (hr == S_OK)
1496 {
1497 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentFragment, (void**)frag);
1498 IXMLDOMNode_Release(node);
1499 }
1500
1501 return hr;
1502 }
1503
1504
1505 static HRESULT WINAPI domdoc_createTextNode(
1506 IXMLDOMDocument3 *iface,
1507 BSTR data,
1508 IXMLDOMText** text )
1509 {
1510 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1511 IXMLDOMNode *node;
1512 VARIANT type;
1513 HRESULT hr;
1514
1515 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), text);
1516
1517 if (!text) return E_INVALIDARG;
1518
1519 *text = NULL;
1520
1521 V_VT(&type) = VT_I1;
1522 V_I1(&type) = NODE_TEXT;
1523
1524 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1525 if (hr == S_OK)
1526 {
1527 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)text);
1528 IXMLDOMNode_Release(node);
1529 hr = IXMLDOMText_put_data(*text, data);
1530 }
1531
1532 return hr;
1533 }
1534
1535
1536 static HRESULT WINAPI domdoc_createComment(
1537 IXMLDOMDocument3 *iface,
1538 BSTR data,
1539 IXMLDOMComment** comment )
1540 {
1541 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1542 VARIANT type;
1543 HRESULT hr;
1544 IXMLDOMNode *node;
1545
1546 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), comment);
1547
1548 if (!comment) return E_INVALIDARG;
1549
1550 *comment = NULL;
1551
1552 V_VT(&type) = VT_I1;
1553 V_I1(&type) = NODE_COMMENT;
1554
1555 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1556 if (hr == S_OK)
1557 {
1558 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)comment);
1559 IXMLDOMNode_Release(node);
1560 hr = IXMLDOMComment_put_data(*comment, data);
1561 }
1562
1563 return hr;
1564 }
1565
1566
1567 static HRESULT WINAPI domdoc_createCDATASection(
1568 IXMLDOMDocument3 *iface,
1569 BSTR data,
1570 IXMLDOMCDATASection** cdata )
1571 {
1572 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1573 IXMLDOMNode *node;
1574 VARIANT type;
1575 HRESULT hr;
1576
1577 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), cdata);
1578
1579 if (!cdata) return E_INVALIDARG;
1580
1581 *cdata = NULL;
1582
1583 V_VT(&type) = VT_I1;
1584 V_I1(&type) = NODE_CDATA_SECTION;
1585
1586 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1587 if (hr == S_OK)
1588 {
1589 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)cdata);
1590 IXMLDOMNode_Release(node);
1591 hr = IXMLDOMCDATASection_put_data(*cdata, data);
1592 }
1593
1594 return hr;
1595 }
1596
1597
1598 static HRESULT WINAPI domdoc_createProcessingInstruction(
1599 IXMLDOMDocument3 *iface,
1600 BSTR target,
1601 BSTR data,
1602 IXMLDOMProcessingInstruction** pi )
1603 {
1604 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1605 IXMLDOMNode *node;
1606 VARIANT type;
1607 HRESULT hr;
1608
1609 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), pi);
1610
1611 if (!pi) return E_INVALIDARG;
1612
1613 *pi = NULL;
1614
1615 V_VT(&type) = VT_I1;
1616 V_I1(&type) = NODE_PROCESSING_INSTRUCTION;
1617
1618 hr = IXMLDOMDocument3_createNode(iface, type, target, NULL, &node);
1619 if (hr == S_OK)
1620 {
1621 xmlnode *node_obj;
1622
1623 /* this is to bypass check in ::put_data() that blocks "<?xml" PIs */
1624 node_obj = get_node_obj(node);
1625 hr = node_set_content(node_obj, data);
1626
1627 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)pi);
1628 IXMLDOMNode_Release(node);
1629 }
1630
1631 return hr;
1632 }
1633
1634
1635 static HRESULT WINAPI domdoc_createAttribute(
1636 IXMLDOMDocument3 *iface,
1637 BSTR name,
1638 IXMLDOMAttribute** attribute )
1639 {
1640 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1641 IXMLDOMNode *node;
1642 VARIANT type;
1643 HRESULT hr;
1644
1645 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), attribute);
1646
1647 if (!attribute || !name) return E_INVALIDARG;
1648
1649 V_VT(&type) = VT_I1;
1650 V_I1(&type) = NODE_ATTRIBUTE;
1651
1652 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1653 if (hr == S_OK)
1654 {
1655 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMAttribute, (void**)attribute);
1656 IXMLDOMNode_Release(node);
1657 }
1658
1659 return hr;
1660 }
1661
1662
1663 static HRESULT WINAPI domdoc_createEntityReference(
1664 IXMLDOMDocument3 *iface,
1665 BSTR name,
1666 IXMLDOMEntityReference** entityref )
1667 {
1668 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1669 IXMLDOMNode *node;
1670 VARIANT type;
1671 HRESULT hr;
1672
1673 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), entityref);
1674
1675 if (!entityref) return E_INVALIDARG;
1676
1677 *entityref = NULL;
1678
1679 V_VT(&type) = VT_I1;
1680 V_I1(&type) = NODE_ENTITY_REFERENCE;
1681
1682 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1683 if (hr == S_OK)
1684 {
1685 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMEntityReference, (void**)entityref);
1686 IXMLDOMNode_Release(node);
1687 }
1688
1689 return hr;
1690 }
1691
1692
1693 static HRESULT WINAPI domdoc_getElementsByTagName(
1694 IXMLDOMDocument3 *iface,
1695 BSTR tagName,
1696 IXMLDOMNodeList** resultList )
1697 {
1698 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1699 HRESULT hr;
1700
1701 TRACE("(%p)->(%s %p)\n", This, debugstr_w(tagName), resultList);
1702
1703 if (!tagName || !resultList) return E_INVALIDARG;
1704
1705 if (tagName[0] == '*' && tagName[1] == 0)
1706 {
1707 static const WCHAR formatallW[] = {'/','/','*',0};
1708 hr = queryresult_create((xmlNodePtr)get_doc(This), formatallW, resultList);
1709 }
1710 else
1711 {
1712 static const WCHAR xpathformat[] =
1713 { '/','/','*','[','l','o','c','a','l','-','n','a','m','e','(',')','=','\'' };
1714 static const WCHAR closeW[] = { '\'',']',0 };
1715
1716 LPWSTR pattern;
1717 WCHAR *ptr;
1718 INT length;
1719
1720 length = lstrlenW(tagName);
1721
1722 /* without two WCHARs from format specifier */
1723 ptr = pattern = heap_alloc(sizeof(xpathformat) + length*sizeof(WCHAR) + sizeof(closeW));
1724
1725 memcpy(ptr, xpathformat, sizeof(xpathformat));
1726 ptr += sizeof(xpathformat)/sizeof(WCHAR);
1727 memcpy(ptr, tagName, length*sizeof(WCHAR));
1728 ptr += length;
1729 memcpy(ptr, closeW, sizeof(closeW));
1730
1731 hr = queryresult_create((xmlNodePtr)get_doc(This), pattern, resultList);
1732 heap_free(pattern);
1733 }
1734
1735 return hr;
1736 }
1737
1738 static HRESULT get_node_type(VARIANT Type, DOMNodeType * type)
1739 {
1740 VARIANT tmp;
1741 HRESULT hr;
1742
1743 VariantInit(&tmp);
1744 hr = VariantChangeType(&tmp, &Type, 0, VT_I4);
1745 if(FAILED(hr))
1746 return E_INVALIDARG;
1747
1748 *type = V_I4(&tmp);
1749
1750 return S_OK;
1751 }
1752
1753 static HRESULT WINAPI domdoc_createNode(
1754 IXMLDOMDocument3 *iface,
1755 VARIANT Type,
1756 BSTR name,
1757 BSTR namespaceURI,
1758 IXMLDOMNode** node )
1759 {
1760 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1761 DOMNodeType node_type;
1762 xmlNodePtr xmlnode;
1763 xmlChar *xml_name, *href;
1764 HRESULT hr;
1765
1766 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(name), debugstr_w(namespaceURI), node);
1767
1768 if(!node) return E_INVALIDARG;
1769
1770 hr = get_node_type(Type, &node_type);
1771 if(FAILED(hr)) return hr;
1772
1773 if(namespaceURI && namespaceURI[0] && node_type != NODE_ELEMENT)
1774 FIXME("nodes with namespaces currently not supported.\n");
1775
1776 TRACE("node_type %d\n", node_type);
1777
1778 /* exit earlier for types that need name */
1779 switch(node_type)
1780 {
1781 case NODE_ELEMENT:
1782 case NODE_ATTRIBUTE:
1783 case NODE_ENTITY_REFERENCE:
1784 case NODE_PROCESSING_INSTRUCTION:
1785 if (!name || *name == 0) return E_FAIL;
1786 default:
1787 break;
1788 }
1789
1790 xml_name = xmlChar_from_wchar(name);
1791 /* prevent empty href to be allocated */
1792 href = namespaceURI ? xmlChar_from_wchar(namespaceURI) : NULL;
1793
1794 switch(node_type)
1795 {
1796 case NODE_ELEMENT:
1797 {
1798 xmlChar *local, *prefix;
1799
1800 local = xmlSplitQName2(xml_name, &prefix);
1801
1802 xmlnode = xmlNewDocNode(get_doc(This), NULL, local ? local : xml_name, NULL);
1803
1804 /* allow to create default namespace xmlns= */
1805 if (local || (href && *href))
1806 {
1807 xmlNsPtr ns = xmlNewNs(xmlnode, href, prefix);
1808 xmlSetNs(xmlnode, ns);
1809 }
1810
1811 xmlFree(local);
1812 xmlFree(prefix);
1813
1814 break;
1815 }
1816 case NODE_ATTRIBUTE:
1817 xmlnode = (xmlNodePtr)xmlNewDocProp(get_doc(This), xml_name, NULL);
1818 break;
1819 case NODE_TEXT:
1820 xmlnode = (xmlNodePtr)xmlNewDocText(get_doc(This), NULL);
1821 break;
1822 case NODE_CDATA_SECTION:
1823 xmlnode = xmlNewCDataBlock(get_doc(This), NULL, 0);
1824 break;
1825 case NODE_ENTITY_REFERENCE:
1826 xmlnode = xmlNewReference(get_doc(This), xml_name);
1827 break;
1828 case NODE_PROCESSING_INSTRUCTION:
1829 #ifdef HAVE_XMLNEWDOCPI
1830 xmlnode = xmlNewDocPI(get_doc(This), xml_name, NULL);
1831 #else
1832 FIXME("xmlNewDocPI() not supported, use libxml2 2.6.15 or greater\n");
1833 xmlnode = NULL;
1834 #endif
1835 break;
1836 case NODE_COMMENT:
1837 xmlnode = xmlNewDocComment(get_doc(This), NULL);
1838 break;
1839 case NODE_DOCUMENT_FRAGMENT:
1840 xmlnode = xmlNewDocFragment(get_doc(This));
1841 break;
1842 /* unsupported types */
1843 case NODE_DOCUMENT:
1844 case NODE_DOCUMENT_TYPE:
1845 case NODE_ENTITY:
1846 case NODE_NOTATION:
1847 heap_free(xml_name);
1848 return E_INVALIDARG;
1849 default:
1850 FIXME("unhandled node type %d\n", node_type);
1851 xmlnode = NULL;
1852 break;
1853 }
1854
1855 *node = create_node(xmlnode);
1856 heap_free(xml_name);
1857 heap_free(href);
1858
1859 if(*node)
1860 {
1861 TRACE("created node (%d, %p, %p)\n", node_type, *node, xmlnode);
1862 xmldoc_add_orphan(xmlnode->doc, xmlnode);
1863 return S_OK;
1864 }
1865
1866 return E_FAIL;
1867 }
1868
1869 static HRESULT WINAPI domdoc_nodeFromID(
1870 IXMLDOMDocument3 *iface,
1871 BSTR idString,
1872 IXMLDOMNode** node )
1873 {
1874 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1875 FIXME("(%p)->(%s %p)\n", This, debugstr_w(idString), node);
1876 return E_NOTIMPL;
1877 }
1878
1879 static HRESULT domdoc_onDataAvailable(void *obj, char *ptr, DWORD len)
1880 {
1881 domdoc *This = obj;
1882 xmlDocPtr xmldoc;
1883
1884 xmldoc = doparse(This, ptr, len, NULL);
1885 if(xmldoc) {
1886 xmldoc->_private = create_priv();
1887 return attach_xmldoc(This, xmldoc);
1888 }
1889
1890 return S_OK;
1891 }
1892
1893 static HRESULT doread( domdoc *This, LPWSTR filename )
1894 {
1895 bsc_t *bsc;
1896 HRESULT hr;
1897
1898 hr = bind_url(filename, domdoc_onDataAvailable, This, &bsc);
1899 if(FAILED(hr))
1900 return hr;
1901
1902 if(This->bsc)
1903 detach_bsc(This->bsc);
1904
1905 This->bsc = bsc;
1906 return S_OK;
1907 }
1908
1909 static HRESULT WINAPI domdoc_load(
1910 IXMLDOMDocument3 *iface,
1911 VARIANT xmlSource,
1912 VARIANT_BOOL* isSuccessful )
1913 {
1914 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1915 LPWSTR filename = NULL;
1916 HRESULT hr = S_FALSE;
1917 IXMLDOMDocument3 *pNewDoc = NULL;
1918 IStream *pStream = NULL;
1919 xmlDocPtr xmldoc;
1920
1921 TRACE("(%p)->type %d\n", This, V_VT(&xmlSource) );
1922
1923 *isSuccessful = VARIANT_FALSE;
1924
1925 assert( &This->node );
1926
1927 switch( V_VT(&xmlSource) )
1928 {
1929 case VT_BSTR:
1930 filename = V_BSTR(&xmlSource);
1931 break;
1932 case VT_UNKNOWN:
1933 hr = IUnknown_QueryInterface(V_UNKNOWN(&xmlSource), &IID_IXMLDOMDocument3, (void**)&pNewDoc);
1934 if(hr == S_OK)
1935 {
1936 if(pNewDoc)
1937 {
1938 domdoc *newDoc = impl_from_IXMLDOMDocument3( pNewDoc );
1939 xmldoc = xmlCopyDoc(get_doc(newDoc), 1);
1940 hr = attach_xmldoc(This, xmldoc);
1941
1942 if(SUCCEEDED(hr))
1943 *isSuccessful = VARIANT_TRUE;
1944
1945 return hr;
1946 }
1947 }
1948 hr = IUnknown_QueryInterface(V_UNKNOWN(&xmlSource), &IID_IStream, (void**)&pStream);
1949 if(hr == S_OK)
1950 {
1951 IPersistStream *pDocStream;
1952 hr = IUnknown_QueryInterface(iface, &IID_IPersistStream, (void**)&pDocStream);
1953 if(hr == S_OK)
1954 {
1955 hr = IPersistStream_Load(pDocStream, pStream);
1956 IStream_Release(pStream);
1957 if(hr == S_OK)
1958 {
1959 *isSuccessful = VARIANT_TRUE;
1960
1961 TRACE("Using IStream to load Document\n");
1962 return S_OK;
1963 }
1964 else
1965 {
1966 ERR("xmldoc_IPersistStream_Load failed (%d)\n", hr);
1967 }
1968 }
1969 else
1970 {
1971 ERR("QueryInterface IID_IPersistStream failed (%d)\n", hr);
1972 }
1973 }
1974 else
1975 {
1976 /* ISequentialStream */
1977 FIXME("Unknown type not supported (%d) (%p)(%p)\n", hr, pNewDoc, V_UNKNOWN(&xmlSource)->lpVtbl);
1978 }
1979 break;
1980 default:
1981 FIXME("VT type not supported (%d)\n", V_VT(&xmlSource));
1982 }
1983
1984 TRACE("filename (%s)\n", debugstr_w(filename));
1985
1986 if ( filename )
1987 {
1988 hr = doread( This, filename );
1989
1990 if ( FAILED(hr) )
1991 This->error = E_FAIL;
1992 else
1993 {
1994 hr = This->error = S_OK;
1995 *isSuccessful = VARIANT_TRUE;
1996 }
1997 }
1998
1999 if(!filename || FAILED(hr)) {
2000 xmldoc = xmlNewDoc(NULL);
2001 xmldoc->_private = create_priv();
2002 hr = attach_xmldoc(This, xmldoc);
2003 if(SUCCEEDED(hr))
2004 hr = S_FALSE;
2005 }
2006
2007 TRACE("ret (%d)\n", hr);
2008
2009 return hr;
2010 }
2011
2012
2013 static HRESULT WINAPI domdoc_get_readyState(
2014 IXMLDOMDocument3 *iface,
2015 LONG *value )
2016 {
2017 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2018 FIXME("stub! (%p)->(%p)\n", This, value);
2019
2020 if (!value)
2021 return E_INVALIDARG;
2022
2023 *value = READYSTATE_COMPLETE;
2024 return S_OK;
2025 }
2026
2027
2028 static HRESULT WINAPI domdoc_get_parseError(
2029 IXMLDOMDocument3 *iface,
2030 IXMLDOMParseError** errorObj )
2031 {
2032 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2033 static const WCHAR err[] = {'e','r','r','o','r',0};
2034 BSTR error_string = NULL;
2035
2036 FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
2037
2038 if(This->error)
2039 error_string = SysAllocString(err);
2040
2041 *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
2042 if(!*errorObj) return E_OUTOFMEMORY;
2043 return S_OK;
2044 }
2045
2046
2047 static HRESULT WINAPI domdoc_get_url(
2048 IXMLDOMDocument3 *iface,
2049 BSTR* urlString )
2050 {
2051 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2052 FIXME("(%p)->(%p)\n", This, urlString);
2053 return E_NOTIMPL;
2054 }
2055
2056
2057 static HRESULT WINAPI domdoc_get_async(
2058 IXMLDOMDocument3 *iface,
2059 VARIANT_BOOL* isAsync )
2060 {
2061 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2062
2063 TRACE("(%p)->(%p: %d)\n", This, isAsync, This->async);
2064 *isAsync = This->async;
2065 return S_OK;
2066 }
2067
2068
2069 static HRESULT WINAPI domdoc_put_async(
2070 IXMLDOMDocument3 *iface,
2071 VARIANT_BOOL isAsync )
2072 {
2073 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2074
2075 TRACE("(%p)->(%d)\n", This, isAsync);
2076 This->async = isAsync;
2077 return S_OK;
2078 }
2079
2080
2081 static HRESULT WINAPI domdoc_abort(
2082 IXMLDOMDocument3 *iface )
2083 {
2084 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2085 FIXME("%p\n", This);
2086 return E_NOTIMPL;
2087 }
2088
2089
2090 static BOOL bstr_to_utf8( BSTR bstr, char **pstr, int *plen )
2091 {
2092 UINT len;
2093 LPSTR str;
2094
2095 len = WideCharToMultiByte( CP_UTF8, 0, bstr, -1, NULL, 0, NULL, NULL );
2096 str = heap_alloc( len );
2097 if ( !str )
2098 return FALSE;
2099 WideCharToMultiByte( CP_UTF8, 0, bstr, -1, str, len, NULL, NULL );
2100 *plen = len;
2101 *pstr = str;
2102 return TRUE;
2103 }
2104
2105 /* don't rely on data to be in BSTR format, treat it as WCHAR string */
2106 static HRESULT WINAPI domdoc_loadXML(
2107 IXMLDOMDocument3 *iface,
2108 BSTR bstrXML,
2109 VARIANT_BOOL* isSuccessful )
2110 {
2111 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2112 static const xmlChar encoding[] = "UTF-8";
2113 xmlDocPtr xmldoc = NULL;
2114 HRESULT hr = S_FALSE, hr2;
2115 char *str;
2116 int len;
2117
2118 TRACE("(%p)->(%s %p)\n", This, debugstr_w( bstrXML ), isSuccessful );
2119
2120 assert ( &This->node );
2121
2122 if ( isSuccessful )
2123 {
2124 *isSuccessful = VARIANT_FALSE;
2125
2126 if ( bstrXML && bstr_to_utf8( bstrXML, &str, &len ) )
2127 {
2128 xmldoc = doparse(This, str, len, encoding);
2129 heap_free( str );
2130 if ( !xmldoc )
2131 {
2132 This->error = E_FAIL;
2133 TRACE("failed to parse document\n");
2134 }
2135 else
2136 {
2137 hr = This->error = S_OK;
2138 *isSuccessful = VARIANT_TRUE;
2139 TRACE("parsed document %p\n", xmldoc);
2140 }
2141 }
2142 }
2143 if(!xmldoc)
2144 xmldoc = xmlNewDoc(NULL);
2145
2146 xmldoc->_private = create_priv();
2147
2148 hr2 = attach_xmldoc(This, xmldoc);
2149 if( FAILED(hr2) )
2150 hr = hr2;
2151
2152 return hr;
2153 }
2154
2155 static int XMLCALL domdoc_save_writecallback(void *ctx, const char *buffer, int len)
2156 {
2157 DWORD written = -1;
2158
2159 if(!WriteFile(ctx, buffer, len, &written, NULL))
2160 {
2161 WARN("write error\n");
2162 return -1;
2163 }
2164 else
2165 return written;
2166 }
2167
2168 static int XMLCALL domdoc_save_closecallback(void *ctx)
2169 {
2170 return CloseHandle(ctx) ? 0 : -1;
2171 }
2172
2173 static int XMLCALL domdoc_stream_save_writecallback(void *ctx, const char *buffer, int len)
2174 {
2175 ULONG written = 0;
2176 HRESULT hr;
2177
2178 hr = IStream_Write((IStream*)ctx, buffer, len, &written);
2179 if (hr != S_OK)
2180 {
2181 WARN("stream write error: 0x%08x\n", hr);
2182 return -1;
2183 }
2184 else
2185 return written;
2186 }
2187
2188 static int XMLCALL domdoc_stream_save_closecallback(void *ctx)
2189 {
2190 IStream_Release((IStream*)ctx);
2191 return 0;
2192 }
2193
2194 static HRESULT WINAPI domdoc_save(
2195 IXMLDOMDocument3 *iface,
2196 VARIANT destination )
2197 {
2198 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2199 xmlSaveCtxtPtr ctx = NULL;
2200 xmlNodePtr xmldecl;
2201 HRESULT ret = S_OK;
2202
2203 TRACE("(%p)->(var(vt %d, %s))\n", This, V_VT(&destination),
2204 V_VT(&destination) == VT_BSTR ? debugstr_w(V_BSTR(&destination)) : NULL);
2205
2206 if(V_VT(&destination) != VT_BSTR && V_VT(&destination) != VT_UNKNOWN)
2207 {
2208 FIXME("Unhandled vt %d\n", V_VT(&destination));
2209 return S_FALSE;
2210 }
2211
2212 if(V_VT(&destination) == VT_UNKNOWN)
2213 {
2214 IUnknown *pUnk = V_UNKNOWN(&destination);
2215 IXMLDOMDocument2 *document;
2216 IStream *stream;
2217
2218 ret = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMDocument3, (void**)&document);
2219 if(ret == S_OK)
2220 {
2221 VARIANT_BOOL success;
2222 BSTR xml;
2223
2224 ret = IXMLDOMDocument3_get_xml(iface, &xml);
2225 if(ret == S_OK)
2226 {
2227 ret = IXMLDOMDocument3_loadXML(document, xml, &success);
2228 SysFreeString(xml);
2229 }
2230
2231 IXMLDOMDocument3_Release(document);
2232 return ret;
2233 }
2234
2235 ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream);
2236 if(ret == S_OK)
2237 {
2238 ctx = xmlSaveToIO(domdoc_stream_save_writecallback,
2239 domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL);
2240
2241 if(!ctx)
2242 {
2243 IStream_Release(stream);
2244 return E_FAIL;
2245 }
2246 }
2247 }
2248 else
2249 {
2250 /* save with file path */
2251 HANDLE handle = CreateFileW( V_BSTR(&destination), GENERIC_WRITE, 0,
2252 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2253 if( handle == INVALID_HANDLE_VALUE )
2254 {
2255 WARN("failed to create file\n");
2256 return E_FAIL;
2257 }
2258
2259 /* disable top XML declaration */
2260 ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback,
2261 handle, NULL, XML_SAVE_NO_DECL);
2262 if (!ctx)
2263 {
2264 CloseHandle(handle);
2265 return E_FAIL;
2266 }
2267 }
2268
2269 xmldecl = xmldoc_unlink_xmldecl(get_doc(This));
2270 if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE;
2271 xmldoc_link_xmldecl(get_doc(This), xmldecl);
2272
2273 /* will release resources through close callback */
2274 xmlSaveClose(ctx);
2275
2276 return ret;
2277 }
2278
2279 static HRESULT WINAPI domdoc_get_validateOnParse(
2280 IXMLDOMDocument3 *iface,
2281 VARIANT_BOOL* isValidating )
2282 {
2283 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2284 TRACE("(%p)->(%p: %d)\n", This, isValidating, This->validating);
2285 *isValidating = This->validating;
2286 return S_OK;
2287 }
2288
2289
2290 static HRESULT WINAPI domdoc_put_validateOnParse(
2291 IXMLDOMDocument3 *iface,
2292 VARIANT_BOOL isValidating )
2293 {
2294 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2295 TRACE("(%p)->(%d)\n", This, isValidating);
2296 This->validating = isValidating;
2297 return S_OK;
2298 }
2299
2300
2301 static HRESULT WINAPI domdoc_get_resolveExternals(
2302 IXMLDOMDocument3 *iface,
2303 VARIANT_BOOL* isResolving )
2304 {
2305 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2306 TRACE("(%p)->(%p: %d)\n", This, isResolving, This->resolving);
2307 *isResolving = This->resolving;
2308 return S_OK;
2309 }
2310
2311
2312 static HRESULT WINAPI domdoc_put_resolveExternals(
2313 IXMLDOMDocument3 *iface,
2314 VARIANT_BOOL isResolving )
2315 {
2316 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2317 TRACE("(%p)->(%d)\n", This, isResolving);
2318 This->resolving = isResolving;
2319 return S_OK;
2320 }
2321
2322
2323 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
2324 IXMLDOMDocument3 *iface,
2325 VARIANT_BOOL* isPreserving )
2326 {
2327 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2328 TRACE("(%p)->(%p: %d)\n", This, isPreserving, This->preserving);
2329 *isPreserving = This->preserving;
2330 return S_OK;
2331 }
2332
2333
2334 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
2335 IXMLDOMDocument3 *iface,
2336 VARIANT_BOOL isPreserving )
2337 {
2338 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2339 TRACE("(%p)->(%d)\n", This, isPreserving);
2340 This->preserving = isPreserving;
2341 return S_OK;
2342 }
2343
2344
2345 static HRESULT WINAPI domdoc_put_onReadyStateChange(
2346 IXMLDOMDocument3 *iface,
2347 VARIANT readyStateChangeSink )
2348 {
2349 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2350 FIXME("%p\n", This);
2351 return E_NOTIMPL;
2352 }
2353
2354
2355 static HRESULT WINAPI domdoc_put_onDataAvailable(
2356 IXMLDOMDocument3 *iface,
2357 VARIANT onDataAvailableSink )
2358 {
2359 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2360 FIXME("%p\n", This);
2361 return E_NOTIMPL;
2362 }
2363
2364 static HRESULT WINAPI domdoc_put_onTransformNode(
2365 IXMLDOMDocument3 *iface,
2366 VARIANT onTransformNodeSink )
2367 {
2368 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2369 FIXME("%p\n", This);
2370 return E_NOTIMPL;
2371 }
2372
2373 static HRESULT WINAPI domdoc_get_namespaces(
2374 IXMLDOMDocument3* iface,
2375 IXMLDOMSchemaCollection** schemaCollection )
2376 {
2377 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2378 FIXME("(%p)->(%p)\n", This, schemaCollection);
2379 return E_NOTIMPL;
2380 }
2381
2382 static HRESULT WINAPI domdoc_get_schemas(
2383 IXMLDOMDocument3* iface,
2384 VARIANT* var1 )
2385 {
2386 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2387 HRESULT hr = S_FALSE;
2388 IXMLDOMSchemaCollection *cur_schema = This->schema;
2389
2390 TRACE("(%p)->(%p)\n", This, var1);
2391
2392 VariantInit(var1); /* Test shows we don't call VariantClear here */
2393 V_VT(var1) = VT_NULL;
2394
2395 if(cur_schema)
2396 {
2397 hr = IXMLDOMSchemaCollection_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
2398 if(SUCCEEDED(hr))
2399 V_VT(var1) = VT_DISPATCH;
2400 }
2401 return hr;
2402 }
2403
2404 static HRESULT WINAPI domdoc_putref_schemas(
2405 IXMLDOMDocument3* iface,
2406 VARIANT var1)
2407 {
2408 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2409 HRESULT hr = E_FAIL;
2410 IXMLDOMSchemaCollection *new_schema = NULL;
2411
2412 FIXME("(%p): semi-stub\n", This);
2413 switch(V_VT(&var1))
2414 {
2415 case VT_UNKNOWN:
2416 hr = IUnknown_QueryInterface(V_UNKNOWN(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2417 break;
2418
2419 case VT_DISPATCH:
2420 hr = IDispatch_QueryInterface(V_DISPATCH(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2421 break;
2422
2423 case VT_NULL:
2424 case VT_EMPTY:
2425 hr = S_OK;
2426 break;
2427
2428 default:
2429 WARN("Can't get schema from vt %x\n", V_VT(&var1));
2430 }
2431
2432 if(SUCCEEDED(hr))
2433 {
2434 IXMLDOMSchemaCollection *old_schema = InterlockedExchangePointer((void**)&This->schema, new_schema);
2435 if(old_schema) IXMLDOMSchemaCollection_Release(old_schema);
2436 }
2437
2438 return hr;
2439 }
2440
2441 static void LIBXML2_LOG_CALLBACK validate_error(void* ctx, char const* msg, ...)
2442 {
2443 va_list ap;
2444 va_start(ap, msg);
2445 LIBXML2_CALLBACK_ERR(domdoc_validate, msg, ap);
2446 va_end(ap);
2447 }
2448
2449 static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ...)
2450 {
2451 va_list ap;
2452 va_start(ap, msg);
2453 LIBXML2_CALLBACK_WARN(domdoc_validate, msg, ap);
2454 va_end(ap);
2455 }
2456
2457 static HRESULT WINAPI domdoc_validate(
2458 IXMLDOMDocument3* iface,
2459 IXMLDOMParseError** err)
2460 {
2461 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2462 LONG state;
2463 xmlValidCtxtPtr vctx;
2464
2465 TRACE("(%p)->(%p)\n", This, err);
2466 domdoc_get_readyState(iface, &state);
2467 if (state != READYSTATE_COMPLETE)
2468 {
2469 if (err)
2470 *err = create_parseError(0, NULL, NULL, NULL, 0, 0, 0);
2471 return E_PENDING;
2472 }
2473
2474 vctx = xmlNewValidCtxt();
2475 vctx->error = validate_error;
2476 vctx->warning = validate_warning;
2477
2478 if (xmlValidateDocument(vctx, get_doc(This)))
2479 {
2480 if (err)
2481 *err = create_parseError(0, NULL, NULL, NULL, 0, 0, 0);
2482 xmlFreeValidCtxt(vctx);
2483 return S_OK;
2484 }
2485
2486 FIXME("partial stub!\n");
2487 if (err)
2488 *err = create_parseError(0xC00CE223, NULL, NULL, NULL, 0, 0, 0);
2489 xmlFreeValidCtxt(vctx);
2490 return S_FALSE;
2491 }
2492
2493 static HRESULT WINAPI domdoc_setProperty(
2494 IXMLDOMDocument3* iface,
2495 BSTR p,
2496 VARIANT var)
2497 {
2498 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2499
2500 TRACE("(%p)->(%s)\n", This, debugstr_w(p));
2501
2502 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2503 {
2504 VARIANT varStr;
2505 HRESULT hr;
2506 BSTR bstr;
2507
2508 V_VT(&varStr) = VT_EMPTY;
2509 if (V_VT(&var) != VT_BSTR)
2510 {
2511 if (FAILED(hr = VariantChangeType(&varStr, &var, 0, VT_BSTR)))
2512 return hr;
2513 bstr = V_BSTR(&varStr);
2514 }
2515 else
2516 bstr = V_BSTR(&var);
2517
2518 hr = S_OK;
2519 if (lstrcmpiW(bstr, PropValueXPathW) == 0)
2520 This->properties->XPath = TRUE;
2521 else if (lstrcmpiW(bstr, PropValueXSLPatternW) == 0)
2522 This->properties->XPath = FALSE;
2523 else
2524 hr = E_FAIL;
2525
2526 VariantClear(&varStr);
2527 return hr;
2528 }
2529 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2530 {
2531 VARIANT varStr;
2532 HRESULT hr;
2533 BSTR bstr;
2534 xmlChar *pTokBegin, *pTokEnd, *pTokInner;
2535 xmlChar *nsStr = (xmlChar*)This->properties->selectNsStr;
2536 xmlXPathContextPtr ctx;
2537 struct list *pNsList;
2538 select_ns_entry* pNsEntry = NULL;
2539
2540 V_VT(&varStr) = VT_EMPTY;
2541 if (V_VT(&var) != VT_BSTR)
2542 {
2543 if (FAILED(hr = VariantChangeType(&varStr, &var, 0, VT_BSTR)))
2544 return hr;
2545 bstr = V_BSTR(&varStr);
2546 }
2547 else
2548 bstr = V_BSTR(&var);
2549
2550 hr = S_OK;
2551
2552 pNsList = &(This->properties->selectNsList);
2553 clear_selectNsList(pNsList);
2554 heap_free(nsStr);
2555 nsStr = xmlChar_from_wchar(bstr);
2556
2557
2558 TRACE("Setting SelectionNamespaces property to: %s\n", nsStr);
2559
2560 This->properties->selectNsStr = nsStr;
2561 This->properties->selectNsStr_len = xmlStrlen(nsStr);
2562 if (bstr && *bstr)
2563 {
2564 ctx = xmlXPathNewContext(This->node.node->doc);
2565 pTokBegin = nsStr;
2566 pTokEnd = nsStr;
2567 for (; *pTokBegin; pTokBegin = pTokEnd)
2568 {
2569 if (pNsEntry != NULL)
2570 memset(pNsEntry, 0, sizeof(select_ns_entry));
2571 else
2572 pNsEntry = heap_alloc_zero(sizeof(select_ns_entry));
2573
2574 while (*pTokBegin == ' ')
2575 ++pTokBegin;
2576 pTokEnd = pTokBegin;
2577 while (*pTokEnd != ' ' && *pTokEnd != 0)
2578 ++pTokEnd;
2579
2580 if (xmlStrncmp(pTokBegin, (xmlChar const*)"xmlns", 5) != 0)
2581 {
2582 hr = E_FAIL;
2583 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2584 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2585 continue;
2586 }
2587
2588 pTokBegin += 5;
2589 if (*pTokBegin == '=')
2590 {
2591 /*valid for XSLPattern?*/
2592 FIXME("Setting default xmlns not supported - skipping.\n");
2593 pTokBegin = pTokEnd;
2594 continue;
2595 }
2596 else if (*pTokBegin == ':')
2597 {
2598 pNsEntry->prefix = ++pTokBegin;
2599 for (pTokInner = pTokBegin; pTokInner != pTokEnd && *pTokInner != '='; ++pTokInner)
2600 ;
2601
2602 if (pTokInner == pTokEnd)
2603 {
2604 hr = E_FAIL;
2605 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2606 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2607 continue;
2608 }
2609
2610 pNsEntry->prefix_end = *pTokInner;
2611 *pTokInner = 0;
2612 ++pTokInner;
2613
2614 if (pTokEnd-pTokInner > 1 &&
2615 ((*pTokInner == '\'' && *(pTokEnd-1) == '\'') ||
2616 (*pTokInner == '"' && *(pTokEnd-1) == '"')))
2617 {
2618 pNsEntry->href = ++pTokInner;
2619 pNsEntry->href_end = *(pTokEnd-1);
2620 *(pTokEnd-1) = 0;
2621 list_add_tail(pNsList, &pNsEntry->entry);
2622 /*let libxml figure out if they're valid from here ;)*/
2623 if (xmlXPathRegisterNs(ctx, pNsEntry->prefix, pNsEntry->href) != 0)
2624 {
2625 hr = E_FAIL;
2626 }
2627 pNsEntry = NULL;
2628 continue;
2629 }
2630 else
2631 {
2632 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2633 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokInner, pTokEnd-pTokInner));
2634 list_add_tail(pNsList, &pNsEntry->entry);
2635
2636 pNsEntry = NULL;
2637 hr = E_FAIL;
2638 continue;
2639 }
2640 }
2641 else
2642 {
2643 hr = E_FAIL;
2644 continue;
2645 }
2646 }
2647 heap_free(pNsEntry);
2648 xmlXPathFreeContext(ctx);
2649 }
2650
2651 VariantClear(&varStr);
2652 return hr;
2653 }
2654 else if (lstrcmpiW(p, PropertyProhibitDTDW) == 0 ||
2655 lstrcmpiW(p, PropertyNewParserW) == 0)
2656 {
2657 /* Ignore */
2658 FIXME("Ignoring property %s, value %d\n", debugstr_w(p), V_BOOL(&var));
2659 return S_OK;
2660 }
2661
2662 FIXME("Unknown property %s\n", wine_dbgstr_w(p));
2663 return E_FAIL;
2664 }
2665
2666 static HRESULT WINAPI domdoc_getProperty(
2667 IXMLDOMDocument3* iface,
2668 BSTR p,
2669 VARIANT* var)
2670 {
2671 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2672
2673 TRACE("(%p)->(%p)\n", This, debugstr_w(p));
2674
2675 if (!var)
2676 return E_INVALIDARG;
2677
2678 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2679 {
2680 V_VT(var) = VT_BSTR;
2681 V_BSTR(var) = This->properties->XPath ?
2682 SysAllocString(PropValueXPathW) :
2683 SysAllocString(PropValueXSLPatternW);
2684 return V_BSTR(var) ? S_OK : E_OUTOFMEMORY;
2685 }
2686 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2687 {
2688 int lenA, lenW;
2689 BSTR rebuiltStr, cur;
2690 const xmlChar *nsStr;
2691 struct list *pNsList;
2692 select_ns_entry* pNsEntry;
2693
2694 V_VT(var) = VT_BSTR;
2695 nsStr = This->properties->selectNsStr;
2696 pNsList = &This->properties->selectNsList;
2697 lenA = This->properties->selectNsStr_len;
2698 lenW = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, NULL, 0);
2699 rebuiltStr = heap_alloc(lenW*sizeof(WCHAR));
2700 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, rebuiltStr, lenW);
2701 cur = rebuiltStr;
2702 /* this is fine because all of the chars that end tokens are ASCII*/
2703 LIST_FOR_EACH_ENTRY(pNsEntry, pNsList, select_ns_entry, entry)
2704 {
2705 while (*cur != 0) ++cur;
2706 if (pNsEntry->prefix_end)
2707 {
2708 *cur = pNsEntry->prefix_end;
2709 while (*cur != 0) ++cur;
2710 }
2711
2712 if (pNsEntry->href_end)
2713 {
2714 *cur = pNsEntry->href_end;
2715 }
2716 }
2717 V_BSTR(var) = SysAllocString(rebuiltStr);
2718 heap_free(rebuiltStr);
2719 return S_OK;
2720 }
2721
2722 FIXME("Unknown property %s\n", wine_dbgstr_w(p));
2723 return E_FAIL;
2724 }
2725
2726 static HRESULT WINAPI domdoc_validateNode(
2727 IXMLDOMDocument3* iface,
2728 IXMLDOMNode* node,
2729 IXMLDOMParseError** error)
2730 {
2731 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2732 FIXME("(%p)->(%p %p): stub\n", This, node, error);
2733 return E_NOTIMPL;
2734 }
2735
2736 static HRESULT WINAPI domdoc_importNode(
2737 IXMLDOMDocument3* iface,
2738 IXMLDOMNode* node,
2739 VARIANT_BOOL deep,
2740 IXMLDOMNode** clone)
2741 {
2742 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2743 FIXME("(%p)->(%p %d %p): stub\n", This, node, deep, clone);
2744 return E_NOTIMPL;
2745 }
2746
2747 static const struct IXMLDOMDocument3Vtbl domdoc_vtbl =
2748 {
2749 domdoc_QueryInterface,
2750 domdoc_AddRef,
2751 domdoc_Release,
2752 domdoc_GetTypeInfoCount,
2753 domdoc_GetTypeInfo,
2754 domdoc_GetIDsOfNames,
2755 domdoc_Invoke,
2756 domdoc_get_nodeName,
2757 domdoc_get_nodeValue,
2758 domdoc_put_nodeValue,
2759 domdoc_get_nodeType,
2760 domdoc_get_parentNode,
2761 domdoc_get_childNodes,
2762 domdoc_get_firstChild,
2763 domdoc_get_lastChild,
2764 domdoc_get_previousSibling,
2765 domdoc_get_nextSibling,
2766 domdoc_get_attributes,
2767 domdoc_insertBefore,
2768 domdoc_replaceChild,
2769 domdoc_removeChild,
2770 domdoc_appendChild,
2771 domdoc_hasChildNodes,
2772 domdoc_get_ownerDocument,
2773 domdoc_cloneNode,
2774 domdoc_get_nodeTypeString,
2775 domdoc_get_text,
2776 domdoc_put_text,
2777 domdoc_get_specified,
2778 domdoc_get_definition,
2779 domdoc_get_nodeTypedValue,
2780 domdoc_put_nodeTypedValue,
2781 domdoc_get_dataType,
2782 domdoc_put_dataType,
2783 domdoc_get_xml,
2784 domdoc_transformNode,
2785 domdoc_selectNodes,
2786 domdoc_selectSingleNode,
2787 domdoc_get_parsed,
2788 domdoc_get_namespaceURI,
2789 domdoc_get_prefix,
2790 domdoc_get_baseName,
2791 domdoc_transformNodeToObject,
2792 domdoc_get_doctype,
2793 domdoc_get_implementation,
2794 domdoc_get_documentElement,
2795 domdoc_put_documentElement,
2796 domdoc_createElement,
2797 domdoc_createDocumentFragment,
2798 domdoc_createTextNode,
2799 domdoc_createComment,
2800 domdoc_createCDATASection,
2801 domdoc_createProcessingInstruction,
2802 domdoc_createAttribute,
2803 domdoc_createEntityReference,
2804 domdoc_getElementsByTagName,
2805 domdoc_createNode,
2806 domdoc_nodeFromID,
2807 domdoc_load,
2808 domdoc_get_readyState,
2809 domdoc_get_parseError,
2810 domdoc_get_url,
2811 domdoc_get_async,
2812 domdoc_put_async,
2813 domdoc_abort,
2814 domdoc_loadXML,
2815 domdoc_save,
2816 domdoc_get_validateOnParse,
2817 domdoc_put_validateOnParse,
2818 domdoc_get_resolveExternals,
2819 domdoc_put_resolveExternals,
2820 domdoc_get_preserveWhiteSpace,
2821 domdoc_put_preserveWhiteSpace,
2822 domdoc_put_onReadyStateChange,
2823 domdoc_put_onDataAvailable,
2824 domdoc_put_onTransformNode,
2825 domdoc_get_namespaces,
2826 domdoc_get_schemas,
2827 domdoc_putref_schemas,
2828 domdoc_validate,
2829 domdoc_setProperty,
2830 domdoc_getProperty,
2831 domdoc_validateNode,
2832 domdoc_importNode
2833 };
2834
2835 /* IConnectionPointContainer */
2836 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
2837 REFIID riid, void **ppv)
2838 {
2839 domdoc *This = impl_from_IConnectionPointContainer(iface);
2840 return IXMLDOMDocument3_QueryInterface((IXMLDOMDocument3*)This, riid, ppv);
2841 }
2842
2843 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
2844 {
2845 domdoc *This = impl_from_IConnectionPointContainer(iface);
2846 return IXMLDOMDocument3_AddRef((IXMLDOMDocument3*)This);
2847 }
2848
2849 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
2850 {
2851 domdoc *This = impl_from_IConnectionPointContainer(iface);
2852 return IXMLDOMDocument3_Release((IXMLDOMDocument3*)This);
2853 }
2854
2855 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
2856 IEnumConnectionPoints **ppEnum)
2857 {
2858 domdoc *This = impl_from_IConnectionPointContainer(iface);
2859 FIXME("(%p)->(%p): stub\n", This, ppEnum);
2860 return E_NOTIMPL;
2861 }
2862
2863 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
2864 REFIID riid, IConnectionPoint **cp)
2865 {
2866 domdoc *This = impl_from_IConnectionPointContainer(iface);
2867 ConnectionPoint *iter;
2868
2869 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), cp);
2870
2871 *cp = NULL;
2872
2873 for(iter = This->cp_list; iter; iter = iter->next)
2874 {
2875 if (IsEqualGUID(iter->iid, riid))
2876 *cp = (IConnectionPoint*)&iter->lpVtblConnectionPoint;
2877 }
2878
2879 if (*cp)
2880 {
2881 IConnectionPoint_AddRef(*cp);
2882 return S_OK;
2883 }
2884
2885 FIXME("unsupported riid %s\n", debugstr_guid(riid));
2886 return CONNECT_E_NOCONNECTION;
2887
2888 }
2889
2890 static const struct IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
2891 {
2892 ConnectionPointContainer_QueryInterface,
2893 ConnectionPointContainer_AddRef,
2894 ConnectionPointContainer_Release,
2895 ConnectionPointContainer_EnumConnectionPoints,
2896 ConnectionPointContainer_FindConnectionPoint
2897 };
2898
2899 /* IConnectionPoint */
2900 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
2901 REFIID riid, void **ppv)
2902 {
2903 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2904
2905 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv );
2906
2907 *ppv = NULL;
2908
2909 if (IsEqualGUID(&IID_IUnknown, riid) ||
2910 IsEqualGUID(&IID_IConnectionPoint, riid))
2911 {
2912 *ppv = iface;
2913 }
2914
2915 if (*ppv)
2916 {
2917 IConnectionPoint_AddRef(iface);
2918 return S_OK;
2919 }
2920
2921 WARN("Unsupported interface %s\n", debugstr_guid(riid));
2922 return E_NOINTERFACE;
2923 }
2924
2925 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
2926 {
2927 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2928 return IConnectionPointContainer_AddRef(This->container);
2929 }
2930
2931 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
2932 {
2933 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2934 return IConnectionPointContainer_Release(This->container);
2935 }
2936
2937 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *iid)
2938 {
2939 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2940
2941 TRACE("(%p)->(%p)\n", This, iid);
2942
2943 if (!iid) return E_POINTER;
2944
2945 *iid = *This->iid;
2946 return S_OK;
2947 }
2948
2949 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
2950 IConnectionPointContainer **container)
2951 {
2952 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2953
2954 TRACE("(%p)->(%p)\n", This, container);
2955
2956 if (!container) return E_POINTER;
2957
2958 *container = This->container;
2959 IConnectionPointContainer_AddRef(*container);
2960 return S_OK;
2961 }
2962
2963 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
2964 DWORD *pdwCookie)
2965 {
2966 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2967 FIXME("(%p)->(%p %p): stub\n", This, pUnkSink, pdwCookie);
2968 return E_NOTIMPL;
2969 }
2970
2971 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD cookie)
2972 {
2973 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2974
2975 TRACE("(%p)->(%d)\n", This, cookie);
2976
2977 if (cookie == 0 || cookie > This->sinks_size || !This->sinks[cookie-1].unk)
2978 return CONNECT_E_NOCONNECTION;
2979
2980 IUnknown_Release(This->sinks[cookie-1].unk);
2981 This->sinks[cookie-1].unk = NULL;
2982
2983 return S_OK;
2984 }
2985
2986 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
2987 IEnumConnections **ppEnum)
2988 {
2989 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
2990 FIXME("(%p)->(%p): stub\n", This, ppEnum);
2991 return E_NOTIMPL;
2992 }
2993
2994 static const IConnectionPointVtbl ConnectionPointVtbl =
2995 {
2996 ConnectionPoint_QueryInterface,
2997 ConnectionPoint_AddRef,
2998 ConnectionPoint_Release,
2999 ConnectionPoint_GetConnectionInterface,
3000 ConnectionPoint_GetConnectionPointContainer,
3001 ConnectionPoint_Advise,
3002 ConnectionPoint_Unadvise,
3003 ConnectionPoint_EnumConnections
3004 };
3005
3006 void ConnectionPoint_Init(ConnectionPoint *cp, struct domdoc *doc, REFIID riid)
3007 {
3008 cp->lpVtblConnectionPoint = &ConnectionPointVtbl;
3009 cp->doc = doc;
3010 cp->iid = riid;
3011 cp->sinks = NULL;
3012 cp->sinks_size = 0;
3013
3014 cp->next = doc->cp_list;
3015 doc->cp_list = cp;
3016
3017 cp->container = (IConnectionPointContainer*)&doc->lpVtblConnectionPointContainer;
3018 }
3019
3020 /* domdoc implementation of IObjectWithSite */
3021 static HRESULT WINAPI
3022 domdoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
3023 {
3024 domdoc *This = impl_from_IObjectWithSite(iface);
3025 return IXMLDOMDocument3_QueryInterface( (IXMLDOMDocument3 *)This, riid, ppvObject );
3026 }
3027
3028 static ULONG WINAPI domdoc_ObjectWithSite_AddRef( IObjectWithSite* iface )
3029 {
3030 domdoc *This = impl_from_IObjectWithSite(iface);
3031 return IXMLDOMDocument3_AddRef((IXMLDOMDocument3 *)This);
3032 }
3033
3034 static ULONG WINAPI domdoc_ObjectWithSite_Release( IObjectWithSite* iface )
3035 {
3036 domdoc *This = impl_from_IObjectWithSite(iface);
3037 return IXMLDOMDocument3_Release((IXMLDOMDocument3 *)This);
3038 }
3039
3040 static HRESULT WINAPI domdoc_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
3041 {
3042 domdoc *This = impl_from_IObjectWithSite(iface);
3043
3044 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
3045
3046 if ( !This->site )
3047 return E_FAIL;
3048
3049 return IUnknown_QueryInterface( This->site, iid, ppvSite );
3050 }
3051
3052 static HRESULT WINAPI domdoc_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
3053 {
3054 domdoc *This = impl_from_IObjectWithSite(iface);
3055
3056 TRACE("(%p)->(%p)\n", iface, punk);
3057
3058 if(!punk)
3059 {
3060 if(This->site)
3061 {
3062 IUnknown_Release( This->site );
3063 This->site = NULL;
3064 }
3065
3066 return S_OK;
3067 }
3068
3069 IUnknown_AddRef( punk );
3070
3071 if(This->site)
3072 IUnknown_Release( This->site );
3073
3074 This->site = punk;
3075
3076 return S_OK;
3077 }
3078
3079 static const IObjectWithSiteVtbl domdocObjectSite =
3080 {
3081 domdoc_ObjectWithSite_QueryInterface,
3082 domdoc_ObjectWithSite_AddRef,
3083 domdoc_ObjectWithSite_Release,
3084 domdoc_ObjectWithSite_SetSite,
3085 domdoc_ObjectWithSite_GetSite
3086 };
3087
3088 static HRESULT WINAPI domdoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
3089 {
3090 domdoc *This = impl_from_IObjectSafety(iface);
3091 return IXMLDOMDocument3_QueryInterface( (IXMLDOMDocument3 *)This, riid, ppv );
3092 }
3093
3094 static ULONG WINAPI domdoc_Safety_AddRef(IObjectSafety *iface)
3095 {
3096 domdoc *This = impl_from_IObjectSafety(iface);
3097 return IXMLDOMDocument3_AddRef((IXMLDOMDocument3 *)This);
3098 }
3099
3100 static ULONG WINAPI domdoc_Safety_Release(IObjectSafety *iface)
3101 {
3102 domdoc *This = impl_from_IObjectSafety(iface);
3103 return IXMLDOMDocument3_Release((IXMLDOMDocument3 *)This);
3104 }
3105
3106 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
3107
3108 static HRESULT WINAPI domdoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3109 DWORD *supported, DWORD *enabled)
3110 {
3111 domdoc *This = impl_from_IObjectSafety(iface);
3112
3113 TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
3114
3115 if(!supported || !enabled) return E_POINTER;
3116
3117 *supported = SAFETY_SUPPORTED_OPTIONS;
3118 *enabled = This->safeopt;
3119
3120 return S_OK;
3121 }
3122
3123 static HRESULT WINAPI domdoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3124 DWORD mask, DWORD enabled)
3125 {
3126 domdoc *This = impl_from_IObjectSafety(iface);
3127 TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
3128
3129 if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
3130 return E_FAIL;
3131
3132 This->safeopt = enabled & mask & SAFETY_SUPPORTED_OPTIONS;
3133 return S_OK;
3134 }
3135
3136 #undef SAFETY_SUPPORTED_OPTIONS
3137
3138 static const IObjectSafetyVtbl domdocObjectSafetyVtbl = {
3139 domdoc_Safety_QueryInterface,
3140 domdoc_Safety_AddRef,
3141 domdoc_Safety_Release,
3142 domdoc_Safety_GetInterfaceSafetyOptions,
3143 domdoc_Safety_SetInterfaceSafetyOptions
3144 };
3145
3146 static const tid_t domdoc_iface_tids[] = {
3147 IXMLDOMNode_tid,
3148 IXMLDOMDocument_tid,
3149 IXMLDOMDocument2_tid,
3150 0
3151 };
3152 static dispex_static_data_t domdoc_dispex = {
3153 NULL,
3154 IXMLDOMDocument2_tid,
3155 NULL,
3156 domdoc_iface_tids
3157 };
3158
3159 HRESULT DOMDocument_create_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument3 **document)
3160 {
3161 domdoc *doc;
3162
3163 doc = heap_alloc( sizeof (*doc) );
3164 if( !doc )
3165 return E_OUTOFMEMORY;
3166
3167 doc->lpVtbl = &domdoc_vtbl;
3168 doc->lpvtblIPersistStreamInit = &xmldoc_IPersistStreamInit_VTable;
3169 doc->lpvtblIObjectWithSite = &domdocObjectSite;
3170 doc->lpvtblIObjectSafety = &domdocObjectSafetyVtbl;
3171 doc->lpvtblISupportErrorInfo = &support_error_vtbl;
3172 doc->lpVtblConnectionPointContainer = &ConnectionPointContainerVtbl;
3173 doc->ref = 1;
3174 doc->async = VARIANT_TRUE;
3175 doc->validating = 0;
3176 doc->resolving = 0;
3177 doc->preserving = 0;
3178 doc->properties = properties_from_xmlDocPtr(xmldoc);
3179 doc->error = S_OK;
3180 doc->schema = NULL;
3181 doc->stream = NULL;
3182 doc->site = NULL;
3183 doc->safeopt = 0;
3184 doc->bsc = NULL;
3185 doc->cp_list = NULL;
3186
3187 /* events connection points */
3188 ConnectionPoint_Init(&doc->cp_dispatch, doc, &IID_IDispatch);
3189 ConnectionPoint_Init(&doc->cp_propnotif, doc, &IID_IPropertyNotifySink);
3190 ConnectionPoint_Init(&doc->cp_domdocevents, doc, &DIID_XMLDOMDocumentEvents);
3191
3192 init_xmlnode(&doc->node, (xmlNodePtr)xmldoc, (IXMLDOMNode*)&doc->lpVtbl, &domdoc_dispex);
3193
3194 *document = (IXMLDOMDocument3*)&doc->lpVtbl;
3195
3196 TRACE("returning iface %p\n", *document);
3197 return S_OK;
3198 }
3199
3200 HRESULT DOMDocument_create(const GUID *clsid, IUnknown *pUnkOuter, void **ppObj)
3201 {
3202 xmlDocPtr xmldoc;
3203 HRESULT hr;
3204
3205 TRACE("(%s, %p, %p)\n", debugstr_guid(clsid), pUnkOuter, ppObj);
3206
3207 xmldoc = xmlNewDoc(NULL);
3208 if(!xmldoc)
3209 return E_OUTOFMEMORY;
3210
3211 xmldoc->_private = create_priv();
3212 priv_from_xmlDocPtr(xmldoc)->properties = create_properties(clsid);
3213
3214 hr = DOMDocument_create_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj);
3215 if(FAILED(hr))
3216 {
3217 free_properties(properties_from_xmlDocPtr(xmldoc));
3218 heap_free(xmldoc->_private);
3219 xmlFreeDoc(xmldoc);
3220 return hr;
3221 }
3222
3223 return hr;
3224 }
3225
3226 IUnknown* create_domdoc( xmlNodePtr document )
3227 {
3228 void* pObj = NULL;
3229 HRESULT hr;
3230
3231 TRACE("(%p)\n", document);
3232
3233 hr = DOMDocument_create_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument3**)&pObj);
3234 if (FAILED(hr))
3235 return NULL;
3236
3237 return pObj;
3238 }
3239
3240 #else
3241
3242 HRESULT DOMDocument_create(const GUID *clsid, IUnknown *pUnkOuter, void **ppObj)
3243 {
3244 MESSAGE("This program tried to use a DOMDocument object, but\n"
3245 "libxml2 support was not present at compile time.\n");
3246 return E_NOTIMPL;
3247 }
3248
3249 #endif
Windows API implementation