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
  48 typedef struct _saxreader
  49 {
  50     const struct IVBSAXXMLReaderVtbl *lpVtbl;
  51     const struct ISAXXMLReaderVtbl *lpSAXXMLReaderVtbl;
  52     LONG ref;
  53     struct ISAXContentHandler *contentHandler;
  54     struct ISAXErrorHandler *errorHandler;
  55     xmlSAXHandler sax;
  56 } saxreader;
  57
  58 typedef struct _saxlocator
  59 {
  60     const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
  61     LONG ref;
  62     saxreader *saxreader;
  63     HRESULT ret;
  64     xmlParserCtxtPtr pParserCtxt;
  65     WCHAR *publicId;
  66     WCHAR *systemId;
  67     xmlChar *lastCur;
  68     int line;
  69     int column;
  70 } saxlocator;
  71
  72 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  73 {
  74     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  75 }
  76
  77 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
  78 {
  79     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
  80 }
  81
  82 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
  83 {
  84     return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
  85 }
  86
  87
  88 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
  89 {
  90     xmlStopParser(This->pParserCtxt);
  91     This->ret = hr;
  92
  93     if(This->saxreader->errorHandler)
  94     {
  95         WCHAR msg[1024];
  96         if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
  97                     NULL, hr, 0, msg, sizeof(msg), NULL))
  98         {
  99             FIXME("MSXML errors not yet supported.\n");
 100             msg[0] = '\0';
 101         }
 102
 103         ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 104                 (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
 105     }
 106 }
 107
 108 static void update_position(saxlocator *This, xmlChar *end)
 109 {
 110     if(This->lastCur == NULL)
 111     {
 112         This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
 113         This->line = 1;
 114         This->column = 1;
 115     }
 116
 117     if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
 118
 119     while(This->lastCur < end)
 120     {
 121         if(*(This->lastCur) == '\n')
 122         {
 123             This->line++;
 124             This->column = 1;
 125         }
 126         else if(*(This->lastCur) == '\r' && (This->lastCur==This->pParserCtxt->input->end || *(This->lastCur+1)!='\n'))
 127         {
 128             This->line++;
 129             This->column = 1;
 130         }
 131         else This->column++;
 132
 133         This->lastCur++;
 134     }
 135 }
 136
 137 /*** LibXML callbacks ***/
 138 static void libxmlStartDocument(void *ctx)
 139 {
 140     saxlocator *This = ctx;
 141     HRESULT hr;
 142
 143     if(This->saxreader->contentHandler)
 144     {
 145         hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
 146         if(hr != S_OK)
 147             format_error_message_from_id(This, hr);
 148     }
 149
 150     update_position(This, NULL);
 151 }
 152
 153 static void libxmlEndDocument(void *ctx)
 154 {
 155     saxlocator *This = ctx;
 156     HRESULT hr;
 157
 158     This->column = 0;
 159     This->line = 0;
 160
 161     if(This->ret != S_OK) return;
 162
 163     if(This->saxreader->contentHandler)
 164     {
 165         hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
 166         if(hr != S_OK)
 167             format_error_message_from_id(This, hr);
 168     }
 169 }
 170
 171 static void libxmlStartElementNS(
 172         void *ctx,
 173         const xmlChar *localname,
 174         const xmlChar *prefix,
 175         const xmlChar *URI,
 176         int nb_namespaces,
 177         const xmlChar **namespaces,
 178         int nb_attributes,
 179         int nb_defaulted,
 180         const xmlChar **attributes)
 181 {
 182     BSTR NamespaceUri, LocalName, QName;
 183     saxlocator *This = ctx;
 184     HRESULT hr;
 185
 186     FIXME("Arguments processing not yet implemented.\n");
 187
 188     update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
 189
 190     if(This->saxreader->contentHandler)
 191     {
 192         NamespaceUri = bstr_from_xmlChar(URI);
 193         LocalName = bstr_from_xmlChar(localname);
 194         QName = bstr_from_xmlChar(localname);
 195
 196         hr = ISAXContentHandler_startElement(
 197                 This->saxreader->contentHandler,
 198                 NamespaceUri, SysStringLen(NamespaceUri),
 199                 LocalName, SysStringLen(LocalName),
 200                 QName, SysStringLen(QName),
 201                 NULL);
 202
 203         SysFreeString(NamespaceUri);
 204         SysFreeString(LocalName);
 205         SysFreeString(QName);
 206
 207         if(hr != S_OK)
 208             format_error_message_from_id(This, hr);
 209     }
 210 }
 211
 212 static void libxmlEndElementNS(
 213         void *ctx,
 214         const xmlChar *localname,
 215         const xmlChar *prefix,
 216         const xmlChar *URI)
 217 {
 218     BSTR NamespaceUri, LocalName, QName;
 219     saxlocator *This = ctx;
 220     HRESULT hr;
 221     xmlChar *end;
 222
 223     end = This->lastCur;
 224     while(*end != '<' && *(end+1) != '/') end++;
 225     update_position(This, end+2);
 226
 227     if(This->saxreader->contentHandler)
 228     {
 229         NamespaceUri = bstr_from_xmlChar(URI);
 230         LocalName = bstr_from_xmlChar(localname);
 231         QName = bstr_from_xmlChar(localname);
 232
 233         hr = ISAXContentHandler_endElement(
 234                 This->saxreader->contentHandler,
 235                 NamespaceUri, SysStringLen(NamespaceUri),
 236                 LocalName, SysStringLen(LocalName),
 237                 QName, SysStringLen(QName));
 238
 239         SysFreeString(NamespaceUri);
 240         SysFreeString(LocalName);
 241         SysFreeString(QName);
 242
 243         if(hr != S_OK)
 244             format_error_message_from_id(This, hr);
 245     }
 246 }
 247
 248 static void libxmlCharacters(
 249         void *ctx,
 250         const xmlChar *ch,
 251         int len)
 252 {
 253     BSTR Chars;
 254     saxlocator *This = ctx;
 255     HRESULT hr;
 256     xmlChar *end;
 257     xmlChar *lastCurCopy;
 258     xmlChar *chEnd;
 259     int columnCopy;
 260     int lineCopy;
 261
 262     if(*(This->lastCur-1) != '>' && *(This->lastCur-1) != '/') return;
 263
 264     if(*(This->lastCur-1) != '>')
 265     {
 266         end = (xmlChar*)This->pParserCtxt->input->cur-len;
 267         while(*(end-1) != '>') end--;
 268         update_position(This, end);
 269     }
 270
 271     chEnd = This->lastCur+len;
 272     while(*chEnd != '<') chEnd++;
 273
 274     Chars = bstr_from_xmlChar(ch);
 275
 276     lastCurCopy = This->lastCur;
 277     columnCopy = This->column;
 278     lineCopy = This->line;
 279     end = This->lastCur;
 280
 281     if(This->saxreader->contentHandler)
 282     {
 283         while(This->lastCur < chEnd)
 284         {
 285             end = This->lastCur;
 286             while(end < chEnd-1)
 287             {
 288                 if(*end == '\r') break;
 289                 end++;
 290             }
 291
 292             Chars = bstr_from_xmlChar(This->lastCur);
 293
 294             if(*end == '\r' && *(end+1) == '\n')
 295             {
 296                 memmove((WCHAR*)Chars+(end-This->lastCur),
 297                         (WCHAR*)Chars+(end-This->lastCur)+1,
 298                         (SysStringLen(Chars)-(end-This->lastCur))*sizeof(WCHAR));
 299                 SysReAllocStringLen(&Chars, Chars, SysStringLen(Chars)-1);
 300             }
 301             else if(*end == '\r') Chars[end-This->lastCur] = '\n';
 302
 303             hr = ISAXContentHandler_characters(This->saxreader->contentHandler, Chars, end-This->lastCur+1);
 304             SysFreeString(Chars);
 305             if(hr != S_OK)
 306             {
 307                 format_error_message_from_id(This, hr);
 308                 return;
 309             }
 310
 311             if(*(end+1) == '\n') end++;
 312             if(end < chEnd) end++;
 313
 314             This->column += end-This->lastCur;
 315             This->lastCur = end;
 316         }
 317
 318         This->lastCur = lastCurCopy;
 319         This->column = columnCopy;
 320         This->line = lineCopy;
 321         update_position(This, chEnd);
 322     }
 323 }
 324
 325 static void libxmlSetDocumentLocator(
 326         void *ctx,
 327         xmlSAXLocatorPtr loc)
 328 {
 329     saxlocator *This = ctx;
 330     HRESULT hr;
 331
 332     hr = ISAXContentHandler_putDocumentLocator(This->saxreader->contentHandler,
 333             (ISAXLocator*)&This->lpSAXLocatorVtbl);
 334
 335     if(FAILED(hr))
 336         format_error_message_from_id(This, hr);
 337 }
 338
 339 void libxmlFatalError(void *ctx, const char *msg, ...)
 340 {
 341     saxlocator *This = ctx;
 342     char message[1024];
 343     WCHAR *wszError;
 344     DWORD len;
 345     va_list args;
 346
 347     if(!This->saxreader->errorHandler)
 348     {
 349         xmlStopParser(This->pParserCtxt);
 350         This->ret = E_FAIL;
 351         return;
 352     }
 353
 354     FIXME("Error handling is not compatible.\n");
 355
 356     va_start(args, msg);
 357     vsprintf(message, msg, args);
 358     va_end(args);
 359
 360     len = MultiByteToWideChar(CP_ACP, 0, message, -1, NULL, 0);
 361     wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 362     MultiByteToWideChar(CP_ACP, 0, message, -1, (LPWSTR)wszError, len);
 363
 364     ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
 365             (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
 366
 367     HeapFree(GetProcessHeap(), 0, wszError);
 368
 369     xmlStopParser(This->pParserCtxt);
 370     This->ret = E_FAIL;
 371 }
 372
 373 /*** ISAXLocator interface ***/
 374 /*** IUnknown methods ***/
 375 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
 376 {
 377     saxlocator *This = impl_from_ISAXLocator( iface );
 378
 379     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 380
 381     *ppvObject = NULL;
 382
 383     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 384             IsEqualGUID( riid, &IID_ISAXLocator ))
 385     {
 386         *ppvObject = iface;
 387     }
 388     else
 389     {
 390         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 391         return E_NOINTERFACE;
 392     }
 393
 394     ISAXLocator_AddRef( iface );
 395
 396     return S_OK;
 397 }
 398
 399 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
 400 {
 401     saxlocator *This = impl_from_ISAXLocator( iface );
 402     TRACE("%p\n", This );
 403     return InterlockedIncrement( &This->ref );
 404 }
 405
 406 static ULONG WINAPI isaxlocator_Release(
 407         ISAXLocator* iface)
 408 {
 409     saxlocator *This = impl_from_ISAXLocator( iface );
 410     LONG ref;
 411
 412     TRACE("%p\n", This );
 413
 414     ref = InterlockedDecrement( &This->ref );
 415     if ( ref == 0 )
 416     {
 417         if(This->publicId)
 418             SysFreeString(This->publicId);
 419         if(This->systemId)
 420             SysFreeString(This->systemId);
 421
 422         ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
 423         HeapFree( GetProcessHeap(), 0, This );
 424     }
 425
 426     return ref;
 427 }
 428
 429 /*** ISAXLocator methods ***/
 430 static HRESULT WINAPI isaxlocator_getColumnNumber(
 431         ISAXLocator* iface,
 432         int *pnColumn)
 433 {
 434     saxlocator *This = impl_from_ISAXLocator( iface );
 435
 436     *pnColumn = This->column;
 437     return S_OK;
 438 }
 439
 440 static HRESULT WINAPI isaxlocator_getLineNumber(
 441         ISAXLocator* iface,
 442         int *pnLine)
 443 {
 444     saxlocator *This = impl_from_ISAXLocator( iface );
 445
 446     *pnLine = This->line;
 447     return S_OK;
 448 }
 449
 450 static HRESULT WINAPI isaxlocator_getPublicId(
 451         ISAXLocator* iface,
 452         const WCHAR ** ppwchPublicId)
 453 {
 454     BSTR publicId;
 455     saxlocator *This = impl_from_ISAXLocator( iface );
 456
 457     if(This->publicId) SysFreeString(This->publicId);
 458
 459     publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
 460     if(SysStringLen(publicId))
 461         This->publicId = (WCHAR*)&publicId;
 462     else
 463     {
 464         SysFreeString(publicId);
 465         This->publicId = NULL;
 466     }
 467
 468     *ppwchPublicId = This->publicId;
 469     return S_OK;
 470 }
 471
 472 static HRESULT WINAPI isaxlocator_getSystemId(
 473         ISAXLocator* iface,
 474         const WCHAR ** ppwchSystemId)
 475 {
 476     BSTR systemId;
 477     saxlocator *This = impl_from_ISAXLocator( iface );
 478
 479     if(This->systemId) SysFreeString(This->systemId);
 480
 481     systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
 482     if(SysStringLen(systemId))
 483         This->systemId = (WCHAR*)&systemId;
 484     else
 485     {
 486         SysFreeString(systemId);
 487         This->systemId = NULL;
 488     }
 489
 490     *ppwchSystemId = This->systemId;
 491     return S_OK;
 492 }
 493
 494 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
 495 {
 496     isaxlocator_QueryInterface,
 497     isaxlocator_AddRef,
 498     isaxlocator_Release,
 499     isaxlocator_getColumnNumber,
 500     isaxlocator_getLineNumber,
 501     isaxlocator_getPublicId,
 502     isaxlocator_getSystemId
 503 };
 504
 505 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator)
 506 {
 507     saxlocator *locator;
 508
 509     locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
 510     if( !locator )
 511         return E_OUTOFMEMORY;
 512
 513     locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
 514     locator->ref = 1;
 515
 516     locator->saxreader = reader;
 517     ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
 518
 519     locator->pParserCtxt = NULL;
 520     locator->publicId = NULL;
 521     locator->systemId = NULL;
 522     locator->lastCur = NULL;
 523     locator->line = 0;
 524     locator->column = 0;
 525     locator->ret = S_OK;
 526
 527     *ppsaxlocator = locator;
 528
 529     TRACE("returning %p\n", *ppsaxlocator);
 530
 531     return S_OK;
 532 }
 533
 534 /*** IVBSAXXMLReader interface ***/
 535 /*** IUnknown methods ***/
 536 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
 537 {
 538     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 539
 540     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 541
 542     *ppvObject = NULL;
 543
 544     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 545          IsEqualGUID( riid, &IID_IDispatch ) ||
 546          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
 547     {
 548         *ppvObject = iface;
 549     }
 550     else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
 551     {
 552         *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
 553     }
 554     else
 555     {
 556         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 557         return E_NOINTERFACE;
 558     }
 559
 560     IVBSAXXMLReader_AddRef( iface );
 561
 562     return S_OK;
 563 }
 564
 565 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
 566 {
 567     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 568     TRACE("%p\n", This );
 569     return InterlockedIncrement( &This->ref );
 570 }
 571
 572 static ULONG WINAPI saxxmlreader_Release(
 573     IVBSAXXMLReader* iface)
 574 {
 575     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 576     LONG ref;
 577
 578     TRACE("%p\n", This );
 579
 580     ref = InterlockedDecrement( &This->ref );
 581     if ( ref == 0 )
 582     {
 583         if(This->contentHandler)
 584             ISAXContentHandler_Release(This->contentHandler);
 585
 586         if(This->errorHandler)
 587             ISAXErrorHandler_Release(This->errorHandler);
 588
 589         HeapFree( GetProcessHeap(), 0, This );
 590     }
 591
 592     return ref;
 593 }
 594 /*** IDispatch ***/
 595 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 596 {
 597     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 598
 599     TRACE("(%p)->(%p)\n", This, pctinfo);
 600
 601     *pctinfo = 1;
 602
 603     return S_OK;
 604 }
 605
 606 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 607     IVBSAXXMLReader *iface,
 608     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 609 {
 610     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 611     HRESULT hr;
 612
 613     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 614
 615     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 616
 617     return hr;
 618 }
 619
 620 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 621     IVBSAXXMLReader *iface,
 622     REFIID riid,
 623     LPOLESTR* rgszNames,
 624     UINT cNames,
 625     LCID lcid,
 626     DISPID* rgDispId)
 627 {
 628     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 629     ITypeInfo *typeinfo;
 630     HRESULT hr;
 631
 632     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 633           lcid, rgDispId);
 634
 635     if(!rgszNames || cNames == 0 || !rgDispId)
 636         return E_INVALIDARG;
 637
 638     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 639     if(SUCCEEDED(hr))
 640     {
 641         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 642         ITypeInfo_Release(typeinfo);
 643     }
 644
 645     return hr;
 646 }
 647
 648 static HRESULT WINAPI saxxmlreader_Invoke(
 649     IVBSAXXMLReader *iface,
 650     DISPID dispIdMember,
 651     REFIID riid,
 652     LCID lcid,
 653     WORD wFlags,
 654     DISPPARAMS* pDispParams,
 655     VARIANT* pVarResult,
 656     EXCEPINFO* pExcepInfo,
 657     UINT* puArgErr)
 658 {
 659     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 660     ITypeInfo *typeinfo;
 661     HRESULT hr;
 662
 663     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 664           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 665
 666     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 667     if(SUCCEEDED(hr))
 668     {
 669         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 670                 pVarResult, pExcepInfo, puArgErr);
 671         ITypeInfo_Release(typeinfo);
 672     }
 673
 674     return hr;
 675 }
 676
 677 /*** IVBSAXXMLReader methods ***/
 678 static HRESULT WINAPI saxxmlreader_getFeature(
 679     IVBSAXXMLReader* iface,
 680     const WCHAR *pFeature,
 681     VARIANT_BOOL *pValue)
 682 {
 683     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 684
 685     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI saxxmlreader_putFeature(
 690     IVBSAXXMLReader* iface,
 691     const WCHAR *pFeature,
 692     VARIANT_BOOL vfValue)
 693 {
 694     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 695
 696     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI saxxmlreader_getProperty(
 701     IVBSAXXMLReader* iface,
 702     const WCHAR *pProp,
 703     VARIANT *pValue)
 704 {
 705     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 706
 707     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI saxxmlreader_putProperty(
 712     IVBSAXXMLReader* iface,
 713     const WCHAR *pProp,
 714     VARIANT value)
 715 {
 716     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 717
 718     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI saxxmlreader_getEntityResolver(
 723     IVBSAXXMLReader* iface,
 724     IVBSAXEntityResolver **pEntityResolver)
 725 {
 726     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 727
 728     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 729     return E_NOTIMPL;
 730 }
 731
 732 static HRESULT WINAPI saxxmlreader_putEntityResolver(
 733     IVBSAXXMLReader* iface,
 734     IVBSAXEntityResolver *pEntityResolver)
 735 {
 736     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 737
 738     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI saxxmlreader_getContentHandler(
 743     IVBSAXXMLReader* iface,
 744     IVBSAXContentHandler **ppContentHandler)
 745 {
 746     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 747
 748     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
 749     return E_NOTIMPL;
 750 }
 751
 752 static HRESULT WINAPI saxxmlreader_putContentHandler(
 753     IVBSAXXMLReader* iface,
 754     IVBSAXContentHandler *contentHandler)
 755 {
 756     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 757
 758     FIXME("(%p)->(%p) stub\n", This, contentHandler);
 759     return E_NOTIMPL;
 760 }
 761
 762 static HRESULT WINAPI saxxmlreader_getDTDHandler(
 763     IVBSAXXMLReader* iface,
 764     IVBSAXDTDHandler **pDTDHandler)
 765 {
 766     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 767
 768     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 769     return E_NOTIMPL;
 770 }
 771
 772 static HRESULT WINAPI saxxmlreader_putDTDHandler(
 773     IVBSAXXMLReader* iface,
 774     IVBSAXDTDHandler *pDTDHandler)
 775 {
 776     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 777
 778     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 779     return E_NOTIMPL;
 780 }
 781
 782 static HRESULT WINAPI saxxmlreader_getErrorHandler(
 783     IVBSAXXMLReader* iface,
 784     IVBSAXErrorHandler **pErrorHandler)
 785 {
 786     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 787
 788     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI saxxmlreader_putErrorHandler(
 793     IVBSAXXMLReader* iface,
 794     IVBSAXErrorHandler *errorHandler)
 795 {
 796     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 797
 798     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI saxxmlreader_getBaseURL(
 803     IVBSAXXMLReader* iface,
 804     const WCHAR **pBaseUrl)
 805 {
 806     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 807
 808     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT WINAPI saxxmlreader_putBaseURL(
 813     IVBSAXXMLReader* iface,
 814     const WCHAR *pBaseUrl)
 815 {
 816     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 817
 818     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 819     return E_NOTIMPL;
 820 }
 821
 822 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
 823     IVBSAXXMLReader* iface,
 824     const WCHAR **pSecureBaseUrl)
 825 {
 826     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 827
 828     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 829     return E_NOTIMPL;
 830 }
 831
 832
 833 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
 834     IVBSAXXMLReader* iface,
 835     const WCHAR *secureBaseUrl)
 836 {
 837     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 838
 839     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI saxxmlreader_parse(
 844     IVBSAXXMLReader* iface,
 845     VARIANT varInput)
 846 {
 847     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 848
 849     FIXME("(%p) stub\n", This);
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI saxxmlreader_parseURL(
 854     IVBSAXXMLReader* iface,
 855     const WCHAR *url)
 856 {
 857     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 858
 859     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 860     return E_NOTIMPL;
 861 }
 862
 863 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
 864 {
 865     saxxmlreader_QueryInterface,
 866     saxxmlreader_AddRef,
 867     saxxmlreader_Release,
 868     saxxmlreader_GetTypeInfoCount,
 869     saxxmlreader_GetTypeInfo,
 870     saxxmlreader_GetIDsOfNames,
 871     saxxmlreader_Invoke,
 872     saxxmlreader_getFeature,
 873     saxxmlreader_putFeature,
 874     saxxmlreader_getProperty,
 875     saxxmlreader_putProperty,
 876     saxxmlreader_getEntityResolver,
 877     saxxmlreader_putEntityResolver,
 878     saxxmlreader_getContentHandler,
 879     saxxmlreader_putContentHandler,
 880     saxxmlreader_getDTDHandler,
 881     saxxmlreader_putDTDHandler,
 882     saxxmlreader_getErrorHandler,
 883     saxxmlreader_putErrorHandler,
 884     saxxmlreader_getBaseURL,
 885     saxxmlreader_putBaseURL,
 886     saxxmlreader_getSecureBaseURL,
 887     saxxmlreader_putSecureBaseURL,
 888     saxxmlreader_parse,
 889     saxxmlreader_parseURL
 890 };
 891
 892 /*** ISAXXMLReader interface ***/
 893 /*** IUnknown methods ***/
 894 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
 895 {
 896     saxreader *This = impl_from_ISAXXMLReader( iface );
 897     return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVtbl, riid, ppvObject);
 898 }
 899
 900 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
 901 {
 902     saxreader *This = impl_from_ISAXXMLReader( iface );
 903     return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVtbl);
 904 }
 905
 906 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
 907 {
 908     saxreader *This = impl_from_ISAXXMLReader( iface );
 909     return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVtbl);
 910 }
 911
 912 /*** ISAXXMLReader methods ***/
 913 static HRESULT WINAPI isaxxmlreader_getFeature(
 914         ISAXXMLReader* iface,
 915         const WCHAR *pFeature,
 916         VARIANT_BOOL *pValue)
 917 {
 918     saxreader *This = impl_from_ISAXXMLReader( iface );
 919
 920     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 921     return E_NOTIMPL;
 922 }
 923
 924 static HRESULT WINAPI isaxxmlreader_putFeature(
 925         ISAXXMLReader* iface,
 926         const WCHAR *pFeature,
 927         VARIANT_BOOL vfValue)
 928 {
 929     saxreader *This = impl_from_ISAXXMLReader( iface );
 930
 931     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI isaxxmlreader_getProperty(
 936         ISAXXMLReader* iface,
 937         const WCHAR *pProp,
 938         VARIANT *pValue)
 939 {
 940     saxreader *This = impl_from_ISAXXMLReader( iface );
 941
 942     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI isaxxmlreader_putProperty(
 947         ISAXXMLReader* iface,
 948         const WCHAR *pProp,
 949         VARIANT value)
 950 {
 951     saxreader *This = impl_from_ISAXXMLReader( iface );
 952
 953     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
 958         ISAXXMLReader* iface,
 959         ISAXEntityResolver **ppEntityResolver)
 960 {
 961     saxreader *This = impl_from_ISAXXMLReader( iface );
 962
 963     FIXME("(%p)->(%p) stub\n", This, ppEntityResolver);
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
 968         ISAXXMLReader* iface,
 969         ISAXEntityResolver *pEntityResolver)
 970 {
 971     saxreader *This = impl_from_ISAXXMLReader( iface );
 972
 973     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI isaxxmlreader_getContentHandler(
 978         ISAXXMLReader* iface,
 979         ISAXContentHandler **pContentHandler)
 980 {
 981     saxreader *This = impl_from_ISAXXMLReader( iface );
 982
 983     TRACE("(%p)->(%p)\n", This, pContentHandler);
 984     if(pContentHandler == NULL)
 985         return E_POINTER;
 986     if(This->contentHandler)
 987         ISAXContentHandler_AddRef(This->contentHandler);
 988     *pContentHandler = This->contentHandler;
 989
 990     return S_OK;
 991 }
 992
 993 static HRESULT WINAPI isaxxmlreader_putContentHandler(
 994         ISAXXMLReader* iface,
 995         ISAXContentHandler *contentHandler)
 996 {
 997     saxreader *This = impl_from_ISAXXMLReader( iface );
 998
 999     TRACE("(%p)->(%p)\n", This, contentHandler);
1000     if(contentHandler)
1001         ISAXContentHandler_AddRef(contentHandler);
1002     if(This->contentHandler)
1003         ISAXContentHandler_Release(This->contentHandler);
1004     This->contentHandler = contentHandler;
1005
1006     return S_OK;
1007 }
1008
1009 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
1010         ISAXXMLReader* iface,
1011         ISAXDTDHandler **pDTDHandler)
1012 {
1013     saxreader *This = impl_from_ISAXXMLReader( iface );
1014
1015     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
1020         ISAXXMLReader* iface,
1021         ISAXDTDHandler *pDTDHandler)
1022 {
1023     saxreader *This = impl_from_ISAXXMLReader( iface );
1024
1025     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1026     return E_NOTIMPL;
1027 }
1028
1029 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
1030         ISAXXMLReader* iface,
1031         ISAXErrorHandler **pErrorHandler)
1032 {
1033     saxreader *This = impl_from_ISAXXMLReader( iface );
1034
1035     TRACE("(%p)->(%p)\n", This, pErrorHandler);
1036     if(pErrorHandler == NULL)
1037         return E_POINTER;
1038     if(This->errorHandler)
1039         ISAXErrorHandler_AddRef(This->errorHandler);
1040     *pErrorHandler = This->errorHandler;
1041
1042     return S_OK;
1043 }
1044
1045 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
1046         ISAXXMLReader* iface,
1047         ISAXErrorHandler *errorHandler)
1048 {
1049     saxreader *This = impl_from_ISAXXMLReader( iface );
1050
1051     TRACE("(%p)->(%p)\n", This, errorHandler);
1052     if(errorHandler)
1053         ISAXErrorHandler_AddRef(errorHandler);
1054     if(This->errorHandler)
1055         ISAXErrorHandler_Release(This->errorHandler);
1056     This->errorHandler = errorHandler;
1057
1058     return S_OK;
1059 }
1060
1061 static HRESULT WINAPI isaxxmlreader_getBaseURL(
1062         ISAXXMLReader* iface,
1063         const WCHAR **pBaseUrl)
1064 {
1065     saxreader *This = impl_from_ISAXXMLReader( iface );
1066
1067     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI isaxxmlreader_putBaseURL(
1072         ISAXXMLReader* iface,
1073         const WCHAR *pBaseUrl)
1074 {
1075     saxreader *This = impl_from_ISAXXMLReader( iface );
1076
1077     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
1078     return E_NOTIMPL;
1079 }
1080
1081 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
1082         ISAXXMLReader* iface,
1083         const WCHAR **pSecureBaseUrl)
1084 {
1085     saxreader *This = impl_from_ISAXXMLReader( iface );
1086
1087     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
1088     return E_NOTIMPL;
1089 }
1090
1091 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
1092         ISAXXMLReader* iface,
1093         const WCHAR *secureBaseUrl)
1094 {
1095     saxreader *This = impl_from_ISAXXMLReader( iface );
1096
1097     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
1098     return E_NOTIMPL;
1099 }
1100
1101 static HRESULT WINAPI isaxxmlreader_parse(
1102         ISAXXMLReader* iface,
1103         VARIANT varInput)
1104 {
1105     saxreader *This = impl_from_ISAXXMLReader( iface );
1106     saxlocator *locator;
1107     xmlChar *data = NULL;
1108     HRESULT hr;
1109
1110     TRACE("(%p)\n", This);
1111
1112     hr = SAXLocator_create(This, &locator);
1113     if(FAILED(hr))
1114         return E_FAIL;
1115
1116     locator->pParserCtxt = xmlNewParserCtxt();
1117     if(!locator->pParserCtxt)
1118     {
1119         ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1120         return E_FAIL;
1121     }
1122
1123     locator->pParserCtxt->sax = &locator->saxreader->sax;
1124     locator->pParserCtxt->userData = locator;
1125
1126     hr = S_OK;
1127     switch(V_VT(&varInput))
1128     {
1129         case VT_BSTR:
1130             data = xmlChar_from_wchar(V_BSTR(&varInput));
1131             xmlSetupParserForBuffer(locator->pParserCtxt, data, NULL);
1132             break;
1133         case VT_ARRAY|VT_UI1: {
1134             void *pSAData;
1135             LONG lBound, uBound;
1136             ULONG dataRead;
1137
1138             hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
1139             if(hr != S_OK) break;
1140             hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
1141             if(hr != S_OK) break;
1142             dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
1143             data = HeapAlloc(GetProcessHeap(), 0, dataRead+1);
1144             if(!data) break;
1145             hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
1146             if(hr != S_OK) break;
1147             memcpy(data, pSAData, dataRead);
1148             data[dataRead] = '\0';
1149             xmlSetupParserForBuffer(locator->pParserCtxt, data, NULL);
1150             SafeArrayUnaccessData(V_ARRAY(&varInput));
1151             break;
1152         }
1153         case VT_UNKNOWN:
1154         case VT_DISPATCH: {
1155             IPersistStream *persistStream;
1156             IStream *stream = NULL;
1157             IXMLDOMDocument *xmlDoc;
1158
1159             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1160                         &IID_IPersistStream, (void**)&persistStream) == S_OK)
1161             {
1162                 hr = IPersistStream_Save(persistStream, stream, TRUE);
1163                 IPersistStream_Release(persistStream);
1164                 if(hr != S_OK) break;
1165             }
1166             if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1167                         &IID_IStream, (void**)&stream) == S_OK)
1168             {
1169                 STATSTG dataInfo;
1170                 ULONG dataRead;
1171
1172                 while(1)
1173                 {
1174                     hr = IStream_Stat(stream, &dataInfo, STATFLAG_NONAME);
1175                     if(hr == E_PENDING) continue;
1176                     break;
1177                 }
1178                 data = HeapAlloc(GetProcessHeap(), 0,
1179                         dataInfo.cbSize.QuadPart+1);
1180                 while(1)
1181                 {
1182                     hr = IStream_Read(stream, data,
1183                             dataInfo.cbSize.QuadPart, &dataRead);
1184                     if(hr == E_PENDING) continue;
1185                     break;
1186                 }
1187                 data[dataInfo.cbSize.QuadPart] = '\0';
1188                 xmlSetupParserForBuffer(locator->pParserCtxt, data, NULL);
1189                 IStream_Release(stream);
1190                 break;
1191             }
1192             if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
1193                                        &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
1194             {
1195                 BSTR bstrData;
1196
1197                 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
1198                 data = xmlChar_from_wchar(bstrData);
1199                 xmlSetupParserForBuffer(locator->pParserCtxt, data, NULL);
1200                 IXMLDOMDocument_Release(xmlDoc);
1201                 hr = E_NOTIMPL;
1202                 break;
1203             }
1204         }
1205         default:
1206             WARN("vt %d not implemented\n", V_VT(&varInput));
1207             hr = E_INVALIDARG;
1208     }
1209
1210     if(hr == S_OK)
1211     {
1212         if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1213         else hr = locator->ret;
1214     }
1215
1216     if(locator->pParserCtxt)
1217     {
1218         locator->pParserCtxt->sax = NULL;
1219         xmlFreeParserCtxt(locator->pParserCtxt);
1220         locator->pParserCtxt = NULL;
1221     }
1222     HeapFree(GetProcessHeap(), 0, data);
1223     ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1224     return hr;
1225 }
1226
1227 static HRESULT WINAPI isaxxmlreader_parseURL(
1228         ISAXXMLReader* iface,
1229         const WCHAR *url)
1230 {
1231     saxreader *This = impl_from_ISAXXMLReader( iface );
1232
1233     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
1234     return E_NOTIMPL;
1235 }
1236
1237 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
1238 {
1239     isaxxmlreader_QueryInterface,
1240     isaxxmlreader_AddRef,
1241     isaxxmlreader_Release,
1242     isaxxmlreader_getFeature,
1243     isaxxmlreader_putFeature,
1244     isaxxmlreader_getProperty,
1245     isaxxmlreader_putProperty,
1246     isaxxmlreader_getEntityResolver,
1247     isaxxmlreader_putEntityResolver,
1248     isaxxmlreader_getContentHandler,
1249     isaxxmlreader_putContentHandler,
1250     isaxxmlreader_getDTDHandler,
1251     isaxxmlreader_putDTDHandler,
1252     isaxxmlreader_getErrorHandler,
1253     isaxxmlreader_putErrorHandler,
1254     isaxxmlreader_getBaseURL,
1255     isaxxmlreader_putBaseURL,
1256     isaxxmlreader_getSecureBaseURL,
1257     isaxxmlreader_putSecureBaseURL,
1258     isaxxmlreader_parse,
1259     isaxxmlreader_parseURL
1260 };
1261
1262 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1263 {
1264     saxreader *reader;
1265
1266     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1267
1268     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
1269     if( !reader )
1270         return E_OUTOFMEMORY;
1271
1272     reader->lpVtbl = &saxreader_vtbl;
1273     reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
1274     reader->ref = 1;
1275     reader->contentHandler = NULL;
1276     reader->errorHandler = NULL;
1277
1278     memset(&reader->sax, 0, sizeof(xmlSAXHandler));
1279     reader->sax.initialized = XML_SAX2_MAGIC;
1280     reader->sax.startDocument = libxmlStartDocument;
1281     reader->sax.endDocument = libxmlEndDocument;
1282     reader->sax.startElementNs = libxmlStartElementNS;
1283     reader->sax.endElementNs = libxmlEndElementNS;
1284     reader->sax.characters = libxmlCharacters;
1285     reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
1286     reader->sax.error = libxmlFatalError;
1287     reader->sax.fatalError = libxmlFatalError;
1288
1289     *ppObj = &reader->lpVtbl;
1290
1291     TRACE("returning iface %p\n", *ppObj);
1292
1293     return S_OK;
1294 }
1295
1296 #else
1297
1298 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1299 {
1300     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
1301             "libxml2 support was not present at compile time.\n");
1302     return E_NOTIMPL;
1303 }
1304
1305 #endif