dlls/msxml3/nodemap.c

   1 /*
   2  *    Node map implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #ifdef HAVE_LIBXML2
  27 # include <libxml/parser.h>
  28 # include <libxml/xmlerror.h>
  29 #endif
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winuser.h"
  34 #include "winnls.h"
  35 #include "ole2.h"
  36 #include "msxml6.h"
  37 #include "msxml2did.h"
  38
  39 #include "msxml_private.h"
  40
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  44
  45 #ifdef HAVE_LIBXML2
  46
  47 typedef struct _xmlnodemap
  48 {
  49     DispatchEx dispex;
  50     IXMLDOMNamedNodeMap IXMLDOMNamedNodeMap_iface;
  51     ISupportErrorInfo ISupportErrorInfo_iface;
  52     LONG ref;
  53
  54     xmlNodePtr node;
  55     LONG iterator;
  56 } xmlnodemap;
  57
  58 static inline xmlnodemap *impl_from_IXMLDOMNamedNodeMap( IXMLDOMNamedNodeMap *iface )
  59 {
  60     return CONTAINING_RECORD(iface, xmlnodemap, IXMLDOMNamedNodeMap_iface);
  61 }
  62
  63 static inline xmlnodemap *impl_from_ISupportErrorInfo( ISupportErrorInfo *iface )
  64 {
  65     return CONTAINING_RECORD(iface, xmlnodemap, ISupportErrorInfo_iface);
  66 }
  67
  68 static HRESULT WINAPI xmlnodemap_QueryInterface(
  69     IXMLDOMNamedNodeMap *iface,
  70     REFIID riid, void** ppvObject )
  71 {
  72     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
  73     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
  74
  75     if( IsEqualGUID( riid, &IID_IUnknown ) ||
  76         IsEqualGUID( riid, &IID_IDispatch ) ||
  77         IsEqualGUID( riid, &IID_IXMLDOMNamedNodeMap ) )
  78     {
  79         *ppvObject = iface;
  80     }
  81     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
  82     {
  83         return *ppvObject ? S_OK : E_NOINTERFACE;
  84     }
  85     else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  86     {
  87         *ppvObject = &This->ISupportErrorInfo_iface;
  88     }
  89     else
  90     {
  91         TRACE("interface %s not implemented\n", debugstr_guid(riid));
  92         *ppvObject = NULL;
  93         return E_NOINTERFACE;
  94     }
  95
  96     IXMLDOMElement_AddRef( iface );
  97
  98     return S_OK;
  99 }
 100
 101 static ULONG WINAPI xmlnodemap_AddRef(
 102     IXMLDOMNamedNodeMap *iface )
 103 {
 104     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 105     ULONG ref = InterlockedIncrement( &This->ref );
 106     TRACE("(%p)->(%d)\n", This, ref);
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI xmlnodemap_Release(
 111     IXMLDOMNamedNodeMap *iface )
 112 {
 113     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 114     ULONG ref = InterlockedDecrement( &This->ref );
 115
 116     TRACE("(%p)->(%d)\n", This, ref);
 117     if ( ref == 0 )
 118     {
 119         xmldoc_release( This->node->doc );
 120         release_dispex(&This->dispex);
 121         heap_free( This );
 122     }
 123
 124     return ref;
 125 }
 126
 127 static HRESULT WINAPI xmlnodemap_GetTypeInfoCount(
 128     IXMLDOMNamedNodeMap *iface,
 129     UINT* pctinfo )
 130 {
 131     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 132
 133     TRACE("(%p)->(%p)\n", This, pctinfo);
 134
 135     *pctinfo = 1;
 136
 137     return S_OK;
 138 }
 139
 140 static HRESULT WINAPI xmlnodemap_GetTypeInfo(
 141     IXMLDOMNamedNodeMap *iface,
 142     UINT iTInfo, LCID lcid,
 143     ITypeInfo** ppTInfo )
 144 {
 145     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 146     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 147     return get_typeinfo(IXMLDOMNamedNodeMap_tid, ppTInfo);
 148 }
 149
 150 static HRESULT WINAPI xmlnodemap_GetIDsOfNames(
 151     IXMLDOMNamedNodeMap *iface,
 152     REFIID riid, LPOLESTR* rgszNames,
 153     UINT cNames, LCID lcid, DISPID* rgDispId )
 154 {
 155     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 156     ITypeInfo *typeinfo;
 157     HRESULT hr;
 158
 159     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 160           lcid, rgDispId);
 161
 162     if(!rgszNames || cNames == 0 || !rgDispId)
 163         return E_INVALIDARG;
 164
 165     hr = get_typeinfo(IXMLDOMNamedNodeMap_tid, &typeinfo);
 166     if(SUCCEEDED(hr))
 167     {
 168         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 169         ITypeInfo_Release(typeinfo);
 170     }
 171
 172     return hr;
 173 }
 174
 175 static HRESULT WINAPI xmlnodemap_Invoke(
 176     IXMLDOMNamedNodeMap *iface,
 177     DISPID dispIdMember, REFIID riid, LCID lcid,
 178     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 179     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 180 {
 181     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 182     ITypeInfo *typeinfo;
 183     HRESULT hr;
 184
 185     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 186           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 187
 188     hr = get_typeinfo(IXMLDOMNamedNodeMap_tid, &typeinfo);
 189     if(SUCCEEDED(hr))
 190     {
 191         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMNamedNodeMap_iface, dispIdMember, wFlags,
 192                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 193         ITypeInfo_Release(typeinfo);
 194     }
 195
 196     return hr;
 197 }
 198
 199 static HRESULT WINAPI xmlnodemap_getNamedItem(
 200     IXMLDOMNamedNodeMap *iface,
 201     BSTR name,
 202     IXMLDOMNode** item)
 203 {
 204     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 205     xmlChar *nameA, *local, *prefix;
 206     BSTR uriW, localW;
 207     xmlNsPtr ns;
 208     HRESULT hr;
 209
 210     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), item );
 211
 212     nameA = xmlchar_from_wchar(name);
 213     local = xmlSplitQName2(nameA, &prefix);
 214     heap_free(nameA);
 215
 216     if (!local)
 217         return IXMLDOMNamedNodeMap_getQualifiedItem(iface, name, NULL, item);
 218
 219     /* try to get namespace uri for supplied qualified name */
 220     ns = xmlSearchNs(This->node->doc, This->node, prefix);
 221
 222     xmlFree(prefix);
 223
 224     if (!ns)
 225     {
 226         xmlFree(local);
 227         if (item) *item = NULL;
 228         return item ? S_FALSE : E_INVALIDARG;
 229     }
 230
 231     uriW = bstr_from_xmlChar(ns->href);
 232     localW = bstr_from_xmlChar(local);
 233     xmlFree(local);
 234
 235     TRACE("got qualified node %s, uri=%s\n", debugstr_w(localW), debugstr_w(uriW));
 236
 237     hr = IXMLDOMNamedNodeMap_getQualifiedItem(iface, localW, uriW, item);
 238
 239     SysFreeString(localW);
 240     SysFreeString(uriW);
 241
 242     return hr;
 243 }
 244
 245 static HRESULT WINAPI xmlnodemap_setNamedItem(
 246     IXMLDOMNamedNodeMap *iface,
 247     IXMLDOMNode* newItem,
 248     IXMLDOMNode** namedItem)
 249 {
 250     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 251     xmlNodePtr nodeNew;
 252     xmlnode *ThisNew;
 253
 254     TRACE("(%p)->(%p %p)\n", This, newItem, namedItem );
 255
 256     if(!newItem)
 257         return E_INVALIDARG;
 258
 259     if(namedItem) *namedItem = NULL;
 260
 261     /* Must be an Attribute */
 262     ThisNew = get_node_obj( newItem );
 263     if(!ThisNew) return E_FAIL;
 264
 265     if(ThisNew->node->type != XML_ATTRIBUTE_NODE)
 266         return E_FAIL;
 267
 268     if(!ThisNew->node->parent)
 269         if(xmldoc_remove_orphan(ThisNew->node->doc, ThisNew->node) != S_OK)
 270             WARN("%p is not an orphan of %p\n", ThisNew->node, ThisNew->node->doc);
 271
 272     nodeNew = xmlAddChild(This->node, ThisNew->node);
 273
 274     if(namedItem)
 275         *namedItem = create_node( nodeNew );
 276     return S_OK;
 277 }
 278
 279 static HRESULT WINAPI xmlnodemap_removeNamedItem(
 280     IXMLDOMNamedNodeMap *iface,
 281     BSTR name,
 282     IXMLDOMNode** namedItem)
 283 {
 284     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 285     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), namedItem );
 286     return IXMLDOMNamedNodeMap_removeQualifiedItem(iface, name, NULL, namedItem);
 287 }
 288
 289 static HRESULT WINAPI xmlnodemap_get_item(
 290     IXMLDOMNamedNodeMap *iface,
 291     LONG index,
 292     IXMLDOMNode** listItem)
 293 {
 294     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 295     xmlAttrPtr curr;
 296     LONG attrIndex;
 297
 298     TRACE("(%p)->(%d %p)\n", This, index, listItem);
 299
 300     *listItem = NULL;
 301
 302     if (index < 0)
 303         return S_FALSE;
 304
 305     curr = This->node->properties;
 306
 307     for (attrIndex = 0; attrIndex < index; attrIndex++) {
 308         if (curr->next == NULL)
 309             return S_FALSE;
 310         else
 311             curr = curr->next;
 312     }
 313
 314     *listItem = create_node( (xmlNodePtr) curr );
 315
 316     return S_OK;
 317 }
 318
 319 static HRESULT WINAPI xmlnodemap_get_length(
 320     IXMLDOMNamedNodeMap *iface,
 321     LONG *listLength)
 322 {
 323     xmlAttrPtr first;
 324     xmlAttrPtr curr;
 325     LONG attrCount;
 326
 327     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 328
 329     TRACE("(%p)->(%p)\n", This, listLength);
 330
 331     if( !listLength )
 332         return E_INVALIDARG;
 333
 334     first = This->node->properties;
 335     if (first == NULL) {
 336         *listLength = 0;
 337         return S_OK;
 338     }
 339
 340     curr = first;
 341     attrCount = 1;
 342     while (curr->next) {
 343         attrCount++;
 344         curr = curr->next;
 345     }
 346     *listLength = attrCount;
 347
 348     return S_OK;
 349 }
 350
 351 static HRESULT WINAPI xmlnodemap_getQualifiedItem(
 352     IXMLDOMNamedNodeMap *iface,
 353     BSTR baseName,
 354     BSTR namespaceURI,
 355     IXMLDOMNode** qualifiedItem)
 356 {
 357     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 358     xmlAttrPtr attr;
 359     xmlChar *href;
 360     xmlChar *name;
 361
 362     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(baseName), debugstr_w(namespaceURI), qualifiedItem);
 363
 364     if (!baseName || !qualifiedItem) return E_INVALIDARG;
 365
 366     if (namespaceURI && *namespaceURI)
 367     {
 368         href = xmlchar_from_wchar(namespaceURI);
 369         if (!href) return E_OUTOFMEMORY;
 370     }
 371     else
 372         href = NULL;
 373
 374     name = xmlchar_from_wchar(baseName);
 375     if (!name)
 376     {
 377         heap_free(href);
 378         return E_OUTOFMEMORY;
 379     }
 380
 381     attr = xmlHasNsProp(This->node, name, href);
 382
 383     heap_free(name);
 384     heap_free(href);
 385
 386     if (!attr)
 387     {
 388         *qualifiedItem = NULL;
 389         return S_FALSE;
 390     }
 391
 392     *qualifiedItem = create_node((xmlNodePtr)attr);
 393
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI xmlnodemap_removeQualifiedItem(
 398     IXMLDOMNamedNodeMap *iface,
 399     BSTR baseName,
 400     BSTR namespaceURI,
 401     IXMLDOMNode** qualifiedItem)
 402 {
 403     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 404     xmlAttrPtr attr;
 405     xmlChar *name;
 406     xmlChar *href;
 407
 408     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(baseName), debugstr_w(namespaceURI), qualifiedItem);
 409
 410     if (!baseName) return E_INVALIDARG;
 411
 412     if (namespaceURI && *namespaceURI)
 413     {
 414         href = xmlchar_from_wchar(namespaceURI);
 415         if (!href) return E_OUTOFMEMORY;
 416     }
 417     else
 418         href = NULL;
 419
 420     name = xmlchar_from_wchar(baseName);
 421     if (!name)
 422     {
 423         heap_free(href);
 424         return E_OUTOFMEMORY;
 425     }
 426
 427     attr = xmlHasNsProp( This->node, name, href );
 428
 429     heap_free(name);
 430     heap_free(href);
 431
 432     if ( !attr )
 433     {
 434         if (qualifiedItem) *qualifiedItem = NULL;
 435         return S_FALSE;
 436     }
 437
 438     if ( qualifiedItem )
 439     {
 440         xmlUnlinkNode( (xmlNodePtr) attr );
 441         xmldoc_add_orphan( attr->doc, (xmlNodePtr) attr );
 442         *qualifiedItem = create_node( (xmlNodePtr) attr );
 443     }
 444     else
 445     {
 446         if (xmlRemoveProp(attr) == -1)
 447             ERR("xmlRemoveProp failed\n");
 448     }
 449
 450     return S_OK;
 451 }
 452
 453 static HRESULT WINAPI xmlnodemap_nextNode(
 454     IXMLDOMNamedNodeMap *iface,
 455     IXMLDOMNode** nextItem)
 456 {
 457     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 458     xmlAttrPtr curr;
 459     LONG attrIndex;
 460
 461     TRACE("(%p)->(%p: %d)\n", This, nextItem, This->iterator);
 462
 463     *nextItem = NULL;
 464
 465     curr = This->node->properties;
 466
 467     for (attrIndex = 0; attrIndex < This->iterator; attrIndex++) {
 468         if (curr->next == NULL)
 469             return S_FALSE;
 470         else
 471             curr = curr->next;
 472     }
 473
 474     This->iterator++;
 475
 476     *nextItem = create_node( (xmlNodePtr) curr );
 477
 478     return S_OK;
 479 }
 480
 481 static HRESULT WINAPI xmlnodemap_reset(
 482     IXMLDOMNamedNodeMap *iface )
 483 {
 484     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 485
 486     TRACE("(%p: %d)\n", This, This->iterator);
 487
 488     This->iterator = 0;
 489
 490     return S_OK;
 491 }
 492
 493 static HRESULT WINAPI xmlnodemap__newEnum(
 494     IXMLDOMNamedNodeMap *iface,
 495     IUnknown** ppUnk)
 496 {
 497     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
 498     FIXME("(%p)->(%p)\n", This, ppUnk);
 499     return E_NOTIMPL;
 500 }
 501
 502 static const struct IXMLDOMNamedNodeMapVtbl xmlnodemap_vtbl =
 503 {
 504     xmlnodemap_QueryInterface,
 505     xmlnodemap_AddRef,
 506     xmlnodemap_Release,
 507     xmlnodemap_GetTypeInfoCount,
 508     xmlnodemap_GetTypeInfo,
 509     xmlnodemap_GetIDsOfNames,
 510     xmlnodemap_Invoke,
 511     xmlnodemap_getNamedItem,
 512     xmlnodemap_setNamedItem,
 513     xmlnodemap_removeNamedItem,
 514     xmlnodemap_get_item,
 515     xmlnodemap_get_length,
 516     xmlnodemap_getQualifiedItem,
 517     xmlnodemap_removeQualifiedItem,
 518     xmlnodemap_nextNode,
 519     xmlnodemap_reset,
 520     xmlnodemap__newEnum,
 521 };
 522
 523 static HRESULT WINAPI support_error_QueryInterface(
 524     ISupportErrorInfo *iface,
 525     REFIID riid, void** ppvObject )
 526 {
 527     xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
 528     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 529     return IXMLDOMNamedNodeMap_QueryInterface(&This->IXMLDOMNamedNodeMap_iface, riid, ppvObject);
 530 }
 531
 532 static ULONG WINAPI support_error_AddRef(
 533     ISupportErrorInfo *iface )
 534 {
 535     xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
 536     return IXMLDOMNamedNodeMap_AddRef(&This->IXMLDOMNamedNodeMap_iface);
 537 }
 538
 539 static ULONG WINAPI support_error_Release(
 540     ISupportErrorInfo *iface )
 541 {
 542     xmlnodemap *This = impl_from_ISupportErrorInfo( iface );
 543     return IXMLDOMNamedNodeMap_Release(&This->IXMLDOMNamedNodeMap_iface);
 544 }
 545
 546 static HRESULT WINAPI support_error_InterfaceSupportsErrorInfo(
 547     ISupportErrorInfo *iface,
 548     REFIID riid )
 549 {
 550     FIXME("(%p)->(%s)\n", iface, debugstr_guid(riid));
 551     return S_FALSE;
 552 }
 553
 554 static const struct ISupportErrorInfoVtbl support_error_vtbl =
 555 {
 556     support_error_QueryInterface,
 557     support_error_AddRef,
 558     support_error_Release,
 559     support_error_InterfaceSupportsErrorInfo
 560 };
 561
 562 static HRESULT xmlnodemap_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid)
 563 {
 564     WCHAR *ptr;
 565     int idx = 0;
 566
 567     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 568         idx = idx*10 + (*ptr-'0');
 569     if(*ptr)
 570         return DISP_E_UNKNOWNNAME;
 571
 572     *dispid = DISPID_DOM_COLLECTION_BASE + idx;
 573     TRACE("ret %x\n", *dispid);
 574     return S_OK;
 575 }
 576
 577 static HRESULT xmlnodemap_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 578         VARIANT *res, EXCEPINFO *ei)
 579 {
 580     xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( (IXMLDOMNamedNodeMap*)iface );
 581
 582     TRACE("(%p)->(%x %x %x %p %p %p)\n", This, id, lcid, flags, params, res, ei);
 583
 584     V_VT(res) = VT_DISPATCH;
 585     V_DISPATCH(res) = NULL;
 586
 587     if (id < DISPID_DOM_COLLECTION_BASE || id > DISPID_DOM_COLLECTION_MAX)
 588         return DISP_E_UNKNOWNNAME;
 589
 590     switch(flags)
 591     {
 592         case INVOKE_PROPERTYGET:
 593         {
 594             IXMLDOMNode *disp = NULL;
 595
 596             IXMLDOMNamedNodeMap_get_item(&This->IXMLDOMNamedNodeMap_iface, id - DISPID_DOM_COLLECTION_BASE, &disp);
 597             V_DISPATCH(res) = (IDispatch*)disp;
 598             break;
 599         }
 600         default:
 601         {
 602             FIXME("unimplemented flags %x\n", flags);
 603             break;
 604         }
 605     }
 606
 607     TRACE("ret %p\n", V_DISPATCH(res));
 608
 609     return S_OK;
 610 }
 611
 612 static const dispex_static_data_vtbl_t xmlnodemap_dispex_vtbl = {
 613     xmlnodemap_get_dispid,
 614     xmlnodemap_invoke
 615 };
 616
 617 static const tid_t xmlnodemap_iface_tids[] = {
 618     IXMLDOMNamedNodeMap_tid,
 619     0
 620 };
 621
 622 static dispex_static_data_t xmlnodemap_dispex = {
 623     &xmlnodemap_dispex_vtbl,
 624     IXMLDOMNamedNodeMap_tid,
 625     NULL,
 626     xmlnodemap_iface_tids
 627 };
 628
 629 IXMLDOMNamedNodeMap *create_nodemap( const xmlNodePtr node )
 630 {
 631     xmlnodemap *This;
 632
 633     This = heap_alloc( sizeof *This );
 634     if ( !This )
 635         return NULL;
 636
 637     This->IXMLDOMNamedNodeMap_iface.lpVtbl = &xmlnodemap_vtbl;
 638     This->ISupportErrorInfo_iface.lpVtbl = &support_error_vtbl;
 639     This->node = node;
 640     This->ref = 1;
 641     This->iterator = 0;
 642
 643     init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMNamedNodeMap_iface, &xmlnodemap_dispex);
 644
 645     xmldoc_add_ref(node->doc);
 646
 647     return &This->IXMLDOMNamedNodeMap_iface;
 648 }
 649
 650 #endif