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