dlls/msxml3/saxreader.c

   1 /*
   2  *    SAX Reader implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   5  * Copyright 2008 Piotr Caban
   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 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33 #include "wininet.h"
  34 #include "urlmon.h"
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "wine/debug.h"
  39
  40 #include "msxml_private.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 #include <libxml/SAX2.h>
  47 #include <libxml/parserInternals.h>
  48
  49 typedef struct _saxreader
  50 {
  51     const struct IVBSAXXMLReaderVtbl *lpVBSAXXMLReaderVtbl;
  52     const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
  53     LONG ref;
  54     struct ISAXContentHandler *contentHandler;
  55     struct IVBSAXContentHandler *vbcontentHandler;
  56     struct ISAXErrorHandler *errorHandler;
  57     struct IVBSAXErrorHandler *vberrorHandler;
  58     xmlSAXHandler sax;
  59 } saxreader;
  60
  61 typedef struct _saxlocator
  62 {
  63     const struct IVBSAXLocatorVtbl *lpVBSAXLocatorVtbl;
  64     const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
  65     LONG ref;
  66     saxreader *saxreader;
  67     HRESULT ret;
  68     xmlParserCtxtPtr pParserCtxt;
  69     WCHAR *publicId;
  70     WCHAR *systemId;
  71     xmlChar *lastCur;
  72     int line;
  73     int column;
  74     BOOL vbInterface;
  75     int nsStackSize;
  76     int nsStackLast;
  77     int *nsStack;
  78 } saxlocator;
  79
  80 typedef struct _saxattributes
  81 {
  82     const struct IVBSAXAttributesVtbl *lpVBSAXAttributesVtbl;
  83     const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
  84     LONG ref;
  85     int nb_attributes;
  86     BSTR *szLocalname;
  87     BSTR *szURI;
  88     BSTR *szValue;
  89     BSTR *szQName;
  90 } saxattributes;
  91
  92 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  93 {
  94     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVBSAXXMLReaderVtbl));
  95 }
  96
  97 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  98 {
  99     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
 100 }
 101
 102 static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
 103 {
 104     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpVBSAXLocatorVtbl));
 105 }
 106
 107 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
 108 {
 109     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
 110 }
 111
 112 static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
 113 {
 114     return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpVBSAXAttributesVtbl));
 115 }
 116
 117 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
 118 {
 119     return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
 120 }
 121
 122
 123 static HRESULT namespacePush(saxlocator *locator, int ns)
 124 {
 125     if(locator->nsStackLast>=locator->nsStackSize)
 126     {
 127         int *new_stack;
 128
 129         new_stack = HeapReAlloc(GetProcessHeap(), 0,
 130                 locator->nsStack, locator->nsStackSize*2);
 131         if(!new_stack) return E_OUTOFMEMORY;
 132         locator->nsStack = new_stack;
 133         locator->nsStackSize *= 2;
 134     }
 135     locator->nsStack[locator->nsStackLast++] = ns;
 136
 137     return S_OK;
 138 }
 139
 140 static int namespacePop(saxlocator *locator)
 141 {
 142     if(locator->nsStackLast == 0) return 0;
 143     return locator->nsStack[--locator->nsStackLast];
 144 }
 145
 146 static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
 147 {
 148     DWORD dLen;
 149     LPWSTR str;
 150     BSTR bstr;
 151
 152     if (!buf)
 153         return NULL;
 154
 155     dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
 156     if(len != -1) dLen++;
 157     str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, dLen * sizeof (WCHAR));
 158     if (!str)
 159         return NULL;
 160     MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, str, dLen);
 161     if(len != -1) str[dLen-1] = '\0';
 162     bstr = SysAllocString(str);
 163     HeapFree(GetProcessHeap(), 0, str);
 164
 165     return bstr;
 166 }
 167
 168 static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
 169 {
 170     DWORD dLen, dLast;
 171     LPWSTR str;
 172     BSTR bstr;
 173
 174     if(!name) return NULL;
 175
 176     if(!prefix || *prefix=='\0')
 177         return bstr_from_xmlChar(name);
 178
 179     dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, NULL, 0)
 180         + MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, NULL, 0);
 181     str = HeapAlloc(GetProcessHeap(), 0, dLen * sizeof(WCHAR));
 182     if(!str)
 183         return NULL;
 184
 185     dLast = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, str, dLen);
 186     str[dLast-1] = ':';
 187     MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &str[dLast], dLen-dLast);
 188     bstr = SysAllocString(str);
 189
 190     HeapFree(GetProcessHeap(), 0, str);
 191
 192     return bstr;
 193 }
 194
 195 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
 196 {
 197     xmlStopParser(This->pParserCtxt);
 198     This->ret = hr;
 199
 200     if(This->saxreader->errorHandler)
 201     {
 202         WCHAR msg[1024];
 203         if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
 204                     NULL, hr, 0, msg, sizeof(msg), NULL))
 205         {
 206             FIXME("MSXML errors not yet supported.\n");
 207             msg[0] = '\0';
 208         }
 209
 210         if(This->vbInterface)
 211         {
 212             BSTR bstrMsg = SysAllocString(msg);
 213             IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
 214                     (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrMsg, hr);
 215         }
 216         else
 217             ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 218                     (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
 219     }
 220 }
 221
 222 static void update_position(saxlocator *This, xmlChar *end)
 223 {
 224     if(This->lastCur == NULL)
 225     {
 226         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 227         This->line = 1;
 228         This->column = 1;
 229     }
 230     else if(This->lastCur < This->pParserCtxt->input->base)
 231     {
 232         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 233         This->line = 1;
 234         This->column = 1;
 235     }
 236
 237     if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
 238
 239     while(This->lastCur < end)
 240     {
 241         if(*(This->lastCur) == '\n')
 242         {
 243             This->line++;
 244             This->column = 1;
 245         }
 246         else if(*(This->lastCur) == '\r' && (This->lastCur==This->pParserCtxt->input->end || *(This->lastCur+1)!='\n'))
 247         {
 248             This->line++;
 249             This->column = 1;
 250         }
 251         else This->column++;
 252
 253         This->lastCur++;
 254     }
 255 }
 256
 257 /*** IVBSAXAttributes interface ***/
 258 /*** IUnknown methods ***/
 259 static HRESULT WINAPI ivbsaxattributes_QueryInterface(
 260         IVBSAXAttributes* iface,
 261         REFIID riid,
 262         void **ppvObject)
 263 {
 264     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 265
 266     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 267
 268     *ppvObject = NULL;
 269
 270     if (IsEqualGUID(riid, &IID_IUnknown) ||
 271             IsEqualGUID(riid, &IID_IDispatch) ||
 272             IsEqualGUID(riid, &IID_IVBSAXAttributes))
 273     {
 274         *ppvObject = iface;
 275     }
 276     else
 277     {
 278         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 279         return E_NOINTERFACE;
 280     }
 281
 282     IVBSAXAttributes_AddRef(iface);
 283
 284     return S_OK;
 285 }
 286
 287 static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
 288 {
 289     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 290     return ISAXAttributes_AddRef((ISAXAttributes*)&This->lpSAXAttributesVtbl);
 291 }
 292
 293 static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
 294 {
 295     saxattributes *This = impl_from_IVBSAXAttributes(iface);
 296     return ISAXAttributes_Release((ISAXAttributes*)&This->lpSAXAttributesVtbl);
 297 }
 298
 299 /*** IDispatch methods ***/
 300 static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
 301 {
 302     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 303
 304     TRACE("(%p)->(%p)\n", This, pctinfo);
 305
 306     *pctinfo = 1;
 307
 308     return S_OK;
 309 }
 310
 311 static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
 312     IVBSAXAttributes *iface,
 313     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 314 {
 315     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 316     HRESULT hr;
 317
 318     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 319
 320     hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
 321
 322     return hr;
 323 }
 324
 325 static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
 326     IVBSAXAttributes *iface,
 327     REFIID riid,
 328     LPOLESTR* rgszNames,
 329     UINT cNames,
 330     LCID lcid,
 331     DISPID* rgDispId)
 332 {
 333     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 334     ITypeInfo *typeinfo;
 335     HRESULT hr;
 336
 337     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 338           lcid, rgDispId);
 339
 340     if(!rgszNames || cNames == 0 || !rgDispId)
 341         return E_INVALIDARG;
 342
 343     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
 344     if(SUCCEEDED(hr))
 345     {
 346         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 347         ITypeInfo_Release(typeinfo);
 348     }
 349
 350     return hr;
 351 }
 352
 353 static HRESULT WINAPI ivbsaxattributes_Invoke(
 354     IVBSAXAttributes *iface,
 355     DISPID dispIdMember,
 356     REFIID riid,
 357     LCID lcid,
 358     WORD wFlags,
 359     DISPPARAMS* pDispParams,
 360     VARIANT* pVarResult,
 361     EXCEPINFO* pExcepInfo,
 362     UINT* puArgErr)
 363 {
 364     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 365     ITypeInfo *typeinfo;
 366     HRESULT hr;
 367
 368     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 369           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 370
 371     hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
 372     if(SUCCEEDED(hr))
 373     {
 374         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXAttributesVtbl), dispIdMember, wFlags, pDispParams,
 375                 pVarResult, pExcepInfo, puArgErr);
 376         ITypeInfo_Release(typeinfo);
 377     }
 378
 379     return hr;
 380 }
 381
 382 /*** IVBSAXAttributes methods ***/
 383 static HRESULT WINAPI ivbsaxattributes_get_length(
 384         IVBSAXAttributes* iface,
 385         int *nLength)
 386 {
 387     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 388     return ISAXAttributes_getLength(
 389             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 390             nLength);
 391 }
 392
 393 static HRESULT WINAPI ivbsaxattributes_getURI(
 394         IVBSAXAttributes* iface,
 395         int nIndex,
 396         BSTR *uri)
 397 {
 398     int len;
 399     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 400     return ISAXAttributes_getURI(
 401             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 402             nIndex, (const WCHAR**)uri, &len);
 403 }
 404
 405 static HRESULT WINAPI ivbsaxattributes_getLocalName(
 406         IVBSAXAttributes* iface,
 407         int nIndex,
 408         BSTR *localName)
 409 {
 410     int len;
 411     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 412     return ISAXAttributes_getLocalName(
 413             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 414             nIndex, (const WCHAR**)localName, &len);
 415 }
 416
 417 static HRESULT WINAPI ivbsaxattributes_getQName(
 418         IVBSAXAttributes* iface,
 419         int nIndex,
 420         BSTR *QName)
 421 {
 422     int len;
 423     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 424     return ISAXAttributes_getQName(
 425             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 426             nIndex, (const WCHAR**)QName, &len);
 427 }
 428
 429 static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
 430         IVBSAXAttributes* iface,
 431         BSTR uri,
 432         BSTR localName,
 433         int *index)
 434 {
 435     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 436     return ISAXAttributes_getIndexFromName(
 437             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 438             (const WCHAR*)uri, SysStringLen(uri),
 439             (const WCHAR*)localName, SysStringLen(localName), index);
 440 }
 441
 442 static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
 443         IVBSAXAttributes* iface,
 444         BSTR QName,
 445         int *index)
 446 {
 447     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 448     return ISAXAttributes_getIndexFromQName(
 449             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 450             (const WCHAR*)QName, SysStringLen(QName), index);
 451 }
 452
 453 static HRESULT WINAPI ivbsaxattributes_getType(
 454         IVBSAXAttributes* iface,
 455         int nIndex,
 456         BSTR *type)
 457 {
 458     int len;
 459     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 460     return ISAXAttributes_getType(
 461             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 462             nIndex, (const WCHAR**)type, &len);
 463 }
 464
 465 static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
 466         IVBSAXAttributes* iface,
 467         BSTR uri,
 468         BSTR localName,
 469         BSTR *type)
 470 {
 471     int len;
 472     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 473     return ISAXAttributes_getTypeFromName(
 474             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 475             (const WCHAR*)uri, SysStringLen(uri),
 476             (const WCHAR*)localName, SysStringLen(localName),
 477             (const WCHAR**)type, &len);
 478 }
 479
 480 static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
 481         IVBSAXAttributes* iface,
 482         BSTR QName,
 483         BSTR *type)
 484 {
 485     int len;
 486     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 487     return ISAXAttributes_getTypeFromQName(
 488             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 489             (const WCHAR*)QName, SysStringLen(QName),
 490             (const WCHAR**)type, &len);
 491 }
 492
 493 static HRESULT WINAPI ivbsaxattributes_getValue(
 494         IVBSAXAttributes* iface,
 495         int nIndex,
 496         BSTR *value)
 497 {
 498     int len;
 499     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 500     return ISAXAttributes_getValue(
 501             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 502             nIndex, (const WCHAR**)value, &len);
 503 }
 504
 505 static HRESULT WINAPI ivbsaxattributes_getValueFromName(
 506         IVBSAXAttributes* iface,
 507         BSTR uri,
 508         BSTR localName,
 509         BSTR *value)
 510 {
 511     int len;
 512     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 513     return ISAXAttributes_getValueFromName(
 514             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 515             (const WCHAR*)uri, SysStringLen(uri),
 516             (const WCHAR*)localName, SysStringLen(localName),
 517             (const WCHAR**)value, &len);
 518 }
 519
 520 static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
 521         IVBSAXAttributes* iface,
 522         BSTR QName,
 523         BSTR *value)
 524 {
 525     int len;
 526     saxattributes *This = impl_from_IVBSAXAttributes( iface );
 527     return ISAXAttributes_getValueFromQName(
 528             (ISAXAttributes*)&This->lpSAXAttributesVtbl,
 529             (const WCHAR*)QName, SysStringLen(QName),
 530             (const WCHAR**)value, &len);
 531 }
 532
 533 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
 534 {
 535     ivbsaxattributes_QueryInterface,
 536     ivbsaxattributes_AddRef,
 537     ivbsaxattributes_Release,
 538     ivbsaxattributes_GetTypeInfoCount,
 539     ivbsaxattributes_GetTypeInfo,
 540     ivbsaxattributes_GetIDsOfNames,
 541     ivbsaxattributes_Invoke,
 542     ivbsaxattributes_get_length,
 543     ivbsaxattributes_getURI,
 544     ivbsaxattributes_getLocalName,
 545     ivbsaxattributes_getQName,
 546     ivbsaxattributes_getIndexFromName,
 547     ivbsaxattributes_getIndexFromQName,
 548     ivbsaxattributes_getType,
 549     ivbsaxattributes_getTypeFromName,
 550     ivbsaxattributes_getTypeFromQName,
 551     ivbsaxattributes_getValue,
 552     ivbsaxattributes_getValueFromName,
 553     ivbsaxattributes_getValueFromQName
 554 };
 555
 556 /*** ISAXAttributes interface ***/
 557 /*** IUnknown methods ***/
 558 static HRESULT WINAPI isaxattributes_QueryInterface(
 559         ISAXAttributes* iface,
 560         REFIID riid,
 561         void **ppvObject)
 562 {
 563     saxattributes *This = impl_from_ISAXAttributes(iface);
 564
 565     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 566
 567     *ppvObject = NULL;
 568
 569     if (IsEqualGUID(riid, &IID_IUnknown) ||
 570             IsEqualGUID(riid, &IID_ISAXAttributes))
 571     {
 572         *ppvObject = iface;
 573     }
 574     else
 575     {
 576         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 577         return E_NOINTERFACE;
 578     }
 579
 580     ISAXAttributes_AddRef(iface);
 581
 582     return S_OK;
 583 }
 584
 585 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
 586 {
 587     saxattributes *This = impl_from_ISAXAttributes(iface);
 588     TRACE("%p\n", This);
 589     return InterlockedIncrement(&This->ref);
 590 }
 591
 592 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
 593 {
 594     saxattributes *This = impl_from_ISAXAttributes(iface);
 595     LONG ref;
 596
 597     TRACE("%p\n", This);
 598
 599     ref = InterlockedDecrement(&This->ref);
 600     if (ref==0)
 601     {
 602         int index;
 603         for(index=0; index<This->nb_attributes; index++)
 604         {
 605             SysFreeString(This->szLocalname[index]);
 606             SysFreeString(This->szURI[index]);
 607             SysFreeString(This->szValue[index]);
 608             SysFreeString(This->szQName[index]);
 609         }
 610
 611         HeapFree(GetProcessHeap(), 0, This->szLocalname);
 612         HeapFree(GetProcessHeap(), 0, This->szURI);
 613         HeapFree(GetProcessHeap(), 0, This->szValue);
 614         HeapFree(GetProcessHeap(), 0, This->szQName);
 615
 616         HeapFree(GetProcessHeap(), 0, This);
 617     }
 618
 619     return ref;
 620 }
 621
 622 /*** ISAXAttributes methods ***/
 623 static HRESULT WINAPI isaxattributes_getLength(
 624         ISAXAttributes* iface,
 625         int *length)
 626 {
 627     saxattributes *This = impl_from_ISAXAttributes( iface );
 628
 629     *length = This->nb_attributes;
 630     TRACE("Length set to %d\n", *length);
 631     return S_OK;
 632 }
 633
 634 static HRESULT WINAPI isaxattributes_getURI(
 635         ISAXAttributes* iface,
 636         int nIndex,
 637         const WCHAR **pUrl,
 638         int *pUriSize)
 639 {
 640     saxattributes *This = impl_from_ISAXAttributes( iface );
 641     TRACE("(%p)->(%d)\n", This, nIndex);
 642
 643     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 644     if(!pUrl || !pUriSize) return E_POINTER;
 645
 646     *pUriSize = SysStringLen(This->szURI[nIndex]);
 647     *pUrl = This->szURI[nIndex];
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI isaxattributes_getLocalName(
 653         ISAXAttributes* iface,
 654         int nIndex,
 655         const WCHAR **pLocalName,
 656         int *pLocalNameLength)
 657 {
 658     saxattributes *This = impl_from_ISAXAttributes( iface );
 659     TRACE("(%p)->(%d)\n", This, nIndex);
 660
 661     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 662     if(!pLocalName || !pLocalNameLength) return E_POINTER;
 663
 664     *pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
 665     *pLocalName = This->szLocalname[nIndex];
 666
 667     return S_OK;
 668 }
 669
 670 static HRESULT WINAPI isaxattributes_getQName(
 671         ISAXAttributes* iface,
 672         int nIndex,
 673         const WCHAR **pQName,
 674         int *pQNameLength)
 675 {
 676     saxattributes *This = impl_from_ISAXAttributes( iface );
 677     TRACE("(%p)->(%d)\n", This, nIndex);
 678
 679     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 680     if(!pQName || !pQNameLength) return E_POINTER;
 681
 682     *pQNameLength = SysStringLen(This->szQName[nIndex]);
 683     *pQName = This->szQName[nIndex];
 684
 685     return S_OK;
 686 }
 687
 688 static HRESULT WINAPI isaxattributes_getName(
 689         ISAXAttributes* iface,
 690         int nIndex,
 691         const WCHAR **pUri,
 692         int *pUriLength,
 693         const WCHAR **pLocalName,
 694         int *pLocalNameSize,
 695         const WCHAR **pQName,
 696         int *pQNameLength)
 697 {
 698     saxattributes *This = impl_from_ISAXAttributes( iface );
 699     TRACE("(%p)->(%d)\n", This, nIndex);
 700
 701     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 702     if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
 703             || !pQName || !pQNameLength) return E_POINTER;
 704
 705     *pUriLength = SysStringLen(This->szURI[nIndex]);
 706     *pUri = This->szURI[nIndex];
 707     *pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
 708     *pLocalName = This->szLocalname[nIndex];
 709     *pQNameLength = SysStringLen(This->szQName[nIndex]);
 710     *pQName = This->szQName[nIndex];
 711
 712     return S_OK;
 713 }
 714
 715 static HRESULT WINAPI isaxattributes_getIndexFromName(
 716         ISAXAttributes* iface,
 717         const WCHAR *pUri,
 718         int cUriLength,
 719         const WCHAR *pLocalName,
 720         int cocalNameLength,
 721         int *index)
 722 {
 723     saxattributes *This = impl_from_ISAXAttributes( iface );
 724     int i;
 725     TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
 726             debugstr_w(pLocalName), cocalNameLength);
 727
 728     if(!pUri || !pLocalName || !index) return E_POINTER;
 729
 730     for(i=0; i<This->nb_attributes; i++)
 731     {
 732         if(cUriLength!=SysStringLen(This->szURI[i])
 733                 || cocalNameLength!=SysStringLen(This->szLocalname[i]))
 734             continue;
 735         if(cUriLength && memcmp(pUri, This->szURI[i],
 736                     sizeof(WCHAR)*cUriLength))
 737             continue;
 738         if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
 739                     sizeof(WCHAR)*cocalNameLength))
 740             continue;
 741
 742         *index = i;
 743         return S_OK;
 744     }
 745
 746     return E_INVALIDARG;
 747 }
 748
 749 static HRESULT WINAPI isaxattributes_getIndexFromQName(
 750         ISAXAttributes* iface,
 751         const WCHAR *pQName,
 752         int nQNameLength,
 753         int *index)
 754 {
 755     saxattributes *This = impl_from_ISAXAttributes( iface );
 756
 757     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQNameLength);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI isaxattributes_getType(
 762         ISAXAttributes* iface,
 763         int nIndex,
 764         const WCHAR **pType,
 765         int *pTypeLength)
 766 {
 767     saxattributes *This = impl_from_ISAXAttributes( iface );
 768
 769     FIXME("(%p)->(%d) stub\n", This, nIndex);
 770     return E_NOTIMPL;
 771 }
 772
 773 static HRESULT WINAPI isaxattributes_getTypeFromName(
 774         ISAXAttributes* iface,
 775         const WCHAR *pUri,
 776         int nUri,
 777         const WCHAR *pLocalName,
 778         int nLocalName,
 779         const WCHAR **pType,
 780         int *nType)
 781 {
 782     saxattributes *This = impl_from_ISAXAttributes( iface );
 783
 784     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
 785             debugstr_w(pLocalName), nLocalName);
 786     return E_NOTIMPL;
 787 }
 788
 789 static HRESULT WINAPI isaxattributes_getTypeFromQName(
 790         ISAXAttributes* iface,
 791         const WCHAR *pQName,
 792         int nQName,
 793         const WCHAR **pType,
 794         int *nType)
 795 {
 796     saxattributes *This = impl_from_ISAXAttributes( iface );
 797
 798     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI isaxattributes_getValue(
 803         ISAXAttributes* iface,
 804         int nIndex,
 805         const WCHAR **pValue,
 806         int *nValue)
 807 {
 808     saxattributes *This = impl_from_ISAXAttributes( iface );
 809     TRACE("(%p)->(%d)\n", This, nIndex);
 810
 811     if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
 812     if(!pValue || !nValue) return E_POINTER;
 813
 814     *nValue = SysStringLen(This->szValue[nIndex]);
 815     *pValue = This->szValue[nIndex];
 816
 817     return S_OK;
 818 }
 819
 820 static HRESULT WINAPI isaxattributes_getValueFromName(
 821         ISAXAttributes* iface,
 822         const WCHAR *pUri,
 823         int nUri,
 824         const WCHAR *pLocalName,
 825         int nLocalName,
 826         const WCHAR **pValue,
 827         int *nValue)
 828 {
 829     saxattributes *This = impl_from_ISAXAttributes( iface );
 830
 831     FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
 832             debugstr_w(pLocalName), nLocalName);
 833     return E_NOTIMPL;
 834 }
 835
 836 static HRESULT WINAPI isaxattributes_getValueFromQName(
 837         ISAXAttributes* iface,
 838         const WCHAR *pQName,
 839         int nQName,
 840         const WCHAR **pValue,
 841         int *nValue)
 842 {
 843     saxattributes *This = impl_from_ISAXAttributes( iface );
 844
 845     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
 846     return E_NOTIMPL;
 847 }
 848
 849 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
 850 {
 851     isaxattributes_QueryInterface,
 852     isaxattributes_AddRef,
 853     isaxattributes_Release,
 854     isaxattributes_getLength,
 855     isaxattributes_getURI,
 856     isaxattributes_getLocalName,
 857     isaxattributes_getQName,
 858     isaxattributes_getName,
 859     isaxattributes_getIndexFromName,
 860     isaxattributes_getIndexFromQName,
 861     isaxattributes_getType,
 862     isaxattributes_getTypeFromName,
 863     isaxattributes_getTypeFromQName,
 864     isaxattributes_getValue,
 865     isaxattributes_getValueFromName,
 866     isaxattributes_getValueFromQName
 867 };
 868
 869 static HRESULT SAXAttributes_create(saxattributes **attr,
 870         int nb_namespaces, const xmlChar **xmlNamespaces,
 871         int nb_attributes, const xmlChar **xmlAttributes)
 872 {
 873     saxattributes *attributes;
 874     int index;
 875     static const xmlChar xmlns[] = "xmlns";
 876
 877     attributes = HeapAlloc(GetProcessHeap(), 0, sizeof(*attributes));
 878     if(!attributes)
 879         return E_OUTOFMEMORY;
 880
 881     attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
 882     attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
 883     attributes->ref = 1;
 884
 885     attributes->nb_attributes = nb_namespaces+nb_attributes;
 886
 887     attributes->szLocalname =
 888         HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
 889     attributes->szURI =
 890         HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
 891     attributes->szValue =
 892         HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
 893     attributes->szQName =
 894         HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
 895
 896     if(!attributes->szLocalname || !attributes->szURI
 897             || !attributes->szValue || !attributes->szQName)
 898     {
 899         HeapFree(GetProcessHeap(), 0, attributes->szLocalname);
 900         HeapFree(GetProcessHeap(), 0, attributes->szURI);
 901         HeapFree(GetProcessHeap(), 0, attributes->szValue);
 902         HeapFree(GetProcessHeap(), 0, attributes->szQName);
 903         HeapFree(GetProcessHeap(), 0, attributes);
 904         return E_FAIL;
 905     }
 906
 907     for(index=0; index<nb_namespaces; index++)
 908     {
 909         attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
 910         attributes->szURI[index] = SysAllocStringLen(NULL, 0);
 911         attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
 912         attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
 913     }
 914
 915     for(index=0; index<nb_attributes; index++)
 916     {
 917         attributes->szLocalname[nb_namespaces+index] =
 918             bstr_from_xmlChar(xmlAttributes[index*5]);
 919         attributes->szURI[nb_namespaces+index] =
 920             bstr_from_xmlChar(xmlAttributes[index*5+2]);
 921         attributes->szValue[nb_namespaces+index] =
 922             bstr_from_xmlCharN(xmlAttributes[index*5+3],
 923                     xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
 924         attributes->szQName[nb_namespaces+index] =
 925             QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
 926     }
 927
 928     *attr = attributes;
 929
 930     TRACE("returning %p\n", *attr);
 931
 932     return S_OK;
 933 }
 934
 935 /*** LibXML callbacks ***/
 936 static void libxmlStartDocument(void *ctx)
 937 {
 938     saxlocator *This = ctx;
 939     HRESULT hr;
 940
 941     if((This->vbInterface && This->saxreader->vbcontentHandler)
 942             || (!This->vbInterface && This->saxreader->contentHandler))
 943     {
 944         if(This->vbInterface)
 945             hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
 946         else
 947             hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
 948
 949         if(hr != S_OK)
 950             format_error_message_from_id(This, hr);
 951     }
 952
 953     update_position(This, NULL);
 954 }
 955
 956 static void libxmlEndDocument(void *ctx)
 957 {
 958     saxlocator *This = ctx;
 959     HRESULT hr;
 960
 961     This->column = 0;
 962     This->line = 0;
 963
 964     if(This->ret != S_OK) return;
 965
 966     if((This->vbInterface && This->saxreader->vbcontentHandler)
 967             || (!This->vbInterface && This->saxreader->contentHandler))
 968     {
 969         if(This->vbInterface)
 970             hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
 971         else
 972             hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
 973
 974         if(hr != S_OK)
 975             format_error_message_from_id(This, hr);
 976     }
 977 }
 978
 979 static void libxmlStartElementNS(
 980         void *ctx,
 981         const xmlChar *localname,
 982         const xmlChar *prefix,
 983         const xmlChar *URI,
 984         int nb_namespaces,
 985         const xmlChar **namespaces,
 986         int nb_attributes,
 987         int nb_defaulted,
 988         const xmlChar **attributes)
 989 {
 990     BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
 991     saxlocator *This = ctx;
 992     HRESULT hr;
 993     saxattributes *attr;
 994     int index;
 995
 996     update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
 997
 998     hr = namespacePush(This, nb_namespaces);
 999     if(hr==S_OK && ((This->vbInterface && This->saxreader->vbcontentHandler)
1000                 || (!This->vbInterface && This->saxreader->contentHandler)))
1001     {
1002         for(index=0; index<nb_namespaces; index++)
1003         {
1004             Prefix = bstr_from_xmlChar(namespaces[2*index]);
1005             Uri = bstr_from_xmlChar(namespaces[2*index+1]);
1006
1007             if(This->vbInterface)
1008                 hr = IVBSAXContentHandler_startPrefixMapping(
1009                         This->saxreader->vbcontentHandler,
1010                         &Prefix, &Uri);
1011             else
1012                 hr = ISAXContentHandler_startPrefixMapping(
1013                         This->saxreader->contentHandler,
1014                         Prefix, SysStringLen(Prefix),
1015                         Uri, SysStringLen(Uri));
1016
1017             SysFreeString(Prefix);
1018             SysFreeString(Uri);
1019
1020             if(hr != S_OK)
1021             {
1022                 format_error_message_from_id(This, hr);
1023                 return;
1024             }
1025         }
1026
1027         NamespaceUri = bstr_from_xmlChar(URI);
1028         LocalName = bstr_from_xmlChar(localname);
1029         QName = QName_from_xmlChar(prefix, localname);
1030
1031         hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
1032         if(hr == S_OK)
1033         {
1034             if(This->vbInterface)
1035                 hr = IVBSAXContentHandler_startElement(
1036                         This->saxreader->vbcontentHandler,
1037                         &NamespaceUri, &LocalName, &QName,
1038                         (IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
1039             else
1040                 hr = ISAXContentHandler_startElement(
1041                         This->saxreader->contentHandler,
1042                         NamespaceUri, SysStringLen(NamespaceUri),
1043                         LocalName, SysStringLen(LocalName),
1044                         QName, SysStringLen(QName),
1045                         (ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1046
1047             ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1048         }
1049
1050         SysFreeString(NamespaceUri);
1051         SysFreeString(LocalName);
1052         SysFreeString(QName);
1053     }
1054
1055     if(hr != S_OK)
1056         format_error_message_from_id(This, hr);
1057 }
1058
1059 static void libxmlEndElementNS(
1060         void *ctx,
1061         const xmlChar *localname,
1062         const xmlChar *prefix,
1063         const xmlChar *URI)
1064 {
1065     BSTR NamespaceUri, LocalName, QName, Prefix;
1066     saxlocator *This = ctx;
1067     HRESULT hr;
1068     xmlChar *end;
1069     int nsNr, index;
1070
1071     end = This->lastCur;
1072     while(*end != '<' && *(end+1) != '/') end++;
1073     update_position(This, end+2);
1074
1075     nsNr = namespacePop(This);
1076
1077     if((This->vbInterface && This->saxreader->vbcontentHandler)
1078             || (!This->vbInterface && This->saxreader->contentHandler))
1079     {
1080         NamespaceUri = bstr_from_xmlChar(URI);
1081         LocalName = bstr_from_xmlChar(localname);
1082         QName = QName_from_xmlChar(prefix, localname);
1083
1084         if(This->vbInterface)
1085             hr = IVBSAXContentHandler_endElement(
1086                     This->saxreader->vbcontentHandler,
1087                     &NamespaceUri, &LocalName, &QName);
1088         else
1089             hr = ISAXContentHandler_endElement(
1090                     This->saxreader->contentHandler,
1091                     NamespaceUri, SysStringLen(NamespaceUri),
1092                     LocalName, SysStringLen(LocalName),
1093                     QName, SysStringLen(QName));
1094
1095         SysFreeString(NamespaceUri);
1096         SysFreeString(LocalName);
1097         SysFreeString(QName);
1098
1099         if(hr != S_OK)
1100         {
1101             format_error_message_from_id(This, hr);
1102             return;
1103         }
1104
1105         for(index=This->pParserCtxt->nsNr-2;
1106                 index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
1107         {
1108             Prefix = bstr_from_xmlChar(This->pParserCtxt->nsTab[index]);
1109
1110             if(This->vbInterface)
1111                 hr = IVBSAXContentHandler_endPrefixMapping(
1112                         This->saxreader->vbcontentHandler, &Prefix);
1113             else
1114                 hr = ISAXContentHandler_endPrefixMapping(
1115                         This->saxreader->contentHandler,
1116                         Prefix, SysStringLen(Prefix));
1117
1118             SysFreeString(Prefix);
1119         }
1120     }
1121 }
1122
1123 static void libxmlCharacters(
1124         void *ctx,
1125         const xmlChar *ch,
1126         int len)
1127 {
1128     BSTR Chars;
1129     saxlocator *This = ctx;
1130     HRESULT hr;
1131     xmlChar *end;
1132     xmlChar *lastCurCopy;
1133     xmlChar *chEnd;
1134     int columnCopy;
1135     int lineCopy;
1136
1137     if(*(This->lastCur-1) != '>' && *(This->lastCur-1) != '/') return;
1138
1139     if(*(This->lastCur-1) != '>')
1140     {
1141         end = (xmlChar*)This->pParserCtxt->input->cur-len;
1142         while(*(end-1) != '>') end--;
1143         update_position(This, end);
1144     }
1145
1146     chEnd = This->lastCur+len;
1147     while(*chEnd != '<') chEnd++;
1148
1149     Chars = bstr_from_xmlChar(ch);
1150
1151     lastCurCopy = This->lastCur;
1152     columnCopy = This->column;
1153     lineCopy = This->line;
1154     end = This->lastCur;
1155
1156     if((This->vbInterface && This->saxreader->vbcontentHandler)
1157             || (!This->vbInterface && This->saxreader->contentHandler))
1158     {
1159         while(This->lastCur < chEnd)
1160         {
1161             end = This->lastCur;
1162             while(end < chEnd-1)
1163             {
1164                 if(*end == '\r') break;
1165                 end++;
1166             }
1167
1168             Chars = bstr_from_xmlChar(This->lastCur);
1169
1170             if(*end == '\r' && *(end+1) == '\n')
1171             {
1172                 memmove((WCHAR*)Chars+(end-This->lastCur),
1173                         (WCHAR*)Chars+(end-This->lastCur)+1,
1174                         (SysStringLen(Chars)-(end-This->lastCur))*sizeof(WCHAR));
1175                 SysReAllocStringLen(&Chars, Chars, SysStringLen(Chars)-1);
1176             }
1177             else if(*end == '\r') Chars[end-This->lastCur] = '\n';
1178
1179             if(This->vbInterface)
1180                 hr = IVBSAXContentHandler_characters(
1181                         This->saxreader->vbcontentHandler, &Chars);
1182             else
1183                 hr = ISAXContentHandler_characters(
1184                         This->saxreader->contentHandler,
1185                         Chars, end-This->lastCur+1);
1186
1187             SysFreeString(Chars);
1188             if(hr != S_OK)
1189             {
1190                 format_error_message_from_id(This, hr);
1191                 return;
1192             }
1193
1194             if(*(end+1) == '\n') end++;
1195             if(end < chEnd) end++;
1196
1197             This->column += end-This->lastCur;
1198             This->lastCur = end;
1199         }
1200
1201         This->lastCur = lastCurCopy;
1202         This->column = columnCopy;
1203         This->line = lineCopy;
1204         update_position(This, chEnd);
1205     }
1206 }
1207
1208 static void libxmlSetDocumentLocator(
1209         void *ctx,
1210         xmlSAXLocatorPtr loc)
1211 {
1212     saxlocator *This = ctx;
1213     HRESULT hr;
1214
1215     if(This->vbInterface)
1216         hr = IVBSAXContentHandler_putref_documentLocator(
1217                 This->saxreader->vbcontentHandler,
1218                 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
1219     else
1220         hr = ISAXContentHandler_putDocumentLocator(
1221                 This->saxreader->contentHandler,
1222                 (ISAXLocator*)&This->lpSAXLocatorVtbl);
1223
1224     if(FAILED(hr))
1225         format_error_message_from_id(This, hr);
1226 }
1227
1228 void libxmlFatalError(void *ctx, const char *msg, ...)
1229 {
1230     saxlocator *This = ctx;
1231     char message[1024];
1232     WCHAR *wszError;
1233     DWORD len;
1234     va_list args;
1235
1236     if(!This->saxreader->errorHandler)
1237     {
1238         xmlStopParser(This->pParserCtxt);
1239         This->ret = E_FAIL;
1240         return;
1241     }
1242
1243     FIXME("Error handling is not compatible.\n");
1244
1245     va_start(args, msg);
1246     vsprintf(message, msg, args);
1247     va_end(args);
1248
1249     len = MultiByteToWideChar(CP_ACP, 0, message, -1, NULL, 0);
1250     wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
1251     MultiByteToWideChar(CP_ACP, 0, message, -1, (LPWSTR)wszError, len);
1252
1253     if(This->vbInterface)
1254     {
1255         BSTR bstrError = SysAllocString(wszError);
1256         IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
1257                 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
1258     }
1259     else
1260         ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
1261                 (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
1262
1263     HeapFree(GetProcessHeap(), 0, wszError);
1264
1265     xmlStopParser(This->pParserCtxt);
1266     This->ret = E_FAIL;
1267 }
1268
1269 /*** IVBSAXLocator interface ***/
1270 /*** IUnknown methods ***/
1271 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1272 {
1273     saxlocator *This = impl_from_IVBSAXLocator( iface );
1274
1275     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1276
1277     *ppvObject = NULL;
1278
1279     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1280             IsEqualGUID( riid, &IID_IDispatch) ||
1281             IsEqualGUID( riid, &IID_IVBSAXLocator ))
1282     {
1283         *ppvObject = iface;
1284     }
1285     else
1286     {
1287         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1288         return E_NOINTERFACE;
1289     }
1290
1291     IVBSAXLocator_AddRef( iface );
1292
1293     return S_OK;
1294 }
1295
1296 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1297 {
1298     saxlocator *This = impl_from_IVBSAXLocator( iface );
1299     TRACE("%p\n", This );
1300     return InterlockedIncrement( &This->ref );
1301 }
1302
1303 static ULONG WINAPI ivbsaxlocator_Release(
1304         IVBSAXLocator* iface)
1305 {
1306     saxlocator *This = impl_from_IVBSAXLocator( iface );
1307     return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1308 }
1309
1310 /*** IDispatch methods ***/
1311 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1312 {
1313     saxlocator *This = impl_from_IVBSAXLocator( iface );
1314
1315     TRACE("(%p)->(%p)\n", This, pctinfo);
1316
1317     *pctinfo = 1;
1318
1319     return S_OK;
1320 }
1321
1322 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1323     IVBSAXLocator *iface,
1324     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1325 {
1326     saxlocator *This = impl_from_IVBSAXLocator( iface );
1327     HRESULT hr;
1328
1329     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1330
1331     hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1332
1333     return hr;
1334 }
1335
1336 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1337     IVBSAXLocator *iface,
1338     REFIID riid,
1339     LPOLESTR* rgszNames,
1340     UINT cNames,
1341     LCID lcid,
1342     DISPID* rgDispId)
1343 {
1344     saxlocator *This = impl_from_IVBSAXLocator( iface );
1345     ITypeInfo *typeinfo;
1346     HRESULT hr;
1347
1348     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1349           lcid, rgDispId);
1350
1351     if(!rgszNames || cNames == 0 || !rgDispId)
1352         return E_INVALIDARG;
1353
1354     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1355     if(SUCCEEDED(hr))
1356     {
1357         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1358         ITypeInfo_Release(typeinfo);
1359     }
1360
1361     return hr;
1362 }
1363
1364 static HRESULT WINAPI ivbsaxlocator_Invoke(
1365     IVBSAXLocator *iface,
1366     DISPID dispIdMember,
1367     REFIID riid,
1368     LCID lcid,
1369     WORD wFlags,
1370     DISPPARAMS* pDispParams,
1371     VARIANT* pVarResult,
1372     EXCEPINFO* pExcepInfo,
1373     UINT* puArgErr)
1374 {
1375     saxlocator *This = impl_from_IVBSAXLocator( iface );
1376     ITypeInfo *typeinfo;
1377     HRESULT hr;
1378
1379     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1380           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1381
1382     hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1383     if(SUCCEEDED(hr))
1384     {
1385         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1386                 pVarResult, pExcepInfo, puArgErr);
1387         ITypeInfo_Release(typeinfo);
1388     }
1389
1390     return hr;
1391 }
1392
1393 /*** IVBSAXLocator methods ***/
1394 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1395         IVBSAXLocator* iface,
1396         int *pnColumn)
1397 {
1398     saxlocator *This = impl_from_IVBSAXLocator( iface );
1399     return ISAXLocator_getColumnNumber(
1400             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1401             pnColumn);
1402 }
1403
1404 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1405         IVBSAXLocator* iface,
1406         int *pnLine)
1407 {
1408     saxlocator *This = impl_from_IVBSAXLocator( iface );
1409     return ISAXLocator_getLineNumber(
1410             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1411             pnLine);
1412 }
1413
1414 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1415         IVBSAXLocator* iface,
1416         BSTR* publicId)
1417 {
1418     saxlocator *This = impl_from_IVBSAXLocator( iface );
1419     return ISAXLocator_getPublicId(
1420             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1421             (const WCHAR**)publicId);
1422 }
1423
1424 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1425         IVBSAXLocator* iface,
1426         BSTR* systemId)
1427 {
1428     saxlocator *This = impl_from_IVBSAXLocator( iface );
1429     return ISAXLocator_getSystemId(
1430             (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1431             (const WCHAR**)systemId);
1432 }
1433
1434 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1435 {
1436     ivbsaxlocator_QueryInterface,
1437     ivbsaxlocator_AddRef,
1438     ivbsaxlocator_Release,
1439     ivbsaxlocator_GetTypeInfoCount,
1440     ivbsaxlocator_GetTypeInfo,
1441     ivbsaxlocator_GetIDsOfNames,
1442     ivbsaxlocator_Invoke,
1443     ivbsaxlocator_get_columnNumber,
1444     ivbsaxlocator_get_lineNumber,
1445     ivbsaxlocator_get_publicId,
1446     ivbsaxlocator_get_systemId
1447 };
1448
1449 /*** ISAXLocator interface ***/
1450 /*** IUnknown methods ***/
1451 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1452 {
1453     saxlocator *This = impl_from_ISAXLocator( iface );
1454
1455     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1456
1457     *ppvObject = NULL;
1458
1459     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1460             IsEqualGUID( riid, &IID_ISAXLocator ))
1461     {
1462         *ppvObject = iface;
1463     }
1464     else
1465     {
1466         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1467         return E_NOINTERFACE;
1468     }
1469
1470     ISAXLocator_AddRef( iface );
1471
1472     return S_OK;
1473 }
1474
1475 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1476 {
1477     saxlocator *This = impl_from_ISAXLocator( iface );
1478     TRACE("%p\n", This );
1479     return InterlockedIncrement( &This->ref );
1480 }
1481
1482 static ULONG WINAPI isaxlocator_Release(
1483         ISAXLocator* iface)
1484 {
1485     saxlocator *This = impl_from_ISAXLocator( iface );
1486     LONG ref;
1487
1488     TRACE("%p\n", This );
1489
1490     ref = InterlockedDecrement( &This->ref );
1491     if ( ref == 0 )
1492     {
1493         if(This->publicId)
1494             SysFreeString(This->publicId);
1495         if(This->systemId)
1496             SysFreeString(This->systemId);
1497         HeapFree(GetProcessHeap(), 0, This->nsStack);
1498
1499         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1500         HeapFree( GetProcessHeap(), 0, This );
1501     }
1502
1503     return ref;
1504 }
1505
1506 /*** ISAXLocator methods ***/
1507 static HRESULT WINAPI isaxlocator_getColumnNumber(
1508         ISAXLocator* iface,
1509         int *pnColumn)
1510 {
1511     saxlocator *This = impl_from_ISAXLocator( iface );
1512
1513     *pnColumn = This->column;
1514     return S_OK;
1515 }
1516
1517 static HRESULT WINAPI isaxlocator_getLineNumber(
1518         ISAXLocator* iface,
1519         int *pnLine)
1520 {
1521     saxlocator *This = impl_from_ISAXLocator( iface );
1522
1523     *pnLine = This->line;
1524     return S_OK;
1525 }
1526
1527 static HRESULT WINAPI isaxlocator_getPublicId(
1528         ISAXLocator* iface,
1529         const WCHAR ** ppwchPublicId)
1530 {
1531     BSTR publicId;
1532     saxlocator *This = impl_from_ISAXLocator( iface );
1533
1534     if(This->publicId) SysFreeString(This->publicId);
1535
1536     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1537     if(SysStringLen(publicId))
1538         This->publicId = (WCHAR*)&publicId;
1539     else
1540     {
1541         SysFreeString(publicId);
1542         This->publicId = NULL;
1543     }
1544
1545     *ppwchPublicId = This->publicId;
1546     return S_OK;
1547 }
1548
1549 static HRESULT WINAPI isaxlocator_getSystemId(
1550         ISAXLocator* iface,
1551         const WCHAR ** ppwchSystemId)
1552 {
1553     BSTR systemId;
1554     saxlocator *This = impl_from_ISAXLocator( iface );
1555
1556     if(This->systemId) SysFreeString(This->systemId);
1557
1558     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1559     if(SysStringLen(systemId))
1560         This->systemId = (WCHAR*)&systemId;
1561     else
1562     {
1563         SysFreeString(systemId);
1564         This->systemId = NULL;
1565     }
1566
1567     *ppwchSystemId = This->systemId;
1568     return S_OK;
1569 }
1570
1571 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1572 {
1573     isaxlocator_QueryInterface,
1574     isaxlocator_AddRef,
1575     isaxlocator_Release,
1576     isaxlocator_getColumnNumber,
1577     isaxlocator_getLineNumber,
1578     isaxlocator_getPublicId,
1579     isaxlocator_getSystemId
1580 };
1581
1582 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1583 {
1584     saxlocator *locator;
1585
1586     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
1587     if( !locator )
1588         return E_OUTOFMEMORY;
1589
1590     locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1591     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1592     locator->ref = 1;
1593     locator->vbInterface = vbInterface;
1594
1595     locator->saxreader = reader;
1596     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1597
1598     locator->pParserCtxt = NULL;
1599     locator->publicId = NULL;
1600     locator->systemId = NULL;
1601     locator->lastCur = NULL;
1602     locator->line = 0;
1603     locator->column = 0;
1604     locator->ret = S_OK;
1605     locator->nsStackSize = 8;
1606     locator->nsStackLast = 0;
1607     locator->nsStack = HeapAlloc(GetProcessHeap(), 0, locator->nsStackSize);
1608     if(!locator->nsStack)
1609     {
1610         ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1611         HeapFree(GetProcessHeap(), 0, locator);
1612         return E_OUTOFMEMORY;
1613     }
1614
1615     *ppsaxlocator = locator;
1616
1617     TRACE("returning %p\n", *ppsaxlocator);
1618
1619     return S_OK;
1620 }
1621
1622 /*** SAXXMLReader internal functions ***/
1623 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1624 {
1625     saxlocator *locator;
1626     HRESULT hr;
1627
1628     hr = SAXLocator_create(This, &locator, vbInterface);
1629     if(FAILED(hr))
1630         return E_FAIL;
1631
1632     locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1633     if(!locator->pParserCtxt)
1634     {
1635         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1636         return E_FAIL;
1637     }
1638
1639     locator->pParserCtxt->sax = &locator->saxreader->sax;
1640     locator->pParserCtxt->userData = locator;
1641
1642     if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1643     else hr = locator->ret;
1644
1645     if(locator->pParserCtxt)
1646     {
1647         locator->pParserCtxt->sax = NULL;
1648         xmlFreeParserCtxt(locator->pParserCtxt);
1649         locator->pParserCtxt = NULL;
1650     }
1651
1652     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1653     return S_OK;
1654 }
1655
1656 static HRESULT WINAPI internal_getEntityResolver(
1657         saxreader *This,
1658         void *pEntityResolver,
1659         BOOL vbInterface)
1660 {
1661     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1662     return E_NOTIMPL;
1663 }
1664
1665 static HRESULT WINAPI internal_putEntityResolver(
1666         saxreader *This,
1667         void *pEntityResolver,
1668         BOOL vbInterface)
1669 {
1670     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1671     return E_NOTIMPL;
1672 }
1673
1674 static HRESULT WINAPI internal_getContentHandler(
1675         saxreader* This,
1676         void *pContentHandler,
1677         BOOL vbInterface)
1678 {
1679     TRACE("(%p)->(%p)\n", This, pContentHandler);
1680     if(pContentHandler == NULL)
1681         return E_POINTER;
1682     if((vbInterface && This->vbcontentHandler)
1683             || (!vbInterface && This->contentHandler))
1684     {
1685         if(vbInterface)
1686             IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1687         else
1688             ISAXContentHandler_AddRef(This->contentHandler);
1689     }
1690     if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1691         This->vbcontentHandler;
1692     else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1693
1694     return S_OK;
1695 }
1696
1697 static HRESULT WINAPI internal_putContentHandler(
1698         saxreader* This,
1699         void *contentHandler,
1700         BOOL vbInterface)
1701 {
1702     TRACE("(%p)->(%p)\n", This, contentHandler);
1703     if(contentHandler)
1704     {
1705         if(vbInterface)
1706             IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1707         else
1708             ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1709     }
1710     if((vbInterface && This->vbcontentHandler)
1711             || (!vbInterface && This->contentHandler))
1712     {
1713         if(vbInterface)
1714             IVBSAXContentHandler_Release(This->vbcontentHandler);
1715         else
1716             ISAXContentHandler_Release(This->contentHandler);
1717     }
1718     if(vbInterface)
1719         This->vbcontentHandler = contentHandler;
1720     else
1721         This->contentHandler = contentHandler;
1722
1723     return S_OK;
1724 }
1725
1726 static HRESULT WINAPI internal_getDTDHandler(
1727         saxreader* This,
1728         void *pDTDHandler,
1729         BOOL vbInterface)
1730 {
1731     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1732     return E_NOTIMPL;
1733 }
1734
1735 static HRESULT WINAPI internal_putDTDHandler(
1736         saxreader* This,
1737         void *pDTDHandler,
1738         BOOL vbInterface)
1739 {
1740     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1741     return E_NOTIMPL;
1742 }
1743
1744 static HRESULT WINAPI internal_getErrorHandler(
1745         saxreader* This,
1746         void *pErrorHandler,
1747         BOOL vbInterface)
1748 {
1749     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1750     if(pErrorHandler == NULL)
1751         return E_POINTER;
1752     if(This->errorHandler)
1753     {
1754         if(vbInterface)
1755             IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1756         else
1757             ISAXErrorHandler_AddRef(This->errorHandler);
1758     }
1759     if(vbInterface)
1760         *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1761     else
1762         *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1763
1764     return S_OK;
1765
1766 }
1767
1768 static HRESULT WINAPI internal_putErrorHandler(
1769         saxreader* This,
1770         void *errorHandler,
1771         BOOL vbInterface)
1772 {
1773     TRACE("(%p)->(%p)\n", This, errorHandler);
1774     if(errorHandler)
1775     {
1776         if(vbInterface)
1777             IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
1778         else
1779             ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
1780     }
1781     if(This->errorHandler)
1782     {
1783         if(vbInterface)
1784             IVBSAXErrorHandler_Release(This->vberrorHandler);
1785         else
1786             ISAXErrorHandler_Release(This->errorHandler);
1787     }
1788     if(vbInterface)
1789         This->vberrorHandler = errorHandler;
1790     else
1791         This->errorHandler = errorHandler;
1792
1793     return S_OK;
1794
1795 }
1796
1797 static HRESULT WINAPI internal_parse(
1798         saxreader* This,
1799         VARIANT varInput,
1800         BOOL vbInterface)
1801 {
1802     HRESULT hr;
1803
1804     TRACE("(%p)\n", This);
1805
1806     hr = S_OK;
1807     switch(V_VT(&varInput))
1808     {
1809         case VT_BSTR:
1810             hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
1811                     SysStringByteLen(V_BSTR(&varInput)), vbInterface);
1812             break;
1813         case VT_ARRAY|VT_UI1: {
1814             void *pSAData;
1815             LONG lBound, uBound;
1816             ULONG dataRead;
1817
1818             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
1819             if(hr != S_OK) break;
1820             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
1821             if(hr != S_OK) break;
1822             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
1823             hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
1824             if(hr != S_OK) break;
1825             hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
1826             SafeArrayUnaccessData(V_ARRAY(&varInput));
1827             break;
1828         }
1829         case VT_UNKNOWN:
1830         case VT_DISPATCH: {
1831             IPersistStream *persistStream;
1832             IStream *stream = NULL;
1833             IXMLDOMDocument *xmlDoc;
1834
1835             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1836                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
1837             {
1838                 hr = IPersistStream_Save(persistStream, stream, TRUE);
1839                 IPersistStream_Release(persistStream);
1840                 if(hr != S_OK) break;
1841             }
1842             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1843                         &IID_IStream, (void**)&stream) == S_OK)
1844             {
1845                 STATSTG dataInfo;
1846                 ULONG dataRead;
1847                 char *data;
1848
1849                 while(1)
1850                 {
1851                     hr = IStream_Stat(stream, &dataInfo, STATFLAG_NONAME);
1852                     if(hr == E_PENDING) continue;
1853                     break;
1854                 }
1855                 data = HeapAlloc(GetProcessHeap(), 0,
1856                         dataInfo.cbSize.QuadPart);
1857                 while(1)
1858                 {
1859                     hr = IStream_Read(stream, data,
1860                             dataInfo.cbSize.QuadPart, &dataRead);
1861                     if(hr == E_PENDING) continue;
1862                     break;
1863                 }
1864                 hr = internal_parseBuffer(This, data,
1865                         dataInfo.cbSize.QuadPart, vbInterface);
1866                 HeapFree(GetProcessHeap(), 0, data);
1867                 IStream_Release(stream);
1868                 break;
1869             }
1870             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1871                                        &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
1872             {
1873                 BSTR bstrData;
1874
1875                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
1876                 hr = internal_parseBuffer(This, (const char*)bstrData,
1877                         SysStringByteLen(bstrData), vbInterface);
1878                 IXMLDOMDocument_Release(xmlDoc);
1879                 hr = E_NOTIMPL;
1880                 break;
1881             }
1882         }
1883         default:
1884             WARN("vt %d not implemented\n", V_VT(&varInput));
1885             hr = E_INVALIDARG;
1886     }
1887
1888     return hr;
1889 }
1890
1891 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
1892 {
1893     saxreader *This = obj;
1894
1895     return internal_parseBuffer(This, ptr, len, TRUE);
1896 }
1897
1898 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
1899 {
1900     saxreader *This = obj;
1901
1902     return internal_parseBuffer(This, ptr, len, FALSE);
1903 }
1904
1905 static HRESULT WINAPI internal_parseURL(
1906         saxreader* This,
1907         const WCHAR *url,
1908         BOOL vbInterface)
1909 {
1910     bsc_t *bsc;
1911     HRESULT hr;
1912
1913     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
1914
1915     if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
1916     else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
1917
1918     if(FAILED(hr))
1919         return hr;
1920
1921     detach_bsc(bsc);
1922
1923     return S_OK;
1924 }
1925
1926 /*** IVBSAXXMLReader interface ***/
1927 /*** IUnknown methods ***/
1928 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
1929 {
1930     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1931
1932     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1933
1934     *ppvObject = NULL;
1935
1936     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1937          IsEqualGUID( riid, &IID_IDispatch ) ||
1938          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
1939     {
1940         *ppvObject = iface;
1941     }
1942     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
1943     {
1944         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
1945     }
1946     else
1947     {
1948         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1949         return E_NOINTERFACE;
1950     }
1951
1952     IVBSAXXMLReader_AddRef( iface );
1953
1954     return S_OK;
1955 }
1956
1957 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
1958 {
1959     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1960     TRACE("%p\n", This );
1961     return InterlockedIncrement( &This->ref );
1962 }
1963
1964 static ULONG WINAPI saxxmlreader_Release(
1965     IVBSAXXMLReader* iface)
1966 {
1967     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1968     LONG ref;
1969
1970     TRACE("%p\n", This );
1971
1972     ref = InterlockedDecrement( &This->ref );
1973     if ( ref == 0 )
1974     {
1975         if(This->contentHandler)
1976             ISAXContentHandler_Release(This->contentHandler);
1977
1978         if(This->errorHandler)
1979             ISAXErrorHandler_Release(This->errorHandler);
1980
1981         HeapFree( GetProcessHeap(), 0, This );
1982     }
1983
1984     return ref;
1985 }
1986 /*** IDispatch ***/
1987 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
1988 {
1989     saxreader *This = impl_from_IVBSAXXMLReader( iface );
1990
1991     TRACE("(%p)->(%p)\n", This, pctinfo);
1992
1993     *pctinfo = 1;
1994
1995     return S_OK;
1996 }
1997
1998 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
1999     IVBSAXXMLReader *iface,
2000     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2001 {
2002     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2003     HRESULT hr;
2004
2005     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2006
2007     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2008
2009     return hr;
2010 }
2011
2012 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2013     IVBSAXXMLReader *iface,
2014     REFIID riid,
2015     LPOLESTR* rgszNames,
2016     UINT cNames,
2017     LCID lcid,
2018     DISPID* rgDispId)
2019 {
2020     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2021     ITypeInfo *typeinfo;
2022     HRESULT hr;
2023
2024     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2025           lcid, rgDispId);
2026
2027     if(!rgszNames || cNames == 0 || !rgDispId)
2028         return E_INVALIDARG;
2029
2030     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2031     if(SUCCEEDED(hr))
2032     {
2033         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2034         ITypeInfo_Release(typeinfo);
2035     }
2036
2037     return hr;
2038 }
2039
2040 static HRESULT WINAPI saxxmlreader_Invoke(
2041     IVBSAXXMLReader *iface,
2042     DISPID dispIdMember,
2043     REFIID riid,
2044     LCID lcid,
2045     WORD wFlags,
2046     DISPPARAMS* pDispParams,
2047     VARIANT* pVarResult,
2048     EXCEPINFO* pExcepInfo,
2049     UINT* puArgErr)
2050 {
2051     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2052     ITypeInfo *typeinfo;
2053     HRESULT hr;
2054
2055     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2056           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2057
2058     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2059     if(SUCCEEDED(hr))
2060     {
2061         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
2062                 pVarResult, pExcepInfo, puArgErr);
2063         ITypeInfo_Release(typeinfo);
2064     }
2065
2066     return hr;
2067 }
2068
2069 /*** IVBSAXXMLReader methods ***/
2070 static HRESULT WINAPI saxxmlreader_getFeature(
2071     IVBSAXXMLReader* iface,
2072     const WCHAR *pFeature,
2073     VARIANT_BOOL *pValue)
2074 {
2075     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2076
2077     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2078     return E_NOTIMPL;
2079 }
2080
2081 static HRESULT WINAPI saxxmlreader_putFeature(
2082     IVBSAXXMLReader* iface,
2083     const WCHAR *pFeature,
2084     VARIANT_BOOL vfValue)
2085 {
2086     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2087
2088     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
2089     return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI saxxmlreader_getProperty(
2093     IVBSAXXMLReader* iface,
2094     const WCHAR *pProp,
2095     VARIANT *pValue)
2096 {
2097     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2098
2099     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
2100     return E_NOTIMPL;
2101 }
2102
2103 static HRESULT WINAPI saxxmlreader_putProperty(
2104     IVBSAXXMLReader* iface,
2105     const WCHAR *pProp,
2106     VARIANT value)
2107 {
2108     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2109
2110     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
2111     return E_NOTIMPL;
2112 }
2113
2114 static HRESULT WINAPI saxxmlreader_getEntityResolver(
2115     IVBSAXXMLReader* iface,
2116     IVBSAXEntityResolver **pEntityResolver)
2117 {
2118     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2119     return internal_getEntityResolver(This, pEntityResolver, TRUE);
2120 }
2121
2122 static HRESULT WINAPI saxxmlreader_putEntityResolver(
2123     IVBSAXXMLReader* iface,
2124     IVBSAXEntityResolver *pEntityResolver)
2125 {
2126     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2127     return internal_putEntityResolver(This, pEntityResolver, TRUE);
2128 }
2129
2130 static HRESULT WINAPI saxxmlreader_getContentHandler(
2131     IVBSAXXMLReader* iface,
2132     IVBSAXContentHandler **ppContentHandler)
2133 {
2134     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2135     return internal_getContentHandler(This, ppContentHandler, TRUE);
2136 }
2137
2138 static HRESULT WINAPI saxxmlreader_putContentHandler(
2139     IVBSAXXMLReader* iface,
2140     IVBSAXContentHandler *contentHandler)
2141 {
2142     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2143     return internal_putContentHandler(This, contentHandler, TRUE);
2144 }
2145
2146 static HRESULT WINAPI saxxmlreader_getDTDHandler(
2147     IVBSAXXMLReader* iface,
2148     IVBSAXDTDHandler **pDTDHandler)
2149 {
2150     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2151     return internal_getDTDHandler(This, pDTDHandler, TRUE);
2152 }
2153
2154 static HRESULT WINAPI saxxmlreader_putDTDHandler(
2155     IVBSAXXMLReader* iface,
2156     IVBSAXDTDHandler *pDTDHandler)
2157 {
2158     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2159     return internal_putDTDHandler(This, pDTDHandler, TRUE);
2160 }
2161
2162 static HRESULT WINAPI saxxmlreader_getErrorHandler(
2163     IVBSAXXMLReader* iface,
2164     IVBSAXErrorHandler **pErrorHandler)
2165 {
2166     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2167     return internal_getErrorHandler(This, pErrorHandler, TRUE);
2168 }
2169
2170 static HRESULT WINAPI saxxmlreader_putErrorHandler(
2171     IVBSAXXMLReader* iface,
2172     IVBSAXErrorHandler *errorHandler)
2173 {
2174     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2175     return internal_putErrorHandler(This, errorHandler, TRUE);
2176 }
2177
2178 static HRESULT WINAPI saxxmlreader_getBaseURL(
2179     IVBSAXXMLReader* iface,
2180     const WCHAR **pBaseUrl)
2181 {
2182     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2183
2184     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2185     return E_NOTIMPL;
2186 }
2187
2188 static HRESULT WINAPI saxxmlreader_putBaseURL(
2189     IVBSAXXMLReader* iface,
2190     const WCHAR *pBaseUrl)
2191 {
2192     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2193
2194     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2195     return E_NOTIMPL;
2196 }
2197
2198 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
2199     IVBSAXXMLReader* iface,
2200     const WCHAR **pSecureBaseUrl)
2201 {
2202     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2203
2204     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2205     return E_NOTIMPL;
2206 }
2207
2208
2209 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
2210     IVBSAXXMLReader* iface,
2211     const WCHAR *secureBaseUrl)
2212 {
2213     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2214
2215     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2216     return E_NOTIMPL;
2217 }
2218
2219 static HRESULT WINAPI saxxmlreader_parse(
2220     IVBSAXXMLReader* iface,
2221     VARIANT varInput)
2222 {
2223     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2224     return internal_parse(This, varInput, TRUE);
2225 }
2226
2227 static HRESULT WINAPI saxxmlreader_parseURL(
2228     IVBSAXXMLReader* iface,
2229     const WCHAR *url)
2230 {
2231     saxreader *This = impl_from_IVBSAXXMLReader( iface );
2232     return internal_parseURL(This, url, TRUE);
2233 }
2234
2235 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2236 {
2237     saxxmlreader_QueryInterface,
2238     saxxmlreader_AddRef,
2239     saxxmlreader_Release,
2240     saxxmlreader_GetTypeInfoCount,
2241     saxxmlreader_GetTypeInfo,
2242     saxxmlreader_GetIDsOfNames,
2243     saxxmlreader_Invoke,
2244     saxxmlreader_getFeature,
2245     saxxmlreader_putFeature,
2246     saxxmlreader_getProperty,
2247     saxxmlreader_putProperty,
2248     saxxmlreader_getEntityResolver,
2249     saxxmlreader_putEntityResolver,
2250     saxxmlreader_getContentHandler,
2251     saxxmlreader_putContentHandler,
2252     saxxmlreader_getDTDHandler,
2253     saxxmlreader_putDTDHandler,
2254     saxxmlreader_getErrorHandler,
2255     saxxmlreader_putErrorHandler,
2256     saxxmlreader_getBaseURL,
2257     saxxmlreader_putBaseURL,
2258     saxxmlreader_getSecureBaseURL,
2259     saxxmlreader_putSecureBaseURL,
2260     saxxmlreader_parse,
2261     saxxmlreader_parseURL
2262 };
2263
2264 /*** ISAXXMLReader interface ***/
2265 /*** IUnknown methods ***/
2266 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2267 {
2268     saxreader *This = impl_from_ISAXXMLReader( iface );
2269     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2270 }
2271
2272 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2273 {
2274     saxreader *This = impl_from_ISAXXMLReader( iface );
2275     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2276 }
2277
2278 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2279 {
2280     saxreader *This = impl_from_ISAXXMLReader( iface );
2281     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2282 }
2283
2284 /*** ISAXXMLReader methods ***/
2285 static HRESULT WINAPI isaxxmlreader_getFeature(
2286         ISAXXMLReader* iface,
2287         const WCHAR *pFeature,
2288         VARIANT_BOOL *pValue)
2289 {
2290     saxreader *This = impl_from_ISAXXMLReader( iface );
2291     return IVBSAXXMLReader_getFeature(
2292             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2293             pFeature, pValue);
2294 }
2295
2296 static HRESULT WINAPI isaxxmlreader_putFeature(
2297         ISAXXMLReader* iface,
2298         const WCHAR *pFeature,
2299         VARIANT_BOOL vfValue)
2300 {
2301     saxreader *This = impl_from_ISAXXMLReader( iface );
2302     return IVBSAXXMLReader_putFeature(
2303             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2304             pFeature, vfValue);
2305 }
2306
2307 static HRESULT WINAPI isaxxmlreader_getProperty(
2308         ISAXXMLReader* iface,
2309         const WCHAR *pProp,
2310         VARIANT *pValue)
2311 {
2312     saxreader *This = impl_from_ISAXXMLReader( iface );
2313     return IVBSAXXMLReader_getProperty(
2314             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2315             pProp, pValue);
2316 }
2317
2318 static HRESULT WINAPI isaxxmlreader_putProperty(
2319         ISAXXMLReader* iface,
2320         const WCHAR *pProp,
2321         VARIANT value)
2322 {
2323     saxreader *This = impl_from_ISAXXMLReader( iface );
2324     return IVBSAXXMLReader_putProperty(
2325             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2326             pProp, value);
2327 }
2328
2329 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2330         ISAXXMLReader* iface,
2331         ISAXEntityResolver **ppEntityResolver)
2332 {
2333     saxreader *This = impl_from_ISAXXMLReader( iface );
2334     return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2335 }
2336
2337 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2338         ISAXXMLReader* iface,
2339         ISAXEntityResolver *pEntityResolver)
2340 {
2341     saxreader *This = impl_from_ISAXXMLReader( iface );
2342     return internal_putEntityResolver(This, pEntityResolver, FALSE);
2343 }
2344
2345 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2346         ISAXXMLReader* iface,
2347         ISAXContentHandler **pContentHandler)
2348 {
2349     saxreader *This = impl_from_ISAXXMLReader( iface );
2350     return internal_getContentHandler(This, pContentHandler, FALSE);
2351 }
2352
2353 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2354         ISAXXMLReader* iface,
2355         ISAXContentHandler *contentHandler)
2356 {
2357     saxreader *This = impl_from_ISAXXMLReader( iface );
2358     return internal_putContentHandler(This, contentHandler, FALSE);
2359 }
2360
2361 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2362         ISAXXMLReader* iface,
2363         ISAXDTDHandler **pDTDHandler)
2364 {
2365     saxreader *This = impl_from_ISAXXMLReader( iface );
2366     return internal_getDTDHandler(This, pDTDHandler, FALSE);
2367 }
2368
2369 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2370         ISAXXMLReader* iface,
2371         ISAXDTDHandler *pDTDHandler)
2372 {
2373     saxreader *This = impl_from_ISAXXMLReader( iface );
2374     return internal_putDTDHandler(This, pDTDHandler, FALSE);
2375 }
2376
2377 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2378         ISAXXMLReader* iface,
2379         ISAXErrorHandler **pErrorHandler)
2380 {
2381     saxreader *This = impl_from_ISAXXMLReader( iface );
2382     return internal_getErrorHandler(This, pErrorHandler, FALSE);
2383 }
2384
2385 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2386         ISAXXMLReader* iface,
2387         ISAXErrorHandler *errorHandler)
2388 {
2389     saxreader *This = impl_from_ISAXXMLReader( iface );
2390     return internal_putErrorHandler(This, errorHandler, FALSE);
2391 }
2392
2393 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2394         ISAXXMLReader* iface,
2395         const WCHAR **pBaseUrl)
2396 {
2397     saxreader *This = impl_from_ISAXXMLReader( iface );
2398     return IVBSAXXMLReader_get_getBaseURL(
2399             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2400             pBaseUrl);
2401 }
2402
2403 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2404         ISAXXMLReader* iface,
2405         const WCHAR *pBaseUrl)
2406 {
2407     saxreader *This = impl_from_ISAXXMLReader( iface );
2408     return IVBSAXXMLReader_put_putBaseURL(
2409             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2410             pBaseUrl);
2411 }
2412
2413 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2414         ISAXXMLReader* iface,
2415         const WCHAR **pSecureBaseUrl)
2416 {
2417     saxreader *This = impl_from_ISAXXMLReader( iface );
2418     return IVBSAXXMLReader_get_getSecureBaseURL(
2419             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2420             pSecureBaseUrl);
2421 }
2422
2423 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2424         ISAXXMLReader* iface,
2425         const WCHAR *secureBaseUrl)
2426 {
2427     saxreader *This = impl_from_ISAXXMLReader( iface );
2428     return IVBSAXXMLReader_put_putSecureBaseURL(
2429             (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2430             secureBaseUrl);
2431 }
2432
2433 static HRESULT WINAPI isaxxmlreader_parse(
2434         ISAXXMLReader* iface,
2435         VARIANT varInput)
2436 {
2437     saxreader *This = impl_from_ISAXXMLReader( iface );
2438     return internal_parse(This, varInput, FALSE);
2439 }
2440
2441 static HRESULT WINAPI isaxxmlreader_parseURL(
2442         ISAXXMLReader* iface,
2443         const WCHAR *url)
2444 {
2445     saxreader *This = impl_from_ISAXXMLReader( iface );
2446     return internal_parseURL(This, url, FALSE);
2447 }
2448
2449 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2450 {
2451     isaxxmlreader_QueryInterface,
2452     isaxxmlreader_AddRef,
2453     isaxxmlreader_Release,
2454     isaxxmlreader_getFeature,
2455     isaxxmlreader_putFeature,
2456     isaxxmlreader_getProperty,
2457     isaxxmlreader_putProperty,
2458     isaxxmlreader_getEntityResolver,
2459     isaxxmlreader_putEntityResolver,
2460     isaxxmlreader_getContentHandler,
2461     isaxxmlreader_putContentHandler,
2462     isaxxmlreader_getDTDHandler,
2463     isaxxmlreader_putDTDHandler,
2464     isaxxmlreader_getErrorHandler,
2465     isaxxmlreader_putErrorHandler,
2466     isaxxmlreader_getBaseURL,
2467     isaxxmlreader_putBaseURL,
2468     isaxxmlreader_getSecureBaseURL,
2469     isaxxmlreader_putSecureBaseURL,
2470     isaxxmlreader_parse,
2471     isaxxmlreader_parseURL
2472 };
2473
2474 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2475 {
2476     saxreader *reader;
2477
2478     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2479
2480     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
2481     if( !reader )
2482         return E_OUTOFMEMORY;
2483
2484     reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2485     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2486     reader->ref = 1;
2487     reader->contentHandler = NULL;
2488     reader->errorHandler = NULL;
2489
2490     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2491     reader->sax.initialized = XML_SAX2_MAGIC;
2492     reader->sax.startDocument = libxmlStartDocument;
2493     reader->sax.endDocument = libxmlEndDocument;
2494     reader->sax.startElementNs = libxmlStartElementNS;
2495     reader->sax.endElementNs = libxmlEndElementNS;
2496     reader->sax.characters = libxmlCharacters;
2497     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2498     reader->sax.error = libxmlFatalError;
2499     reader->sax.fatalError = libxmlFatalError;
2500
2501     *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2502
2503     TRACE("returning iface %p\n", *ppObj);
2504
2505     return S_OK;
2506 }
2507
2508 #else
2509
2510 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2511 {
2512     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2513             "libxml2 support was not present at compile time.\n");
2514     return E_NOTIMPL;
2515 }
2516
2517 #endif