?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9/tests: Implemented ConvertAdjacencyToPointReps test.
[wine/multimedia.git] / dlls / msxml3 / saxreader.c
blob4f0a5f163450de3659f2e5c73c9bfbc8579eb450
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 switch(V_VT(&varInput))
2002 {
2003 case VT_BSTR:
2004 hr = internal_parseBuffer(This, (const char*)V_BSTR(&varInput),
2005 SysStringByteLen(V_BSTR(&varInput)), vbInterface);
2006 break;
2007 case VT_ARRAY|VT_UI1: {
2008 void *pSAData;
2009 LONG lBound, uBound;
2010 ULONG dataRead;
2011
2012 hr = SafeArrayGetLBound(V_ARRAY(&varInput), 1, &lBound);
2013 if(hr != S_OK) break;
2014 hr = SafeArrayGetUBound(V_ARRAY(&varInput), 1, &uBound);
2015 if(hr != S_OK) break;
2016 dataRead = (uBound-lBound)*SafeArrayGetElemsize(V_ARRAY(&varInput));
2017 hr = SafeArrayAccessData(V_ARRAY(&varInput), &pSAData);
2018 if(hr != S_OK) break;
2019 hr = internal_parseBuffer(This, pSAData, dataRead, vbInterface);
2020 SafeArrayUnaccessData(V_ARRAY(&varInput));
2021 break;
2022 }
2023 case VT_UNKNOWN:
2024 case VT_DISPATCH: {
2025 IPersistStream *persistStream;
2026 IStream *stream = NULL;
2027 IXMLDOMDocument *xmlDoc;
2028
2029 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2030 &IID_IXMLDOMDocument, (void**)&xmlDoc) == S_OK)
2031 {
2032 BSTR bstrData;
2033
2034 IXMLDOMDocument_get_xml(xmlDoc, &bstrData);
2035 hr = internal_parseBuffer(This, (const char*)bstrData,
2036 SysStringByteLen(bstrData), vbInterface);
2037 IXMLDOMDocument_Release(xmlDoc);
2038 SysFreeString(bstrData);
2039 break;
2040 }
2041
2042 if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2043 &IID_IPersistStream, (void**)&persistStream) == S_OK)
2044 {
2045 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2046 if(hr != S_OK)
2047 {
2048 IPersistStream_Release(persistStream);
2049 return hr;
2050 }
2051
2052 hr = IPersistStream_Save(persistStream, stream, TRUE);
2053 IPersistStream_Release(persistStream);
2054 if(hr != S_OK)
2055 {
2056 IStream_Release(stream);
2057 break;
2058 }
2059 }
2060 if(stream || IUnknown_QueryInterface(V_UNKNOWN(&varInput),
2061 &IID_IStream, (void**)&stream) == S_OK)
2062 {
2063 hr = internal_parseStream(This, stream, vbInterface);
2064 IStream_Release(stream);
2065 break;
2066 }
2067 }
2068 default:
2069 WARN("vt %d not implemented\n", V_VT(&varInput));
2070 hr = E_INVALIDARG;
2071 }
2072
2073 return hr;
2074 }
2075
2076 static HRESULT internal_vbonDataAvailable(void *obj, char *ptr, DWORD len)
2077 {
2078 saxreader *This = obj;
2079
2080 return internal_parseBuffer(This, ptr, len, TRUE);
2081 }
2082
2083 static HRESULT internal_onDataAvailable(void *obj, char *ptr, DWORD len)
2084 {
2085 saxreader *This = obj;
2086
2087 return internal_parseBuffer(This, ptr, len, FALSE);
2088 }
2089
2090 static HRESULT internal_parseURL(
2091 saxreader* This,
2092 const WCHAR *url,
2093 BOOL vbInterface)
2094 {
2095 bsc_t *bsc;
2096 HRESULT hr;
2097
2098 TRACE("(%p)->(%s)\n", This, debugstr_w(url));
2099
2100 if(vbInterface) hr = bind_url(url, internal_vbonDataAvailable, This, &bsc);
2101 else hr = bind_url(url, internal_onDataAvailable, This, &bsc);
2102
2103 if(FAILED(hr))
2104 return hr;
2105
2106 detach_bsc(bsc);
2107
2108 return S_OK;
2109 }
2110
2111 static HRESULT internal_putProperty(
2112 saxreader* This,
2113 const WCHAR *pProp,
2114 VARIANT value,
2115 BOOL vbInterface)
2116 {
2117 static const WCHAR wszCharset[] = {
2118 'c','h','a','r','s','e','t',0
2119 };
2120 static const WCHAR wszDeclarationHandler[] = {
2121 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2122 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2123 'd','e','c','l','a','r','a','t','i','o','n',
2124 '-','h','a','n','d','l','e','r',0
2125 };
2126 static const WCHAR wszDomNode[] = {
2127 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2128 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2129 'd','o','m','-','n','o','d','e',0
2130 };
2131 static const WCHAR wszInputSource[] = {
2132 'i','n','p','u','t','-','s','o','u','r','c','e',0
2133 };
2134 static const WCHAR wszLexicalHandler[] = {
2135 'h','t','t','p',':','/','/','x','m','l','.','o','r','g','/',
2136 's','a','x','/','p','r','o','p','e','r','t','i','e','s','/',
2137 'l','e','x','i','c','a','l','-','h','a','n','d','l','e','r',0
2138 };
2139 static const WCHAR wszMaxElementDepth[] = {
2140 'm','a','x','-','e','l','e','m','e','n','t','-','d','e','p','t','h',0
2141 };
2142 static const WCHAR wszMaxXMLSize[] = {
2143 'm','a','x','-','x','m','l','-','s','i','z','e',0
2144 };
2145 static const WCHAR wszSchemaDeclarationHandler[] = {
2146 's','c','h','e','m','a','-',
2147 'd','e','c','l','a','r','a','t','i','o','n','-',
2148 'h','a','n','d','l','e','r',0
2149 };
2150 static const WCHAR wszXMLDeclEncoding[] = {
2151 'x','m','l','d','e','c','l','-','e','n','c','o','d','i','n','g',0
2152 };
2153 static const WCHAR wszXMLDeclStandalone[] = {
2154 'x','m','l','d','e','c','l',
2155 '-','s','t','a','n','d','a','l','o','n','e',0
2156 };
2157 static const WCHAR wszXMLDeclVersion[] = {
2158 'x','m','l','d','e','c','l','-','v','e','r','s','i','o','n',0
2159 };
2160
2161 TRACE("(%p)->(%s %s)\n", This, debugstr_w(pProp), debugstr_variant(&value));
2162
2163 if(!memcmp(pProp, wszDeclarationHandler, sizeof(wszDeclarationHandler)))
2164 {
2165 if(This->isParsing) return E_FAIL;
2166
2167 if(V_UNKNOWN(&value))
2168 {
2169 if(vbInterface)
2170 IVBSAXDeclHandler_AddRef((IVBSAXDeclHandler*)V_UNKNOWN(&value));
2171 else
2172 ISAXDeclHandler_AddRef((ISAXDeclHandler*)V_UNKNOWN(&value));
2173 }
2174 if((vbInterface && This->vbdeclHandler)
2175 || (!vbInterface && This->declHandler))
2176 {
2177 if(vbInterface)
2178 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2179 else
2180 ISAXDeclHandler_Release(This->declHandler);
2181 }
2182 if(vbInterface)
2183 This->vbdeclHandler = (IVBSAXDeclHandler*)V_UNKNOWN(&value);
2184 else
2185 This->declHandler = (ISAXDeclHandler*)V_UNKNOWN(&value);
2186 return S_OK;
2187 }
2188
2189 if(!memcmp(pProp, wszLexicalHandler, sizeof(wszLexicalHandler)))
2190 {
2191 if(This->isParsing) return E_FAIL;
2192
2193 if(V_UNKNOWN(&value))
2194 {
2195 if(vbInterface)
2196 IVBSAXLexicalHandler_AddRef(
2197 (IVBSAXLexicalHandler*)V_UNKNOWN(&value));
2198 else
2199 ISAXLexicalHandler_AddRef(
2200 (ISAXLexicalHandler*)V_UNKNOWN(&value));
2201 }
2202 if((vbInterface && This->vblexicalHandler)
2203 || (!vbInterface && This->lexicalHandler))
2204 {
2205 if(vbInterface)
2206 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2207 else
2208 ISAXLexicalHandler_Release(This->lexicalHandler);
2209 }
2210 if(vbInterface)
2211 This->vblexicalHandler = (IVBSAXLexicalHandler*)V_UNKNOWN(&value);
2212 else
2213 This->lexicalHandler = (ISAXLexicalHandler*)V_UNKNOWN(&value);
2214 return S_OK;
2215 }
2216
2217 FIXME("(%p)->(%s): unsupported property\n", This, debugstr_w(pProp));
2218
2219 if(!memcmp(pProp, wszCharset, sizeof(wszCharset)))
2220 return E_NOTIMPL;
2221
2222 if(!memcmp(pProp, wszDomNode, sizeof(wszDomNode)))
2223 return E_FAIL;
2224
2225 if(!memcmp(pProp, wszInputSource, sizeof(wszInputSource)))
2226 return E_NOTIMPL;
2227
2228 if(!memcmp(pProp, wszMaxElementDepth, sizeof(wszMaxElementDepth)))
2229 return E_NOTIMPL;
2230
2231 if(!memcmp(pProp, wszMaxXMLSize, sizeof(wszMaxXMLSize)))
2232 return E_NOTIMPL;
2233
2234 if(!memcmp(pProp, wszSchemaDeclarationHandler,
2235 sizeof(wszSchemaDeclarationHandler)))
2236 return E_NOTIMPL;
2237
2238 if(!memcmp(pProp, wszXMLDeclEncoding, sizeof(wszXMLDeclEncoding)))
2239 return E_FAIL;
2240
2241 if(!memcmp(pProp, wszXMLDeclStandalone, sizeof(wszXMLDeclStandalone)))
2242 return E_FAIL;
2243
2244 if(!memcmp(pProp, wszXMLDeclVersion, sizeof(wszXMLDeclVersion)))
2245 return E_FAIL;
2246
2247 return E_INVALIDARG;
2248 }
2249
2250 /*** IVBSAXXMLReader interface ***/
2251 /*** IUnknown methods ***/
2252 static HRESULT WINAPI saxxmlreader_QueryInterface(IVBSAXXMLReader* iface, REFIID riid, void **ppvObject)
2253 {
2254 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2255
2256 TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
2257
2258 *ppvObject = NULL;
2259
2260 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
2261 IsEqualGUID( riid, &IID_IDispatch ) ||
2262 IsEqualGUID( riid, &IID_IVBSAXXMLReader ))
2263 {
2264 *ppvObject = iface;
2265 }
2266 else if( IsEqualGUID( riid, &IID_ISAXXMLReader ))
2267 {
2268 *ppvObject = &This->ISAXXMLReader_iface;
2269 }
2270 else
2271 {
2272 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2273 return E_NOINTERFACE;
2274 }
2275
2276 IVBSAXXMLReader_AddRef( iface );
2277
2278 return S_OK;
2279 }
2280
2281 static ULONG WINAPI saxxmlreader_AddRef(IVBSAXXMLReader* iface)
2282 {
2283 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2284 TRACE("%p\n", This );
2285 return InterlockedIncrement( &This->ref );
2286 }
2287
2288 static ULONG WINAPI saxxmlreader_Release(
2289 IVBSAXXMLReader* iface)
2290 {
2291 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2292 LONG ref;
2293
2294 TRACE("%p\n", This );
2295
2296 ref = InterlockedDecrement( &This->ref );
2297 if ( ref == 0 )
2298 {
2299 if(This->contentHandler)
2300 ISAXContentHandler_Release(This->contentHandler);
2301
2302 if(This->vbcontentHandler)
2303 IVBSAXContentHandler_Release(This->vbcontentHandler);
2304
2305 if(This->errorHandler)
2306 ISAXErrorHandler_Release(This->errorHandler);
2307
2308 if(This->vberrorHandler)
2309 IVBSAXErrorHandler_Release(This->vberrorHandler);
2310
2311 if(This->lexicalHandler)
2312 ISAXLexicalHandler_Release(This->lexicalHandler);
2313
2314 if(This->vblexicalHandler)
2315 IVBSAXLexicalHandler_Release(This->vblexicalHandler);
2316
2317 if(This->declHandler)
2318 ISAXDeclHandler_Release(This->declHandler);
2319
2320 if(This->vbdeclHandler)
2321 IVBSAXDeclHandler_Release(This->vbdeclHandler);
2322
2323 heap_free( This );
2324 }
2325
2326 return ref;
2327 }
2328 /*** IDispatch ***/
2329 static HRESULT WINAPI saxxmlreader_GetTypeInfoCount( IVBSAXXMLReader *iface, UINT* pctinfo )
2330 {
2331 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2332
2333 TRACE("(%p)->(%p)\n", This, pctinfo);
2334
2335 *pctinfo = 1;
2336
2337 return S_OK;
2338 }
2339
2340 static HRESULT WINAPI saxxmlreader_GetTypeInfo(
2341 IVBSAXXMLReader *iface,
2342 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
2343 {
2344 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2345 HRESULT hr;
2346
2347 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2348
2349 hr = get_typeinfo(IVBSAXXMLReader_tid, ppTInfo);
2350
2351 return hr;
2352 }
2353
2354 static HRESULT WINAPI saxxmlreader_GetIDsOfNames(
2355 IVBSAXXMLReader *iface,
2356 REFIID riid,
2357 LPOLESTR* rgszNames,
2358 UINT cNames,
2359 LCID lcid,
2360 DISPID* rgDispId)
2361 {
2362 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2363 ITypeInfo *typeinfo;
2364 HRESULT hr;
2365
2366 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2367 lcid, rgDispId);
2368
2369 if(!rgszNames || cNames == 0 || !rgDispId)
2370 return E_INVALIDARG;
2371
2372 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2373 if(SUCCEEDED(hr))
2374 {
2375 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
2376 ITypeInfo_Release(typeinfo);
2377 }
2378
2379 return hr;
2380 }
2381
2382 static HRESULT WINAPI saxxmlreader_Invoke(
2383 IVBSAXXMLReader *iface,
2384 DISPID dispIdMember,
2385 REFIID riid,
2386 LCID lcid,
2387 WORD wFlags,
2388 DISPPARAMS* pDispParams,
2389 VARIANT* pVarResult,
2390 EXCEPINFO* pExcepInfo,
2391 UINT* puArgErr)
2392 {
2393 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2394 ITypeInfo *typeinfo;
2395 HRESULT hr;
2396
2397 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2398 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2399
2400 hr = get_typeinfo(IVBSAXXMLReader_tid, &typeinfo);
2401 if(SUCCEEDED(hr))
2402 {
2403 hr = ITypeInfo_Invoke(typeinfo, &This->IVBSAXXMLReader_iface, dispIdMember, wFlags,
2404 pDispParams, pVarResult, pExcepInfo, puArgErr);
2405 ITypeInfo_Release(typeinfo);
2406 }
2407
2408 return hr;
2409 }
2410
2411 /*** IVBSAXXMLReader methods ***/
2412 static HRESULT WINAPI saxxmlreader_getFeature(
2413 IVBSAXXMLReader* iface,
2414 const WCHAR *pFeature,
2415 VARIANT_BOOL *pValue)
2416 {
2417 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2418
2419 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pFeature), pValue);
2420 return E_NOTIMPL;
2421 }
2422
2423 static HRESULT WINAPI saxxmlreader_putFeature(
2424 IVBSAXXMLReader* iface,
2425 const WCHAR *pFeature,
2426 VARIANT_BOOL vfValue)
2427 {
2428 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2429
2430 FIXME("(%p)->(%s %x) stub\n", This, debugstr_w(pFeature), vfValue);
2431 return E_NOTIMPL;
2432 }
2433
2434 static HRESULT WINAPI saxxmlreader_getProperty(
2435 IVBSAXXMLReader* iface,
2436 const WCHAR *pProp,
2437 VARIANT *pValue)
2438 {
2439 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2440
2441 FIXME("(%p)->(%s %p) stub\n", This, debugstr_w(pProp), pValue);
2442 return E_NOTIMPL;
2443 }
2444
2445 static HRESULT WINAPI saxxmlreader_putProperty(
2446 IVBSAXXMLReader* iface,
2447 const WCHAR *pProp,
2448 VARIANT value)
2449 {
2450 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2451 return internal_putProperty(This, pProp, value, TRUE);
2452 }
2453
2454 static HRESULT WINAPI saxxmlreader_get_entityResolver(
2455 IVBSAXXMLReader* iface,
2456 IVBSAXEntityResolver **pEntityResolver)
2457 {
2458 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2459 return internal_getEntityResolver(This, pEntityResolver, TRUE);
2460 }
2461
2462 static HRESULT WINAPI saxxmlreader_put_entityResolver(
2463 IVBSAXXMLReader* iface,
2464 IVBSAXEntityResolver *pEntityResolver)
2465 {
2466 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2467 return internal_putEntityResolver(This, pEntityResolver, TRUE);
2468 }
2469
2470 static HRESULT WINAPI saxxmlreader_get_contentHandler(
2471 IVBSAXXMLReader* iface,
2472 IVBSAXContentHandler **ppContentHandler)
2473 {
2474 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2475 return internal_getContentHandler(This, ppContentHandler, TRUE);
2476 }
2477
2478 static HRESULT WINAPI saxxmlreader_put_contentHandler(
2479 IVBSAXXMLReader* iface,
2480 IVBSAXContentHandler *contentHandler)
2481 {
2482 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2483 return internal_putContentHandler(This, contentHandler, TRUE);
2484 }
2485
2486 static HRESULT WINAPI saxxmlreader_get_dtdHandler(
2487 IVBSAXXMLReader* iface,
2488 IVBSAXDTDHandler **pDTDHandler)
2489 {
2490 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2491 return internal_getDTDHandler(This, pDTDHandler, TRUE);
2492 }
2493
2494 static HRESULT WINAPI saxxmlreader_put_dtdHandler(
2495 IVBSAXXMLReader* iface,
2496 IVBSAXDTDHandler *pDTDHandler)
2497 {
2498 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2499 return internal_putDTDHandler(This, pDTDHandler, TRUE);
2500 }
2501
2502 static HRESULT WINAPI saxxmlreader_get_errorHandler(
2503 IVBSAXXMLReader* iface,
2504 IVBSAXErrorHandler **pErrorHandler)
2505 {
2506 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2507 return internal_getErrorHandler(This, pErrorHandler, TRUE);
2508 }
2509
2510 static HRESULT WINAPI saxxmlreader_put_errorHandler(
2511 IVBSAXXMLReader* iface,
2512 IVBSAXErrorHandler *errorHandler)
2513 {
2514 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2515 return internal_putErrorHandler(This, errorHandler, TRUE);
2516 }
2517
2518 static HRESULT WINAPI saxxmlreader_get_baseURL(
2519 IVBSAXXMLReader* iface,
2520 const WCHAR **pBaseUrl)
2521 {
2522 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2523
2524 FIXME("(%p)->(%p) stub\n", This, pBaseUrl);
2525 return E_NOTIMPL;
2526 }
2527
2528 static HRESULT WINAPI saxxmlreader_put_baseURL(
2529 IVBSAXXMLReader* iface,
2530 const WCHAR *pBaseUrl)
2531 {
2532 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2533
2534 FIXME("(%p)->(%s) stub\n", This, debugstr_w(pBaseUrl));
2535 return E_NOTIMPL;
2536 }
2537
2538 static HRESULT WINAPI saxxmlreader_get_secureBaseURL(
2539 IVBSAXXMLReader* iface,
2540 const WCHAR **pSecureBaseUrl)
2541 {
2542 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2543
2544 FIXME("(%p)->(%p) stub\n", This, pSecureBaseUrl);
2545 return E_NOTIMPL;
2546 }
2547
2548
2549 static HRESULT WINAPI saxxmlreader_put_secureBaseURL(
2550 IVBSAXXMLReader* iface,
2551 const WCHAR *secureBaseUrl)
2552 {
2553 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2554
2555 FIXME("(%p)->(%s) stub\n", This, debugstr_w(secureBaseUrl));
2556 return E_NOTIMPL;
2557 }
2558
2559 static HRESULT WINAPI saxxmlreader_parse(
2560 IVBSAXXMLReader* iface,
2561 VARIANT varInput)
2562 {
2563 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2564 return internal_parse(This, varInput, TRUE);
2565 }
2566
2567 static HRESULT WINAPI saxxmlreader_parseURL(
2568 IVBSAXXMLReader* iface,
2569 const WCHAR *url)
2570 {
2571 saxreader *This = impl_from_IVBSAXXMLReader( iface );
2572 return internal_parseURL(This, url, TRUE);
2573 }
2574
2575 static const struct IVBSAXXMLReaderVtbl saxreader_vtbl =
2576 {
2577 saxxmlreader_QueryInterface,
2578 saxxmlreader_AddRef,
2579 saxxmlreader_Release,
2580 saxxmlreader_GetTypeInfoCount,
2581 saxxmlreader_GetTypeInfo,
2582 saxxmlreader_GetIDsOfNames,
2583 saxxmlreader_Invoke,
2584 saxxmlreader_getFeature,
2585 saxxmlreader_putFeature,
2586 saxxmlreader_getProperty,
2587 saxxmlreader_putProperty,
2588 saxxmlreader_get_entityResolver,
2589 saxxmlreader_put_entityResolver,
2590 saxxmlreader_get_contentHandler,
2591 saxxmlreader_put_contentHandler,
2592 saxxmlreader_get_dtdHandler,
2593 saxxmlreader_put_dtdHandler,
2594 saxxmlreader_get_errorHandler,
2595 saxxmlreader_put_errorHandler,
2596 saxxmlreader_get_baseURL,
2597 saxxmlreader_put_baseURL,
2598 saxxmlreader_get_secureBaseURL,
2599 saxxmlreader_put_secureBaseURL,
2600 saxxmlreader_parse,
2601 saxxmlreader_parseURL
2602 };
2603
2604 /*** ISAXXMLReader interface ***/
2605 /*** IUnknown methods ***/
2606 static HRESULT WINAPI isaxxmlreader_QueryInterface(ISAXXMLReader* iface, REFIID riid, void **ppvObject)
2607 {
2608 saxreader *This = impl_from_ISAXXMLReader( iface );
2609 return saxxmlreader_QueryInterface(&This->IVBSAXXMLReader_iface, riid, ppvObject);
2610 }
2611
2612 static ULONG WINAPI isaxxmlreader_AddRef(ISAXXMLReader* iface)
2613 {
2614 saxreader *This = impl_from_ISAXXMLReader( iface );
2615 return saxxmlreader_AddRef(&This->IVBSAXXMLReader_iface);
2616 }
2617
2618 static ULONG WINAPI isaxxmlreader_Release(ISAXXMLReader* iface)
2619 {
2620 saxreader *This = impl_from_ISAXXMLReader( iface );
2621 return saxxmlreader_Release(&This->IVBSAXXMLReader_iface);
2622 }
2623
2624 /*** ISAXXMLReader methods ***/
2625 static HRESULT WINAPI isaxxmlreader_getFeature(
2626 ISAXXMLReader* iface,
2627 const WCHAR *pFeature,
2628 VARIANT_BOOL *pValue)
2629 {
2630 saxreader *This = impl_from_ISAXXMLReader( iface );
2631 return IVBSAXXMLReader_getFeature(&This->IVBSAXXMLReader_iface, pFeature, pValue);
2632 }
2633
2634 static HRESULT WINAPI isaxxmlreader_putFeature(
2635 ISAXXMLReader* iface,
2636 const WCHAR *pFeature,
2637 VARIANT_BOOL vfValue)
2638 {
2639 saxreader *This = impl_from_ISAXXMLReader( iface );
2640 return IVBSAXXMLReader_putFeature(&This->IVBSAXXMLReader_iface, pFeature, vfValue);
2641 }
2642
2643 static HRESULT WINAPI isaxxmlreader_getProperty(
2644 ISAXXMLReader* iface,
2645 const WCHAR *pProp,
2646 VARIANT *pValue)
2647 {
2648 saxreader *This = impl_from_ISAXXMLReader( iface );
2649 return IVBSAXXMLReader_getProperty(&This->IVBSAXXMLReader_iface, pProp, pValue);
2650 }
2651
2652 static HRESULT WINAPI isaxxmlreader_putProperty(
2653 ISAXXMLReader* iface,
2654 const WCHAR *pProp,
2655 VARIANT value)
2656 {
2657 saxreader *This = impl_from_ISAXXMLReader( iface );
2658 return internal_putProperty(This, pProp, value, FALSE);
2659 }
2660
2661 static HRESULT WINAPI isaxxmlreader_getEntityResolver(
2662 ISAXXMLReader* iface,
2663 ISAXEntityResolver **ppEntityResolver)
2664 {
2665 saxreader *This = impl_from_ISAXXMLReader( iface );
2666 return internal_getEntityResolver(This, ppEntityResolver, FALSE);
2667 }
2668
2669 static HRESULT WINAPI isaxxmlreader_putEntityResolver(
2670 ISAXXMLReader* iface,
2671 ISAXEntityResolver *pEntityResolver)
2672 {
2673 saxreader *This = impl_from_ISAXXMLReader( iface );
2674 return internal_putEntityResolver(This, pEntityResolver, FALSE);
2675 }
2676
2677 static HRESULT WINAPI isaxxmlreader_getContentHandler(
2678 ISAXXMLReader* iface,
2679 ISAXContentHandler **pContentHandler)
2680 {
2681 saxreader *This = impl_from_ISAXXMLReader( iface );
2682 return internal_getContentHandler(This, pContentHandler, FALSE);
2683 }
2684
2685 static HRESULT WINAPI isaxxmlreader_putContentHandler(
2686 ISAXXMLReader* iface,
2687 ISAXContentHandler *contentHandler)
2688 {
2689 saxreader *This = impl_from_ISAXXMLReader( iface );
2690 return internal_putContentHandler(This, contentHandler, FALSE);
2691 }
2692
2693 static HRESULT WINAPI isaxxmlreader_getDTDHandler(
2694 ISAXXMLReader* iface,
2695 ISAXDTDHandler **pDTDHandler)
2696 {
2697 saxreader *This = impl_from_ISAXXMLReader( iface );
2698 return internal_getDTDHandler(This, pDTDHandler, FALSE);
2699 }
2700
2701 static HRESULT WINAPI isaxxmlreader_putDTDHandler(
2702 ISAXXMLReader* iface,
2703 ISAXDTDHandler *pDTDHandler)
2704 {
2705 saxreader *This = impl_from_ISAXXMLReader( iface );
2706 return internal_putDTDHandler(This, pDTDHandler, FALSE);
2707 }
2708
2709 static HRESULT WINAPI isaxxmlreader_getErrorHandler(
2710 ISAXXMLReader* iface,
2711 ISAXErrorHandler **pErrorHandler)
2712 {
2713 saxreader *This = impl_from_ISAXXMLReader( iface );
2714 return internal_getErrorHandler(This, pErrorHandler, FALSE);
2715 }
2716
2717 static HRESULT WINAPI isaxxmlreader_putErrorHandler(
2718 ISAXXMLReader* iface,
2719 ISAXErrorHandler *errorHandler)
2720 {
2721 saxreader *This = impl_from_ISAXXMLReader( iface );
2722 return internal_putErrorHandler(This, errorHandler, FALSE);
2723 }
2724
2725 static HRESULT WINAPI isaxxmlreader_getBaseURL(
2726 ISAXXMLReader* iface,
2727 const WCHAR **pBaseUrl)
2728 {
2729 saxreader *This = impl_from_ISAXXMLReader( iface );
2730 return IVBSAXXMLReader_get_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
2731 }
2732
2733 static HRESULT WINAPI isaxxmlreader_putBaseURL(
2734 ISAXXMLReader* iface,
2735 const WCHAR *pBaseUrl)
2736 {
2737 saxreader *This = impl_from_ISAXXMLReader( iface );
2738 return IVBSAXXMLReader_put_baseURL(&This->IVBSAXXMLReader_iface, pBaseUrl);
2739 }
2740
2741 static HRESULT WINAPI isaxxmlreader_getSecureBaseURL(
2742 ISAXXMLReader* iface,
2743 const WCHAR **pSecureBaseUrl)
2744 {
2745 saxreader *This = impl_from_ISAXXMLReader( iface );
2746 return IVBSAXXMLReader_get_secureBaseURL(&This->IVBSAXXMLReader_iface, pSecureBaseUrl);
2747 }
2748
2749 static HRESULT WINAPI isaxxmlreader_putSecureBaseURL(
2750 ISAXXMLReader* iface,
2751 const WCHAR *secureBaseUrl)
2752 {
2753 saxreader *This = impl_from_ISAXXMLReader( iface );
2754 return IVBSAXXMLReader_put_secureBaseURL(&This->IVBSAXXMLReader_iface, secureBaseUrl);
2755 }
2756
2757 static HRESULT WINAPI isaxxmlreader_parse(
2758 ISAXXMLReader* iface,
2759 VARIANT varInput)
2760 {
2761 saxreader *This = impl_from_ISAXXMLReader( iface );
2762 return internal_parse(This, varInput, FALSE);
2763 }
2764
2765 static HRESULT WINAPI isaxxmlreader_parseURL(
2766 ISAXXMLReader* iface,
2767 const WCHAR *url)
2768 {
2769 saxreader *This = impl_from_ISAXXMLReader( iface );
2770 return internal_parseURL(This, url, FALSE);
2771 }
2772
2773 static const struct ISAXXMLReaderVtbl isaxreader_vtbl =
2774 {
2775 isaxxmlreader_QueryInterface,
2776 isaxxmlreader_AddRef,
2777 isaxxmlreader_Release,
2778 isaxxmlreader_getFeature,
2779 isaxxmlreader_putFeature,
2780 isaxxmlreader_getProperty,
2781 isaxxmlreader_putProperty,
2782 isaxxmlreader_getEntityResolver,
2783 isaxxmlreader_putEntityResolver,
2784 isaxxmlreader_getContentHandler,
2785 isaxxmlreader_putContentHandler,
2786 isaxxmlreader_getDTDHandler,
2787 isaxxmlreader_putDTDHandler,
2788 isaxxmlreader_getErrorHandler,
2789 isaxxmlreader_putErrorHandler,
2790 isaxxmlreader_getBaseURL,
2791 isaxxmlreader_putBaseURL,
2792 isaxxmlreader_getSecureBaseURL,
2793 isaxxmlreader_putSecureBaseURL,
2794 isaxxmlreader_parse,
2795 isaxxmlreader_parseURL
2796 };
2797
2798 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2799 {
2800 saxreader *reader;
2801
2802 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2803
2804 reader = heap_alloc( sizeof (*reader) );
2805 if( !reader )
2806 return E_OUTOFMEMORY;
2807
2808 reader->IVBSAXXMLReader_iface.lpVtbl = &saxreader_vtbl;
2809 reader->ISAXXMLReader_iface.lpVtbl = &isaxreader_vtbl;
2810 reader->ref = 1;
2811 reader->contentHandler = NULL;
2812 reader->vbcontentHandler = NULL;
2813 reader->errorHandler = NULL;
2814 reader->vberrorHandler = NULL;
2815 reader->lexicalHandler = NULL;
2816 reader->vblexicalHandler = NULL;
2817 reader->declHandler = NULL;
2818 reader->vbdeclHandler = NULL;
2819 reader->isParsing = FALSE;
2820
2821 memset(&reader->sax, 0, sizeof(xmlSAXHandler));
2822 reader->sax.initialized = XML_SAX2_MAGIC;
2823 reader->sax.startDocument = libxmlStartDocument;
2824 reader->sax.endDocument = libxmlEndDocument;
2825 reader->sax.startElementNs = libxmlStartElementNS;
2826 reader->sax.endElementNs = libxmlEndElementNS;
2827 reader->sax.characters = libxmlCharacters;
2828 reader->sax.setDocumentLocator = libxmlSetDocumentLocator;
2829 reader->sax.comment = libxmlComment;
2830 reader->sax.error = libxmlFatalError;
2831 reader->sax.fatalError = libxmlFatalError;
2832 reader->sax.cdataBlock = libxmlCDataBlock;
2833
2834 *ppObj = &reader->IVBSAXXMLReader_iface;
2835
2836 TRACE("returning iface %p\n", *ppObj);
2837
2838 return S_OK;
2839 }
2840
2841 #else
2842
2843 HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2844 {
2845 MESSAGE("This program tried to use a SAX XML Reader object, but\n"
2846 "libxml2 support was not present at compile time.\n");
2847 return E_NOTIMPL;
2848 }
2849
2850 #endif
Maarten's multimedia branch