dlls/msxml3/domdoc.c

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