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