dlls/msxml3/saxreader.c

   1 /*
   2  *    SAX Reader implementation
   3  *
   4  * Copyright 2008 Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #define COBJMACROS
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31 #include "msxml2.h"
  32 #include "wininet.h"
  33 #include "urlmon.h"
  34 #include "winreg.h"
  35 #include "shlwapi.h"
  36
  37 #include "wine/debug.h"
  38
  39 #include "msxml_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  42
  43 #ifdef HAVE_LIBXML2
  44
  45 #include <libxml/SAX2.h>
  46
  47 typedef struct _saxreader
  48 {
  49     const struct IVBSAXXMLReaderVtbl *lpVtbl;
  50     LONG ref;
  51     xmlSAXHandler sax;
  52 } saxreader;
  53
  54 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
  55 {
  56     return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVtbl));
  57 }
  58
  59 /*** IUnknown methods ***/
  60 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
  61 {
  62     saxreader *This = impl_from_IVBSAXXMLReader( iface );
  63
  64     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
  65
  66     *ppvObject = NULL;
  67
  68     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
  69          IsEqualGUID( riid, &IID_IDispatch ) ||
  70          IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
  71     {
  72         *ppvObject = iface;
  73     }
  74     else
  75     {
  76         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  77         return E_NOINTERFACE;
  78     }
  79
  80     IVBSAXXMLReader_AddRef( iface );
  81
  82     return S_OK;
  83 }
  84
  85 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
  86 {
  87     saxreader *This = impl_from_IVBSAXXMLReader( iface );
  88     TRACE("%p\n", This );
  89     return InterlockedIncrement( &This->ref );
  90 }
  91
  92 static ULONG WINAPI saxxmlreader_Release(
  93     IVBSAXXMLReader* iface)
  94 {
  95     saxreader *This = impl_from_IVBSAXXMLReader( iface );
  96     LONG ref;
  97
  98     TRACE("%p\n", This );
  99
 100     ref = InterlockedDecrement( &This->ref );
 101     if ( ref == 0 )
 102     {
 103         HeapFree( GetProcessHeap(), 0, This );
 104     }
 105
 106     return ref;
 107 }
 108 /*** IDispatch ***/
 109 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
 110 {
 111     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 112
 113     TRACE("(%p)->(%p)\n", This, pctinfo);
 114
 115     *pctinfo = 1;
 116
 117     return S_OK;
 118 }
 119
 120 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
 121     IVBSAXXMLReader *iface,
 122     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 123 {
 124     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 125     HRESULT hr;
 126
 127     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 128
 129     hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
 130
 131     return hr;
 132 }
 133
 134 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
 135     IVBSAXXMLReader *iface,
 136     REFIID riid,
 137     LPOLESTR* rgszNames,
 138     UINT cNames,
 139     LCID lcid,
 140     DISPID* rgDispId)
 141 {
 142     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 143     ITypeInfo *typeinfo;
 144     HRESULT hr;
 145
 146     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 147           lcid, rgDispId);
 148
 149     if(!rgszNames || cNames == 0 || !rgDispId)
 150         return E_INVALIDARG;
 151
 152     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 153     if(SUCCEEDED(hr))
 154     {
 155         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 156         ITypeInfo_Release(typeinfo);
 157     }
 158
 159     return hr;
 160 }
 161
 162 static HRESULT WINAPI saxxmlreader_Invoke(
 163     IVBSAXXMLReader *iface,
 164     DISPID dispIdMember,
 165     REFIID riid,
 166     LCID lcid,
 167     WORD wFlags,
 168     DISPPARAMS* pDispParams,
 169     VARIANT* pVarResult,
 170     EXCEPINFO* pExcepInfo,
 171     UINT* puArgErr)
 172 {
 173     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 174     ITypeInfo *typeinfo;
 175     HRESULT hr;
 176
 177     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 178           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 179
 180     hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
 181     if(SUCCEEDED(hr))
 182     {
 183         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 184                 pVarResult, pExcepInfo, puArgErr);
 185         ITypeInfo_Release(typeinfo);
 186     }
 187
 188     return hr;
 189 }
 190
 191 /*** IVBSAXXMLReader methods ***/
 192 static HRESULT WINAPI saxxmlreader_getFeature(
 193     IVBSAXXMLReader* iface,
 194     const WCHAR *pFeature,
 195     VARIANT_BOOL *pValue)
 196 {
 197     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 198
 199     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI saxxmlreader_putFeature(
 204     IVBSAXXMLReader* iface,
 205     const WCHAR *pFeature,
 206     VARIANT_BOOL vfValue)
 207 {
 208     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 209
 210     FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI saxxmlreader_getProperty(
 215     IVBSAXXMLReader* iface,
 216     const WCHAR *pProp,
 217     VARIANT *pValue)
 218 {
 219     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 220
 221     FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI saxxmlreader_putProperty(
 226     IVBSAXXMLReader* iface,
 227     const WCHAR *pProp,
 228     VARIANT value)
 229 {
 230     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 231
 232     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pProp));
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI saxxmlreader_getEntityResolver(
 237     IVBSAXXMLReader* iface,
 238     IVBSAXEntityResolver **pEntityResolver)
 239 {
 240     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 241
 242     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI saxxmlreader_putEntityResolver(
 247     IVBSAXXMLReader* iface,
 248     IVBSAXEntityResolver *pEntityResolver)
 249 {
 250     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 251
 252     FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI saxxmlreader_getContentHandler(
 257     IVBSAXXMLReader* iface,
 258     IVBSAXContentHandler **ppContentHandler)
 259 {
 260     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 261
 262     FIXME("(%p)->(%p) stub\n", This, ppContentHandler);
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI saxxmlreader_putContentHandler(
 267     IVBSAXXMLReader* iface,
 268     IVBSAXContentHandler *contentHandler)
 269 {
 270     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 271
 272     FIXME("(%p)->(%p) stub\n", This, contentHandler);
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI saxxmlreader_getDTDHandler(
 277     IVBSAXXMLReader* iface,
 278     IVBSAXDTDHandler **pDTDHandler)
 279 {
 280     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 281
 282     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI saxxmlreader_putDTDHandler(
 287     IVBSAXXMLReader* iface,
 288     IVBSAXDTDHandler *pDTDHandler)
 289 {
 290     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 291
 292     FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI saxxmlreader_getErrorHandler(
 297     IVBSAXXMLReader* iface,
 298     IVBSAXErrorHandler **pErrorHandler)
 299 {
 300     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 301
 302     FIXME("(%p)->(%p) stub\n", This, pErrorHandler);
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT WINAPI saxxmlreader_putErrorHandler(
 307     IVBSAXXMLReader* iface,
 308     IVBSAXErrorHandler *errorHandler)
 309 {
 310     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 311
 312     FIXME("(%p)->(%p) stub\n", This, errorHandler);
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI saxxmlreader_getBaseURL(
 317     IVBSAXXMLReader* iface,
 318     const WCHAR **pBaseUrl)
 319 {
 320     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 321
 322     FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI saxxmlreader_putBaseURL(
 327     IVBSAXXMLReader* iface,
 328     const WCHAR *pBaseUrl)
 329 {
 330     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 331
 332     FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI saxxmlreader_getSecureBaseURL(
 337     IVBSAXXMLReader* iface,
 338     const WCHAR **pSecureBaseUrl)
 339 {
 340     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 341
 342     FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
 343     return E_NOTIMPL;
 344 }
 345
 346
 347 static HRESULT WINAPI saxxmlreader_putSecureBaseURL(
 348     IVBSAXXMLReader* iface,
 349     const WCHAR *secureBaseUrl)
 350 {
 351     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 352
 353     FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
 354     return E_NOTIMPL;
 355 }
 356
 357 static HRESULT WINAPI saxxmlreader_parse(
 358     IVBSAXXMLReader* iface,
 359     VARIANT varInput)
 360 {
 361     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 362
 363     FIXME("(%p) stub\n", This);
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI saxxmlreader_parseURL(
 368     IVBSAXXMLReader* iface,
 369     const WCHAR *url)
 370 {
 371     saxreader *This = impl_from_IVBSAXXMLReader( iface );
 372
 373     FIXME("(%p)->(%s) stub\n", This, debugstr_w(url));
 374     return E_NOTIMPL;
 375 }
 376
 377 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
 378 {
 379     saxxmlreader_QueryInterface,
 380     saxxmlreader_AddRef,
 381     saxxmlreader_Release,
 382     saxxmlreader_GetTypeInfoCount,
 383     saxxmlreader_GetTypeInfo,
 384     saxxmlreader_GetIDsOfNames,
 385     saxxmlreader_Invoke,
 386     saxxmlreader_getFeature,
 387     saxxmlreader_putFeature,
 388     saxxmlreader_getProperty,
 389     saxxmlreader_putProperty,
 390     saxxmlreader_getEntityResolver,
 391     saxxmlreader_putEntityResolver,
 392     saxxmlreader_getContentHandler,
 393     saxxmlreader_putContentHandler,
 394     saxxmlreader_getDTDHandler,
 395     saxxmlreader_putDTDHandler,
 396     saxxmlreader_getErrorHandler,
 397     saxxmlreader_putErrorHandler,
 398     saxxmlreader_getBaseURL,
 399     saxxmlreader_putBaseURL,
 400     saxxmlreader_getSecureBaseURL,
 401     saxxmlreader_putSecureBaseURL,
 402     saxxmlreader_parse,
 403     saxxmlreader_parseURL
 404 };
 405
 406 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 407 {
 408     saxreader *reader;
 409
 410     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 411
 412     reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
 413     if( !reader )
 414         return E_OUTOFMEMORY;
 415
 416     reader->lpVtbl = &saxreader_vtbl;
 417     reader->ref = 1;
 418
 419     *ppObj = &reader->lpVtbl;
 420
 421     TRACE("returning iface %p\n", *ppObj);
 422
 423     return S_OK;
 424 }
 425
 426 #else
 427
 428 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 429 {
 430     MESSAGE("This program tried to use a SAX XML Reader object, but\n"
 431             "libxml2 support was not present at compile time.\n");
 432     return E_NOTIMPL;
 433 }
 434
 435 #endif