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