push 07a2b33f792746135ccf34a3b3e1dfb2a3c1e823
[wine/hacks.git] / dlls / msxml3 / saxreader.c
blob9fc226ad6d2e3a8953609d00ca1acc4e3f2c2c91
1 /*
2 * SAX Reader implementation
4 * Copyright 2008 Alistair Leslie-Hughes
5 * Copyright 2008 Piotr Caban
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.
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.
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
21 #define COBJMACROS
23 #include "config.h"
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"
38 #include "wine/debug.h"
40 #include "msxml_private.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
44 #ifdef HAVE_LIBXML2
46 #include <libxml/SAX2.h>
47 #include <libxml/parserInternals.h>
49 typedef struct _saxreader
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 struct ISAXLexicalHandler *lexicalHandler;
59 struct IVBSAXLexicalHandler *vblexicalHandler;
60 struct ISAXDeclHandler *declHandler;
61 struct IVBSAXDeclHandler *vbdeclHandler;
62 xmlSAXHandler sax;
63 BOOL isParsing;
64 } saxreader;
66 typedef struct _saxlocator
68 const struct IVBSAXLocatorVtbl *lpVBSAXLocatorVtbl;
69 const struct ISAXLocatorVtbl *lpSAXLocatorVtbl;
70 LONG ref;
71 saxreader *saxreader;
72 HRESULT ret;
73 xmlParserCtxtPtr pParserCtxt;
74 WCHAR *publicId;
75 WCHAR *systemId;
76 xmlChar *lastCur;
77 int line;
78 int realLine;
79 int column;
80 int realColumn;
81 BOOL vbInterface;
82 int nsStackSize;
83 int nsStackLast;
84 int *nsStack;
85 } saxlocator;
87 typedef struct _saxattributes
89 const struct IVBSAXAttributesVtbl *lpVBSAXAttributesVtbl;
90 const struct ISAXAttributesVtbl *lpSAXAttributesVtbl;
91 LONG ref;
92 int nb_attributes;
93 BSTR *szLocalname;
94 BSTR *szURI;
95 BSTR *szValue;
96 BSTR *szQName;
97 } saxattributes;
99 static inline saxreader *impl_from_IVBSAXXMLReader( IVBSAXXMLReader *iface )
101 return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpVBSAXXMLReaderVtbl));
104 static inline saxreader *impl_from_ISAXXMLReader( ISAXXMLReader *iface )
106 return (saxreader *)((char*)iface - FIELD_OFFSET(saxreader, lpSAXXMLReaderVtbl));
109 static inline saxlocator *impl_from_IVBSAXLocator( IVBSAXLocator *iface )
111 return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpVBSAXLocatorVtbl));
114 static inline saxlocator *impl_from_ISAXLocator( ISAXLocator *iface )
116 return (saxlocator *)((char*)iface - FIELD_OFFSET(saxlocator, lpSAXLocatorVtbl));
119 static inline saxattributes *impl_from_IVBSAXAttributes( IVBSAXAttributes *iface )
121 return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpVBSAXAttributesVtbl));
124 static inline saxattributes *impl_from_ISAXAttributes( ISAXAttributes *iface )
126 return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
130 static HRESULT namespacePush(saxlocator *locator, int ns)
132 if(locator->nsStackLast>=locator->nsStackSize)
134 int *new_stack;
136 new_stack = HeapReAlloc(GetProcessHeap(), 0,
137 locator->nsStack, locator->nsStackSize*2);
138 if(!new_stack) return E_OUTOFMEMORY;
139 locator->nsStack = new_stack;
140 locator->nsStackSize *= 2;
142 locator->nsStack[locator->nsStackLast++] = ns;
144 return S_OK;
147 static int namespacePop(saxlocator *locator)
149 if(locator->nsStackLast == 0) return 0;
150 return locator->nsStack[--locator->nsStackLast];
153 static BSTR bstr_from_xmlCharN(const xmlChar *buf, int len)
155 DWORD dLen;
156 LPWSTR str;
157 BSTR bstr;
159 if (!buf)
160 return NULL;
162 dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
163 if(len != -1) dLen++;
164 str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, dLen * sizeof (WCHAR));
165 if (!str)
166 return NULL;
167 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, str, dLen);
168 if(len != -1) str[dLen-1] = '\0';
169 bstr = SysAllocString(str);
170 HeapFree(GetProcessHeap(), 0, str);
172 return bstr;
175 static BSTR QName_from_xmlChar(const xmlChar *prefix, const xmlChar *name)
177 DWORD dLen, dLast;
178 LPWSTR str;
179 BSTR bstr;
181 if(!name) return NULL;
183 if(!prefix || *prefix=='\0')
184 return bstr_from_xmlChar(name);
186 dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, NULL, 0)
187 + MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, NULL, 0);
188 str = HeapAlloc(GetProcessHeap(), 0, dLen * sizeof(WCHAR));
189 if(!str)
190 return NULL;
192 dLast = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, str, dLen);
193 str[dLast-1] = ':';
194 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &str[dLast], dLen-dLast);
195 bstr = SysAllocString(str);
197 HeapFree(GetProcessHeap(), 0, str);
199 return bstr;
202 static void format_error_message_from_id(saxlocator *This, HRESULT hr)
204 xmlStopParser(This->pParserCtxt);
205 This->ret = hr;
207 if((This->vbInterface && This->saxreader->vberrorHandler)
208 || (!This->vbInterface && This->saxreader->errorHandler))
210 WCHAR msg[1024];
211 if(!FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
212 NULL, hr, 0, msg, sizeof(msg), NULL))
214 FIXME("MSXML errors not yet supported.\n");
215 msg[0] = '\0';
218 if(This->vbInterface)
220 BSTR bstrMsg = SysAllocString(msg);
221 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
222 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrMsg, hr);
224 else
225 ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
226 (ISAXLocator*)&This->lpSAXLocatorVtbl, msg, hr);
230 static void update_position(saxlocator *This, xmlChar *end)
232 if(This->lastCur == NULL)
234 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
235 This->realLine = 1;
236 This->realColumn = 1;
238 else if(This->lastCur < This->pParserCtxt->input->base)
240 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
241 This->realLine = 1;
242 This->realColumn = 1;
245 if(This->pParserCtxt->input->cur<This->lastCur)
247 This->lastCur = (xmlChar*)This->pParserCtxt->input->base;
248 This->realLine -= 1;
249 This->realColumn = 1;
252 if(!end) end = (xmlChar*)This->pParserCtxt->input->cur;
254 while(This->lastCur < end)
256 if(*(This->lastCur) == '\n')
258 This->realLine++;
259 This->realColumn = 1;
261 else if(*(This->lastCur) == '\r' &&
262 (This->lastCur==This->pParserCtxt->input->end ||
263 *(This->lastCur+1)!='\n'))
265 This->realLine++;
266 This->realColumn = 1;
268 else This->realColumn++;
270 This->lastCur++;
272 /* Count multibyte UTF8 encoded characters once */
273 while((*(This->lastCur)&0xC0) == 0x80) This->lastCur++;
276 This->line = This->realLine;
277 This->column = This->realColumn;
280 /*** IVBSAXAttributes interface ***/
281 /*** IUnknown methods ***/
282 static HRESULT WINAPI ivbsaxattributes_QueryInterface(
283 IVBSAXAttributes* iface,
284 REFIID riid,
285 void **ppvObject)
287 saxattributes *This = impl_from_IVBSAXAttributes(iface);
289 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
291 *ppvObject = NULL;
293 if (IsEqualGUID(riid, &IID_IUnknown) ||
294 IsEqualGUID(riid, &IID_IDispatch) ||
295 IsEqualGUID(riid, &IID_IVBSAXAttributes))
297 *ppvObject = iface;
299 else
301 FIXME("interface %s not implemented\n", debugstr_guid(riid));
302 return E_NOINTERFACE;
305 IVBSAXAttributes_AddRef(iface);
307 return S_OK;
310 static ULONG WINAPI ivbsaxattributes_AddRef(IVBSAXAttributes* iface)
312 saxattributes *This = impl_from_IVBSAXAttributes(iface);
313 return ISAXAttributes_AddRef((ISAXAttributes*)&This->lpSAXAttributesVtbl);
316 static ULONG WINAPI ivbsaxattributes_Release(IVBSAXAttributes* iface)
318 saxattributes *This = impl_from_IVBSAXAttributes(iface);
319 return ISAXAttributes_Release((ISAXAttributes*)&This->lpSAXAttributesVtbl);
322 /*** IDispatch methods ***/
323 static HRESULT WINAPI ivbsaxattributes_GetTypeInfoCount( IVBSAXAttributes *iface, UINT* pctinfo )
325 saxattributes *This = impl_from_IVBSAXAttributes( iface );
327 TRACE("(%p)->(%p)\n", This, pctinfo);
329 *pctinfo = 1;
331 return S_OK;
334 static HRESULT WINAPI ivbsaxattributes_GetTypeInfo(
335 IVBSAXAttributes *iface,
336 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
338 saxattributes *This = impl_from_IVBSAXAttributes( iface );
339 HRESULT hr;
341 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
343 hr = get_typeinfo(IVBSAXAttributes_tid, ppTInfo);
345 return hr;
348 static HRESULT WINAPI ivbsaxattributes_GetIDsOfNames(
349 IVBSAXAttributes *iface,
350 REFIID riid,
351 LPOLESTR* rgszNames,
352 UINT cNames,
353 LCID lcid,
354 DISPID* rgDispId)
356 saxattributes *This = impl_from_IVBSAXAttributes( iface );
357 ITypeInfo *typeinfo;
358 HRESULT hr;
360 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
361 lcid, rgDispId);
363 if(!rgszNames || cNames == 0 || !rgDispId)
364 return E_INVALIDARG;
366 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
367 if(SUCCEEDED(hr))
369 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
370 ITypeInfo_Release(typeinfo);
373 return hr;
376 static HRESULT WINAPI ivbsaxattributes_Invoke(
377 IVBSAXAttributes *iface,
378 DISPID dispIdMember,
379 REFIID riid,
380 LCID lcid,
381 WORD wFlags,
382 DISPPARAMS* pDispParams,
383 VARIANT* pVarResult,
384 EXCEPINFO* pExcepInfo,
385 UINT* puArgErr)
387 saxattributes *This = impl_from_IVBSAXAttributes( iface );
388 ITypeInfo *typeinfo;
389 HRESULT hr;
391 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
392 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
394 hr = get_typeinfo(IVBSAXAttributes_tid, &typeinfo);
395 if(SUCCEEDED(hr))
397 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXAttributesVtbl), dispIdMember, wFlags, pDispParams,
398 pVarResult, pExcepInfo, puArgErr);
399 ITypeInfo_Release(typeinfo);
402 return hr;
405 /*** IVBSAXAttributes methods ***/
406 static HRESULT WINAPI ivbsaxattributes_get_length(
407 IVBSAXAttributes* iface,
408 int *nLength)
410 saxattributes *This = impl_from_IVBSAXAttributes( iface );
411 return ISAXAttributes_getLength(
412 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
413 nLength);
416 static HRESULT WINAPI ivbsaxattributes_getURI(
417 IVBSAXAttributes* iface,
418 int nIndex,
419 BSTR *uri)
421 int len;
422 saxattributes *This = impl_from_IVBSAXAttributes( iface );
423 return ISAXAttributes_getURI(
424 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
425 nIndex, (const WCHAR**)uri, &len);
428 static HRESULT WINAPI ivbsaxattributes_getLocalName(
429 IVBSAXAttributes* iface,
430 int nIndex,
431 BSTR *localName)
433 int len;
434 saxattributes *This = impl_from_IVBSAXAttributes( iface );
435 return ISAXAttributes_getLocalName(
436 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
437 nIndex, (const WCHAR**)localName, &len);
440 static HRESULT WINAPI ivbsaxattributes_getQName(
441 IVBSAXAttributes* iface,
442 int nIndex,
443 BSTR *QName)
445 int len;
446 saxattributes *This = impl_from_IVBSAXAttributes( iface );
447 return ISAXAttributes_getQName(
448 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
449 nIndex, (const WCHAR**)QName, &len);
452 static HRESULT WINAPI ivbsaxattributes_getIndexFromName(
453 IVBSAXAttributes* iface,
454 BSTR uri,
455 BSTR localName,
456 int *index)
458 saxattributes *This = impl_from_IVBSAXAttributes( iface );
459 return ISAXAttributes_getIndexFromName(
460 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
461 (const WCHAR*)uri, SysStringLen(uri),
462 (const WCHAR*)localName, SysStringLen(localName), index);
465 static HRESULT WINAPI ivbsaxattributes_getIndexFromQName(
466 IVBSAXAttributes* iface,
467 BSTR QName,
468 int *index)
470 saxattributes *This = impl_from_IVBSAXAttributes( iface );
471 return ISAXAttributes_getIndexFromQName(
472 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
473 (const WCHAR*)QName, SysStringLen(QName), index);
476 static HRESULT WINAPI ivbsaxattributes_getType(
477 IVBSAXAttributes* iface,
478 int nIndex,
479 BSTR *type)
481 int len;
482 saxattributes *This = impl_from_IVBSAXAttributes( iface );
483 return ISAXAttributes_getType(
484 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
485 nIndex, (const WCHAR**)type, &len);
488 static HRESULT WINAPI ivbsaxattributes_getTypeFromName(
489 IVBSAXAttributes* iface,
490 BSTR uri,
491 BSTR localName,
492 BSTR *type)
494 int len;
495 saxattributes *This = impl_from_IVBSAXAttributes( iface );
496 return ISAXAttributes_getTypeFromName(
497 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
498 (const WCHAR*)uri, SysStringLen(uri),
499 (const WCHAR*)localName, SysStringLen(localName),
500 (const WCHAR**)type, &len);
503 static HRESULT WINAPI ivbsaxattributes_getTypeFromQName(
504 IVBSAXAttributes* iface,
505 BSTR QName,
506 BSTR *type)
508 int len;
509 saxattributes *This = impl_from_IVBSAXAttributes( iface );
510 return ISAXAttributes_getTypeFromQName(
511 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
512 (const WCHAR*)QName, SysStringLen(QName),
513 (const WCHAR**)type, &len);
516 static HRESULT WINAPI ivbsaxattributes_getValue(
517 IVBSAXAttributes* iface,
518 int nIndex,
519 BSTR *value)
521 int len;
522 saxattributes *This = impl_from_IVBSAXAttributes( iface );
523 return ISAXAttributes_getValue(
524 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
525 nIndex, (const WCHAR**)value, &len);
528 static HRESULT WINAPI ivbsaxattributes_getValueFromName(
529 IVBSAXAttributes* iface,
530 BSTR uri,
531 BSTR localName,
532 BSTR *value)
534 int len;
535 saxattributes *This = impl_from_IVBSAXAttributes( iface );
536 return ISAXAttributes_getValueFromName(
537 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
538 (const WCHAR*)uri, SysStringLen(uri),
539 (const WCHAR*)localName, SysStringLen(localName),
540 (const WCHAR**)value, &len);
543 static HRESULT WINAPI ivbsaxattributes_getValueFromQName(
544 IVBSAXAttributes* iface,
545 BSTR QName,
546 BSTR *value)
548 int len;
549 saxattributes *This = impl_from_IVBSAXAttributes( iface );
550 return ISAXAttributes_getValueFromQName(
551 (ISAXAttributes*)&This->lpSAXAttributesVtbl,
552 (const WCHAR*)QName, SysStringLen(QName),
553 (const WCHAR**)value, &len);
556 static const struct IVBSAXAttributesVtbl ivbsaxattributes_vtbl =
558 ivbsaxattributes_QueryInterface,
559 ivbsaxattributes_AddRef,
560 ivbsaxattributes_Release,
561 ivbsaxattributes_GetTypeInfoCount,
562 ivbsaxattributes_GetTypeInfo,
563 ivbsaxattributes_GetIDsOfNames,
564 ivbsaxattributes_Invoke,
565 ivbsaxattributes_get_length,
566 ivbsaxattributes_getURI,
567 ivbsaxattributes_getLocalName,
568 ivbsaxattributes_getQName,
569 ivbsaxattributes_getIndexFromName,
570 ivbsaxattributes_getIndexFromQName,
571 ivbsaxattributes_getType,
572 ivbsaxattributes_getTypeFromName,
573 ivbsaxattributes_getTypeFromQName,
574 ivbsaxattributes_getValue,
575 ivbsaxattributes_getValueFromName,
576 ivbsaxattributes_getValueFromQName
579 /*** ISAXAttributes interface ***/
580 /*** IUnknown methods ***/
581 static HRESULT WINAPI isaxattributes_QueryInterface(
582 ISAXAttributes* iface,
583 REFIID riid,
584 void **ppvObject)
586 saxattributes *This = impl_from_ISAXAttributes(iface);
588 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
590 *ppvObject = NULL;
592 if (IsEqualGUID(riid, &IID_IUnknown) ||
593 IsEqualGUID(riid, &IID_ISAXAttributes))
595 *ppvObject = iface;
597 else
599 FIXME("interface %s not implemented\n", debugstr_guid(riid));
600 return E_NOINTERFACE;
603 ISAXAttributes_AddRef(iface);
605 return S_OK;
608 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
610 saxattributes *This = impl_from_ISAXAttributes(iface);
611 TRACE("%p\n", This);
612 return InterlockedIncrement(&This->ref);
615 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
617 saxattributes *This = impl_from_ISAXAttributes(iface);
618 LONG ref;
620 TRACE("%p\n", This);
622 ref = InterlockedDecrement(&This->ref);
623 if (ref==0)
625 int index;
626 for(index=0; index<This->nb_attributes; index++)
628 SysFreeString(This->szLocalname[index]);
629 SysFreeString(This->szURI[index]);
630 SysFreeString(This->szValue[index]);
631 SysFreeString(This->szQName[index]);
634 HeapFree(GetProcessHeap(), 0, This->szLocalname);
635 HeapFree(GetProcessHeap(), 0, This->szURI);
636 HeapFree(GetProcessHeap(), 0, This->szValue);
637 HeapFree(GetProcessHeap(), 0, This->szQName);
639 HeapFree(GetProcessHeap(), 0, This);
642 return ref;
645 /*** ISAXAttributes methods ***/
646 static HRESULT WINAPI isaxattributes_getLength(
647 ISAXAttributes* iface,
648 int *length)
650 saxattributes *This = impl_from_ISAXAttributes( iface );
652 *length = This->nb_attributes;
653 TRACE("Length set to %d\n", *length);
654 return S_OK;
657 static HRESULT WINAPI isaxattributes_getURI(
658 ISAXAttributes* iface,
659 int nIndex,
660 const WCHAR **pUrl,
661 int *pUriSize)
663 saxattributes *This = impl_from_ISAXAttributes( iface );
664 TRACE("(%p)->(%d)\n", This, nIndex);
666 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
667 if(!pUrl || !pUriSize) return E_POINTER;
669 *pUriSize = SysStringLen(This->szURI[nIndex]);
670 *pUrl = This->szURI[nIndex];
672 return S_OK;
675 static HRESULT WINAPI isaxattributes_getLocalName(
676 ISAXAttributes* iface,
677 int nIndex,
678 const WCHAR **pLocalName,
679 int *pLocalNameLength)
681 saxattributes *This = impl_from_ISAXAttributes( iface );
682 TRACE("(%p)->(%d)\n", This, nIndex);
684 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
685 if(!pLocalName || !pLocalNameLength) return E_POINTER;
687 *pLocalNameLength = SysStringLen(This->szLocalname[nIndex]);
688 *pLocalName = This->szLocalname[nIndex];
690 return S_OK;
693 static HRESULT WINAPI isaxattributes_getQName(
694 ISAXAttributes* iface,
695 int nIndex,
696 const WCHAR **pQName,
697 int *pQNameLength)
699 saxattributes *This = impl_from_ISAXAttributes( iface );
700 TRACE("(%p)->(%d)\n", This, nIndex);
702 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
703 if(!pQName || !pQNameLength) return E_POINTER;
705 *pQNameLength = SysStringLen(This->szQName[nIndex]);
706 *pQName = This->szQName[nIndex];
708 return S_OK;
711 static HRESULT WINAPI isaxattributes_getName(
712 ISAXAttributes* iface,
713 int nIndex,
714 const WCHAR **pUri,
715 int *pUriLength,
716 const WCHAR **pLocalName,
717 int *pLocalNameSize,
718 const WCHAR **pQName,
719 int *pQNameLength)
721 saxattributes *This = impl_from_ISAXAttributes( iface );
722 TRACE("(%p)->(%d)\n", This, nIndex);
724 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
725 if(!pUri || !pUriLength || !pLocalName || !pLocalNameSize
726 || !pQName || !pQNameLength) return E_POINTER;
728 *pUriLength = SysStringLen(This->szURI[nIndex]);
729 *pUri = This->szURI[nIndex];
730 *pLocalNameSize = SysStringLen(This->szLocalname[nIndex]);
731 *pLocalName = This->szLocalname[nIndex];
732 *pQNameLength = SysStringLen(This->szQName[nIndex]);
733 *pQName = This->szQName[nIndex];
735 return S_OK;
738 static HRESULT WINAPI isaxattributes_getIndexFromName(
739 ISAXAttributes* iface,
740 const WCHAR *pUri,
741 int cUriLength,
742 const WCHAR *pLocalName,
743 int cocalNameLength,
744 int *index)
746 saxattributes *This = impl_from_ISAXAttributes( iface );
747 int i;
748 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), cUriLength,
749 debugstr_w(pLocalName), cocalNameLength);
751 if(!pUri || !pLocalName || !index) return E_POINTER;
753 for(i=0; i<This->nb_attributes; i++)
755 if(cUriLength!=SysStringLen(This->szURI[i])
756 || cocalNameLength!=SysStringLen(This->szLocalname[i]))
757 continue;
758 if(cUriLength && memcmp(pUri, This->szURI[i],
759 sizeof(WCHAR)*cUriLength))
760 continue;
761 if(cocalNameLength && memcmp(pLocalName, This->szLocalname[i],
762 sizeof(WCHAR)*cocalNameLength))
763 continue;
765 *index = i;
766 return S_OK;
769 return E_INVALIDARG;
772 static HRESULT WINAPI isaxattributes_getIndexFromQName(
773 ISAXAttributes* iface,
774 const WCHAR *pQName,
775 int nQNameLength,
776 int *index)
778 saxattributes *This = impl_from_ISAXAttributes( iface );
779 int i;
780 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQNameLength);
782 if(!pQName || !index) return E_POINTER;
783 if(!nQNameLength) return E_INVALIDARG;
785 for(i=0; i<This->nb_attributes; i++)
787 if(nQNameLength!=SysStringLen(This->szQName[i])) continue;
788 if(memcmp(pQName, This->szQName, sizeof(WCHAR)*nQNameLength)) continue;
790 *index = i;
791 return S_OK;
794 return E_INVALIDARG;
797 static HRESULT WINAPI isaxattributes_getType(
798 ISAXAttributes* iface,
799 int nIndex,
800 const WCHAR **pType,
801 int *pTypeLength)
803 saxattributes *This = impl_from_ISAXAttributes( iface );
805 FIXME("(%p)->(%d) stub\n", This, nIndex);
806 return E_NOTIMPL;
809 static HRESULT WINAPI isaxattributes_getTypeFromName(
810 ISAXAttributes* iface,
811 const WCHAR *pUri,
812 int nUri,
813 const WCHAR *pLocalName,
814 int nLocalName,
815 const WCHAR **pType,
816 int *nType)
818 saxattributes *This = impl_from_ISAXAttributes( iface );
820 FIXME("(%p)->(%s, %d, %s, %d) stub\n", This, debugstr_w(pUri), nUri,
821 debugstr_w(pLocalName), nLocalName);
822 return E_NOTIMPL;
825 static HRESULT WINAPI isaxattributes_getTypeFromQName(
826 ISAXAttributes* iface,
827 const WCHAR *pQName,
828 int nQName,
829 const WCHAR **pType,
830 int *nType)
832 saxattributes *This = impl_from_ISAXAttributes( iface );
834 FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(pQName), nQName);
835 return E_NOTIMPL;
838 static HRESULT WINAPI isaxattributes_getValue(
839 ISAXAttributes* iface,
840 int nIndex,
841 const WCHAR **pValue,
842 int *nValue)
844 saxattributes *This = impl_from_ISAXAttributes( iface );
845 TRACE("(%p)->(%d)\n", This, nIndex);
847 if(nIndex>=This->nb_attributes || nIndex<0) return E_INVALIDARG;
848 if(!pValue || !nValue) return E_POINTER;
850 *nValue = SysStringLen(This->szValue[nIndex]);
851 *pValue = This->szValue[nIndex];
853 return S_OK;
856 static HRESULT WINAPI isaxattributes_getValueFromName(
857 ISAXAttributes* iface,
858 const WCHAR *pUri,
859 int nUri,
860 const WCHAR *pLocalName,
861 int nLocalName,
862 const WCHAR **pValue,
863 int *nValue)
865 HRESULT hr;
866 int index;
867 saxattributes *This = impl_from_ISAXAttributes( iface );
868 TRACE("(%p)->(%s, %d, %s, %d)\n", This, debugstr_w(pUri), nUri,
869 debugstr_w(pLocalName), nLocalName);
871 hr = ISAXAttributes_getIndexFromName(iface,
872 pUri, nUri, pLocalName, nLocalName, &index);
873 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
875 return hr;
878 static HRESULT WINAPI isaxattributes_getValueFromQName(
879 ISAXAttributes* iface,
880 const WCHAR *pQName,
881 int nQName,
882 const WCHAR **pValue,
883 int *nValue)
885 HRESULT hr;
886 int index;
887 saxattributes *This = impl_from_ISAXAttributes( iface );
888 TRACE("(%p)->(%s, %d)\n", This, debugstr_w(pQName), nQName);
890 hr = ISAXAttributes_getIndexFromQName(iface, pQName, nQName, &index);
891 if(hr==S_OK) hr = ISAXAttributes_getValue(iface, index, pValue, nValue);
893 return hr;
896 static const struct ISAXAttributesVtbl isaxattributes_vtbl =
898 isaxattributes_QueryInterface,
899 isaxattributes_AddRef,
900 isaxattributes_Release,
901 isaxattributes_getLength,
902 isaxattributes_getURI,
903 isaxattributes_getLocalName,
904 isaxattributes_getQName,
905 isaxattributes_getName,
906 isaxattributes_getIndexFromName,
907 isaxattributes_getIndexFromQName,
908 isaxattributes_getType,
909 isaxattributes_getTypeFromName,
910 isaxattributes_getTypeFromQName,
911 isaxattributes_getValue,
912 isaxattributes_getValueFromName,
913 isaxattributes_getValueFromQName
916 static HRESULT SAXAttributes_create(saxattributes **attr,
917 int nb_namespaces, const xmlChar **xmlNamespaces,
918 int nb_attributes, const xmlChar **xmlAttributes)
920 saxattributes *attributes;
921 int index;
922 static const xmlChar xmlns[] = "xmlns";
924 attributes = HeapAlloc(GetProcessHeap(), 0, sizeof(*attributes));
925 if(!attributes)
926 return E_OUTOFMEMORY;
928 attributes->lpVBSAXAttributesVtbl = &ivbsaxattributes_vtbl;
929 attributes->lpSAXAttributesVtbl = &isaxattributes_vtbl;
930 attributes->ref = 1;
932 attributes->nb_attributes = nb_namespaces+nb_attributes;
934 attributes->szLocalname =
935 HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
936 attributes->szURI =
937 HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
938 attributes->szValue =
939 HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
940 attributes->szQName =
941 HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
943 if(!attributes->szLocalname || !attributes->szURI
944 || !attributes->szValue || !attributes->szQName)
946 HeapFree(GetProcessHeap(), 0, attributes->szLocalname);
947 HeapFree(GetProcessHeap(), 0, attributes->szURI);
948 HeapFree(GetProcessHeap(), 0, attributes->szValue);
949 HeapFree(GetProcessHeap(), 0, attributes->szQName);
950 HeapFree(GetProcessHeap(), 0, attributes);
951 return E_FAIL;
954 for(index=0; index<nb_namespaces; index++)
956 attributes->szLocalname[index] = SysAllocStringLen(NULL, 0);
957 attributes->szURI[index] = SysAllocStringLen(NULL, 0);
958 attributes->szValue[index] = bstr_from_xmlChar(xmlNamespaces[2*index+1]);
959 attributes->szQName[index] = QName_from_xmlChar(xmlns, xmlNamespaces[2*index]);
962 for(index=0; index<nb_attributes; index++)
964 attributes->szLocalname[nb_namespaces+index] =
965 bstr_from_xmlChar(xmlAttributes[index*5]);
966 attributes->szURI[nb_namespaces+index] =
967 bstr_from_xmlChar(xmlAttributes[index*5+2]);
968 attributes->szValue[nb_namespaces+index] =
969 bstr_from_xmlCharN(xmlAttributes[index*5+3],
970 xmlAttributes[index*5+4]-xmlAttributes[index*5+3]);
971 attributes->szQName[nb_namespaces+index] =
972 QName_from_xmlChar(xmlAttributes[index*5+1], xmlAttributes[index*5]);
975 *attr = attributes;
977 TRACE("returning %p\n", *attr);
979 return S_OK;
982 /*** LibXML callbacks ***/
983 static void libxmlStartDocument(void *ctx)
985 saxlocator *This = ctx;
986 HRESULT hr;
988 if((This->vbInterface && This->saxreader->vbcontentHandler)
989 || (!This->vbInterface && This->saxreader->contentHandler))
991 if(This->vbInterface)
992 hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
993 else
994 hr = ISAXContentHandler_startDocument(This->saxreader->contentHandler);
996 if(hr != S_OK)
997 format_error_message_from_id(This, hr);
1000 update_position(This, NULL);
1003 static void libxmlEndDocument(void *ctx)
1005 saxlocator *This = ctx;
1006 HRESULT hr;
1008 This->column = 0;
1009 This->line = 0;
1011 if(This->ret != S_OK) return;
1013 if((This->vbInterface && This->saxreader->vbcontentHandler)
1014 || (!This->vbInterface && This->saxreader->contentHandler))
1016 if(This->vbInterface)
1017 hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
1018 else
1019 hr = ISAXContentHandler_endDocument(This->saxreader->contentHandler);
1021 if(hr != S_OK)
1022 format_error_message_from_id(This, hr);
1026 static void libxmlStartElementNS(
1027 void *ctx,
1028 const xmlChar *localname,
1029 const xmlChar *prefix,
1030 const xmlChar *URI,
1031 int nb_namespaces,
1032 const xmlChar **namespaces,
1033 int nb_attributes,
1034 int nb_defaulted,
1035 const xmlChar **attributes)
1037 BSTR NamespaceUri, LocalName, QName, Prefix, Uri;
1038 saxlocator *This = ctx;
1039 HRESULT hr;
1040 saxattributes *attr;
1041 int index;
1043 if(*(This->pParserCtxt->input->cur) == '/')
1044 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+2);
1045 else
1046 update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
1048 hr = namespacePush(This, nb_namespaces);
1049 if(hr==S_OK && ((This->vbInterface && This->saxreader->vbcontentHandler)
1050 || (!This->vbInterface && This->saxreader->contentHandler)))
1052 for(index=0; index<nb_namespaces; index++)
1054 Prefix = bstr_from_xmlChar(namespaces[2*index]);
1055 Uri = bstr_from_xmlChar(namespaces[2*index+1]);
1057 if(This->vbInterface)
1058 hr = IVBSAXContentHandler_startPrefixMapping(
1059 This->saxreader->vbcontentHandler,
1060 &Prefix, &Uri);
1061 else
1062 hr = ISAXContentHandler_startPrefixMapping(
1063 This->saxreader->contentHandler,
1064 Prefix, SysStringLen(Prefix),
1065 Uri, SysStringLen(Uri));
1067 SysFreeString(Prefix);
1068 SysFreeString(Uri);
1070 if(hr != S_OK)
1072 format_error_message_from_id(This, hr);
1073 return;
1077 NamespaceUri = bstr_from_xmlChar(URI);
1078 LocalName = bstr_from_xmlChar(localname);
1079 QName = QName_from_xmlChar(prefix, localname);
1081 hr = SAXAttributes_create(&attr, nb_namespaces, namespaces, nb_attributes, attributes);
1082 if(hr == S_OK)
1084 if(This->vbInterface)
1085 hr = IVBSAXContentHandler_startElement(
1086 This->saxreader->vbcontentHandler,
1087 &NamespaceUri, &LocalName, &QName,
1088 (IVBSAXAttributes*)&attr->lpVBSAXAttributesVtbl);
1089 else
1090 hr = ISAXContentHandler_startElement(
1091 This->saxreader->contentHandler,
1092 NamespaceUri, SysStringLen(NamespaceUri),
1093 LocalName, SysStringLen(LocalName),
1094 QName, SysStringLen(QName),
1095 (ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1097 ISAXAttributes_Release((ISAXAttributes*)&attr->lpSAXAttributesVtbl);
1100 SysFreeString(NamespaceUri);
1101 SysFreeString(LocalName);
1102 SysFreeString(QName);
1105 if(hr != S_OK)
1106 format_error_message_from_id(This, hr);
1109 static void libxmlEndElementNS(
1110 void *ctx,
1111 const xmlChar *localname,
1112 const xmlChar *prefix,
1113 const xmlChar *URI)
1115 BSTR NamespaceUri, LocalName, QName, Prefix;
1116 saxlocator *This = ctx;
1117 HRESULT hr;
1118 xmlChar *end;
1119 int nsNr, index;
1121 end = (xmlChar*)This->pParserCtxt->input->cur;
1122 if(*(end-1) != '>' || *(end-2) != '/')
1123 while(*(end-2)!='<' && *(end-1)!='/') end--;
1125 update_position(This, end);
1127 nsNr = namespacePop(This);
1129 if((This->vbInterface && This->saxreader->vbcontentHandler)
1130 || (!This->vbInterface && This->saxreader->contentHandler))
1132 NamespaceUri = bstr_from_xmlChar(URI);
1133 LocalName = bstr_from_xmlChar(localname);
1134 QName = QName_from_xmlChar(prefix, localname);
1136 if(This->vbInterface)
1137 hr = IVBSAXContentHandler_endElement(
1138 This->saxreader->vbcontentHandler,
1139 &NamespaceUri, &LocalName, &QName);
1140 else
1141 hr = ISAXContentHandler_endElement(
1142 This->saxreader->contentHandler,
1143 NamespaceUri, SysStringLen(NamespaceUri),
1144 LocalName, SysStringLen(LocalName),
1145 QName, SysStringLen(QName));
1147 SysFreeString(NamespaceUri);
1148 SysFreeString(LocalName);
1149 SysFreeString(QName);
1151 if(hr != S_OK)
1153 format_error_message_from_id(This, hr);
1154 return;
1157 for(index=This->pParserCtxt->nsNr-2;
1158 index>=This->pParserCtxt->nsNr-nsNr*2; index-=2)
1160 Prefix = bstr_from_xmlChar(This->pParserCtxt->nsTab[index]);
1162 if(This->vbInterface)
1163 hr = IVBSAXContentHandler_endPrefixMapping(
1164 This->saxreader->vbcontentHandler, &Prefix);
1165 else
1166 hr = ISAXContentHandler_endPrefixMapping(
1167 This->saxreader->contentHandler,
1168 Prefix, SysStringLen(Prefix));
1170 SysFreeString(Prefix);
1172 if(hr != S_OK)
1174 format_error_message_from_id(This, hr);
1175 return;
1181 update_position(This, NULL);
1184 static void libxmlCharacters(
1185 void *ctx,
1186 const xmlChar *ch,
1187 int len)
1189 saxlocator *This = ctx;
1190 BSTR Chars;
1191 HRESULT hr;
1192 xmlChar *cur;
1193 xmlChar *end;
1194 BOOL lastEvent = FALSE;
1196 if((This->vbInterface && !This->saxreader->vbcontentHandler)
1197 || (!This->vbInterface && !This->saxreader->contentHandler))
1198 return;
1200 cur = (xmlChar*)ch;
1201 if(*(ch-1)=='\r') cur--;
1202 end = cur;
1204 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1205 This->column++;
1207 while(1)
1209 while(end-ch<len && *end!='\r') end++;
1210 if(end-ch==len)
1212 end--;
1213 lastEvent = TRUE;
1216 if(!lastEvent) *end = '\n';
1218 Chars = bstr_from_xmlCharN(cur, end-cur+1);
1219 if(This->vbInterface)
1220 hr = IVBSAXContentHandler_characters(
1221 This->saxreader->vbcontentHandler, &Chars);
1222 else
1223 hr = ISAXContentHandler_characters(
1224 This->saxreader->contentHandler,
1225 Chars, SysStringLen(Chars));
1226 SysFreeString(Chars);
1228 if(hr != S_OK)
1230 format_error_message_from_id(This, hr);
1231 return;
1234 This->column += end-cur+1;
1236 if(lastEvent)
1237 break;
1239 *end = '\r';
1240 end++;
1241 if(*end == '\n')
1243 end++;
1244 This->column++;
1246 cur = end;
1248 if(end-ch == len) break;
1251 if(ch<This->pParserCtxt->input->base || ch>This->pParserCtxt->input->end)
1252 This->column = This->realColumn
1253 +This->pParserCtxt->input->cur-This->lastCur;
1256 static void libxmlSetDocumentLocator(
1257 void *ctx,
1258 xmlSAXLocatorPtr loc)
1260 saxlocator *This = ctx;
1261 HRESULT hr;
1263 if(This->vbInterface)
1264 hr = IVBSAXContentHandler_putref_documentLocator(
1265 This->saxreader->vbcontentHandler,
1266 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl);
1267 else
1268 hr = ISAXContentHandler_putDocumentLocator(
1269 This->saxreader->contentHandler,
1270 (ISAXLocator*)&This->lpSAXLocatorVtbl);
1272 if(FAILED(hr))
1273 format_error_message_from_id(This, hr);
1276 static void libxmlComment(void *ctx, const xmlChar *value)
1278 saxlocator *This = ctx;
1279 BSTR bValue;
1280 HRESULT hr;
1281 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur;
1283 while(memcmp(beg-4, "<!--", sizeof(char[4]))) beg--;
1284 update_position(This, beg);
1286 if(!This->vbInterface && !This->saxreader->lexicalHandler) return;
1287 if(This->vbInterface && !This->saxreader->vblexicalHandler) return;
1289 bValue = bstr_from_xmlChar(value);
1291 if(This->vbInterface)
1292 hr = IVBSAXLexicalHandler_comment(
1293 This->saxreader->vblexicalHandler, &bValue);
1294 else
1295 hr = ISAXLexicalHandler_comment(
1296 This->saxreader->lexicalHandler,
1297 bValue, SysStringLen(bValue));
1299 SysFreeString(bValue);
1301 if(FAILED(hr))
1302 format_error_message_from_id(This, hr);
1304 update_position(This, NULL);
1307 static void libxmlFatalError(void *ctx, const char *msg, ...)
1309 saxlocator *This = ctx;
1310 char message[1024];
1311 WCHAR *wszError;
1312 DWORD len;
1313 va_list args;
1315 if((This->vbInterface && !This->saxreader->vberrorHandler)
1316 || (!This->vbInterface && !This->saxreader->errorHandler))
1318 xmlStopParser(This->pParserCtxt);
1319 This->ret = E_FAIL;
1320 return;
1323 FIXME("Error handling is not compatible.\n");
1325 va_start(args, msg);
1326 vsprintf(message, msg, args);
1327 va_end(args);
1329 len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
1330 wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
1331 if(wszError)
1332 MultiByteToWideChar(CP_UNIXCP, 0, message, -1, (LPWSTR)wszError, len);
1334 if(This->vbInterface)
1336 BSTR bstrError = SysAllocString(wszError);
1337 IVBSAXErrorHandler_fatalError(This->saxreader->vberrorHandler,
1338 (IVBSAXLocator*)&This->lpVBSAXLocatorVtbl, &bstrError, E_FAIL);
1340 else
1341 ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
1342 (ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
1344 HeapFree(GetProcessHeap(), 0, wszError);
1346 xmlStopParser(This->pParserCtxt);
1347 This->ret = E_FAIL;
1350 static void libxmlCDataBlock(void *ctx, const xmlChar *value, int len)
1352 saxlocator *This = ctx;
1353 HRESULT hr = S_OK;
1354 xmlChar *beg = (xmlChar*)This->pParserCtxt->input->cur-len;
1355 xmlChar *cur, *end;
1356 int realLen;
1357 BSTR Chars;
1358 BOOL lastEvent = FALSE, change;
1360 while(memcmp(beg-9, "<![CDATA[", sizeof(char[9]))) beg--;
1361 update_position(This, beg);
1363 if(This->vbInterface && This->saxreader->vblexicalHandler)
1364 hr = IVBSAXLexicalHandler_startCDATA(This->saxreader->vblexicalHandler);
1365 if(!This->vbInterface && This->saxreader->lexicalHandler)
1366 hr = ISAXLexicalHandler_startCDATA(This->saxreader->lexicalHandler);
1368 if(FAILED(hr))
1370 format_error_message_from_id(This, hr);
1371 return;
1374 realLen = This->pParserCtxt->input->cur-beg-3;
1375 cur = beg;
1376 end = beg;
1378 while(1)
1380 while(end-beg<realLen && *end!='\r') end++;
1381 if(end-beg==realLen)
1383 end--;
1384 lastEvent = TRUE;
1386 else if(end-beg==realLen-1 && *end=='\r' && *(end+1)=='\n')
1387 lastEvent = TRUE;
1389 if(*end == '\r') change = TRUE;
1390 else change = FALSE;
1392 if(change) *end = '\n';
1394 if((This->vbInterface && This->saxreader->vbcontentHandler) ||
1395 (!This->vbInterface && This->saxreader->contentHandler))
1397 Chars = bstr_from_xmlCharN(cur, end-cur+1);
1398 if(This->vbInterface)
1399 hr = IVBSAXContentHandler_characters(
1400 This->saxreader->vbcontentHandler, &Chars);
1401 else
1402 hr = ISAXContentHandler_characters(
1403 This->saxreader->contentHandler,
1404 Chars, SysStringLen(Chars));
1405 SysFreeString(Chars);
1408 if(change) *end = '\r';
1410 if(lastEvent)
1411 break;
1413 This->column += end-cur+2;
1414 end += 2;
1415 cur = end;
1418 if(This->vbInterface && This->saxreader->vblexicalHandler)
1419 hr = IVBSAXLexicalHandler_endCDATA(This->saxreader->vblexicalHandler);
1420 if(!This->vbInterface && This->saxreader->lexicalHandler)
1421 hr = ISAXLexicalHandler_endCDATA(This->saxreader->lexicalHandler);
1423 if(FAILED(hr))
1424 format_error_message_from_id(This, hr);
1426 This->column += 4+end-cur;
1429 /*** IVBSAXLocator interface ***/
1430 /*** IUnknown methods ***/
1431 static HRESULT WINAPI ivbsaxlocator_QueryInterface(IVBSAXLocator* iface, REFIID riid, void **ppvObject)
1433 saxlocator *This = impl_from_IVBSAXLocator( iface );
1435 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject);
1437 *ppvObject = NULL;
1439 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1440 IsEqualGUID( riid, &IID_IDispatch) ||
1441 IsEqualGUID( riid, &IID_IVBSAXLocator ))
1443 *ppvObject = iface;
1445 else
1447 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1448 return E_NOINTERFACE;
1451 IVBSAXLocator_AddRef( iface );
1453 return S_OK;
1456 static ULONG WINAPI ivbsaxlocator_AddRef(IVBSAXLocator* iface)
1458 saxlocator *This = impl_from_IVBSAXLocator( iface );
1459 TRACE("%p\n", This );
1460 return InterlockedIncrement( &This->ref );
1463 static ULONG WINAPI ivbsaxlocator_Release(
1464 IVBSAXLocator* iface)
1466 saxlocator *This = impl_from_IVBSAXLocator( iface );
1467 return ISAXLocator_Release((ISAXLocator*)&This->lpVBSAXLocatorVtbl);
1470 /*** IDispatch methods ***/
1471 static HRESULT WINAPI ivbsaxlocator_GetTypeInfoCount( IVBSAXLocator *iface, UINT* pctinfo )
1473 saxlocator *This = impl_from_IVBSAXLocator( iface );
1475 TRACE("(%p)->(%p)\n", This, pctinfo);
1477 *pctinfo = 1;
1479 return S_OK;
1482 static HRESULT WINAPI ivbsaxlocator_GetTypeInfo(
1483 IVBSAXLocator *iface,
1484 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
1486 saxlocator *This = impl_from_IVBSAXLocator( iface );
1487 HRESULT hr;
1489 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1491 hr = get_typeinfo(IVBSAXLocator_tid, ppTInfo);
1493 return hr;
1496 static HRESULT WINAPI ivbsaxlocator_GetIDsOfNames(
1497 IVBSAXLocator *iface,
1498 REFIID riid,
1499 LPOLESTR* rgszNames,
1500 UINT cNames,
1501 LCID lcid,
1502 DISPID* rgDispId)
1504 saxlocator *This = impl_from_IVBSAXLocator( iface );
1505 ITypeInfo *typeinfo;
1506 HRESULT hr;
1508 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1509 lcid, rgDispId);
1511 if(!rgszNames || cNames == 0 || !rgDispId)
1512 return E_INVALIDARG;
1514 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1515 if(SUCCEEDED(hr))
1517 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1518 ITypeInfo_Release(typeinfo);
1521 return hr;
1524 static HRESULT WINAPI ivbsaxlocator_Invoke(
1525 IVBSAXLocator *iface,
1526 DISPID dispIdMember,
1527 REFIID riid,
1528 LCID lcid,
1529 WORD wFlags,
1530 DISPPARAMS* pDispParams,
1531 VARIANT* pVarResult,
1532 EXCEPINFO* pExcepInfo,
1533 UINT* puArgErr)
1535 saxlocator *This = impl_from_IVBSAXLocator( iface );
1536 ITypeInfo *typeinfo;
1537 HRESULT hr;
1539 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1540 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1542 hr = get_typeinfo(IVBSAXLocator_tid, &typeinfo);
1543 if(SUCCEEDED(hr))
1545 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXLocatorVtbl), dispIdMember, wFlags, pDispParams,
1546 pVarResult, pExcepInfo, puArgErr);
1547 ITypeInfo_Release(typeinfo);
1550 return hr;
1553 /*** IVBSAXLocator methods ***/
1554 static HRESULT WINAPI ivbsaxlocator_get_columnNumber(
1555 IVBSAXLocator* iface,
1556 int *pnColumn)
1558 saxlocator *This = impl_from_IVBSAXLocator( iface );
1559 return ISAXLocator_getColumnNumber(
1560 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1561 pnColumn);
1564 static HRESULT WINAPI ivbsaxlocator_get_lineNumber(
1565 IVBSAXLocator* iface,
1566 int *pnLine)
1568 saxlocator *This = impl_from_IVBSAXLocator( iface );
1569 return ISAXLocator_getLineNumber(
1570 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1571 pnLine);
1574 static HRESULT WINAPI ivbsaxlocator_get_publicId(
1575 IVBSAXLocator* iface,
1576 BSTR* publicId)
1578 saxlocator *This = impl_from_IVBSAXLocator( iface );
1579 return ISAXLocator_getPublicId(
1580 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1581 (const WCHAR**)publicId);
1584 static HRESULT WINAPI ivbsaxlocator_get_systemId(
1585 IVBSAXLocator* iface,
1586 BSTR* systemId)
1588 saxlocator *This = impl_from_IVBSAXLocator( iface );
1589 return ISAXLocator_getSystemId(
1590 (ISAXLocator*)&This->lpVBSAXLocatorVtbl,
1591 (const WCHAR**)systemId);
1594 static const struct IVBSAXLocatorVtbl ivbsaxlocator_vtbl =
1596 ivbsaxlocator_QueryInterface,
1597 ivbsaxlocator_AddRef,
1598 ivbsaxlocator_Release,
1599 ivbsaxlocator_GetTypeInfoCount,
1600 ivbsaxlocator_GetTypeInfo,
1601 ivbsaxlocator_GetIDsOfNames,
1602 ivbsaxlocator_Invoke,
1603 ivbsaxlocator_get_columnNumber,
1604 ivbsaxlocator_get_lineNumber,
1605 ivbsaxlocator_get_publicId,
1606 ivbsaxlocator_get_systemId
1609 /*** ISAXLocator interface ***/
1610 /*** IUnknown methods ***/
1611 static HRESULT WINAPI isaxlocator_QueryInterface(ISAXLocator* iface, REFIID riid, void **ppvObject)
1613 saxlocator *This = impl_from_ISAXLocator( iface );
1615 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
1617 *ppvObject = NULL;
1619 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
1620 IsEqualGUID( riid, &IID_ISAXLocator ))
1622 *ppvObject = iface;
1624 else
1626 FIXME("interface %s not implemented\n", debugstr_guid(riid));
1627 return E_NOINTERFACE;
1630 ISAXLocator_AddRef( iface );
1632 return S_OK;
1635 static ULONG WINAPI isaxlocator_AddRef(ISAXLocator* iface)
1637 saxlocator *This = impl_from_ISAXLocator( iface );
1638 TRACE("%p\n", This );
1639 return InterlockedIncrement( &This->ref );
1642 static ULONG WINAPI isaxlocator_Release(
1643 ISAXLocator* iface)
1645 saxlocator *This = impl_from_ISAXLocator( iface );
1646 LONG ref;
1648 TRACE("%p\n", This );
1650 ref = InterlockedDecrement( &This->ref );
1651 if ( ref == 0 )
1653 SysFreeString(This->publicId);
1654 SysFreeString(This->systemId);
1655 HeapFree(GetProcessHeap(), 0, This->nsStack);
1657 ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
1658 HeapFree( GetProcessHeap(), 0, This );
1661 return ref;
1664 /*** ISAXLocator methods ***/
1665 static HRESULT WINAPI isaxlocator_getColumnNumber(
1666 ISAXLocator* iface,
1667 int *pnColumn)
1669 saxlocator *This = impl_from_ISAXLocator( iface );
1671 *pnColumn = This->column;
1672 return S_OK;
1675 static HRESULT WINAPI isaxlocator_getLineNumber(
1676 ISAXLocator* iface,
1677 int *pnLine)
1679 saxlocator *This = impl_from_ISAXLocator( iface );
1681 *pnLine = This->line;
1682 return S_OK;
1685 static HRESULT WINAPI isaxlocator_getPublicId(
1686 ISAXLocator* iface,
1687 const WCHAR ** ppwchPublicId)
1689 BSTR publicId;
1690 saxlocator *This = impl_from_ISAXLocator( iface );
1692 SysFreeString(This->publicId);
1694 publicId = bstr_from_xmlChar(xmlSAX2GetPublicId(This->pParserCtxt));
1695 if(SysStringLen(publicId))
1696 This->publicId = (WCHAR*)&publicId;
1697 else
1699 SysFreeString(publicId);
1700 This->publicId = NULL;
1703 *ppwchPublicId = This->publicId;
1704 return S_OK;
1707 static HRESULT WINAPI isaxlocator_getSystemId(
1708 ISAXLocator* iface,
1709 const WCHAR ** ppwchSystemId)
1711 BSTR systemId;
1712 saxlocator *This = impl_from_ISAXLocator( iface );
1714 SysFreeString(This->systemId);
1716 systemId = bstr_from_xmlChar(xmlSAX2GetSystemId(This->pParserCtxt));
1717 if(SysStringLen(systemId))
1718 This->systemId = (WCHAR*)&systemId;
1719 else
1721 SysFreeString(systemId);
1722 This->systemId = NULL;
1725 *ppwchSystemId = This->systemId;
1726 return S_OK;
1729 static const struct ISAXLocatorVtbl isaxlocator_vtbl =
1731 isaxlocator_QueryInterface,
1732 isaxlocator_AddRef,
1733 isaxlocator_Release,
1734 isaxlocator_getColumnNumber,
1735 isaxlocator_getLineNumber,
1736 isaxlocator_getPublicId,
1737 isaxlocator_getSystemId
1740 static HRESULT SAXLocator_create(saxreader *reader, saxlocator **ppsaxlocator, BOOL vbInterface)
1742 saxlocator *locator;
1744 locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
1745 if( !locator )
1746 return E_OUTOFMEMORY;
1748 locator->lpVBSAXLocatorVtbl = &ivbsaxlocator_vtbl;
1749 locator->lpSAXLocatorVtbl = &isaxlocator_vtbl;
1750 locator->ref = 1;
1751 locator->vbInterface = vbInterface;
1753 locator->saxreader = reader;
1754 ISAXXMLReader_AddRef((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1756 locator->pParserCtxt = NULL;
1757 locator->publicId = NULL;
1758 locator->systemId = NULL;
1759 locator->lastCur = NULL;
1760 locator->line = 0;
1761 locator->column = 0;
1762 locator->ret = S_OK;
1763 locator->nsStackSize = 8;
1764 locator->nsStackLast = 0;
1765 locator->nsStack = HeapAlloc(GetProcessHeap(), 0, locator->nsStackSize);
1766 if(!locator->nsStack)
1768 ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
1769 HeapFree(GetProcessHeap(), 0, locator);
1770 return E_OUTOFMEMORY;
1773 *ppsaxlocator = locator;
1775 TRACE("returning %p\n", *ppsaxlocator);
1777 return S_OK;
1780 /*** SAXXMLReader internal functions ***/
1781 static HRESULT internal_parseBuffer(saxreader *This, const char *buffer, int size, BOOL vbInterface)
1783 saxlocator *locator;
1784 HRESULT hr;
1786 hr = SAXLocator_create(This, &locator, vbInterface);
1787 if(FAILED(hr))
1788 return hr;
1790 locator->pParserCtxt = xmlCreateMemoryParserCtxt(buffer, size);
1791 if(!locator->pParserCtxt)
1793 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1794 return E_FAIL;
1797 locator->pParserCtxt->sax = &locator->saxreader->sax;
1798 locator->pParserCtxt->userData = locator;
1800 This->isParsing = TRUE;
1801 if(xmlParseDocument(locator->pParserCtxt)) hr = E_FAIL;
1802 else hr = locator->ret;
1803 This->isParsing = FALSE;
1805 if(locator->pParserCtxt)
1807 locator->pParserCtxt->sax = NULL;
1808 xmlFreeParserCtxt(locator->pParserCtxt);
1809 locator->pParserCtxt = NULL;
1812 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1813 return hr;
1816 static HRESULT internal_parseStream(saxreader *This, IStream *stream, BOOL vbInterface)
1818 saxlocator *locator;
1819 HRESULT hr;
1820 ULONG dataRead;
1821 char data[1024];
1823 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1824 if(hr != S_OK)
1825 return hr;
1827 hr = SAXLocator_create(This, &locator, vbInterface);
1828 if(FAILED(hr))
1829 return hr;
1831 locator->pParserCtxt = xmlCreatePushParserCtxt(
1832 &locator->saxreader->sax, locator,
1833 data, dataRead, NULL);
1834 if(!locator->pParserCtxt)
1836 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1837 return E_FAIL;
1840 This->isParsing = TRUE;
1841 while(1)
1843 hr = IStream_Read(stream, data, sizeof(data), &dataRead);
1844 if(hr != S_OK)
1845 break;
1847 if(xmlParseChunk(locator->pParserCtxt, data, dataRead, 0)) hr = E_FAIL;
1848 else hr = locator->ret;
1850 if(hr != S_OK) break;
1852 if(dataRead != sizeof(data))
1854 if(xmlParseChunk(locator->pParserCtxt, data, 0, 1)) hr = E_FAIL;
1855 else hr = locator->ret;
1857 break;
1860 This->isParsing = FALSE;
1862 locator->pParserCtxt->sax = NULL;
1863 xmlFreeParserCtxt(locator->pParserCtxt);
1864 locator->pParserCtxt = NULL;
1865 ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
1866 return hr;
1869 static HRESULT WINAPI internal_getEntityResolver(
1870 saxreader *This,
1871 void *pEntityResolver,
1872 BOOL vbInterface)
1874 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1875 return E_NOTIMPL;
1878 static HRESULT WINAPI internal_putEntityResolver(
1879 saxreader *This,
1880 void *pEntityResolver,
1881 BOOL vbInterface)
1883 FIXME("(%p)->(%p) stub\n", This, pEntityResolver);
1884 return E_NOTIMPL;
1887 static HRESULT WINAPI internal_getContentHandler(
1888 saxreader* This,
1889 void *pContentHandler,
1890 BOOL vbInterface)
1892 TRACE("(%p)->(%p)\n", This, pContentHandler);
1893 if(pContentHandler == NULL)
1894 return E_POINTER;
1895 if((vbInterface && This->vbcontentHandler)
1896 || (!vbInterface && This->contentHandler))
1898 if(vbInterface)
1899 IVBSAXContentHandler_AddRef(This->vbcontentHandler);
1900 else
1901 ISAXContentHandler_AddRef(This->contentHandler);
1903 if(vbInterface) *(IVBSAXContentHandler**)pContentHandler =
1904 This->vbcontentHandler;
1905 else *(ISAXContentHandler**)pContentHandler = This->contentHandler;
1907 return S_OK;
1910 static HRESULT WINAPI internal_putContentHandler(
1911 saxreader* This,
1912 void *contentHandler,
1913 BOOL vbInterface)
1915 TRACE("(%p)->(%p)\n", This, contentHandler);
1916 if(contentHandler)
1918 if(vbInterface)
1919 IVBSAXContentHandler_AddRef((IVBSAXContentHandler*)contentHandler);
1920 else
1921 ISAXContentHandler_AddRef((ISAXContentHandler*)contentHandler);
1923 if((vbInterface && This->vbcontentHandler)
1924 || (!vbInterface && This->contentHandler))
1926 if(vbInterface)
1927 IVBSAXContentHandler_Release(This->vbcontentHandler);
1928 else
1929 ISAXContentHandler_Release(This->contentHandler);
1931 if(vbInterface)
1932 This->vbcontentHandler = contentHandler;
1933 else
1934 This->contentHandler = contentHandler;
1936 return S_OK;
1939 static HRESULT WINAPI internal_getDTDHandler(
1940 saxreader* This,
1941 void *pDTDHandler,
1942 BOOL vbInterface)
1944 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1945 return E_NOTIMPL;
1948 static HRESULT WINAPI internal_putDTDHandler(
1949 saxreader* This,
1950 void *pDTDHandler,
1951 BOOL vbInterface)
1953 FIXME("(%p)->(%p) stub\n", This, pDTDHandler);
1954 return E_NOTIMPL;
1957 static HRESULT WINAPI internal_getErrorHandler(
1958 saxreader* This,
1959 void *pErrorHandler,
1960 BOOL vbInterface)
1962 TRACE("(%p)->(%p)\n", This, pErrorHandler);
1963 if(pErrorHandler == NULL)
1964 return E_POINTER;
1966 if(vbInterface && This->vberrorHandler)
1967 IVBSAXErrorHandler_AddRef(This->vberrorHandler);
1968 else if(!vbInterface && This->errorHandler)
1969 ISAXErrorHandler_AddRef(This->errorHandler);
1971 if(vbInterface)
1972 *(IVBSAXErrorHandler**)pErrorHandler = This->vberrorHandler;
1973 else
1974 *(ISAXErrorHandler**)pErrorHandler = This->errorHandler;
1976 return S_OK;
1980 static HRESULT WINAPI internal_putErrorHandler(
1981 saxreader* This,
1982 void *errorHandler,
1983 BOOL vbInterface)
1985 TRACE("(%p)->(%p)\n", This, errorHandler);
1986 if(errorHandler)
1988 if(vbInterface)
1989 IVBSAXErrorHandler_AddRef((IVBSAXErrorHandler*)errorHandler);
1990 else
1991 ISAXErrorHandler_AddRef((ISAXErrorHandler*)errorHandler);
1994 if(vbInterface && This->vberrorHandler)
1995 IVBSAXErrorHandler_Release(This->vberrorHandler);
1996 else if(!vbInterface && This->errorHandler)
1997 ISAXErrorHandler_Release(This->errorHandler);
1999 if(vbInterface)
2000 This->vberrorHandler = errorHandler;
2001 else
2002 This->errorHandler = errorHandler;
2004 return S_OK;
2008 static HRESULT WINAPI internal_parse(
2009 saxreader* This,
2010 VARIANT varInput,
2011 BOOL vbInterface)
2013 HRESULT hr;
2015 TRACE("(%p)\n", This);
2017 hr = S_OK;
2018 switch(V_VT(&varInput))
2020 case VT_BSTR:
2021 hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2022 SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2023 break;
2024 case VT_ARRAY|VT_UI1: {
2025 void *pSAData;
2026 LONG lBound, uBound;
2027 ULONG dataRead;
2029 hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2030 if(hr != S_OK) break;
2031 hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2032 if(hr != S_OK) break;
2033 dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2034 hr = SafeArrayAccessData(V_ARRAY(&varInput), (void**)&pSAData);
2035 if(hr != S_OK) break;
2036 hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2037 SafeArrayUnaccessData(V_ARRAY(&varInput));
2038 break;
2040 case VT_UNKNOWN:
2041 case VT_DISPATCH: {
2042 IPersistStream *persistStream;
2043 IStream *stream = NULL;
2044 IXMLDOMDocument *xmlDoc;
2046 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2047 &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2049 BSTR bstrData;
2051 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2052 hr = internal_parseBuffer(This, (const char*)bstrData,
2053 SysStringByteLen(bstrData), vbInterface);
2054 IXMLDOMDocument_Release(xmlDoc);
2055 break;
2057 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2058 &IID_IPersistStream, (void**)&persistStream) == S_OK)
2060 hr = IPersistStream_Save(persistStream, stream, TRUE);
2061 IPersistStream_Release(persistStream);
2062 if(hr != S_OK) break;
2064 if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2065 &IID_IStream, (void**)&stream) == S_OK)
2067 hr = internal_parseStream(This, stream, vbInterface);
2068 IStream_Release(stream);
2069 break;
2072 default:
2073 WARN("vt %d not implemented\n", V_VT(&varInput));
2074 hr = E_INVALIDARG;
2077 return hr;
2080 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2082 saxreader *This = obj;
2084 return internal_parseBuffer(This, ptr, len, TRUE);
2087 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2089 saxreader *This = obj;
2091 return internal_parseBuffer(This, ptr, len, FALSE);
2094 static HRESULT WINAPI internal_parseURL(
2095 saxreader* This,
2096 const WCHAR *url,
2097 BOOL vbInterface)
2099 bsc_t *bsc;
2100 HRESULT hr;
2102 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2104 if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
2105 else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
2107 if(FAILED(hr))
2108 return hr;
2110 detach_bsc(bsc);
2112 return S_OK;
2115 static HRESULT WINAPI internal_putProperty(
2116 saxreader* This,
2117 const WCHAR *pProp,
2118 VARIANT value,
2119 BOOL vbInterface)
2121 static const WCHAR wszCharset[] = {
2122 'c','h','a','r','s','e','t',0
2124 static const WCHAR wszDeclarationHandler[] = {
2125 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2126 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2127 'd','e','c','l','a','r','a','t','i','o','n',
2128 '-','h','a','n','d','l','e','r',0
2130 static const WCHAR wszDomNode[] = {
2131 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2132 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2133 'd','o','m','-','n','o','d','e',0
2135 static const WCHAR wszInputSource[] = {
2136 'i','n','p','u','t','-','s','o','u','r','c','e',0
2138 static const WCHAR wszLexicalHandler[] = {
2139 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2140 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2141 'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
2143 static const WCHAR wszMaxElementDepth[] = {
2144 'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
2146 static const WCHAR wszMaxXMLSize[] = {
2147 'm','a','x','-','x','m','l','-','s','i','z','e',0
2149 static const WCHAR wszSchemaDeclarationHandler[] = {
2150 's','c','h','e','m','a','-',
2151 'd','e','c','l','a','r','a','t','i','o','n','-',
2152 'h','a','n','d','l','e','r',0
2154 static const WCHAR wszXMLDeclEncoding[] = {
2155 'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
2157 static const WCHAR wszXMLDeclStandalone[] = {
2158 'x','m','l','d','e','c','l',
2159 '-','s','t','a','n','d','a','l','o','n','e',0
2161 static const WCHAR wszXMLDeclVersion[] = {
2162 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
2165 FIXME("(%p)->(%s): semi-stub\n", This, debugstr_w(pProp));
2167 if(!memcmp(pProp, wszCharset, sizeof(wszCharset)))
2168 return E_NOTIMPL;
2170 if(!memcmp(pProp, wszDeclarationHandler, sizeof(wszDeclarationHandler)))
2172 if(This->isParsing) return E_FAIL;
2174 if(V_UNKNOWN(&value))
2176 if(vbInterface)
2177 IVBSAXDeclHandler_AddRef((IVBSAXDeclHandler*)V_UNKNOWN(&value));
2178 else
2179 ISAXDeclHandler_AddRef((ISAXDeclHandler*)V_UNKNOWN(&value));
2181 if((vbInterface && This->vbdeclHandler)
2182 || (!vbInterface && This->declHandler))
2184 if(vbInterface)
2185 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2186 else
2187 ISAXDeclHandler_Release(This->declHandler);
2189 if(vbInterface)
2190 This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2191 else
2192 This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2193 return S_OK;
2196 if(!memcmp(pProp, wszDomNode, sizeof(wszDomNode)))
2197 return E_FAIL;
2199 if(!memcmp(pProp, wszInputSource, sizeof(wszInputSource)))
2200 return E_NOTIMPL;
2202 if(!memcmp(pProp, wszLexicalHandler, sizeof(wszLexicalHandler)))
2204 if(This->isParsing) return E_FAIL;
2206 if(V_UNKNOWN(&value))
2208 if(vbInterface)
2209 IVBSAXLexicalHandler_AddRef(
2210 (IVBSAXLexicalHandler*)V_UNKNOWN(&value));
2211 else
2212 ISAXLexicalHandler_AddRef(
2213 (ISAXLexicalHandler*)V_UNKNOWN(&value));
2215 if((vbInterface && This->vblexicalHandler)
2216 || (!vbInterface && This->lexicalHandler))
2218 if(vbInterface)
2219 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2220 else
2221 ISAXLexicalHandler_Release(This->lexicalHandler);
2223 if(vbInterface)
2224 This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2225 else
2226 This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2227 return S_OK;
2230 if(!memcmp(pProp, wszMaxElementDepth, sizeof(wszMaxElementDepth)))
2231 return E_NOTIMPL;
2233 if(!memcmp(pProp, wszMaxXMLSize, sizeof(wszMaxXMLSize)))
2234 return E_NOTIMPL;
2236 if(!memcmp(pProp, wszSchemaDeclarationHandler,
2237 sizeof(wszSchemaDeclarationHandler)))
2238 return E_NOTIMPL;
2240 if(!memcmp(pProp, wszXMLDeclEncoding, sizeof(wszXMLDeclEncoding)))
2241 return E_FAIL;
2243 if(!memcmp(pProp, wszXMLDeclStandalone, sizeof(wszXMLDeclStandalone)))
2244 return E_FAIL;
2246 if(!memcmp(pProp, wszXMLDeclVersion, sizeof(wszXMLDeclVersion)))
2247 return E_FAIL;
2249 return E_INVALIDARG;
2252 /*** IVBSAXXMLReader interface ***/
2253 /*** IUnknown methods ***/
2254 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2256 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2258 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2260 *ppvObject = NULL;
2262 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2263 IsEqualGUID( riid, &IID_IDispatch ) ||
2264 IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2266 *ppvObject = iface;
2268 else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2270 *ppvObject = (ISAXXMLReader*)&This->lpSAXXMLReaderVtbl;
2272 else
2274 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2275 return E_NOINTERFACE;
2278 IVBSAXXMLReader_AddRef( iface );
2280 return S_OK;
2283 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2285 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2286 TRACE("%p\n", This );
2287 return InterlockedIncrement( &This->ref );
2290 static ULONG WINAPI saxxmlreader_Release(
2291 IVBSAXXMLReader* iface)
2293 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2294 LONG ref;
2296 TRACE("%p\n", This );
2298 ref = InterlockedDecrement( &This->ref );
2299 if ( ref == 0 )
2301 if(This->contentHandler)
2302 ISAXContentHandler_Release(This->contentHandler);
2304 if(This->vbcontentHandler)
2305 IVBSAXContentHandler_Release(This->vbcontentHandler);
2307 if(This->errorHandler)
2308 ISAXErrorHandler_Release(This->errorHandler);
2310 if(This->vberrorHandler)
2311 IVBSAXErrorHandler_Release(This->vberrorHandler);
2313 if(This->lexicalHandler)
2314 ISAXLexicalHandler_Release(This->lexicalHandler);
2316 if(This->vblexicalHandler)
2317 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2319 if(This->declHandler)
2320 ISAXDeclHandler_Release(This->declHandler);
2322 if(This->vbdeclHandler)
2323 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2325 HeapFree( GetProcessHeap(), 0, This );
2328 return ref;
2330 /*** IDispatch ***/
2331 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2333 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2335 TRACE("(%p)->(%p)\n", This, pctinfo);
2337 *pctinfo = 1;
2339 return S_OK;
2342 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2343 IVBSAXXMLReader *iface,
2344 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2346 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2347 HRESULT hr;
2349 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2351 hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2353 return hr;
2356 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2357 IVBSAXXMLReader *iface,
2358 REFIID riid,
2359 LPOLESTR* rgszNames,
2360 UINT cNames,
2361 LCID lcid,
2362 DISPID* rgDispId)
2364 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2365 ITypeInfo *typeinfo;
2366 HRESULT hr;
2368 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2369 lcid, rgDispId);
2371 if(!rgszNames || cNames == 0 || !rgDispId)
2372 return E_INVALIDARG;
2374 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2375 if(SUCCEEDED(hr))
2377 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2378 ITypeInfo_Release(typeinfo);
2381 return hr;
2384 static HRESULT WINAPI saxxmlreader_Invoke(
2385 IVBSAXXMLReader *iface,
2386 DISPID dispIdMember,
2387 REFIID riid,
2388 LCID lcid,
2389 WORD wFlags,
2390 DISPPARAMS* pDispParams,
2391 VARIANT* pVarResult,
2392 EXCEPINFO* pExcepInfo,
2393 UINT* puArgErr)
2395 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2396 ITypeInfo *typeinfo;
2397 HRESULT hr;
2399 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2400 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2402 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2403 if(SUCCEEDED(hr))
2405 hr = ITypeInfo_Invoke(typeinfo, &(This->lpVBSAXXMLReaderVtbl), dispIdMember, wFlags, pDispParams,
2406 pVarResult, pExcepInfo, puArgErr);
2407 ITypeInfo_Release(typeinfo);
2410 return hr;
2413 /*** IVBSAXXMLReader methods ***/
2414 static HRESULT WINAPI saxxmlreader_getFeature(
2415 IVBSAXXMLReader* iface,
2416 const WCHAR *pFeature,
2417 VARIANT_BOOL *pValue)
2419 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2421 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2422 return E_NOTIMPL;
2425 static HRESULT WINAPI saxxmlreader_putFeature(
2426 IVBSAXXMLReader* iface,
2427 const WCHAR *pFeature,
2428 VARIANT_BOOL vfValue)
2430 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2432 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
2433 return E_NOTIMPL;
2436 static HRESULT WINAPI saxxmlreader_getProperty(
2437 IVBSAXXMLReader* iface,
2438 const WCHAR *pProp,
2439 VARIANT *pValue)
2441 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2443 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
2444 return E_NOTIMPL;
2447 static HRESULT WINAPI saxxmlreader_putProperty(
2448 IVBSAXXMLReader* iface,
2449 const WCHAR *pProp,
2450 VARIANT value)
2452 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2453 return internal_putProperty(This, pProp, value, TRUE);
2456 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2457 IVBSAXXMLReader* iface,
2458 IVBSAXEntityResolver **pEntityResolver)
2460 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2461 return internal_getEntityResolver(This, pEntityResolver, TRUE);
2464 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2465 IVBSAXXMLReader* iface,
2466 IVBSAXEntityResolver *pEntityResolver)
2468 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2469 return internal_putEntityResolver(This, pEntityResolver, TRUE);
2472 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2473 IVBSAXXMLReader* iface,
2474 IVBSAXContentHandler **ppContentHandler)
2476 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2477 return internal_getContentHandler(This, ppContentHandler, TRUE);
2480 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2481 IVBSAXXMLReader* iface,
2482 IVBSAXContentHandler *contentHandler)
2484 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2485 return internal_putContentHandler(This, contentHandler, TRUE);
2488 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2489 IVBSAXXMLReader* iface,
2490 IVBSAXDTDHandler **pDTDHandler)
2492 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2493 return internal_getDTDHandler(This, pDTDHandler, TRUE);
2496 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2497 IVBSAXXMLReader* iface,
2498 IVBSAXDTDHandler *pDTDHandler)
2500 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2501 return internal_putDTDHandler(This, pDTDHandler, TRUE);
2504 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2505 IVBSAXXMLReader* iface,
2506 IVBSAXErrorHandler **pErrorHandler)
2508 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2509 return internal_getErrorHandler(This, pErrorHandler, TRUE);
2512 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2513 IVBSAXXMLReader* iface,
2514 IVBSAXErrorHandler *errorHandler)
2516 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2517 return internal_putErrorHandler(This, errorHandler, TRUE);
2520 static HRESULT WINAPI saxxmlreader_get_baseURL(
2521 IVBSAXXMLReader* iface,
2522 const WCHAR **pBaseUrl)
2524 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2526 FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2527 return E_NOTIMPL;
2530 static HRESULT WINAPI saxxmlreader_put_baseURL(
2531 IVBSAXXMLReader* iface,
2532 const WCHAR *pBaseUrl)
2534 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2536 FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2537 return E_NOTIMPL;
2540 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2541 IVBSAXXMLReader* iface,
2542 const WCHAR **pSecureBaseUrl)
2544 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2546 FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2547 return E_NOTIMPL;
2551 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
2552 IVBSAXXMLReader* iface,
2553 const WCHAR *secureBaseUrl)
2555 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2557 FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2558 return E_NOTIMPL;
2561 static HRESULT WINAPI saxxmlreader_parse(
2562 IVBSAXXMLReader* iface,
2563 VARIANT varInput)
2565 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2566 return internal_parse(This, varInput, TRUE);
2569 static HRESULT WINAPI saxxmlreader_parseURL(
2570 IVBSAXXMLReader* iface,
2571 const WCHAR *url)
2573 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2574 return internal_parseURL(This, url, TRUE);
2577 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2579 saxxmlreader_QueryInterface,
2580 saxxmlreader_AddRef,
2581 saxxmlreader_Release,
2582 saxxmlreader_GetTypeInfoCount,
2583 saxxmlreader_GetTypeInfo,
2584 saxxmlreader_GetIDsOfNames,
2585 saxxmlreader_Invoke,
2586 saxxmlreader_getFeature,
2587 saxxmlreader_putFeature,
2588 saxxmlreader_getProperty,
2589 saxxmlreader_putProperty,
2590 saxxmlreader_get_entityResolver,
2591 saxxmlreader_put_entityResolver,
2592 saxxmlreader_get_contentHandler,
2593 saxxmlreader_put_contentHandler,
2594 saxxmlreader_get_dtdHandler,
2595 saxxmlreader_put_dtdHandler,
2596 saxxmlreader_get_errorHandler,
2597 saxxmlreader_put_errorHandler,
2598 saxxmlreader_get_baseURL,
2599 saxxmlreader_put_baseURL,
2600 saxxmlreader_get_secureBaseURL,
2601 saxxmlreader_put_secureBaseURL,
2602 saxxmlreader_parse,
2603 saxxmlreader_parseURL
2606 /*** ISAXXMLReader interface ***/
2607 /*** IUnknown methods ***/
2608 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2610 saxreader *This = impl_from_ISAXXMLReader( iface );
2611 return saxxmlreader_QueryInterface((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl, riid, ppvObject);
2614 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2616 saxreader *This = impl_from_ISAXXMLReader( iface );
2617 return saxxmlreader_AddRef((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2620 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2622 saxreader *This = impl_from_ISAXXMLReader( iface );
2623 return saxxmlreader_Release((IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl);
2626 /*** ISAXXMLReader methods ***/
2627 static HRESULT WINAPI isaxxmlreader_getFeature(
2628 ISAXXMLReader* iface,
2629 const WCHAR *pFeature,
2630 VARIANT_BOOL *pValue)
2632 saxreader *This = impl_from_ISAXXMLReader( iface );
2633 return IVBSAXXMLReader_getFeature(
2634 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2635 pFeature, pValue);
2638 static HRESULT WINAPI isaxxmlreader_putFeature(
2639 ISAXXMLReader* iface,
2640 const WCHAR *pFeature,
2641 VARIANT_BOOL vfValue)
2643 saxreader *This = impl_from_ISAXXMLReader( iface );
2644 return IVBSAXXMLReader_putFeature(
2645 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2646 pFeature, vfValue);
2649 static HRESULT WINAPI isaxxmlreader_getProperty(
2650 ISAXXMLReader* iface,
2651 const WCHAR *pProp,
2652 VARIANT *pValue)
2654 saxreader *This = impl_from_ISAXXMLReader( iface );
2655 return IVBSAXXMLReader_getProperty(
2656 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2657 pProp, pValue);
2660 static HRESULT WINAPI isaxxmlreader_putProperty(
2661 ISAXXMLReader* iface,
2662 const WCHAR *pProp,
2663 VARIANT value)
2665 saxreader *This = impl_from_ISAXXMLReader( iface );
2666 return internal_putProperty(This, pProp, value, FALSE);
2669 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2670 ISAXXMLReader* iface,
2671 ISAXEntityResolver **ppEntityResolver)
2673 saxreader *This = impl_from_ISAXXMLReader( iface );
2674 return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2677 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2678 ISAXXMLReader* iface,
2679 ISAXEntityResolver *pEntityResolver)
2681 saxreader *This = impl_from_ISAXXMLReader( iface );
2682 return internal_putEntityResolver(This, pEntityResolver, FALSE);
2685 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2686 ISAXXMLReader* iface,
2687 ISAXContentHandler **pContentHandler)
2689 saxreader *This = impl_from_ISAXXMLReader( iface );
2690 return internal_getContentHandler(This, pContentHandler, FALSE);
2693 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2694 ISAXXMLReader* iface,
2695 ISAXContentHandler *contentHandler)
2697 saxreader *This = impl_from_ISAXXMLReader( iface );
2698 return internal_putContentHandler(This, contentHandler, FALSE);
2701 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2702 ISAXXMLReader* iface,
2703 ISAXDTDHandler **pDTDHandler)
2705 saxreader *This = impl_from_ISAXXMLReader( iface );
2706 return internal_getDTDHandler(This, pDTDHandler, FALSE);
2709 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2710 ISAXXMLReader* iface,
2711 ISAXDTDHandler *pDTDHandler)
2713 saxreader *This = impl_from_ISAXXMLReader( iface );
2714 return internal_putDTDHandler(This, pDTDHandler, FALSE);
2717 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2718 ISAXXMLReader* iface,
2719 ISAXErrorHandler **pErrorHandler)
2721 saxreader *This = impl_from_ISAXXMLReader( iface );
2722 return internal_getErrorHandler(This, pErrorHandler, FALSE);
2725 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2726 ISAXXMLReader* iface,
2727 ISAXErrorHandler *errorHandler)
2729 saxreader *This = impl_from_ISAXXMLReader( iface );
2730 return internal_putErrorHandler(This, errorHandler, FALSE);
2733 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2734 ISAXXMLReader* iface,
2735 const WCHAR **pBaseUrl)
2737 saxreader *This = impl_from_ISAXXMLReader( iface );
2738 return IVBSAXXMLReader_get_baseURL(
2739 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2740 pBaseUrl);
2743 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2744 ISAXXMLReader* iface,
2745 const WCHAR *pBaseUrl)
2747 saxreader *This = impl_from_ISAXXMLReader( iface );
2748 return IVBSAXXMLReader_put_baseURL(
2749 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2750 pBaseUrl);
2753 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2754 ISAXXMLReader* iface,
2755 const WCHAR **pSecureBaseUrl)
2757 saxreader *This = impl_from_ISAXXMLReader( iface );
2758 return IVBSAXXMLReader_get_secureBaseURL(
2759 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2760 pSecureBaseUrl);
2763 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2764 ISAXXMLReader* iface,
2765 const WCHAR *secureBaseUrl)
2767 saxreader *This = impl_from_ISAXXMLReader( iface );
2768 return IVBSAXXMLReader_put_secureBaseURL(
2769 (IVBSAXXMLReader*)&This->lpVBSAXXMLReaderVtbl,
2770 secureBaseUrl);
2773 static HRESULT WINAPI isaxxmlreader_parse(
2774 ISAXXMLReader* iface,
2775 VARIANT varInput)
2777 saxreader *This = impl_from_ISAXXMLReader( iface );
2778 return internal_parse(This, varInput, FALSE);
2781 static HRESULT WINAPI isaxxmlreader_parseURL(
2782 ISAXXMLReader* iface,
2783 const WCHAR *url)
2785 saxreader *This = impl_from_ISAXXMLReader( iface );
2786 return internal_parseURL(This, url, FALSE);
2789 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2791 isaxxmlreader_QueryInterface,
2792 isaxxmlreader_AddRef,
2793 isaxxmlreader_Release,
2794 isaxxmlreader_getFeature,
2795 isaxxmlreader_putFeature,
2796 isaxxmlreader_getProperty,
2797 isaxxmlreader_putProperty,
2798 isaxxmlreader_getEntityResolver,
2799 isaxxmlreader_putEntityResolver,
2800 isaxxmlreader_getContentHandler,
2801 isaxxmlreader_putContentHandler,
2802 isaxxmlreader_getDTDHandler,
2803 isaxxmlreader_putDTDHandler,
2804 isaxxmlreader_getErrorHandler,
2805 isaxxmlreader_putErrorHandler,
2806 isaxxmlreader_getBaseURL,
2807 isaxxmlreader_putBaseURL,
2808 isaxxmlreader_getSecureBaseURL,
2809 isaxxmlreader_putSecureBaseURL,
2810 isaxxmlreader_parse,
2811 isaxxmlreader_parseURL
2814 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2816 saxreader *reader;
2818 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2820 reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
2821 if( !reader )
2822 return E_OUTOFMEMORY;
2824 reader->lpVBSAXXMLReaderVtbl = &saxreader_vtbl;
2825 reader->lpSAXXMLReaderVtbl = &isaxreader_vtbl;
2826 reader->ref = 1;
2827 reader->contentHandler = NULL;
2828 reader->vbcontentHandler = NULL;
2829 reader->errorHandler = NULL;
2830 reader->vberrorHandler = NULL;
2831 reader->lexicalHandler = NULL;
2832 reader->vblexicalHandler = NULL;
2833 reader->declHandler = NULL;
2834 reader->vbdeclHandler = NULL;
2835 reader->isParsing = FALSE;
2837 memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2838 reader->sax.initialized = XML_SAX2_MAGIC;
2839 reader->sax.startDocument = libxmlStartDocument;
2840 reader->sax.endDocument = libxmlEndDocument;
2841 reader->sax.startElementNs = libxmlStartElementNS;
2842 reader->sax.endElementNs = libxmlEndElementNS;
2843 reader->sax.characters = libxmlCharacters;
2844 reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2845 reader->sax.comment = libxmlComment;
2846 reader->sax.error = libxmlFatalError;
2847 reader->sax.fatalError = libxmlFatalError;
2848 reader->sax.cdataBlock = libxmlCDataBlock;
2850 *ppObj = &reader->lpVBSAXXMLReaderVtbl;
2852 TRACE("returning iface %p\n", *ppObj);
2854 return S_OK;
2857 #else
2859 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2861 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2862 "libxml2 support was not present at compile time.\n");
2863 return E_NOTIMPL;
2866 #endif