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