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