dlls/msxml3/mxnamespace.c

   1 /*
   2  *    IMXNamespaceManager implementation
   3  *
   4  * Copyright 2011-2012 Nikolay Sivov for CodeWeavers
   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 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #ifdef HAVE_LIBXML2
  27 # include <libxml/parser.h>
  28 # include <libxml/xmlerror.h>
  29 # include <libxml/encoding.h>
  30 #endif
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winuser.h"
  35 #include "ole2.h"
  36 #include "msxml6.h"
  37
  38 #include "msxml_private.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 struct ns
  45 {
  46     BSTR prefix;
  47     BSTR uri;
  48 };
  49
  50 struct nscontext
  51 {
  52     struct list entry;
  53
  54     struct ns *ns;
  55     int   count;
  56     int   max_alloc;
  57 };
  58
  59 #define DEFAULT_PREFIX_ALLOC_COUNT 16
  60
  61 static const WCHAR xmlW[] = {'x','m','l',0};
  62 static const WCHAR xmluriW[] = {'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g',
  63     '/','X','M','L','/','1','9','9','8','/','n','a','m','e','s','p','a','c','e',0};
  64
  65 typedef struct
  66 {
  67     DispatchEx dispex;
  68     IMXNamespaceManager   IMXNamespaceManager_iface;
  69     IVBMXNamespaceManager IVBMXNamespaceManager_iface;
  70     LONG ref;
  71
  72     struct list ctxts;
  73
  74     VARIANT_BOOL override;
  75 } namespacemanager;
  76
  77 static inline namespacemanager *impl_from_IMXNamespaceManager( IMXNamespaceManager *iface )
  78 {
  79     return CONTAINING_RECORD(iface, namespacemanager, IMXNamespaceManager_iface);
  80 }
  81
  82 static inline namespacemanager *impl_from_IVBMXNamespaceManager( IVBMXNamespaceManager *iface )
  83 {
  84     return CONTAINING_RECORD(iface, namespacemanager, IVBMXNamespaceManager_iface);
  85 }
  86
  87 static HRESULT declare_prefix(namespacemanager *This, const WCHAR *prefix, const WCHAR *uri)
  88 {
  89     struct nscontext *ctxt = LIST_ENTRY(list_head(&This->ctxts), struct nscontext, entry);
  90     static const WCHAR emptyW[] = {0};
  91     struct ns *ns;
  92     int i;
  93
  94     if (ctxt->count == ctxt->max_alloc)
  95     {
  96         ctxt->max_alloc *= 2;
  97         ctxt->ns = heap_realloc(ctxt->ns, ctxt->max_alloc*sizeof(*ctxt->ns));
  98     }
  99
 100     if (!prefix) prefix = emptyW;
 101
 102     ns = NULL;
 103     for (i = 0; i < ctxt->count; i++)
 104         if (!strcmpW(ctxt->ns[i].prefix, prefix))
 105         {
 106             ns = &ctxt->ns[i];
 107             break;
 108         }
 109
 110     if (ns)
 111     {
 112         if (This->override == VARIANT_TRUE)
 113         {
 114             SysFreeString(ns->uri);
 115             ns->uri = SysAllocString(uri);
 116             return S_FALSE;
 117         }
 118         else
 119             return E_FAIL;
 120     }
 121     else
 122     {
 123         ctxt->ns[ctxt->count].prefix = SysAllocString(prefix);
 124         ctxt->ns[ctxt->count].uri = SysAllocString(uri);
 125         ctxt->count++;
 126     }
 127
 128     return S_OK;
 129 }
 130
 131 /* returned stored pointer, caller needs to copy it */
 132 static HRESULT get_declared_prefix_idx(const struct nscontext *ctxt, LONG index, BSTR *prefix)
 133 {
 134     *prefix = NULL;
 135
 136     if (index >= ctxt->count || index < 0) return E_FAIL;
 137
 138     if (index > 0) index = ctxt->count - index;
 139     *prefix = ctxt->ns[index].prefix;
 140
 141     return S_OK;
 142 }
 143
 144 /* returned stored pointer, caller needs to copy it */
 145 static HRESULT get_declared_prefix_uri(const struct list *ctxts, const WCHAR *uri, BSTR *prefix)
 146 {
 147     struct nscontext *ctxt;
 148
 149     LIST_FOR_EACH_ENTRY(ctxt, ctxts, struct nscontext, entry)
 150     {
 151         int i;
 152         for (i = 0; i < ctxt->count; i++)
 153             if (!strcmpW(ctxt->ns[i].uri, uri))
 154             {
 155                 *prefix = ctxt->ns[i].prefix;
 156                 return S_OK;
 157             }
 158     }
 159
 160     *prefix = NULL;
 161     return E_FAIL;
 162 }
 163
 164 static HRESULT get_uri_from_prefix(const struct nscontext *ctxt, const WCHAR *prefix, BSTR *uri)
 165 {
 166     int i;
 167
 168     for (i = 0; i < ctxt->count; i++)
 169         if (!strcmpW(ctxt->ns[i].prefix, prefix))
 170         {
 171             *uri = ctxt->ns[i].uri;
 172             return S_OK;
 173         }
 174
 175     *uri = NULL;
 176     return S_FALSE;
 177 }
 178
 179 static struct nscontext* alloc_ns_context(void)
 180 {
 181     struct nscontext *ctxt;
 182
 183     ctxt = heap_alloc(sizeof(*ctxt));
 184     if (!ctxt) return NULL;
 185
 186     ctxt->count = 0;
 187     ctxt->max_alloc = DEFAULT_PREFIX_ALLOC_COUNT;
 188     ctxt->ns = heap_alloc(ctxt->max_alloc*sizeof(*ctxt->ns));
 189     if (!ctxt->ns)
 190     {
 191         heap_free(ctxt);
 192         return NULL;
 193     }
 194
 195     /* first allocated prefix is always 'xml' */
 196     ctxt->ns[0].prefix = SysAllocString(xmlW);
 197     ctxt->ns[0].uri = SysAllocString(xmluriW);
 198     ctxt->count++;
 199     if (!ctxt->ns[0].prefix || !ctxt->ns[0].uri)
 200     {
 201         heap_free(ctxt->ns);
 202         heap_free(ctxt);
 203         return NULL;
 204     }
 205
 206     return ctxt;
 207 }
 208
 209 static void free_ns_context(struct nscontext *ctxt)
 210 {
 211     int i;
 212
 213     for (i = 0; i < ctxt->count; i++)
 214     {
 215         SysFreeString(ctxt->ns[i].prefix);
 216         SysFreeString(ctxt->ns[i].uri);
 217     }
 218
 219     heap_free(ctxt->ns);
 220     heap_free(ctxt);
 221 }
 222
 223 static HRESULT WINAPI namespacemanager_QueryInterface(IMXNamespaceManager *iface, REFIID riid, void **ppvObject)
 224 {
 225     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 226     return IVBMXNamespaceManager_QueryInterface(&This->IVBMXNamespaceManager_iface, riid, ppvObject);
 227 }
 228
 229 static ULONG WINAPI namespacemanager_AddRef(IMXNamespaceManager *iface)
 230 {
 231     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 232     return IVBMXNamespaceManager_AddRef(&This->IVBMXNamespaceManager_iface);
 233 }
 234
 235 static ULONG WINAPI namespacemanager_Release(IMXNamespaceManager *iface)
 236 {
 237     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 238     return IVBMXNamespaceManager_Release(&This->IVBMXNamespaceManager_iface);
 239 }
 240
 241 static HRESULT WINAPI namespacemanager_putAllowOverride(IMXNamespaceManager *iface,
 242     VARIANT_BOOL override)
 243 {
 244     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 245     return IVBMXNamespaceManager_put_allowOverride(&This->IVBMXNamespaceManager_iface, override);
 246 }
 247
 248 static HRESULT WINAPI namespacemanager_getAllowOverride(IMXNamespaceManager *iface,
 249     VARIANT_BOOL *override)
 250 {
 251     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 252     return IVBMXNamespaceManager_get_allowOverride(&This->IVBMXNamespaceManager_iface, override);
 253 }
 254
 255 static HRESULT WINAPI namespacemanager_reset(IMXNamespaceManager *iface)
 256 {
 257     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 258     return IVBMXNamespaceManager_reset(&This->IVBMXNamespaceManager_iface);
 259 }
 260
 261 static HRESULT WINAPI namespacemanager_pushContext(IMXNamespaceManager *iface)
 262 {
 263     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 264     return IVBMXNamespaceManager_pushContext(&This->IVBMXNamespaceManager_iface);
 265 }
 266
 267 static HRESULT WINAPI namespacemanager_pushNodeContext(IMXNamespaceManager *iface,
 268     IXMLDOMNode *node, VARIANT_BOOL deep)
 269 {
 270     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 271     return IVBMXNamespaceManager_pushNodeContext(&This->IVBMXNamespaceManager_iface, node, deep);
 272 }
 273
 274 static HRESULT WINAPI namespacemanager_popContext(IMXNamespaceManager *iface)
 275 {
 276     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 277     return IVBMXNamespaceManager_popContext(&This->IVBMXNamespaceManager_iface);
 278 }
 279
 280 static HRESULT WINAPI namespacemanager_declarePrefix(IMXNamespaceManager *iface,
 281     const WCHAR *prefix, const WCHAR *namespaceURI)
 282 {
 283     static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
 284
 285     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 286
 287     TRACE("(%p)->(%s %s)\n", This, debugstr_w(prefix), debugstr_w(namespaceURI));
 288
 289     if (prefix && (!strcmpW(prefix, xmlW) || !strcmpW(prefix, xmlnsW) || !namespaceURI))
 290         return E_INVALIDARG;
 291
 292     return declare_prefix(This, prefix, namespaceURI);
 293 }
 294
 295 static HRESULT WINAPI namespacemanager_getDeclaredPrefix(IMXNamespaceManager *iface,
 296     LONG index, WCHAR *prefix, int *prefix_len)
 297 {
 298     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 299     struct nscontext *ctxt;
 300     HRESULT hr;
 301     BSTR prfx;
 302
 303     TRACE("(%p)->(%d %p %p)\n", This, index, prefix, prefix_len);
 304
 305     if (!prefix_len) return E_POINTER;
 306
 307     ctxt = LIST_ENTRY(list_head(&This->ctxts), struct nscontext, entry);
 308     hr = get_declared_prefix_idx(ctxt, index, &prfx);
 309     if (hr != S_OK) return hr;
 310
 311     if (prefix)
 312     {
 313         if (*prefix_len < (INT)SysStringLen(prfx)) return E_XML_BUFFERTOOSMALL;
 314         strcpyW(prefix, prfx);
 315     }
 316
 317     *prefix_len = SysStringLen(prfx);
 318
 319     return S_OK;
 320 }
 321
 322 static HRESULT WINAPI namespacemanager_getPrefix(IMXNamespaceManager *iface,
 323     const WCHAR *uri, LONG index, WCHAR *prefix, int *prefix_len)
 324 {
 325     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 326     HRESULT hr;
 327     BSTR prfx;
 328
 329     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(uri), index, prefix, prefix_len);
 330
 331     if (!uri || !*uri || !prefix_len) return E_INVALIDARG;
 332
 333     hr = get_declared_prefix_uri(&This->ctxts, uri, &prfx);
 334     if (hr == S_OK)
 335     {
 336         /* TODO: figure out what index argument is for */
 337         if (index) return E_FAIL;
 338
 339         if (prefix)
 340         {
 341             if (*prefix_len < (INT)SysStringLen(prfx)) return E_XML_BUFFERTOOSMALL;
 342             strcpyW(prefix, prfx);
 343         }
 344
 345         *prefix_len = SysStringLen(prfx);
 346         TRACE("prefix=%s\n", debugstr_w(prfx));
 347     }
 348
 349     return hr;
 350 }
 351
 352 static HRESULT WINAPI namespacemanager_getURI(IMXNamespaceManager *iface,
 353     const WCHAR *prefix, IXMLDOMNode *node, WCHAR *uri, int *uri_len)
 354 {
 355     namespacemanager *This = impl_from_IMXNamespaceManager( iface );
 356     struct nscontext *ctxt;
 357     HRESULT hr;
 358     BSTR urib;
 359
 360     TRACE("(%p)->(%s %p %p %p)\n", This, debugstr_w(prefix), node, uri, uri_len);
 361
 362     if (!prefix) return E_INVALIDARG;
 363     if (!uri_len) return E_POINTER;
 364
 365     if (node)
 366     {
 367         FIXME("namespaces from DOM node not supported\n");
 368         return E_NOTIMPL;
 369     }
 370
 371     ctxt = LIST_ENTRY(list_head(&This->ctxts), struct nscontext, entry);
 372     hr = get_uri_from_prefix(ctxt, prefix, &urib);
 373     if (hr == S_OK)
 374     {
 375         if (uri)
 376         {
 377            if (*uri_len < (INT)SysStringLen(urib)) return E_XML_BUFFERTOOSMALL;
 378            strcpyW(uri, urib);
 379         }
 380     }
 381     else
 382         if (uri) *uri = 0;
 383
 384     *uri_len = SysStringLen(urib);
 385
 386     return hr;
 387 }
 388
 389 static const struct IMXNamespaceManagerVtbl MXNamespaceManagerVtbl =
 390 {
 391     namespacemanager_QueryInterface,
 392     namespacemanager_AddRef,
 393     namespacemanager_Release,
 394     namespacemanager_putAllowOverride,
 395     namespacemanager_getAllowOverride,
 396     namespacemanager_reset,
 397     namespacemanager_pushContext,
 398     namespacemanager_pushNodeContext,
 399     namespacemanager_popContext,
 400     namespacemanager_declarePrefix,
 401     namespacemanager_getDeclaredPrefix,
 402     namespacemanager_getPrefix,
 403     namespacemanager_getURI
 404 };
 405
 406 static HRESULT WINAPI vbnamespacemanager_QueryInterface(IVBMXNamespaceManager *iface, REFIID riid, void **obj)
 407 {
 408     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 409     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 410
 411     if ( IsEqualGUID( riid, &IID_IMXNamespaceManager) ||
 412          IsEqualGUID( riid, &IID_IUnknown) )
 413     {
 414         *obj = &This->IMXNamespaceManager_iface;
 415     }
 416     else if ( IsEqualGUID( riid, &IID_IVBMXNamespaceManager) ||
 417               IsEqualGUID( riid, &IID_IDispatch) )
 418     {
 419         *obj = &This->IVBMXNamespaceManager_iface;
 420     }
 421     else if (dispex_query_interface(&This->dispex, riid, obj))
 422     {
 423         return *obj ? S_OK : E_NOINTERFACE;
 424     }
 425     else
 426     {
 427         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
 428         *obj = NULL;
 429         return E_NOINTERFACE;
 430     }
 431
 432     IVBMXNamespaceManager_AddRef( iface );
 433
 434     return S_OK;
 435 }
 436
 437 static ULONG WINAPI vbnamespacemanager_AddRef(IVBMXNamespaceManager *iface)
 438 {
 439     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 440     ULONG ref = InterlockedIncrement( &This->ref );
 441     TRACE("(%p)->(%u)\n", This, ref );
 442     return ref;
 443 }
 444
 445 static ULONG WINAPI vbnamespacemanager_Release(IVBMXNamespaceManager *iface)
 446 {
 447     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 448     ULONG ref = InterlockedDecrement( &This->ref );
 449
 450     TRACE("(%p)->(%u)\n", This, ref );
 451
 452     if ( ref == 0 )
 453     {
 454         struct nscontext *ctxt, *ctxt2;
 455
 456         LIST_FOR_EACH_ENTRY_SAFE(ctxt, ctxt2, &This->ctxts, struct nscontext, entry)
 457         {
 458             list_remove(&ctxt->entry);
 459             free_ns_context(ctxt);
 460         }
 461
 462         heap_free( This );
 463     }
 464
 465     return ref;
 466 }
 467
 468 static HRESULT WINAPI vbnamespacemanager_GetTypeInfoCount(IVBMXNamespaceManager *iface, UINT *pctinfo)
 469 {
 470     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 471     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 472 }
 473
 474 static HRESULT WINAPI vbnamespacemanager_GetTypeInfo(IVBMXNamespaceManager *iface, UINT iTInfo,
 475         LCID lcid, ITypeInfo **ppTInfo)
 476 {
 477     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 478     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
 479         iTInfo, lcid, ppTInfo);
 480 }
 481
 482 static HRESULT WINAPI vbnamespacemanager_GetIDsOfNames(IVBMXNamespaceManager *iface, REFIID riid,
 483         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 484 {
 485     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 486     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
 487         riid, rgszNames, cNames, lcid, rgDispId);
 488 }
 489
 490 static HRESULT WINAPI vbnamespacemanager_Invoke(IVBMXNamespaceManager *iface, DISPID dispIdMember, REFIID riid,
 491         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 492         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 493 {
 494     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 495     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
 496         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 497 }
 498
 499 static HRESULT WINAPI vbnamespacemanager_put_allowOverride(IVBMXNamespaceManager *iface,
 500     VARIANT_BOOL override)
 501 {
 502     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 503
 504     TRACE("(%p)->(%d)\n", This, override);
 505     This->override = override;
 506
 507     return S_OK;
 508 }
 509
 510 static HRESULT WINAPI vbnamespacemanager_get_allowOverride(IVBMXNamespaceManager *iface,
 511     VARIANT_BOOL *override)
 512 {
 513     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 514
 515     TRACE("(%p)->(%p)\n", This, override);
 516
 517     if (!override) return E_POINTER;
 518     *override = This->override;
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI vbnamespacemanager_reset(IVBMXNamespaceManager *iface)
 524 {
 525     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 526     FIXME("(%p): stub\n", This);
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI vbnamespacemanager_pushContext(IVBMXNamespaceManager *iface)
 531 {
 532     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 533     struct nscontext *ctxt;
 534
 535     TRACE("(%p)\n", This);
 536
 537     ctxt = alloc_ns_context();
 538     if (!ctxt) return E_OUTOFMEMORY;
 539
 540     list_add_head(&This->ctxts, &ctxt->entry);
 541
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI vbnamespacemanager_pushNodeContext(IVBMXNamespaceManager *iface,
 546     IXMLDOMNode *node, VARIANT_BOOL deep)
 547 {
 548     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 549     FIXME("(%p)->(%p %d): stub\n", This, node, deep);
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI vbnamespacemanager_popContext(IVBMXNamespaceManager *iface)
 554 {
 555     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 556     const struct list *next;
 557     struct nscontext *ctxt;
 558
 559     TRACE("(%p)\n", This);
 560
 561     next = list_next(&This->ctxts, list_head(&This->ctxts));
 562     if (!next) return E_FAIL;
 563
 564     ctxt = LIST_ENTRY(list_head(&This->ctxts), struct nscontext, entry);
 565     list_remove(list_head(&This->ctxts));
 566
 567     free_ns_context(ctxt);
 568
 569     return S_OK;
 570 }
 571
 572 static HRESULT WINAPI vbnamespacemanager_declarePrefix(IVBMXNamespaceManager *iface,
 573     BSTR prefix, BSTR namespaceURI)
 574 {
 575     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 576     return IMXNamespaceManager_declarePrefix(&This->IMXNamespaceManager_iface, prefix, namespaceURI);
 577 }
 578
 579 static HRESULT WINAPI vbnamespacemanager_getDeclaredPrefixes(IVBMXNamespaceManager *iface,
 580     IMXNamespacePrefixes** prefixes)
 581 {
 582     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 583     FIXME("(%p)->(%p): stub\n", This, prefixes);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI vbnamespacemanager_getPrefixes(IVBMXNamespaceManager *iface,
 588     BSTR namespaceURI, IMXNamespacePrefixes** prefixes)
 589 {
 590     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 591     FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(namespaceURI), prefixes);
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI vbnamespacemanager_getURI(IVBMXNamespaceManager *iface,
 596     BSTR prefix, VARIANT* uri)
 597 {
 598     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 599     FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(prefix), uri);
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI vbnamespacemanager_getURIFromNode(IVBMXNamespaceManager *iface,
 604     BSTR prefix, IXMLDOMNode *node, VARIANT *uri)
 605 {
 606     namespacemanager *This = impl_from_IVBMXNamespaceManager( iface );
 607     FIXME("(%p)->(%s %p %p): stub\n", This, debugstr_w(prefix), node, uri);
 608     return E_NOTIMPL;
 609 }
 610
 611 static const struct IVBMXNamespaceManagerVtbl VBMXNamespaceManagerVtbl =
 612 {
 613     vbnamespacemanager_QueryInterface,
 614     vbnamespacemanager_AddRef,
 615     vbnamespacemanager_Release,
 616     vbnamespacemanager_GetTypeInfoCount,
 617     vbnamespacemanager_GetTypeInfo,
 618     vbnamespacemanager_GetIDsOfNames,
 619     vbnamespacemanager_Invoke,
 620     vbnamespacemanager_put_allowOverride,
 621     vbnamespacemanager_get_allowOverride,
 622     vbnamespacemanager_reset,
 623     vbnamespacemanager_pushContext,
 624     vbnamespacemanager_pushNodeContext,
 625     vbnamespacemanager_popContext,
 626     vbnamespacemanager_declarePrefix,
 627     vbnamespacemanager_getDeclaredPrefixes,
 628     vbnamespacemanager_getPrefixes,
 629     vbnamespacemanager_getURI,
 630     vbnamespacemanager_getURIFromNode
 631 };
 632
 633 static const tid_t namespacemanager_iface_tids[] = {
 634     IVBMXNamespaceManager_tid,
 635     0
 636 };
 637
 638 static dispex_static_data_t namespacemanager_dispex = {
 639     NULL,
 640     IVBMXNamespaceManager_tid,
 641     NULL,
 642     namespacemanager_iface_tids
 643 };
 644
 645 HRESULT MXNamespaceManager_create(void **obj)
 646 {
 647     namespacemanager *This;
 648     struct nscontext *ctxt;
 649
 650     TRACE("(%p)\n", obj);
 651
 652     This = heap_alloc( sizeof (*This) );
 653     if( !This )
 654         return E_OUTOFMEMORY;
 655
 656     This->IMXNamespaceManager_iface.lpVtbl = &MXNamespaceManagerVtbl;
 657     This->IVBMXNamespaceManager_iface.lpVtbl = &VBMXNamespaceManagerVtbl;
 658     This->ref = 1;
 659     init_dispex(&This->dispex, (IUnknown*)&This->IVBMXNamespaceManager_iface, &namespacemanager_dispex);
 660
 661     list_init(&This->ctxts);
 662     ctxt = alloc_ns_context();
 663     if (!ctxt)
 664     {
 665         heap_free(This);
 666         return E_OUTOFMEMORY;
 667     }
 668
 669     list_add_head(&This->ctxts, &ctxt->entry);
 670
 671     This->override = VARIANT_TRUE;
 672
 673     *obj = &This->IMXNamespaceManager_iface;
 674
 675     TRACE("returning iface %p\n", *obj);
 676
 677     return S_OK;
 678 }