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