?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Map glDrawArraysInstanced() to glDrawArraysInstancedARB().
[wine.git] / dlls / xmllite / reader.c
blob8a078a4a2e071eed7baf4501a8f102142965ceb2
1 /*
2 * IXmlReader implementation
3 *
4 * Copyright 2010, 2012-2013 Nikolay Sivov
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22
23 #include <stdio.h>
24 #include <stdarg.h>
25 #include "windef.h"
26 #include "winbase.h"
27 #include "initguid.h"
28 #include "objbase.h"
29 #include "xmllite.h"
30 #include "xmllite_private.h"
31
32 #include "wine/debug.h"
33 #include "wine/list.h"
34 #include "wine/unicode.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(xmllite);
37
38 /* not defined in public headers */
39 DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
40
41 typedef enum
42 {
43 XmlReadInState_Initial,
44 XmlReadInState_XmlDecl,
45 XmlReadInState_Misc_DTD,
46 XmlReadInState_DTD,
47 XmlReadInState_DTD_Misc,
48 XmlReadInState_Element,
49 XmlReadInState_Content,
50 XmlReadInState_MiscEnd, /* optional Misc at the end of a document */
51 XmlReadInState_Eof
52 } XmlReaderInternalState;
53
54 /* This state denotes where parsing was interrupted by input problem.
55 Reader resumes parsing using this information. */
56 typedef enum
57 {
58 XmlReadResumeState_Initial,
59 XmlReadResumeState_PITarget,
60 XmlReadResumeState_PIBody,
61 XmlReadResumeState_CDATA,
62 XmlReadResumeState_Comment,
63 XmlReadResumeState_STag,
64 XmlReadResumeState_CharData,
65 XmlReadResumeState_Whitespace
66 } XmlReaderResumeState;
67
68 /* saved pointer index to resume from particular input position */
69 typedef enum
70 {
71 XmlReadResume_Name, /* PITarget, name for NCName, prefix for QName */
72 XmlReadResume_Local, /* local for QName */
73 XmlReadResume_Body, /* PI body, comment text, CDATA text, CharData text */
74 XmlReadResume_Last
75 } XmlReaderResume;
76
77 typedef enum
78 {
79 StringValue_LocalName,
80 StringValue_Prefix,
81 StringValue_QualifiedName,
82 StringValue_Value,
83 StringValue_Last
84 } XmlReaderStringValue;
85
86 static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
87 static const WCHAR utf8W[] = {'U','T','F','-','8',0};
88
89 static const WCHAR dblquoteW[] = {'\"',0};
90 static const WCHAR quoteW[] = {'\'',0};
91 static const WCHAR ltW[] = {'<',0};
92 static const WCHAR gtW[] = {'>',0};
93 static const WCHAR commentW[] = {'<','!','-','-',0};
94 static const WCHAR piW[] = {'<','?',0};
95
96 static const char *debugstr_nodetype(XmlNodeType nodetype)
97 {
98 static const char * const type_names[] =
99 {
100 "None",
101 "Element",
102 "Attribute",
103 "Text",
104 "CDATA",
105 "",
106 "",
107 "ProcessingInstruction",
108 "Comment",
109 "",
110 "DocumentType",
111 "",
112 "",
113 "Whitespace",
114 "",
115 "EndElement",
116 "",
117 "XmlDeclaration"
118 };
119
120 if (nodetype > _XmlNodeType_Last)
121 return wine_dbg_sprintf("unknown type=%d", nodetype);
122
123 return type_names[nodetype];
124 }
125
126 static const char *debugstr_reader_prop(XmlReaderProperty prop)
127 {
128 static const char * const prop_names[] =
129 {
130 "MultiLanguage",
131 "ConformanceLevel",
132 "RandomAccess",
133 "XmlResolver",
134 "DtdProcessing",
135 "ReadState",
136 "MaxElementDepth",
137 "MaxEntityExpansion"
138 };
139
140 if (prop > _XmlReaderProperty_Last)
141 return wine_dbg_sprintf("unknown property=%d", prop);
142
143 return prop_names[prop];
144 }
145
146 struct xml_encoding_data
147 {
148 const WCHAR *name;
149 xml_encoding enc;
150 UINT cp;
151 };
152
153 static const struct xml_encoding_data xml_encoding_map[] = {
154 { utf16W, XmlEncoding_UTF16, ~0 },
155 { utf8W, XmlEncoding_UTF8, CP_UTF8 }
156 };
157
158 const WCHAR *get_encoding_name(xml_encoding encoding)
159 {
160 return xml_encoding_map[encoding].name;
161 }
162
163 xml_encoding get_encoding_from_codepage(UINT codepage)
164 {
165 int i;
166 for (i = 0; i < sizeof(xml_encoding_map)/sizeof(xml_encoding_map[0]); i++)
167 {
168 if (xml_encoding_map[i].cp == codepage) return xml_encoding_map[i].enc;
169 }
170 return XmlEncoding_Unknown;
171 }
172
173 typedef struct
174 {
175 char *data;
176 UINT cur;
177 unsigned int allocated;
178 unsigned int written;
179 } encoded_buffer;
180
181 typedef struct input_buffer input_buffer;
182
183 typedef struct
184 {
185 IXmlReaderInput IXmlReaderInput_iface;
186 LONG ref;
187 /* reference passed on IXmlReaderInput creation, is kept when input is created */
188 IUnknown *input;
189 IMalloc *imalloc;
190 xml_encoding encoding;
191 BOOL hint;
192 WCHAR *baseuri;
193 /* stream reference set after SetInput() call from reader,
194 stored as sequential stream, cause currently
195 optimizations possible with IStream aren't implemented */
196 ISequentialStream *stream;
197 input_buffer *buffer;
198 unsigned int pending : 1;
199 } xmlreaderinput;
200
201 static const struct IUnknownVtbl xmlreaderinputvtbl;
202
203 /* Structure to hold parsed string of specific length.
204
205 Reader stores node value as 'start' pointer, on request
206 a null-terminated version of it is allocated.
207
208 To init a strval variable use reader_init_strval(),
209 to set strval as a reader value use reader_set_strval().
210 */
211 typedef struct
212 {
213 WCHAR *str; /* allocated null-terminated string */
214 UINT len; /* length in WCHARs, altered after ReadValueChunk */
215 UINT start; /* input position where value starts */
216 } strval;
217
218 static WCHAR emptyW[] = {0};
219 static const strval strval_empty = { emptyW };
220
221 struct attribute
222 {
223 struct list entry;
224 strval localname;
225 strval value;
226 };
227
228 struct element
229 {
230 struct list entry;
231 strval qname;
232 strval localname;
233 };
234
235 typedef struct
236 {
237 IXmlReader IXmlReader_iface;
238 LONG ref;
239 xmlreaderinput *input;
240 IMalloc *imalloc;
241 XmlReadState state;
242 XmlReaderInternalState instate;
243 XmlReaderResumeState resumestate;
244 XmlNodeType nodetype;
245 DtdProcessing dtdmode;
246 UINT line, pos; /* reader position in XML stream */
247 struct list attrs; /* attributes list for current node */
248 struct attribute *attr; /* current attribute */
249 UINT attr_count;
250 struct list elements;
251 strval strvalues[StringValue_Last];
252 UINT depth;
253 UINT max_depth;
254 BOOL empty_element;
255 UINT resume[XmlReadResume_Last]; /* offsets used to resume reader */
256 } xmlreader;
257
258 struct input_buffer
259 {
260 encoded_buffer utf16;
261 encoded_buffer encoded;
262 UINT code_page;
263 xmlreaderinput *input;
264 };
265
266 static inline xmlreader *impl_from_IXmlReader(IXmlReader *iface)
267 {
268 return CONTAINING_RECORD(iface, xmlreader, IXmlReader_iface);
269 }
270
271 static inline xmlreaderinput *impl_from_IXmlReaderInput(IXmlReaderInput *iface)
272 {
273 return CONTAINING_RECORD(iface, xmlreaderinput, IXmlReaderInput_iface);
274 }
275
276 /* reader memory allocation functions */
277 static inline void *reader_alloc(xmlreader *reader, size_t len)
278 {
279 return m_alloc(reader->imalloc, len);
280 }
281
282 static inline void reader_free(xmlreader *reader, void *mem)
283 {
284 m_free(reader->imalloc, mem);
285 }
286
287 /* Just return pointer from offset, no attempt to read more. */
288 static inline WCHAR *reader_get_ptr2(const xmlreader *reader, UINT offset)
289 {
290 encoded_buffer *buffer = &reader->input->buffer->utf16;
291 return (WCHAR*)buffer->data + offset;
292 }
293
294 static inline WCHAR *reader_get_strptr(const xmlreader *reader, const strval *v)
295 {
296 return v->str ? v->str : reader_get_ptr2(reader, v->start);
297 }
298
299 static HRESULT reader_strvaldup(xmlreader *reader, const strval *src, strval *dest)
300 {
301 *dest = *src;
302
303 if (src->str != strval_empty.str)
304 {
305 dest->str = reader_alloc(reader, (dest->len+1)*sizeof(WCHAR));
306 if (!dest->str) return E_OUTOFMEMORY;
307 memcpy(dest->str, reader_get_strptr(reader, src), dest->len*sizeof(WCHAR));
308 dest->str[dest->len] = 0;
309 dest->start = 0;
310 }
311
312 return S_OK;
313 }
314
315 /* reader input memory allocation functions */
316 static inline void *readerinput_alloc(xmlreaderinput *input, size_t len)
317 {
318 return m_alloc(input->imalloc, len);
319 }
320
321 static inline void *readerinput_realloc(xmlreaderinput *input, void *mem, size_t len)
322 {
323 return m_realloc(input->imalloc, mem, len);
324 }
325
326 static inline void readerinput_free(xmlreaderinput *input, void *mem)
327 {
328 m_free(input->imalloc, mem);
329 }
330
331 static inline WCHAR *readerinput_strdupW(xmlreaderinput *input, const WCHAR *str)
332 {
333 LPWSTR ret = NULL;
334
335 if(str) {
336 DWORD size;
337
338 size = (strlenW(str)+1)*sizeof(WCHAR);
339 ret = readerinput_alloc(input, size);
340 if (ret) memcpy(ret, str, size);
341 }
342
343 return ret;
344 }
345
346 static void reader_clear_attrs(xmlreader *reader)
347 {
348 struct attribute *attr, *attr2;
349 LIST_FOR_EACH_ENTRY_SAFE(attr, attr2, &reader->attrs, struct attribute, entry)
350 {
351 reader_free(reader, attr);
352 }
353 list_init(&reader->attrs);
354 reader->attr_count = 0;
355 reader->attr = NULL;
356 }
357
358 /* attribute data holds pointers to buffer data, so buffer shrink is not possible
359 while we are on a node with attributes */
360 static HRESULT reader_add_attr(xmlreader *reader, strval *localname, strval *value)
361 {
362 struct attribute *attr;
363
364 attr = reader_alloc(reader, sizeof(*attr));
365 if (!attr) return E_OUTOFMEMORY;
366
367 attr->localname = *localname;
368 attr->value = *value;
369 list_add_tail(&reader->attrs, &attr->entry);
370 reader->attr_count++;
371
372 return S_OK;
373 }
374
375 /* This one frees stored string value if needed */
376 static void reader_free_strvalued(xmlreader *reader, strval *v)
377 {
378 if (v->str != strval_empty.str)
379 {
380 reader_free(reader, v->str);
381 *v = strval_empty;
382 }
383 }
384
385 static inline void reader_init_strvalue(UINT start, UINT len, strval *v)
386 {
387 v->start = start;
388 v->len = len;
389 v->str = NULL;
390 }
391
392 static inline const char* debug_strval(const xmlreader *reader, const strval *v)
393 {
394 return debugstr_wn(reader_get_strptr(reader, v), v->len);
395 }
396
397 /* used to initialize from constant string */
398 static inline void reader_init_cstrvalue(WCHAR *str, UINT len, strval *v)
399 {
400 v->start = 0;
401 v->len = len;
402 v->str = str;
403 }
404
405 static void reader_free_strvalue(xmlreader *reader, XmlReaderStringValue type)
406 {
407 reader_free_strvalued(reader, &reader->strvalues[type]);
408 }
409
410 static void reader_free_strvalues(xmlreader *reader)
411 {
412 int type;
413 for (type = 0; type < StringValue_Last; type++)
414 reader_free_strvalue(reader, type);
415 }
416
417 /* This helper should only be used to test if strings are the same,
418 it doesn't try to sort. */
419 static inline int strval_eq(const xmlreader *reader, const strval *str1, const strval *str2)
420 {
421 if (str1->len != str2->len) return 0;
422 return !memcmp(reader_get_strptr(reader, str1), reader_get_strptr(reader, str2), str1->len*sizeof(WCHAR));
423 }
424
425 static void reader_clear_elements(xmlreader *reader)
426 {
427 struct element *elem, *elem2;
428 LIST_FOR_EACH_ENTRY_SAFE(elem, elem2, &reader->elements, struct element, entry)
429 {
430 reader_free_strvalued(reader, &elem->qname);
431 reader_free(reader, elem);
432 }
433 list_init(&reader->elements);
434 reader->empty_element = FALSE;
435 }
436
437 static HRESULT reader_inc_depth(xmlreader *reader)
438 {
439 if (++reader->depth > reader->max_depth) return SC_E_MAXELEMENTDEPTH;
440 return S_OK;
441 }
442
443 static void reader_dec_depth(xmlreader *reader)
444 {
445 if (reader->depth > 1) reader->depth--;
446 }
447
448 static HRESULT reader_push_element(xmlreader *reader, strval *qname, strval *localname)
449 {
450 struct element *elem;
451 HRESULT hr;
452
453 elem = reader_alloc(reader, sizeof(*elem));
454 if (!elem) return E_OUTOFMEMORY;
455
456 hr = reader_strvaldup(reader, qname, &elem->qname);
457 if (FAILED(hr)) {
458 reader_free(reader, elem);
459 return hr;
460 }
461
462 hr = reader_strvaldup(reader, localname, &elem->localname);
463 if (FAILED(hr))
464 {
465 reader_free_strvalued(reader, &elem->qname);
466 reader_free(reader, elem);
467 return hr;
468 }
469
470 if (!list_empty(&reader->elements))
471 {
472 hr = reader_inc_depth(reader);
473 if (FAILED(hr)) {
474 reader_free(reader, elem);
475 return hr;
476 }
477 }
478
479 list_add_head(&reader->elements, &elem->entry);
480 reader->empty_element = FALSE;
481 return hr;
482 }
483
484 static void reader_pop_element(xmlreader *reader)
485 {
486 struct element *elem = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
487
488 if (elem)
489 {
490 list_remove(&elem->entry);
491 reader_free_strvalued(reader, &elem->qname);
492 reader_free_strvalued(reader, &elem->localname);
493 reader_free(reader, elem);
494 reader_dec_depth(reader);
495 }
496 }
497
498 /* Always make a copy, cause strings are supposed to be null terminated. Null pointer for 'value'
499 means node value is to be determined. */
500 static void reader_set_strvalue(xmlreader *reader, XmlReaderStringValue type, const strval *value)
501 {
502 strval *v = &reader->strvalues[type];
503
504 reader_free_strvalue(reader, type);
505 if (!value)
506 {
507 v->str = NULL;
508 v->start = 0;
509 v->len = 0;
510 return;
511 }
512
513 if (value->str == strval_empty.str)
514 *v = *value;
515 else
516 {
517 if (type == StringValue_Value)
518 {
519 /* defer allocation for value string */
520 v->str = NULL;
521 v->start = value->start;
522 v->len = value->len;
523 }
524 else
525 {
526 v->str = reader_alloc(reader, (value->len + 1)*sizeof(WCHAR));
527 memcpy(v->str, reader_get_strptr(reader, value), value->len*sizeof(WCHAR));
528 v->str[value->len] = 0;
529 v->len = value->len;
530 }
531 }
532 }
533
534 static inline int is_reader_pending(xmlreader *reader)
535 {
536 return reader->input->pending;
537 }
538
539 static HRESULT init_encoded_buffer(xmlreaderinput *input, encoded_buffer *buffer)
540 {
541 const int initial_len = 0x2000;
542 buffer->data = readerinput_alloc(input, initial_len);
543 if (!buffer->data) return E_OUTOFMEMORY;
544
545 memset(buffer->data, 0, 4);
546 buffer->cur = 0;
547 buffer->allocated = initial_len;
548 buffer->written = 0;
549
550 return S_OK;
551 }
552
553 static void free_encoded_buffer(xmlreaderinput *input, encoded_buffer *buffer)
554 {
555 readerinput_free(input, buffer->data);
556 }
557
558 HRESULT get_code_page(xml_encoding encoding, UINT *cp)
559 {
560 if (encoding == XmlEncoding_Unknown)
561 {
562 FIXME("unsupported encoding %d\n", encoding);
563 return E_NOTIMPL;
564 }
565
566 *cp = xml_encoding_map[encoding].cp;
567
568 return S_OK;
569 }
570
571 xml_encoding parse_encoding_name(const WCHAR *name, int len)
572 {
573 int min, max, n, c;
574
575 if (!name) return XmlEncoding_Unknown;
576
577 min = 0;
578 max = sizeof(xml_encoding_map)/sizeof(struct xml_encoding_data) - 1;
579
580 while (min <= max)
581 {
582 n = (min+max)/2;
583
584 if (len != -1)
585 c = strncmpiW(xml_encoding_map[n].name, name, len);
586 else
587 c = strcmpiW(xml_encoding_map[n].name, name);
588 if (!c)
589 return xml_encoding_map[n].enc;
590
591 if (c > 0)
592 max = n-1;
593 else
594 min = n+1;
595 }
596
597 return XmlEncoding_Unknown;
598 }
599
600 static HRESULT alloc_input_buffer(xmlreaderinput *input)
601 {
602 input_buffer *buffer;
603 HRESULT hr;
604
605 input->buffer = NULL;
606
607 buffer = readerinput_alloc(input, sizeof(*buffer));
608 if (!buffer) return E_OUTOFMEMORY;
609
610 buffer->input = input;
611 buffer->code_page = ~0; /* code page is unknown at this point */
612 hr = init_encoded_buffer(input, &buffer->utf16);
613 if (hr != S_OK) {
614 readerinput_free(input, buffer);
615 return hr;
616 }
617
618 hr = init_encoded_buffer(input, &buffer->encoded);
619 if (hr != S_OK) {
620 free_encoded_buffer(input, &buffer->utf16);
621 readerinput_free(input, buffer);
622 return hr;
623 }
624
625 input->buffer = buffer;
626 return S_OK;
627 }
628
629 static void free_input_buffer(input_buffer *buffer)
630 {
631 free_encoded_buffer(buffer->input, &buffer->encoded);
632 free_encoded_buffer(buffer->input, &buffer->utf16);
633 readerinput_free(buffer->input, buffer);
634 }
635
636 static void readerinput_release_stream(xmlreaderinput *readerinput)
637 {
638 if (readerinput->stream) {
639 ISequentialStream_Release(readerinput->stream);
640 readerinput->stream = NULL;
641 }
642 }
643
644 /* Queries already stored interface for IStream/ISequentialStream.
645 Interface supplied on creation will be overwritten */
646 static inline HRESULT readerinput_query_for_stream(xmlreaderinput *readerinput)
647 {
648 HRESULT hr;
649
650 readerinput_release_stream(readerinput);
651 hr = IUnknown_QueryInterface(readerinput->input, &IID_IStream, (void**)&readerinput->stream);
652 if (hr != S_OK)
653 hr = IUnknown_QueryInterface(readerinput->input, &IID_ISequentialStream, (void**)&readerinput->stream);
654
655 return hr;
656 }
657
658 /* reads a chunk to raw buffer */
659 static HRESULT readerinput_growraw(xmlreaderinput *readerinput)
660 {
661 encoded_buffer *buffer = &readerinput->buffer->encoded;
662 /* to make sure aligned length won't exceed allocated length */
663 ULONG len = buffer->allocated - buffer->written - 4;
664 ULONG read;
665 HRESULT hr;
666
667 /* always try to get aligned to 4 bytes, so the only case we can get partially read characters is
668 variable width encodings like UTF-8 */
669 len = (len + 3) & ~3;
670 /* try to use allocated space or grow */
671 if (buffer->allocated - buffer->written < len)
672 {
673 buffer->allocated *= 2;
674 buffer->data = readerinput_realloc(readerinput, buffer->data, buffer->allocated);
675 len = buffer->allocated - buffer->written;
676 }
677
678 read = 0;
679 hr = ISequentialStream_Read(readerinput->stream, buffer->data + buffer->written, len, &read);
680 TRACE("written=%d, alloc=%d, requested=%d, read=%d, ret=0x%08x\n", buffer->written, buffer->allocated, len, read, hr);
681 readerinput->pending = hr == E_PENDING;
682 if (FAILED(hr)) return hr;
683 buffer->written += read;
684
685 return hr;
686 }
687
688 /* grows UTF-16 buffer so it has at least 'length' WCHAR chars free on return */
689 static void readerinput_grow(xmlreaderinput *readerinput, int length)
690 {
691 encoded_buffer *buffer = &readerinput->buffer->utf16;
692
693 length *= sizeof(WCHAR);
694 /* grow if needed, plus 4 bytes to be sure null terminator will fit in */
695 if (buffer->allocated < buffer->written + length + 4)
696 {
697 int grown_size = max(2*buffer->allocated, buffer->allocated + length);
698 buffer->data = readerinput_realloc(readerinput, buffer->data, grown_size);
699 buffer->allocated = grown_size;
700 }
701 }
702
703 static inline BOOL readerinput_is_utf8(xmlreaderinput *readerinput)
704 {
705 static const char startA[] = {'<','?'};
706 static const char commentA[] = {'<','!'};
707 encoded_buffer *buffer = &readerinput->buffer->encoded;
708 unsigned char *ptr = (unsigned char*)buffer->data;
709
710 return !memcmp(buffer->data, startA, sizeof(startA)) ||
711 !memcmp(buffer->data, commentA, sizeof(commentA)) ||
712 /* test start byte */
713 (ptr[0] == '<' &&
714 (
715 (ptr[1] && (ptr[1] <= 0x7f)) ||
716 (buffer->data[1] >> 5) == 0x6 || /* 2 bytes */
717 (buffer->data[1] >> 4) == 0xe || /* 3 bytes */
718 (buffer->data[1] >> 3) == 0x1e) /* 4 bytes */
719 );
720 }
721
722 static HRESULT readerinput_detectencoding(xmlreaderinput *readerinput, xml_encoding *enc)
723 {
724 encoded_buffer *buffer = &readerinput->buffer->encoded;
725 static const WCHAR startW[] = {'<','?'};
726 static const WCHAR commentW[] = {'<','!'};
727 static const char utf8bom[] = {0xef,0xbb,0xbf};
728 static const char utf16lebom[] = {0xff,0xfe};
729
730 *enc = XmlEncoding_Unknown;
731
732 if (buffer->written <= 3)
733 {
734 HRESULT hr = readerinput_growraw(readerinput);
735 if (FAILED(hr)) return hr;
736 if (buffer->written <= 3) return MX_E_INPUTEND;
737 }
738
739 /* try start symbols if we have enough data to do that, input buffer should contain
740 first chunk already */
741 if (readerinput_is_utf8(readerinput))
742 *enc = XmlEncoding_UTF8;
743 else if (!memcmp(buffer->data, startW, sizeof(startW)) ||
744 !memcmp(buffer->data, commentW, sizeof(commentW)))
745 *enc = XmlEncoding_UTF16;
746 /* try with BOM now */
747 else if (!memcmp(buffer->data, utf8bom, sizeof(utf8bom)))
748 {
749 buffer->cur += sizeof(utf8bom);
750 *enc = XmlEncoding_UTF8;
751 }
752 else if (!memcmp(buffer->data, utf16lebom, sizeof(utf16lebom)))
753 {
754 buffer->cur += sizeof(utf16lebom);
755 *enc = XmlEncoding_UTF16;
756 }
757
758 return S_OK;
759 }
760
761 static int readerinput_get_utf8_convlen(xmlreaderinput *readerinput)
762 {
763 encoded_buffer *buffer = &readerinput->buffer->encoded;
764 int len = buffer->written;
765
766 /* complete single byte char */
767 if (!(buffer->data[len-1] & 0x80)) return len;
768
769 /* find start byte of multibyte char */
770 while (--len && !(buffer->data[len] & 0xc0))
771 ;
772
773 return len;
774 }
775
776 /* Returns byte length of complete char sequence for buffer code page,
777 it's relative to current buffer position which is currently used for BOM handling
778 only. */
779 static int readerinput_get_convlen(xmlreaderinput *readerinput)
780 {
781 encoded_buffer *buffer = &readerinput->buffer->encoded;
782 int len;
783
784 if (readerinput->buffer->code_page == CP_UTF8)
785 len = readerinput_get_utf8_convlen(readerinput);
786 else
787 len = buffer->written;
788
789 TRACE("%d\n", len - buffer->cur);
790 return len - buffer->cur;
791 }
792
793 /* It's possible that raw buffer has some leftovers from last conversion - some char
794 sequence that doesn't represent a full code point. Length argument should be calculated with
795 readerinput_get_convlen(), if it's -1 it will be calculated here. */
796 static void readerinput_shrinkraw(xmlreaderinput *readerinput, int len)
797 {
798 encoded_buffer *buffer = &readerinput->buffer->encoded;
799
800 if (len == -1)
801 len = readerinput_get_convlen(readerinput);
802
803 memmove(buffer->data, buffer->data + buffer->cur + (buffer->written - len), len);
804 /* everything below cur is lost too */
805 buffer->written -= len + buffer->cur;
806 /* after this point we don't need cur offset really,
807 it's used only to mark where actual data begins when first chunk is read */
808 buffer->cur = 0;
809 }
810
811 /* note that raw buffer content is kept */
812 static void readerinput_switchencoding(xmlreaderinput *readerinput, xml_encoding enc)
813 {
814 encoded_buffer *src = &readerinput->buffer->encoded;
815 encoded_buffer *dest = &readerinput->buffer->utf16;
816 int len, dest_len;
817 HRESULT hr;
818 WCHAR *ptr;
819 UINT cp;
820
821 hr = get_code_page(enc, &cp);
822 if (FAILED(hr)) return;
823
824 readerinput->buffer->code_page = cp;
825 len = readerinput_get_convlen(readerinput);
826
827 TRACE("switching to cp %d\n", cp);
828
829 /* just copy in this case */
830 if (enc == XmlEncoding_UTF16)
831 {
832 readerinput_grow(readerinput, len);
833 memcpy(dest->data, src->data + src->cur, len);
834 dest->written += len*sizeof(WCHAR);
835 return;
836 }
837
838 dest_len = MultiByteToWideChar(cp, 0, src->data + src->cur, len, NULL, 0);
839 readerinput_grow(readerinput, dest_len);
840 ptr = (WCHAR*)dest->data;
841 MultiByteToWideChar(cp, 0, src->data + src->cur, len, ptr, dest_len);
842 ptr[dest_len] = 0;
843 dest->written += dest_len*sizeof(WCHAR);
844 }
845
846 /* shrinks parsed data a buffer begins with */
847 static void reader_shrink(xmlreader *reader)
848 {
849 encoded_buffer *buffer = &reader->input->buffer->utf16;
850
851 /* avoid to move too often using threshold shrink length */
852 if (buffer->cur*sizeof(WCHAR) > buffer->written / 2)
853 {
854 buffer->written -= buffer->cur*sizeof(WCHAR);
855 memmove(buffer->data, (WCHAR*)buffer->data + buffer->cur, buffer->written);
856 buffer->cur = 0;
857 *(WCHAR*)&buffer->data[buffer->written] = 0;
858 }
859 }
860
861 /* This is a normal way for reader to get new data converted from raw buffer to utf16 buffer.
862 It won't attempt to shrink but will grow destination buffer if needed */
863 static HRESULT reader_more(xmlreader *reader)
864 {
865 xmlreaderinput *readerinput = reader->input;
866 encoded_buffer *src = &readerinput->buffer->encoded;
867 encoded_buffer *dest = &readerinput->buffer->utf16;
868 UINT cp = readerinput->buffer->code_page;
869 int len, dest_len;
870 HRESULT hr;
871 WCHAR *ptr;
872
873 /* get some raw data from stream first */
874 hr = readerinput_growraw(readerinput);
875 len = readerinput_get_convlen(readerinput);
876
877 /* just copy for UTF-16 case */
878 if (cp == ~0)
879 {
880 readerinput_grow(readerinput, len);
881 memcpy(dest->data + dest->written, src->data + src->cur, len);
882 dest->written += len*sizeof(WCHAR);
883 return hr;
884 }
885
886 dest_len = MultiByteToWideChar(cp, 0, src->data + src->cur, len, NULL, 0);
887 readerinput_grow(readerinput, dest_len);
888 ptr = (WCHAR*)(dest->data + dest->written);
889 MultiByteToWideChar(cp, 0, src->data + src->cur, len, ptr, dest_len);
890 ptr[dest_len] = 0;
891 dest->written += dest_len*sizeof(WCHAR);
892 /* get rid of processed data */
893 readerinput_shrinkraw(readerinput, len);
894
895 return hr;
896 }
897
898 static inline UINT reader_get_cur(xmlreader *reader)
899 {
900 return reader->input->buffer->utf16.cur;
901 }
902
903 static inline WCHAR *reader_get_ptr(xmlreader *reader)
904 {
905 encoded_buffer *buffer = &reader->input->buffer->utf16;
906 WCHAR *ptr = (WCHAR*)buffer->data + buffer->cur;
907 if (!*ptr) reader_more(reader);
908 return (WCHAR*)buffer->data + buffer->cur;
909 }
910
911 static int reader_cmp(xmlreader *reader, const WCHAR *str)
912 {
913 int i=0;
914 const WCHAR *ptr = reader_get_ptr(reader);
915 while (str[i])
916 {
917 if (!ptr[i])
918 {
919 reader_more(reader);
920 ptr = reader_get_ptr(reader);
921 }
922 if (str[i] != ptr[i])
923 return ptr[i] - str[i];
924 i++;
925 }
926 return 0;
927 }
928
929 /* moves cursor n WCHARs forward */
930 static void reader_skipn(xmlreader *reader, int n)
931 {
932 encoded_buffer *buffer = &reader->input->buffer->utf16;
933 const WCHAR *ptr = reader_get_ptr(reader);
934
935 while (*ptr++ && n--)
936 {
937 buffer->cur++;
938 reader->pos++;
939 }
940 }
941
942 static inline BOOL is_wchar_space(WCHAR ch)
943 {
944 return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
945 }
946
947 /* [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
948 static int reader_skipspaces(xmlreader *reader)
949 {
950 encoded_buffer *buffer = &reader->input->buffer->utf16;
951 const WCHAR *ptr = reader_get_ptr(reader);
952 UINT start = reader_get_cur(reader);
953
954 while (is_wchar_space(*ptr))
955 {
956 if (*ptr == '\r')
957 reader->pos = 0;
958 else if (*ptr == '\n')
959 {
960 reader->line++;
961 reader->pos = 0;
962 }
963 else
964 reader->pos++;
965
966 buffer->cur++;
967 ptr = reader_get_ptr(reader);
968 }
969
970 return reader_get_cur(reader) - start;
971 }
972
973 /* [26] VersionNum ::= '1.' [0-9]+ */
974 static HRESULT reader_parse_versionnum(xmlreader *reader, strval *val)
975 {
976 static const WCHAR onedotW[] = {'1','.',0};
977 WCHAR *ptr, *ptr2;
978 UINT start;
979
980 if (reader_cmp(reader, onedotW)) return WC_E_XMLDECL;
981
982 start = reader_get_cur(reader);
983 /* skip "1." */
984 reader_skipn(reader, 2);
985
986 ptr2 = ptr = reader_get_ptr(reader);
987 while (*ptr >= '0' && *ptr <= '9')
988 {
989 reader_skipn(reader, 1);
990 ptr = reader_get_ptr(reader);
991 }
992
993 if (ptr2 == ptr) return WC_E_DIGIT;
994 reader_init_strvalue(start, reader_get_cur(reader)-start, val);
995 TRACE("version=%s\n", debug_strval(reader, val));
996 return S_OK;
997 }
998
999 /* [25] Eq ::= S? '=' S? */
1000 static HRESULT reader_parse_eq(xmlreader *reader)
1001 {
1002 static const WCHAR eqW[] = {'=',0};
1003 reader_skipspaces(reader);
1004 if (reader_cmp(reader, eqW)) return WC_E_EQUAL;
1005 /* skip '=' */
1006 reader_skipn(reader, 1);
1007 reader_skipspaces(reader);
1008 return S_OK;
1009 }
1010
1011 /* [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"') */
1012 static HRESULT reader_parse_versioninfo(xmlreader *reader)
1013 {
1014 static const WCHAR versionW[] = {'v','e','r','s','i','o','n',0};
1015 strval val, name;
1016 HRESULT hr;
1017
1018 if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
1019
1020 if (reader_cmp(reader, versionW)) return WC_E_XMLDECL;
1021 reader_init_strvalue(reader_get_cur(reader), 7, &name);
1022 /* skip 'version' */
1023 reader_skipn(reader, 7);
1024
1025 hr = reader_parse_eq(reader);
1026 if (FAILED(hr)) return hr;
1027
1028 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1029 return WC_E_QUOTE;
1030 /* skip "'"|'"' */
1031 reader_skipn(reader, 1);
1032
1033 hr = reader_parse_versionnum(reader, &val);
1034 if (FAILED(hr)) return hr;
1035
1036 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1037 return WC_E_QUOTE;
1038
1039 /* skip "'"|'"' */
1040 reader_skipn(reader, 1);
1041
1042 return reader_add_attr(reader, &name, &val);
1043 }
1044
1045 /* ([A-Za-z0-9._] | '-') */
1046 static inline BOOL is_wchar_encname(WCHAR ch)
1047 {
1048 return ((ch >= 'A' && ch <= 'Z') ||
1049 (ch >= 'a' && ch <= 'z') ||
1050 (ch >= '0' && ch <= '9') ||
1051 (ch == '.') || (ch == '_') ||
1052 (ch == '-'));
1053 }
1054
1055 /* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* */
1056 static HRESULT reader_parse_encname(xmlreader *reader, strval *val)
1057 {
1058 WCHAR *start = reader_get_ptr(reader), *ptr;
1059 xml_encoding enc;
1060 int len;
1061
1062 if ((*start < 'A' || *start > 'Z') && (*start < 'a' || *start > 'z'))
1063 return WC_E_ENCNAME;
1064
1065 val->start = reader_get_cur(reader);
1066
1067 ptr = start;
1068 while (is_wchar_encname(*++ptr))
1069 ;
1070
1071 len = ptr - start;
1072 enc = parse_encoding_name(start, len);
1073 TRACE("encoding name %s\n", debugstr_wn(start, len));
1074 val->str = start;
1075 val->len = len;
1076
1077 if (enc == XmlEncoding_Unknown)
1078 return WC_E_ENCNAME;
1079
1080 /* skip encoding name */
1081 reader_skipn(reader, len);
1082 return S_OK;
1083 }
1084
1085 /* [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" ) */
1086 static HRESULT reader_parse_encdecl(xmlreader *reader)
1087 {
1088 static const WCHAR encodingW[] = {'e','n','c','o','d','i','n','g',0};
1089 strval name, val;
1090 HRESULT hr;
1091
1092 if (!reader_skipspaces(reader)) return S_FALSE;
1093
1094 if (reader_cmp(reader, encodingW)) return S_FALSE;
1095 name.str = reader_get_ptr(reader);
1096 name.start = reader_get_cur(reader);
1097 name.len = 8;
1098 /* skip 'encoding' */
1099 reader_skipn(reader, 8);
1100
1101 hr = reader_parse_eq(reader);
1102 if (FAILED(hr)) return hr;
1103
1104 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1105 return WC_E_QUOTE;
1106 /* skip "'"|'"' */
1107 reader_skipn(reader, 1);
1108
1109 hr = reader_parse_encname(reader, &val);
1110 if (FAILED(hr)) return hr;
1111
1112 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1113 return WC_E_QUOTE;
1114
1115 /* skip "'"|'"' */
1116 reader_skipn(reader, 1);
1117
1118 return reader_add_attr(reader, &name, &val);
1119 }
1120
1121 /* [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"')) */
1122 static HRESULT reader_parse_sddecl(xmlreader *reader)
1123 {
1124 static const WCHAR standaloneW[] = {'s','t','a','n','d','a','l','o','n','e',0};
1125 static const WCHAR yesW[] = {'y','e','s',0};
1126 static const WCHAR noW[] = {'n','o',0};
1127 strval name, val;
1128 UINT start;
1129 HRESULT hr;
1130
1131 if (!reader_skipspaces(reader)) return S_FALSE;
1132
1133 if (reader_cmp(reader, standaloneW)) return S_FALSE;
1134 reader_init_strvalue(reader_get_cur(reader), 10, &name);
1135 /* skip 'standalone' */
1136 reader_skipn(reader, 10);
1137
1138 hr = reader_parse_eq(reader);
1139 if (FAILED(hr)) return hr;
1140
1141 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1142 return WC_E_QUOTE;
1143 /* skip "'"|'"' */
1144 reader_skipn(reader, 1);
1145
1146 if (reader_cmp(reader, yesW) && reader_cmp(reader, noW))
1147 return WC_E_XMLDECL;
1148
1149 start = reader_get_cur(reader);
1150 /* skip 'yes'|'no' */
1151 reader_skipn(reader, reader_cmp(reader, yesW) ? 2 : 3);
1152 reader_init_strvalue(start, reader_get_cur(reader)-start, &val);
1153 TRACE("standalone=%s\n", debug_strval(reader, &val));
1154
1155 if (reader_cmp(reader, quoteW) && reader_cmp(reader, dblquoteW))
1156 return WC_E_QUOTE;
1157 /* skip "'"|'"' */
1158 reader_skipn(reader, 1);
1159
1160 return reader_add_attr(reader, &name, &val);
1161 }
1162
1163 /* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' */
1164 static HRESULT reader_parse_xmldecl(xmlreader *reader)
1165 {
1166 static const WCHAR xmldeclW[] = {'<','?','x','m','l',' ',0};
1167 static const WCHAR declcloseW[] = {'?','>',0};
1168 HRESULT hr;
1169
1170 /* check if we have "<?xml " */
1171 if (reader_cmp(reader, xmldeclW)) return S_FALSE;
1172
1173 reader_skipn(reader, 5);
1174 hr = reader_parse_versioninfo(reader);
1175 if (FAILED(hr))
1176 return hr;
1177
1178 hr = reader_parse_encdecl(reader);
1179 if (FAILED(hr))
1180 return hr;
1181
1182 hr = reader_parse_sddecl(reader);
1183 if (FAILED(hr))
1184 return hr;
1185
1186 reader_skipspaces(reader);
1187 if (reader_cmp(reader, declcloseW)) return WC_E_XMLDECL;
1188 reader_skipn(reader, 2);
1189
1190 reader_inc_depth(reader);
1191 reader->nodetype = XmlNodeType_XmlDeclaration;
1192 reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
1193 reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
1194 reader_set_strvalue(reader, StringValue_Value, &strval_empty);
1195
1196 return S_OK;
1197 }
1198
1199 /* [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' */
1200 static HRESULT reader_parse_comment(xmlreader *reader)
1201 {
1202 WCHAR *ptr;
1203 UINT start;
1204
1205 if (reader->resumestate == XmlReadResumeState_Comment)
1206 {
1207 start = reader->resume[XmlReadResume_Body];
1208 ptr = reader_get_ptr(reader);
1209 }
1210 else
1211 {
1212 /* skip '<!--' */
1213 reader_skipn(reader, 4);
1214 reader_shrink(reader);
1215 ptr = reader_get_ptr(reader);
1216 start = reader_get_cur(reader);
1217 reader->nodetype = XmlNodeType_Comment;
1218 reader->resume[XmlReadResume_Body] = start;
1219 reader->resumestate = XmlReadResumeState_Comment;
1220 reader_set_strvalue(reader, StringValue_LocalName, NULL);
1221 reader_set_strvalue(reader, StringValue_QualifiedName, NULL);
1222 reader_set_strvalue(reader, StringValue_Value, NULL);
1223 }
1224
1225 /* will exit when there's no more data, it won't attempt to
1226 read more from stream */
1227 while (*ptr)
1228 {
1229 if (ptr[0] == '-')
1230 {
1231 if (ptr[1] == '-')
1232 {
1233 if (ptr[2] == '>')
1234 {
1235 strval value;
1236
1237 reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
1238 TRACE("%s\n", debug_strval(reader, &value));
1239
1240 /* skip rest of markup '->' */
1241 reader_skipn(reader, 3);
1242
1243 reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
1244 reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
1245 reader_set_strvalue(reader, StringValue_Value, &value);
1246 reader->resume[XmlReadResume_Body] = 0;
1247 reader->resumestate = XmlReadResumeState_Initial;
1248 return S_OK;
1249 }
1250 else
1251 return WC_E_COMMENT;
1252 }
1253 }
1254
1255 reader_skipn(reader, 1);
1256 ptr++;
1257 }
1258
1259 return S_OK;
1260 }
1261
1262 /* [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] */
1263 static inline BOOL is_char(WCHAR ch)
1264 {
1265 return (ch == '\t') || (ch == '\r') || (ch == '\n') ||
1266 (ch >= 0x20 && ch <= 0xd7ff) ||
1267 (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
1268 (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
1269 (ch >= 0xe000 && ch <= 0xfffd);
1270 }
1271
1272 /* [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] */
1273 static inline BOOL is_pubchar(WCHAR ch)
1274 {
1275 return (ch == ' ') ||
1276 (ch >= 'a' && ch <= 'z') ||
1277 (ch >= 'A' && ch <= 'Z') ||
1278 (ch >= '0' && ch <= '9') ||
1279 (ch >= '-' && ch <= ';') || /* '()*+,-./:; */
1280 (ch == '=') || (ch == '?') ||
1281 (ch == '@') || (ch == '!') ||
1282 (ch >= '#' && ch <= '%') || /* #$% */
1283 (ch == '_') || (ch == '\r') || (ch == '\n');
1284 }
1285
1286 static inline BOOL is_namestartchar(WCHAR ch)
1287 {
1288 return (ch == ':') || (ch >= 'A' && ch <= 'Z') ||
1289 (ch == '_') || (ch >= 'a' && ch <= 'z') ||
1290 (ch >= 0xc0 && ch <= 0xd6) ||
1291 (ch >= 0xd8 && ch <= 0xf6) ||
1292 (ch >= 0xf8 && ch <= 0x2ff) ||
1293 (ch >= 0x370 && ch <= 0x37d) ||
1294 (ch >= 0x37f && ch <= 0x1fff) ||
1295 (ch >= 0x200c && ch <= 0x200d) ||
1296 (ch >= 0x2070 && ch <= 0x218f) ||
1297 (ch >= 0x2c00 && ch <= 0x2fef) ||
1298 (ch >= 0x3001 && ch <= 0xd7ff) ||
1299 (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
1300 (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
1301 (ch >= 0xf900 && ch <= 0xfdcf) ||
1302 (ch >= 0xfdf0 && ch <= 0xfffd);
1303 }
1304
1305 /* [4 NS] NCName ::= Name - (Char* ':' Char*) */
1306 static inline BOOL is_ncnamechar(WCHAR ch)
1307 {
1308 return (ch >= 'A' && ch <= 'Z') ||
1309 (ch == '_') || (ch >= 'a' && ch <= 'z') ||
1310 (ch == '-') || (ch == '.') ||
1311 (ch >= '0' && ch <= '9') ||
1312 (ch == 0xb7) ||
1313 (ch >= 0xc0 && ch <= 0xd6) ||
1314 (ch >= 0xd8 && ch <= 0xf6) ||
1315 (ch >= 0xf8 && ch <= 0x2ff) ||
1316 (ch >= 0x300 && ch <= 0x36f) ||
1317 (ch >= 0x370 && ch <= 0x37d) ||
1318 (ch >= 0x37f && ch <= 0x1fff) ||
1319 (ch >= 0x200c && ch <= 0x200d) ||
1320 (ch >= 0x203f && ch <= 0x2040) ||
1321 (ch >= 0x2070 && ch <= 0x218f) ||
1322 (ch >= 0x2c00 && ch <= 0x2fef) ||
1323 (ch >= 0x3001 && ch <= 0xd7ff) ||
1324 (ch >= 0xd800 && ch <= 0xdbff) || /* high surrogate */
1325 (ch >= 0xdc00 && ch <= 0xdfff) || /* low surrogate */
1326 (ch >= 0xf900 && ch <= 0xfdcf) ||
1327 (ch >= 0xfdf0 && ch <= 0xfffd);
1328 }
1329
1330 static inline BOOL is_namechar(WCHAR ch)
1331 {
1332 return (ch == ':') || is_ncnamechar(ch);
1333 }
1334
1335 static XmlNodeType reader_get_nodetype(const xmlreader *reader)
1336 {
1337 /* When we're on attribute always return attribute type, container node type is kept.
1338 Note that container is not necessarily an element, and attribute doesn't mean it's
1339 an attribute in XML spec terms. */
1340 return reader->attr ? XmlNodeType_Attribute : reader->nodetype;
1341 }
1342
1343 /* [4] NameStartChar ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] |
1344 [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] |
1345 [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
1346 [4a] NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
1347 [5] Name ::= NameStartChar (NameChar)* */
1348 static HRESULT reader_parse_name(xmlreader *reader, strval *name)
1349 {
1350 WCHAR *ptr;
1351 UINT start;
1352
1353 if (reader->resume[XmlReadResume_Name])
1354 {
1355 start = reader->resume[XmlReadResume_Name];
1356 ptr = reader_get_ptr(reader);
1357 }
1358 else
1359 {
1360 ptr = reader_get_ptr(reader);
1361 start = reader_get_cur(reader);
1362 if (!is_namestartchar(*ptr)) return WC_E_NAMECHARACTER;
1363 }
1364
1365 while (is_namechar(*ptr))
1366 {
1367 reader_skipn(reader, 1);
1368 ptr = reader_get_ptr(reader);
1369 }
1370
1371 if (is_reader_pending(reader))
1372 {
1373 reader->resume[XmlReadResume_Name] = start;
1374 return E_PENDING;
1375 }
1376 else
1377 reader->resume[XmlReadResume_Name] = 0;
1378
1379 reader_init_strvalue(start, reader_get_cur(reader)-start, name);
1380 TRACE("name %s:%d\n", debug_strval(reader, name), name->len);
1381
1382 return S_OK;
1383 }
1384
1385 /* [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) */
1386 static HRESULT reader_parse_pitarget(xmlreader *reader, strval *target)
1387 {
1388 static const WCHAR xmlW[] = {'x','m','l'};
1389 static const strval xmlval = { (WCHAR*)xmlW, 3 };
1390 strval name;
1391 WCHAR *ptr;
1392 HRESULT hr;
1393 UINT i;
1394
1395 hr = reader_parse_name(reader, &name);
1396 if (FAILED(hr)) return is_reader_pending(reader) ? E_PENDING : WC_E_PI;
1397
1398 /* now that we got name check for illegal content */
1399 if (strval_eq(reader, &name, &xmlval))
1400 return WC_E_LEADINGXML;
1401
1402 /* PITarget can't be a qualified name */
1403 ptr = reader_get_strptr(reader, &name);
1404 for (i = 0; i < name.len; i++)
1405 if (ptr[i] == ':')
1406 return i ? NC_E_NAMECOLON : WC_E_PI;
1407
1408 TRACE("pitarget %s:%d\n", debug_strval(reader, &name), name.len);
1409 *target = name;
1410 return S_OK;
1411 }
1412
1413 /* [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' */
1414 static HRESULT reader_parse_pi(xmlreader *reader)
1415 {
1416 strval target;
1417 WCHAR *ptr;
1418 UINT start;
1419 HRESULT hr;
1420
1421 switch (reader->resumestate)
1422 {
1423 case XmlReadResumeState_Initial:
1424 /* skip '<?' */
1425 reader_skipn(reader, 2);
1426 reader_shrink(reader);
1427 reader->resumestate = XmlReadResumeState_PITarget;
1428 case XmlReadResumeState_PITarget:
1429 hr = reader_parse_pitarget(reader, &target);
1430 if (FAILED(hr)) return hr;
1431 reader_set_strvalue(reader, StringValue_LocalName, &target);
1432 reader_set_strvalue(reader, StringValue_QualifiedName, &target);
1433 reader_set_strvalue(reader, StringValue_Value, &strval_empty);
1434 reader->resumestate = XmlReadResumeState_PIBody;
1435 reader->resume[XmlReadResume_Body] = reader_get_cur(reader);
1436 default:
1437 ;
1438 }
1439
1440 start = reader->resume[XmlReadResume_Body];
1441 ptr = reader_get_ptr(reader);
1442 while (*ptr)
1443 {
1444 if (ptr[0] == '?')
1445 {
1446 if (ptr[1] == '>')
1447 {
1448 UINT cur = reader_get_cur(reader);
1449 strval value;
1450
1451 /* strip all leading whitespace chars */
1452 while (start < cur)
1453 {
1454 ptr = reader_get_ptr2(reader, start);
1455 if (!is_wchar_space(*ptr)) break;
1456 start++;
1457 }
1458
1459 reader_init_strvalue(start, cur-start, &value);
1460
1461 /* skip '?>' */
1462 reader_skipn(reader, 2);
1463 TRACE("%s\n", debug_strval(reader, &value));
1464 reader->nodetype = XmlNodeType_ProcessingInstruction;
1465 reader->resumestate = XmlReadResumeState_Initial;
1466 reader->resume[XmlReadResume_Body] = 0;
1467 reader_set_strvalue(reader, StringValue_Value, &value);
1468 return S_OK;
1469 }
1470 }
1471
1472 reader_skipn(reader, 1);
1473 ptr = reader_get_ptr(reader);
1474 }
1475
1476 return S_OK;
1477 }
1478
1479 /* This one is used to parse significant whitespace nodes, like in Misc production */
1480 static HRESULT reader_parse_whitespace(xmlreader *reader)
1481 {
1482 switch (reader->resumestate)
1483 {
1484 case XmlReadResumeState_Initial:
1485 reader_shrink(reader);
1486 reader->resumestate = XmlReadResumeState_Whitespace;
1487 reader->resume[XmlReadResume_Body] = reader_get_cur(reader);
1488 reader->nodetype = XmlNodeType_Whitespace;
1489 reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
1490 reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
1491 reader_set_strvalue(reader, StringValue_Value, &strval_empty);
1492 /* fallthrough */
1493 case XmlReadResumeState_Whitespace:
1494 {
1495 strval value;
1496 UINT start;
1497
1498 reader_skipspaces(reader);
1499 if (is_reader_pending(reader)) return S_OK;
1500
1501 start = reader->resume[XmlReadResume_Body];
1502 reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
1503 reader_set_strvalue(reader, StringValue_Value, &value);
1504 TRACE("%s\n", debug_strval(reader, &value));
1505 reader->resumestate = XmlReadResumeState_Initial;
1506 }
1507 default:
1508 ;
1509 }
1510
1511 return S_OK;
1512 }
1513
1514 /* [27] Misc ::= Comment | PI | S */
1515 static HRESULT reader_parse_misc(xmlreader *reader)
1516 {
1517 HRESULT hr = S_FALSE;
1518
1519 if (reader->resumestate != XmlReadResumeState_Initial)
1520 {
1521 hr = reader_more(reader);
1522 if (FAILED(hr)) return hr;
1523
1524 /* finish current node */
1525 switch (reader->resumestate)
1526 {
1527 case XmlReadResumeState_PITarget:
1528 case XmlReadResumeState_PIBody:
1529 return reader_parse_pi(reader);
1530 case XmlReadResumeState_Comment:
1531 return reader_parse_comment(reader);
1532 case XmlReadResumeState_Whitespace:
1533 return reader_parse_whitespace(reader);
1534 default:
1535 ERR("unknown resume state %d\n", reader->resumestate);
1536 }
1537 }
1538
1539 while (1)
1540 {
1541 const WCHAR *cur = reader_get_ptr(reader);
1542
1543 if (is_wchar_space(*cur))
1544 hr = reader_parse_whitespace(reader);
1545 else if (!reader_cmp(reader, commentW))
1546 hr = reader_parse_comment(reader);
1547 else if (!reader_cmp(reader, piW))
1548 hr = reader_parse_pi(reader);
1549 else
1550 break;
1551
1552 if (hr != S_FALSE) return hr;
1553 }
1554
1555 return hr;
1556 }
1557
1558 /* [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") */
1559 static HRESULT reader_parse_sys_literal(xmlreader *reader, strval *literal)
1560 {
1561 WCHAR *cur = reader_get_ptr(reader), quote;
1562 UINT start;
1563
1564 if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
1565
1566 quote = *cur;
1567 reader_skipn(reader, 1);
1568
1569 cur = reader_get_ptr(reader);
1570 start = reader_get_cur(reader);
1571 while (is_char(*cur) && *cur != quote)
1572 {
1573 reader_skipn(reader, 1);
1574 cur = reader_get_ptr(reader);
1575 }
1576 reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
1577 if (*cur == quote) reader_skipn(reader, 1);
1578
1579 TRACE("%s\n", debug_strval(reader, literal));
1580 return S_OK;
1581 }
1582
1583 /* [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
1584 [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] */
1585 static HRESULT reader_parse_pub_literal(xmlreader *reader, strval *literal)
1586 {
1587 WCHAR *cur = reader_get_ptr(reader), quote;
1588 UINT start;
1589
1590 if (*cur != '"' && *cur != '\'') return WC_E_QUOTE;
1591
1592 quote = *cur;
1593 reader_skipn(reader, 1);
1594
1595 start = reader_get_cur(reader);
1596 cur = reader_get_ptr(reader);
1597 while (is_pubchar(*cur) && *cur != quote)
1598 {
1599 reader_skipn(reader, 1);
1600 cur = reader_get_ptr(reader);
1601 }
1602
1603 reader_init_strvalue(start, reader_get_cur(reader)-start, literal);
1604 TRACE("%s\n", debug_strval(reader, literal));
1605 return S_OK;
1606 }
1607
1608 /* [75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral */
1609 static HRESULT reader_parse_externalid(xmlreader *reader)
1610 {
1611 static WCHAR systemW[] = {'S','Y','S','T','E','M',0};
1612 static WCHAR publicW[] = {'P','U','B','L','I','C',0};
1613 strval name;
1614 HRESULT hr;
1615 int cnt;
1616
1617 if (reader_cmp(reader, systemW))
1618 {
1619 if (reader_cmp(reader, publicW))
1620 return S_FALSE;
1621 else
1622 {
1623 strval pub;
1624
1625 /* public id */
1626 reader_skipn(reader, 6);
1627 cnt = reader_skipspaces(reader);
1628 if (!cnt) return WC_E_WHITESPACE;
1629
1630 hr = reader_parse_pub_literal(reader, &pub);
1631 if (FAILED(hr)) return hr;
1632
1633 reader_init_cstrvalue(publicW, strlenW(publicW), &name);
1634 return reader_add_attr(reader, &name, &pub);
1635 }
1636 }
1637 else
1638 {
1639 strval sys;
1640
1641 /* system id */
1642 reader_skipn(reader, 6);
1643 cnt = reader_skipspaces(reader);
1644 if (!cnt) return WC_E_WHITESPACE;
1645
1646 hr = reader_parse_sys_literal(reader, &sys);
1647 if (FAILED(hr)) return hr;
1648
1649 reader_init_cstrvalue(systemW, strlenW(systemW), &name);
1650 return reader_add_attr(reader, &name, &sys);
1651 }
1652
1653 return hr;
1654 }
1655
1656 /* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>' */
1657 static HRESULT reader_parse_dtd(xmlreader *reader)
1658 {
1659 static const WCHAR doctypeW[] = {'<','!','D','O','C','T','Y','P','E',0};
1660 strval name;
1661 WCHAR *cur;
1662 HRESULT hr;
1663
1664 /* check if we have "<!DOCTYPE" */
1665 if (reader_cmp(reader, doctypeW)) return S_FALSE;
1666 reader_shrink(reader);
1667
1668 /* DTD processing is not allowed by default */
1669 if (reader->dtdmode == DtdProcessing_Prohibit) return WC_E_DTDPROHIBITED;
1670
1671 reader_skipn(reader, 9);
1672 if (!reader_skipspaces(reader)) return WC_E_WHITESPACE;
1673
1674 /* name */
1675 hr = reader_parse_name(reader, &name);
1676 if (FAILED(hr)) return WC_E_DECLDOCTYPE;
1677
1678 reader_skipspaces(reader);
1679
1680 hr = reader_parse_externalid(reader);
1681 if (FAILED(hr)) return hr;
1682
1683 reader_skipspaces(reader);
1684
1685 cur = reader_get_ptr(reader);
1686 if (*cur != '>')
1687 {
1688 FIXME("internal subset parsing not implemented\n");
1689 return E_NOTIMPL;
1690 }
1691
1692 /* skip '>' */
1693 reader_skipn(reader, 1);
1694
1695 reader->nodetype = XmlNodeType_DocumentType;
1696 reader_set_strvalue(reader, StringValue_LocalName, &name);
1697 reader_set_strvalue(reader, StringValue_QualifiedName, &name);
1698
1699 return S_OK;
1700 }
1701
1702 /* [11 NS] LocalPart ::= NCName */
1703 static HRESULT reader_parse_local(xmlreader *reader, strval *local)
1704 {
1705 WCHAR *ptr;
1706 UINT start;
1707
1708 if (reader->resume[XmlReadResume_Local])
1709 {
1710 start = reader->resume[XmlReadResume_Local];
1711 ptr = reader_get_ptr(reader);
1712 }
1713 else
1714 {
1715 ptr = reader_get_ptr(reader);
1716 start = reader_get_cur(reader);
1717 }
1718
1719 while (is_ncnamechar(*ptr))
1720 {
1721 reader_skipn(reader, 1);
1722 ptr = reader_get_ptr(reader);
1723 }
1724
1725 if (is_reader_pending(reader))
1726 {
1727 reader->resume[XmlReadResume_Local] = start;
1728 return E_PENDING;
1729 }
1730 else
1731 reader->resume[XmlReadResume_Local] = 0;
1732
1733 reader_init_strvalue(start, reader_get_cur(reader)-start, local);
1734
1735 return S_OK;
1736 }
1737
1738 /* [7 NS] QName ::= PrefixedName | UnprefixedName
1739 [8 NS] PrefixedName ::= Prefix ':' LocalPart
1740 [9 NS] UnprefixedName ::= LocalPart
1741 [10 NS] Prefix ::= NCName */
1742 static HRESULT reader_parse_qname(xmlreader *reader, strval *prefix, strval *local, strval *qname)
1743 {
1744 WCHAR *ptr;
1745 UINT start;
1746 HRESULT hr;
1747
1748 if (reader->resume[XmlReadResume_Name])
1749 {
1750 start = reader->resume[XmlReadResume_Name];
1751 ptr = reader_get_ptr(reader);
1752 }
1753 else
1754 {
1755 ptr = reader_get_ptr(reader);
1756 start = reader_get_cur(reader);
1757 reader->resume[XmlReadResume_Name] = start;
1758 if (!is_ncnamechar(*ptr)) return NC_E_QNAMECHARACTER;
1759 }
1760
1761 if (reader->resume[XmlReadResume_Local])
1762 {
1763 hr = reader_parse_local(reader, local);
1764 if (FAILED(hr)) return hr;
1765
1766 reader_init_strvalue(reader->resume[XmlReadResume_Name],
1767 local->start - reader->resume[XmlReadResume_Name] - 1,
1768 prefix);
1769 }
1770 else
1771 {
1772 /* skip prefix part */
1773 while (is_ncnamechar(*ptr))
1774 {
1775 reader_skipn(reader, 1);
1776 ptr = reader_get_ptr(reader);
1777 }
1778
1779 if (is_reader_pending(reader)) return E_PENDING;
1780
1781 /* got a qualified name */
1782 if (*ptr == ':')
1783 {
1784 reader_init_strvalue(start, reader_get_cur(reader)-start, prefix);
1785
1786 /* skip ':' */
1787 reader_skipn(reader, 1);
1788 hr = reader_parse_local(reader, local);
1789 if (FAILED(hr)) return hr;
1790 }
1791 else
1792 {
1793 reader_init_strvalue(reader->resume[XmlReadResume_Name], reader_get_cur(reader)-reader->resume[XmlReadResume_Name], local);
1794 reader_init_strvalue(0, 0, prefix);
1795 }
1796 }
1797
1798 reader_init_strvalue(start, reader_get_cur(reader)-start, local);
1799
1800 if (prefix->len)
1801 TRACE("qname %s:%s\n", debug_strval(reader, prefix), debug_strval(reader, local));
1802 else
1803 TRACE("ncname %s\n", debug_strval(reader, local));
1804
1805 reader_init_strvalue(prefix->len ? prefix->start : local->start,
1806 /* count ':' too */
1807 (prefix->len ? prefix->len + 1 : 0) + local->len,
1808 qname);
1809
1810 reader->resume[XmlReadResume_Name] = 0;
1811 reader->resume[XmlReadResume_Local] = 0;
1812
1813 return S_OK;
1814 }
1815
1816 /* Applies normalization rules to a single char, used for attribute values.
1817
1818 Rules include 2 steps:
1819
1820 1) replacing \r\n with a single \n;
1821 2) replacing all whitespace chars with ' '.
1822
1823 */
1824 static void reader_normalize_space(xmlreader *reader, WCHAR *ptr)
1825 {
1826 encoded_buffer *buffer = &reader->input->buffer->utf16;
1827
1828 if (!is_wchar_space(*ptr)) return;
1829
1830 if (*ptr == '\r' && *(ptr+1) == '\n')
1831 {
1832 int len = buffer->written - ((char*)ptr - buffer->data) - 2*sizeof(WCHAR);
1833 memmove(ptr+1, ptr+2, len);
1834 }
1835 *ptr = ' ';
1836 }
1837
1838 static WCHAR get_predefined_entity(const xmlreader *reader, const strval *name)
1839 {
1840 static const WCHAR entltW[] = {'l','t'};
1841 static const WCHAR entgtW[] = {'g','t'};
1842 static const WCHAR entampW[] = {'a','m','p'};
1843 static const WCHAR entaposW[] = {'a','p','o','s'};
1844 static const WCHAR entquotW[] = {'q','u','o','t'};
1845 static const strval lt = { (WCHAR*)entltW, 2 };
1846 static const strval gt = { (WCHAR*)entgtW, 2 };
1847 static const strval amp = { (WCHAR*)entampW, 3 };
1848 static const strval apos = { (WCHAR*)entaposW, 4 };
1849 static const strval quot = { (WCHAR*)entquotW, 4 };
1850 WCHAR *str = reader_get_strptr(reader, name);
1851
1852 switch (*str)
1853 {
1854 case 'l':
1855 if (strval_eq(reader, name, &lt)) return '<';
1856 break;
1857 case 'g':
1858 if (strval_eq(reader, name, &gt)) return '>';
1859 break;
1860 case 'a':
1861 if (strval_eq(reader, name, &amp))
1862 return '&';
1863 else if (strval_eq(reader, name, &apos))
1864 return '\'';
1865 break;
1866 case 'q':
1867 if (strval_eq(reader, name, &quot)) return '\"';
1868 break;
1869 default:
1870 ;
1871 }
1872
1873 return 0;
1874 }
1875
1876 /* [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'
1877 [67] Reference ::= EntityRef | CharRef
1878 [68] EntityRef ::= '&' Name ';' */
1879 static HRESULT reader_parse_reference(xmlreader *reader)
1880 {
1881 encoded_buffer *buffer = &reader->input->buffer->utf16;
1882 WCHAR *start = reader_get_ptr(reader), *ptr;
1883 UINT cur = reader_get_cur(reader);
1884 WCHAR ch = 0;
1885 int len;
1886
1887 /* skip '&' */
1888 reader_skipn(reader, 1);
1889 ptr = reader_get_ptr(reader);
1890
1891 if (*ptr == '#')
1892 {
1893 reader_skipn(reader, 1);
1894 ptr = reader_get_ptr(reader);
1895
1896 /* hex char or decimal */
1897 if (*ptr == 'x')
1898 {
1899 reader_skipn(reader, 1);
1900 ptr = reader_get_ptr(reader);
1901
1902 while (*ptr != ';')
1903 {
1904 if ((*ptr >= '0' && *ptr <= '9'))
1905 ch = ch*16 + *ptr - '0';
1906 else if ((*ptr >= 'a' && *ptr <= 'f'))
1907 ch = ch*16 + *ptr - 'a' + 10;
1908 else if ((*ptr >= 'A' && *ptr <= 'F'))
1909 ch = ch*16 + *ptr - 'A' + 10;
1910 else
1911 return ch ? WC_E_SEMICOLON : WC_E_HEXDIGIT;
1912 reader_skipn(reader, 1);
1913 ptr = reader_get_ptr(reader);
1914 }
1915 }
1916 else
1917 {
1918 while (*ptr != ';')
1919 {
1920 if ((*ptr >= '0' && *ptr <= '9'))
1921 {
1922 ch = ch*10 + *ptr - '0';
1923 reader_skipn(reader, 1);
1924 ptr = reader_get_ptr(reader);
1925 }
1926 else
1927 return ch ? WC_E_SEMICOLON : WC_E_DIGIT;
1928 }
1929 }
1930
1931 if (!is_char(ch)) return WC_E_XMLCHARACTER;
1932
1933 /* normalize */
1934 if (is_wchar_space(ch)) ch = ' ';
1935
1936 len = buffer->written - ((char*)ptr - buffer->data) - sizeof(WCHAR);
1937 memmove(start+1, ptr+1, len);
1938 buffer->cur = cur + 1;
1939
1940 *start = ch;
1941 }
1942 else
1943 {
1944 strval name;
1945 HRESULT hr;
1946
1947 hr = reader_parse_name(reader, &name);
1948 if (FAILED(hr)) return hr;
1949
1950 ptr = reader_get_ptr(reader);
1951 if (*ptr != ';') return WC_E_SEMICOLON;
1952
1953 /* predefined entities resolve to a single character */
1954 ch = get_predefined_entity(reader, &name);
1955 if (ch)
1956 {
1957 len = buffer->written - ((char*)ptr - buffer->data) - sizeof(WCHAR);
1958 memmove(start+1, ptr+1, len);
1959 buffer->cur = cur + 1;
1960
1961 *start = ch;
1962 }
1963 else
1964 {
1965 FIXME("undeclared entity %s\n", debug_strval(reader, &name));
1966 return WC_E_UNDECLAREDENTITY;
1967 }
1968
1969 }
1970
1971 return S_OK;
1972 }
1973
1974 /* [10 NS] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'" */
1975 static HRESULT reader_parse_attvalue(xmlreader *reader, strval *value)
1976 {
1977 WCHAR *ptr, quote;
1978 UINT start;
1979
1980 ptr = reader_get_ptr(reader);
1981
1982 /* skip opening quote */
1983 quote = *ptr;
1984 if (quote != '\"' && quote != '\'') return WC_E_QUOTE;
1985 reader_skipn(reader, 1);
1986
1987 ptr = reader_get_ptr(reader);
1988 start = reader_get_cur(reader);
1989 while (*ptr)
1990 {
1991 if (*ptr == '<') return WC_E_LESSTHAN;
1992
1993 if (*ptr == quote)
1994 {
1995 reader_init_strvalue(start, reader_get_cur(reader)-start, value);
1996 /* skip closing quote */
1997 reader_skipn(reader, 1);
1998 return S_OK;
1999 }
2000
2001 if (*ptr == '&')
2002 {
2003 HRESULT hr = reader_parse_reference(reader);
2004 if (FAILED(hr)) return hr;
2005 }
2006 else
2007 {
2008 reader_normalize_space(reader, ptr);
2009 reader_skipn(reader, 1);
2010 }
2011 ptr = reader_get_ptr(reader);
2012 }
2013
2014 return WC_E_QUOTE;
2015 }
2016
2017 /* [1 NS] NSAttName ::= PrefixedAttName | DefaultAttName
2018 [2 NS] PrefixedAttName ::= 'xmlns:' NCName
2019 [3 NS] DefaultAttName ::= 'xmlns'
2020 [15 NS] Attribute ::= NSAttName Eq AttValue | QName Eq AttValue */
2021 static HRESULT reader_parse_attribute(xmlreader *reader)
2022 {
2023 static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
2024 strval prefix, local, qname, xmlns, value;
2025 HRESULT hr;
2026
2027 hr = reader_parse_qname(reader, &prefix, &local, &qname);
2028 if (FAILED(hr)) return hr;
2029
2030 reader_init_cstrvalue((WCHAR*)xmlnsW, 5, &xmlns);
2031
2032 if (strval_eq(reader, &prefix, &xmlns))
2033 {
2034 FIXME("namespace definitions not supported\n");
2035 return E_NOTIMPL;
2036 }
2037
2038 if (strval_eq(reader, &qname, &xmlns))
2039 FIXME("default namespace definitions not supported\n");
2040
2041 hr = reader_parse_eq(reader);
2042 if (FAILED(hr)) return hr;
2043
2044 hr = reader_parse_attvalue(reader, &value);
2045 if (FAILED(hr)) return hr;
2046
2047 TRACE("%s=%s\n", debug_strval(reader, &local), debug_strval(reader, &value));
2048 return reader_add_attr(reader, &local, &value);
2049 }
2050
2051 /* [12 NS] STag ::= '<' QName (S Attribute)* S? '>'
2052 [14 NS] EmptyElemTag ::= '<' QName (S Attribute)* S? '/>' */
2053 static HRESULT reader_parse_stag(xmlreader *reader, strval *prefix, strval *local, strval *qname, int *empty)
2054 {
2055 HRESULT hr;
2056
2057 hr = reader_parse_qname(reader, prefix, local, qname);
2058 if (FAILED(hr)) return hr;
2059
2060 while (1)
2061 {
2062 static const WCHAR endW[] = {'/','>',0};
2063
2064 reader_skipspaces(reader);
2065
2066 /* empty element */
2067 if ((*empty = !reader_cmp(reader, endW)))
2068 {
2069 /* skip '/>' */
2070 reader_skipn(reader, 2);
2071 reader->empty_element = TRUE;
2072 return S_OK;
2073 }
2074
2075 /* got a start tag */
2076 if (!reader_cmp(reader, gtW))
2077 {
2078 /* skip '>' */
2079 reader_skipn(reader, 1);
2080 return reader_push_element(reader, qname, local);
2081 }
2082
2083 hr = reader_parse_attribute(reader);
2084 if (FAILED(hr)) return hr;
2085 }
2086
2087 return S_OK;
2088 }
2089
2090 /* [39] element ::= EmptyElemTag | STag content ETag */
2091 static HRESULT reader_parse_element(xmlreader *reader)
2092 {
2093 HRESULT hr;
2094
2095 switch (reader->resumestate)
2096 {
2097 case XmlReadResumeState_Initial:
2098 /* check if we are really on element */
2099 if (reader_cmp(reader, ltW)) return S_FALSE;
2100
2101 /* skip '<' */
2102 reader_skipn(reader, 1);
2103
2104 reader_shrink(reader);
2105 reader->resumestate = XmlReadResumeState_STag;
2106 case XmlReadResumeState_STag:
2107 {
2108 strval qname, prefix, local;
2109 int empty = 0;
2110
2111 /* this handles empty elements too */
2112 hr = reader_parse_stag(reader, &prefix, &local, &qname, &empty);
2113 if (FAILED(hr)) return hr;
2114
2115 /* FIXME: need to check for defined namespace to reject invalid prefix,
2116 currently reject all prefixes */
2117 if (prefix.len) return NC_E_UNDECLAREDPREFIX;
2118
2119 /* if we got empty element and stack is empty go straight to Misc */
2120 if (empty && list_empty(&reader->elements))
2121 reader->instate = XmlReadInState_MiscEnd;
2122 else
2123 reader->instate = XmlReadInState_Content;
2124
2125 reader->nodetype = XmlNodeType_Element;
2126 reader->resumestate = XmlReadResumeState_Initial;
2127 reader_set_strvalue(reader, StringValue_LocalName, &local);
2128 reader_set_strvalue(reader, StringValue_Prefix, &prefix);
2129 reader_set_strvalue(reader, StringValue_QualifiedName, &qname);
2130 break;
2131 }
2132 default:
2133 hr = E_FAIL;
2134 }
2135
2136 return hr;
2137 }
2138
2139 /* [13 NS] ETag ::= '</' QName S? '>' */
2140 static HRESULT reader_parse_endtag(xmlreader *reader)
2141 {
2142 strval prefix, local, qname;
2143 struct element *elem;
2144 HRESULT hr;
2145
2146 /* skip '</' */
2147 reader_skipn(reader, 2);
2148
2149 hr = reader_parse_qname(reader, &prefix, &local, &qname);
2150 if (FAILED(hr)) return hr;
2151
2152 reader_skipspaces(reader);
2153
2154 if (reader_cmp(reader, gtW)) return WC_E_GREATERTHAN;
2155
2156 /* skip '>' */
2157 reader_skipn(reader, 1);
2158
2159 /* Element stack should never be empty at this point, cause we shouldn't get to
2160 content parsing if it's empty. */
2161 elem = LIST_ENTRY(list_head(&reader->elements), struct element, entry);
2162 if (!strval_eq(reader, &elem->qname, &qname)) return WC_E_ELEMENTMATCH;
2163
2164 reader_pop_element(reader);
2165
2166 /* It was a root element, the rest is expected as Misc */
2167 if (list_empty(&reader->elements))
2168 reader->instate = XmlReadInState_MiscEnd;
2169
2170 reader->nodetype = XmlNodeType_EndElement;
2171 reader_set_strvalue(reader, StringValue_LocalName, &local);
2172 reader_set_strvalue(reader, StringValue_QualifiedName, &qname);
2173
2174 return S_OK;
2175 }
2176
2177 /* [18] CDSect ::= CDStart CData CDEnd
2178 [19] CDStart ::= '<![CDATA['
2179 [20] CData ::= (Char* - (Char* ']]>' Char*))
2180 [21] CDEnd ::= ']]>' */
2181 static HRESULT reader_parse_cdata(xmlreader *reader)
2182 {
2183 WCHAR *ptr;
2184 UINT start;
2185
2186 if (reader->resumestate == XmlReadResumeState_CDATA)
2187 {
2188 start = reader->resume[XmlReadResume_Body];
2189 ptr = reader_get_ptr(reader);
2190 }
2191 else
2192 {
2193 /* skip markup '<![CDATA[' */
2194 reader_skipn(reader, 9);
2195 reader_shrink(reader);
2196 ptr = reader_get_ptr(reader);
2197 start = reader_get_cur(reader);
2198 reader->nodetype = XmlNodeType_CDATA;
2199 reader->resume[XmlReadResume_Body] = start;
2200 reader->resumestate = XmlReadResumeState_CDATA;
2201 reader_set_strvalue(reader, StringValue_LocalName, NULL);
2202 reader_set_strvalue(reader, StringValue_QualifiedName, NULL);
2203 reader_set_strvalue(reader, StringValue_Value, NULL);
2204 }
2205
2206 while (*ptr)
2207 {
2208 if (*ptr == ']' && *(ptr+1) == ']' && *(ptr+2) == '>')
2209 {
2210 strval value;
2211
2212 reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
2213
2214 /* skip ']]>' */
2215 reader_skipn(reader, 3);
2216 TRACE("%s\n", debug_strval(reader, &value));
2217
2218 reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
2219 reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
2220 reader_set_strvalue(reader, StringValue_Value, &value);
2221 reader->resume[XmlReadResume_Body] = 0;
2222 reader->resumestate = XmlReadResumeState_Initial;
2223 return S_OK;
2224 }
2225 else
2226 {
2227 /* Value normalization is not fully implemented, rules are:
2228
2229 - single '\r' -> '\n';
2230 - sequence '\r\n' -> '\n', in this case value length changes;
2231 */
2232 if (*ptr == '\r') *ptr = '\n';
2233 reader_skipn(reader, 1);
2234 ptr++;
2235 }
2236 }
2237
2238 return S_OK;
2239 }
2240
2241 /* [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) */
2242 static HRESULT reader_parse_chardata(xmlreader *reader)
2243 {
2244 WCHAR *ptr;
2245 UINT start;
2246
2247 if (reader->resumestate == XmlReadResumeState_CharData)
2248 {
2249 start = reader->resume[XmlReadResume_Body];
2250 ptr = reader_get_ptr(reader);
2251 }
2252 else
2253 {
2254 reader_shrink(reader);
2255 ptr = reader_get_ptr(reader);
2256 start = reader_get_cur(reader);
2257 /* There's no text */
2258 if (!*ptr || *ptr == '<') return S_OK;
2259 reader->nodetype = is_wchar_space(*ptr) ? XmlNodeType_Whitespace : XmlNodeType_Text;
2260 reader->resume[XmlReadResume_Body] = start;
2261 reader->resumestate = XmlReadResumeState_CharData;
2262 reader_set_strvalue(reader, StringValue_LocalName, &strval_empty);
2263 reader_set_strvalue(reader, StringValue_QualifiedName, &strval_empty);
2264 reader_set_strvalue(reader, StringValue_Value, NULL);
2265 }
2266
2267 while (*ptr)
2268 {
2269 /* CDATA closing sequence ']]>' is not allowed */
2270 if (ptr[0] == ']' && ptr[1] == ']' && ptr[2] == '>')
2271 return WC_E_CDSECTEND;
2272
2273 /* Found next markup part */
2274 if (ptr[0] == '<')
2275 {
2276 strval value;
2277
2278 reader_init_strvalue(start, reader_get_cur(reader)-start, &value);
2279 reader_set_strvalue(reader, StringValue_Value, &value);
2280 reader->resume[XmlReadResume_Body] = 0;
2281 reader->resumestate = XmlReadResumeState_Initial;
2282 return S_OK;
2283 }
2284
2285 reader_skipn(reader, 1);
2286
2287 /* this covers a case when text has leading whitespace chars */
2288 if (!is_wchar_space(*ptr)) reader->nodetype = XmlNodeType_Text;
2289 ptr++;
2290 }
2291
2292 return S_OK;
2293 }
2294
2295 /* [43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)* */
2296 static HRESULT reader_parse_content(xmlreader *reader)
2297 {
2298 static const WCHAR cdstartW[] = {'<','!','[','C','D','A','T','A','[',0};
2299 static const WCHAR etagW[] = {'<','/',0};
2300 static const WCHAR ampW[] = {'&',0};
2301
2302 if (reader->resumestate != XmlReadResumeState_Initial)
2303 {
2304 switch (reader->resumestate)
2305 {
2306 case XmlReadResumeState_CDATA:
2307 return reader_parse_cdata(reader);
2308 case XmlReadResumeState_Comment:
2309 return reader_parse_comment(reader);
2310 case XmlReadResumeState_PIBody:
2311 case XmlReadResumeState_PITarget:
2312 return reader_parse_pi(reader);
2313 case XmlReadResumeState_CharData:
2314 return reader_parse_chardata(reader);
2315 default:
2316 ERR("unknown resume state %d\n", reader->resumestate);
2317 }
2318 }
2319
2320 reader_shrink(reader);
2321
2322 /* handle end tag here, it indicates end of content as well */
2323 if (!reader_cmp(reader, etagW))
2324 return reader_parse_endtag(reader);
2325
2326 if (!reader_cmp(reader, commentW))
2327 return reader_parse_comment(reader);
2328
2329 if (!reader_cmp(reader, piW))
2330 return reader_parse_pi(reader);
2331
2332 if (!reader_cmp(reader, cdstartW))
2333 return reader_parse_cdata(reader);
2334
2335 if (!reader_cmp(reader, ampW))
2336 return reader_parse_reference(reader);
2337
2338 if (!reader_cmp(reader, ltW))
2339 return reader_parse_element(reader);
2340
2341 /* what's left must be CharData */
2342 return reader_parse_chardata(reader);
2343 }
2344
2345 static HRESULT reader_parse_nextnode(xmlreader *reader)
2346 {
2347 HRESULT hr;
2348
2349 if (!is_reader_pending(reader))
2350 reader_clear_attrs(reader);
2351
2352 while (1)
2353 {
2354 switch (reader->instate)
2355 {
2356 /* if it's a first call for a new input we need to detect stream encoding */
2357 case XmlReadInState_Initial:
2358 {
2359 xml_encoding enc;
2360
2361 hr = readerinput_growraw(reader->input);
2362 if (FAILED(hr)) return hr;
2363
2364 /* try to detect encoding by BOM or data and set input code page */
2365 hr = readerinput_detectencoding(reader->input, &enc);
2366 TRACE("detected encoding %s, 0x%08x\n", debugstr_w(xml_encoding_map[enc].name), hr);
2367 if (FAILED(hr)) return hr;
2368
2369 /* always switch first time cause we have to put something in */
2370 readerinput_switchencoding(reader->input, enc);
2371
2372 /* parse xml declaration */
2373 hr = reader_parse_xmldecl(reader);
2374 if (FAILED(hr)) return hr;
2375
2376 readerinput_shrinkraw(reader->input, -1);
2377 reader->instate = XmlReadInState_Misc_DTD;
2378 if (hr == S_OK) return hr;
2379 }
2380 break;
2381 case XmlReadInState_Misc_DTD:
2382 hr = reader_parse_misc(reader);
2383 if (FAILED(hr)) return hr;
2384
2385 if (hr == S_FALSE)
2386 reader->instate = XmlReadInState_DTD;
2387 else
2388 return hr;
2389 break;
2390 case XmlReadInState_DTD:
2391 hr = reader_parse_dtd(reader);
2392 if (FAILED(hr)) return hr;
2393
2394 if (hr == S_OK)
2395 {
2396 reader->instate = XmlReadInState_DTD_Misc;
2397 return hr;
2398 }
2399 else
2400 reader->instate = XmlReadInState_Element;
2401 break;
2402 case XmlReadInState_DTD_Misc:
2403 hr = reader_parse_misc(reader);
2404 if (FAILED(hr)) return hr;
2405
2406 if (hr == S_FALSE)
2407 reader->instate = XmlReadInState_Element;
2408 else
2409 return hr;
2410 break;
2411 case XmlReadInState_Element:
2412 return reader_parse_element(reader);
2413 case XmlReadInState_Content:
2414 return reader_parse_content(reader);
2415 case XmlReadInState_MiscEnd:
2416 hr = reader_parse_misc(reader);
2417 if (FAILED(hr)) return hr;
2418
2419 if (hr == S_FALSE)
2420 reader->instate = XmlReadInState_Eof;
2421 return hr;
2422 case XmlReadInState_Eof:
2423 return S_FALSE;
2424 default:
2425 FIXME("internal state %d not handled\n", reader->instate);
2426 return E_NOTIMPL;
2427 }
2428 }
2429
2430 return E_NOTIMPL;
2431 }
2432
2433 static HRESULT WINAPI xmlreader_QueryInterface(IXmlReader *iface, REFIID riid, void** ppvObject)
2434 {
2435 xmlreader *This = impl_from_IXmlReader(iface);
2436
2437 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
2438
2439 if (IsEqualGUID(riid, &IID_IUnknown) ||
2440 IsEqualGUID(riid, &IID_IXmlReader))
2441 {
2442 *ppvObject = iface;
2443 }
2444 else
2445 {
2446 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2447 *ppvObject = NULL;
2448 return E_NOINTERFACE;
2449 }
2450
2451 IXmlReader_AddRef(iface);
2452
2453 return S_OK;
2454 }
2455
2456 static ULONG WINAPI xmlreader_AddRef(IXmlReader *iface)
2457 {
2458 xmlreader *This = impl_from_IXmlReader(iface);
2459 ULONG ref = InterlockedIncrement(&This->ref);
2460 TRACE("(%p)->(%d)\n", This, ref);
2461 return ref;
2462 }
2463
2464 static ULONG WINAPI xmlreader_Release(IXmlReader *iface)
2465 {
2466 xmlreader *This = impl_from_IXmlReader(iface);
2467 LONG ref = InterlockedDecrement(&This->ref);
2468
2469 TRACE("(%p)->(%d)\n", This, ref);
2470
2471 if (ref == 0)
2472 {
2473 IMalloc *imalloc = This->imalloc;
2474 if (This->input) IUnknown_Release(&This->input->IXmlReaderInput_iface);
2475 reader_clear_attrs(This);
2476 reader_clear_elements(This);
2477 reader_free_strvalues(This);
2478 reader_free(This, This);
2479 if (imalloc) IMalloc_Release(imalloc);
2480 }
2481
2482 return ref;
2483 }
2484
2485 static HRESULT WINAPI xmlreader_SetInput(IXmlReader* iface, IUnknown *input)
2486 {
2487 xmlreader *This = impl_from_IXmlReader(iface);
2488 IXmlReaderInput *readerinput;
2489 HRESULT hr;
2490
2491 TRACE("(%p)->(%p)\n", This, input);
2492
2493 if (This->input)
2494 {
2495 readerinput_release_stream(This->input);
2496 IUnknown_Release(&This->input->IXmlReaderInput_iface);
2497 This->input = NULL;
2498 }
2499
2500 This->line = This->pos = 0;
2501 reader_clear_elements(This);
2502 This->depth = 0;
2503 This->resumestate = XmlReadResumeState_Initial;
2504 memset(This->resume, 0, sizeof(This->resume));
2505
2506 /* just reset current input */
2507 if (!input)
2508 {
2509 This->state = XmlReadState_Initial;
2510 return S_OK;
2511 }
2512
2513 /* now try IXmlReaderInput, ISequentialStream, IStream */
2514 hr = IUnknown_QueryInterface(input, &IID_IXmlReaderInput, (void**)&readerinput);
2515 if (hr == S_OK)
2516 {
2517 if (readerinput->lpVtbl == &xmlreaderinputvtbl)
2518 This->input = impl_from_IXmlReaderInput(readerinput);
2519 else
2520 {
2521 ERR("got external IXmlReaderInput implementation: %p, vtbl=%p\n",
2522 readerinput, readerinput->lpVtbl);
2523 IUnknown_Release(readerinput);
2524 return E_FAIL;
2525
2526 }
2527 }
2528
2529 if (hr != S_OK || !readerinput)
2530 {
2531 /* create IXmlReaderInput basing on supplied interface */
2532 hr = CreateXmlReaderInputWithEncodingName(input,
2533 This->imalloc, NULL, FALSE, NULL, &readerinput);
2534 if (hr != S_OK) return hr;
2535 This->input = impl_from_IXmlReaderInput(readerinput);
2536 }
2537
2538 /* set stream for supplied IXmlReaderInput */
2539 hr = readerinput_query_for_stream(This->input);
2540 if (hr == S_OK)
2541 {
2542 This->state = XmlReadState_Initial;
2543 This->instate = XmlReadInState_Initial;
2544 }
2545
2546 return hr;
2547 }
2548
2549 static HRESULT WINAPI xmlreader_GetProperty(IXmlReader* iface, UINT property, LONG_PTR *value)
2550 {
2551 xmlreader *This = impl_from_IXmlReader(iface);
2552
2553 TRACE("(%p)->(%s %p)\n", This, debugstr_reader_prop(property), value);
2554
2555 if (!value) return E_INVALIDARG;
2556
2557 switch (property)
2558 {
2559 case XmlReaderProperty_DtdProcessing:
2560 *value = This->dtdmode;
2561 break;
2562 case XmlReaderProperty_ReadState:
2563 *value = This->state;
2564 break;
2565 default:
2566 FIXME("Unimplemented property (%u)\n", property);
2567 return E_NOTIMPL;
2568 }
2569
2570 return S_OK;
2571 }
2572
2573 static HRESULT WINAPI xmlreader_SetProperty(IXmlReader* iface, UINT property, LONG_PTR value)
2574 {
2575 xmlreader *This = impl_from_IXmlReader(iface);
2576
2577 TRACE("(%p)->(%s %lu)\n", This, debugstr_reader_prop(property), value);
2578
2579 switch (property)
2580 {
2581 case XmlReaderProperty_DtdProcessing:
2582 if (value < 0 || value > _DtdProcessing_Last) return E_INVALIDARG;
2583 This->dtdmode = value;
2584 break;
2585 default:
2586 FIXME("Unimplemented property (%u)\n", property);
2587 return E_NOTIMPL;
2588 }
2589
2590 return S_OK;
2591 }
2592
2593 static HRESULT WINAPI xmlreader_Read(IXmlReader* iface, XmlNodeType *nodetype)
2594 {
2595 xmlreader *This = impl_from_IXmlReader(iface);
2596 XmlNodeType oldtype = This->nodetype;
2597 HRESULT hr;
2598
2599 TRACE("(%p)->(%p)\n", This, nodetype);
2600
2601 if (This->state == XmlReadState_Closed) return S_FALSE;
2602
2603 hr = reader_parse_nextnode(This);
2604 if (oldtype == XmlNodeType_None && This->nodetype != oldtype)
2605 This->state = XmlReadState_Interactive;
2606 if (hr == S_OK)
2607 {
2608 TRACE("node type %s\n", debugstr_nodetype(This->nodetype));
2609 *nodetype = This->nodetype;
2610 }
2611
2612 return hr;
2613 }
2614
2615 static HRESULT WINAPI xmlreader_GetNodeType(IXmlReader* iface, XmlNodeType *node_type)
2616 {
2617 xmlreader *This = impl_from_IXmlReader(iface);
2618 TRACE("(%p)->(%p)\n", This, node_type);
2619
2620 *node_type = reader_get_nodetype(This);
2621 return This->state == XmlReadState_Closed ? S_FALSE : S_OK;
2622 }
2623
2624 static HRESULT WINAPI xmlreader_MoveToFirstAttribute(IXmlReader* iface)
2625 {
2626 xmlreader *This = impl_from_IXmlReader(iface);
2627
2628 TRACE("(%p)\n", This);
2629
2630 if (!This->attr_count) return S_FALSE;
2631 This->attr = LIST_ENTRY(list_head(&This->attrs), struct attribute, entry);
2632 reader_set_strvalue(This, StringValue_LocalName, &This->attr->localname);
2633 reader_set_strvalue(This, StringValue_Value, &This->attr->value);
2634
2635 return S_OK;
2636 }
2637
2638 static HRESULT WINAPI xmlreader_MoveToNextAttribute(IXmlReader* iface)
2639 {
2640 xmlreader *This = impl_from_IXmlReader(iface);
2641 const struct list *next;
2642
2643 TRACE("(%p)\n", This);
2644
2645 if (!This->attr_count) return S_FALSE;
2646
2647 if (!This->attr)
2648 return IXmlReader_MoveToFirstAttribute(iface);
2649
2650 next = list_next(&This->attrs, &This->attr->entry);
2651 if (next)
2652 {
2653 This->attr = LIST_ENTRY(next, struct attribute, entry);
2654 reader_set_strvalue(This, StringValue_LocalName, &This->attr->localname);
2655 reader_set_strvalue(This, StringValue_Value, &This->attr->value);
2656 }
2657
2658 return next ? S_OK : S_FALSE;
2659 }
2660
2661 static HRESULT WINAPI xmlreader_MoveToAttributeByName(IXmlReader* iface,
2662 LPCWSTR local_name,
2663 LPCWSTR namespaceUri)
2664 {
2665 FIXME("(%p %p %p): stub\n", iface, local_name, namespaceUri);
2666 return E_NOTIMPL;
2667 }
2668
2669 static HRESULT WINAPI xmlreader_MoveToElement(IXmlReader* iface)
2670 {
2671 xmlreader *This = impl_from_IXmlReader(iface);
2672 struct element *elem;
2673
2674 TRACE("(%p)\n", This);
2675
2676 if (!This->attr_count) return S_FALSE;
2677 This->attr = NULL;
2678
2679 /* FIXME: support other node types with 'attributes' like DTD */
2680 elem = LIST_ENTRY(list_head(&This->elements), struct element, entry);
2681 if (elem)
2682 {
2683 reader_set_strvalue(This, StringValue_QualifiedName, &elem->qname);
2684 reader_set_strvalue(This, StringValue_LocalName, &elem->localname);
2685 }
2686
2687 return S_OK;
2688 }
2689
2690 static HRESULT WINAPI xmlreader_GetQualifiedName(IXmlReader* iface, LPCWSTR *name, UINT *len)
2691 {
2692 xmlreader *This = impl_from_IXmlReader(iface);
2693
2694 TRACE("(%p)->(%p %p)\n", This, name, len);
2695 *name = This->strvalues[StringValue_QualifiedName].str;
2696 if (len) *len = This->strvalues[StringValue_QualifiedName].len;
2697 return S_OK;
2698 }
2699
2700 static HRESULT WINAPI xmlreader_GetNamespaceUri(IXmlReader* iface,
2701 LPCWSTR *namespaceUri,
2702 UINT *namespaceUri_length)
2703 {
2704 FIXME("(%p %p %p): stub\n", iface, namespaceUri, namespaceUri_length);
2705 return E_NOTIMPL;
2706 }
2707
2708 static HRESULT WINAPI xmlreader_GetLocalName(IXmlReader* iface, LPCWSTR *name, UINT *len)
2709 {
2710 xmlreader *This = impl_from_IXmlReader(iface);
2711
2712 TRACE("(%p)->(%p %p)\n", This, name, len);
2713 *name = This->strvalues[StringValue_LocalName].str;
2714 if (len) *len = This->strvalues[StringValue_LocalName].len;
2715 return S_OK;
2716 }
2717
2718 static HRESULT WINAPI xmlreader_GetPrefix(IXmlReader* iface, LPCWSTR *prefix, UINT *len)
2719 {
2720 xmlreader *This = impl_from_IXmlReader(iface);
2721
2722 TRACE("(%p)->(%p %p)\n", This, prefix, len);
2723 *prefix = This->strvalues[StringValue_Prefix].str;
2724 if (len) *len = This->strvalues[StringValue_Prefix].len;
2725 return S_OK;
2726 }
2727
2728 static HRESULT WINAPI xmlreader_GetValue(IXmlReader* iface, const WCHAR **value, UINT *len)
2729 {
2730 xmlreader *reader = impl_from_IXmlReader(iface);
2731 strval *val = &reader->strvalues[StringValue_Value];
2732
2733 TRACE("(%p)->(%p %p)\n", reader, value, len);
2734
2735 *value = NULL;
2736
2737 if ((reader->nodetype == XmlNodeType_Comment && !val->str) || is_reader_pending(reader))
2738 {
2739 XmlNodeType type;
2740 HRESULT hr;
2741
2742 hr = IXmlReader_Read(iface, &type);
2743 if (FAILED(hr)) return hr;
2744
2745 /* return if still pending, partially read values are not reported */
2746 if (is_reader_pending(reader)) return E_PENDING;
2747 }
2748
2749 if (!val->str)
2750 {
2751 WCHAR *ptr = reader_alloc(reader, (val->len+1)*sizeof(WCHAR));
2752 if (!ptr) return E_OUTOFMEMORY;
2753 memcpy(ptr, reader_get_strptr(reader, val), val->len*sizeof(WCHAR));
2754 ptr[val->len] = 0;
2755 val->str = ptr;
2756 }
2757
2758 *value = val->str;
2759 if (len) *len = val->len;
2760 return S_OK;
2761 }
2762
2763 static HRESULT WINAPI xmlreader_ReadValueChunk(IXmlReader* iface, WCHAR *buffer, UINT chunk_size, UINT *read)
2764 {
2765 xmlreader *reader = impl_from_IXmlReader(iface);
2766 strval *val = &reader->strvalues[StringValue_Value];
2767 UINT len;
2768
2769 TRACE("(%p)->(%p %u %p)\n", reader, buffer, chunk_size, read);
2770
2771 /* Value is already allocated, chunked reads are not possible. */
2772 if (val->str) return S_FALSE;
2773
2774 if (val->len)
2775 {
2776 len = min(chunk_size, val->len);
2777 memcpy(buffer, reader_get_ptr2(reader, val->start), len);
2778 val->start += len;
2779 val->len -= len;
2780 if (read) *read = len;
2781 }
2782
2783 return S_OK;
2784 }
2785
2786 static HRESULT WINAPI xmlreader_GetBaseUri(IXmlReader* iface,
2787 LPCWSTR *baseUri,
2788 UINT *baseUri_length)
2789 {
2790 FIXME("(%p %p %p): stub\n", iface, baseUri, baseUri_length);
2791 return E_NOTIMPL;
2792 }
2793
2794 static BOOL WINAPI xmlreader_IsDefault(IXmlReader* iface)
2795 {
2796 FIXME("(%p): stub\n", iface);
2797 return FALSE;
2798 }
2799
2800 static BOOL WINAPI xmlreader_IsEmptyElement(IXmlReader* iface)
2801 {
2802 xmlreader *This = impl_from_IXmlReader(iface);
2803 TRACE("(%p)\n", This);
2804 /* Empty elements are not placed in stack, it's stored as a global reader flag that makes sense
2805 when current node is start tag of an element */
2806 return (reader_get_nodetype(This) == XmlNodeType_Element) ? This->empty_element : FALSE;
2807 }
2808
2809 static HRESULT WINAPI xmlreader_GetLineNumber(IXmlReader* iface, UINT *lineNumber)
2810 {
2811 xmlreader *This = impl_from_IXmlReader(iface);
2812
2813 TRACE("(%p %p)\n", This, lineNumber);
2814
2815 if (!lineNumber) return E_INVALIDARG;
2816
2817 *lineNumber = This->line;
2818
2819 return S_OK;
2820 }
2821
2822 static HRESULT WINAPI xmlreader_GetLinePosition(IXmlReader* iface, UINT *linePosition)
2823 {
2824 xmlreader *This = impl_from_IXmlReader(iface);
2825
2826 TRACE("(%p %p)\n", This, linePosition);
2827
2828 if (!linePosition) return E_INVALIDARG;
2829
2830 *linePosition = This->pos;
2831
2832 return S_OK;
2833 }
2834
2835 static HRESULT WINAPI xmlreader_GetAttributeCount(IXmlReader* iface, UINT *count)
2836 {
2837 xmlreader *This = impl_from_IXmlReader(iface);
2838
2839 TRACE("(%p)->(%p)\n", This, count);
2840
2841 if (!count) return E_INVALIDARG;
2842
2843 *count = This->attr_count;
2844 return S_OK;
2845 }
2846
2847 static HRESULT WINAPI xmlreader_GetDepth(IXmlReader* iface, UINT *depth)
2848 {
2849 xmlreader *This = impl_from_IXmlReader(iface);
2850 TRACE("(%p)->(%p)\n", This, depth);
2851 *depth = This->depth;
2852 return S_OK;
2853 }
2854
2855 static BOOL WINAPI xmlreader_IsEOF(IXmlReader* iface)
2856 {
2857 FIXME("(%p): stub\n", iface);
2858 return FALSE;
2859 }
2860
2861 static const struct IXmlReaderVtbl xmlreader_vtbl =
2862 {
2863 xmlreader_QueryInterface,
2864 xmlreader_AddRef,
2865 xmlreader_Release,
2866 xmlreader_SetInput,
2867 xmlreader_GetProperty,
2868 xmlreader_SetProperty,
2869 xmlreader_Read,
2870 xmlreader_GetNodeType,
2871 xmlreader_MoveToFirstAttribute,
2872 xmlreader_MoveToNextAttribute,
2873 xmlreader_MoveToAttributeByName,
2874 xmlreader_MoveToElement,
2875 xmlreader_GetQualifiedName,
2876 xmlreader_GetNamespaceUri,
2877 xmlreader_GetLocalName,
2878 xmlreader_GetPrefix,
2879 xmlreader_GetValue,
2880 xmlreader_ReadValueChunk,
2881 xmlreader_GetBaseUri,
2882 xmlreader_IsDefault,
2883 xmlreader_IsEmptyElement,
2884 xmlreader_GetLineNumber,
2885 xmlreader_GetLinePosition,
2886 xmlreader_GetAttributeCount,
2887 xmlreader_GetDepth,
2888 xmlreader_IsEOF
2889 };
2890
2891 /** IXmlReaderInput **/
2892 static HRESULT WINAPI xmlreaderinput_QueryInterface(IXmlReaderInput *iface, REFIID riid, void** ppvObject)
2893 {
2894 xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
2895
2896 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
2897
2898 if (IsEqualGUID(riid, &IID_IXmlReaderInput) ||
2899 IsEqualGUID(riid, &IID_IUnknown))
2900 {
2901 *ppvObject = iface;
2902 }
2903 else
2904 {
2905 WARN("interface %s not implemented\n", debugstr_guid(riid));
2906 *ppvObject = NULL;
2907 return E_NOINTERFACE;
2908 }
2909
2910 IUnknown_AddRef(iface);
2911
2912 return S_OK;
2913 }
2914
2915 static ULONG WINAPI xmlreaderinput_AddRef(IXmlReaderInput *iface)
2916 {
2917 xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
2918 ULONG ref = InterlockedIncrement(&This->ref);
2919 TRACE("(%p)->(%d)\n", This, ref);
2920 return ref;
2921 }
2922
2923 static ULONG WINAPI xmlreaderinput_Release(IXmlReaderInput *iface)
2924 {
2925 xmlreaderinput *This = impl_from_IXmlReaderInput(iface);
2926 LONG ref = InterlockedDecrement(&This->ref);
2927
2928 TRACE("(%p)->(%d)\n", This, ref);
2929
2930 if (ref == 0)
2931 {
2932 IMalloc *imalloc = This->imalloc;
2933 if (This->input) IUnknown_Release(This->input);
2934 if (This->stream) ISequentialStream_Release(This->stream);
2935 if (This->buffer) free_input_buffer(This->buffer);
2936 readerinput_free(This, This->baseuri);
2937 readerinput_free(This, This);
2938 if (imalloc) IMalloc_Release(imalloc);
2939 }
2940
2941 return ref;
2942 }
2943
2944 static const struct IUnknownVtbl xmlreaderinputvtbl =
2945 {
2946 xmlreaderinput_QueryInterface,
2947 xmlreaderinput_AddRef,
2948 xmlreaderinput_Release
2949 };
2950
2951 HRESULT WINAPI CreateXmlReader(REFIID riid, void **obj, IMalloc *imalloc)
2952 {
2953 xmlreader *reader;
2954 int i;
2955
2956 TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), obj, imalloc);
2957
2958 if (!IsEqualGUID(riid, &IID_IXmlReader))
2959 {
2960 ERR("Unexpected IID requested -> (%s)\n", wine_dbgstr_guid(riid));
2961 return E_FAIL;
2962 }
2963
2964 if (imalloc)
2965 reader = IMalloc_Alloc(imalloc, sizeof(*reader));
2966 else
2967 reader = heap_alloc(sizeof(*reader));
2968 if(!reader) return E_OUTOFMEMORY;
2969
2970 reader->IXmlReader_iface.lpVtbl = &xmlreader_vtbl;
2971 reader->ref = 1;
2972 reader->input = NULL;
2973 reader->state = XmlReadState_Closed;
2974 reader->instate = XmlReadInState_Initial;
2975 reader->resumestate = XmlReadResumeState_Initial;
2976 reader->dtdmode = DtdProcessing_Prohibit;
2977 reader->line = reader->pos = 0;
2978 reader->imalloc = imalloc;
2979 if (imalloc) IMalloc_AddRef(imalloc);
2980 reader->nodetype = XmlNodeType_None;
2981 list_init(&reader->attrs);
2982 reader->attr_count = 0;
2983 reader->attr = NULL;
2984 list_init(&reader->elements);
2985 reader->depth = 0;
2986 reader->max_depth = 256;
2987 reader->empty_element = FALSE;
2988 memset(reader->resume, 0, sizeof(reader->resume));
2989
2990 for (i = 0; i < StringValue_Last; i++)
2991 reader->strvalues[i] = strval_empty;
2992
2993 *obj = &reader->IXmlReader_iface;
2994
2995 TRACE("returning iface %p\n", *obj);
2996
2997 return S_OK;
2998 }
2999
3000 HRESULT WINAPI CreateXmlReaderInputWithEncodingName(IUnknown *stream,
3001 IMalloc *imalloc,
3002 LPCWSTR encoding,
3003 BOOL hint,
3004 LPCWSTR base_uri,
3005 IXmlReaderInput **ppInput)
3006 {
3007 xmlreaderinput *readerinput;
3008 HRESULT hr;
3009
3010 TRACE("%p %p %s %d %s %p\n", stream, imalloc, wine_dbgstr_w(encoding),
3011 hint, wine_dbgstr_w(base_uri), ppInput);
3012
3013 if (!stream || !ppInput) return E_INVALIDARG;
3014
3015 if (imalloc)
3016 readerinput = IMalloc_Alloc(imalloc, sizeof(*readerinput));
3017 else
3018 readerinput = heap_alloc(sizeof(*readerinput));
3019 if(!readerinput) return E_OUTOFMEMORY;
3020
3021 readerinput->IXmlReaderInput_iface.lpVtbl = &xmlreaderinputvtbl;
3022 readerinput->ref = 1;
3023 readerinput->imalloc = imalloc;
3024 readerinput->stream = NULL;
3025 if (imalloc) IMalloc_AddRef(imalloc);
3026 readerinput->encoding = parse_encoding_name(encoding, -1);
3027 readerinput->hint = hint;
3028 readerinput->baseuri = readerinput_strdupW(readerinput, base_uri);
3029 readerinput->pending = 0;
3030
3031 hr = alloc_input_buffer(readerinput);
3032 if (hr != S_OK)
3033 {
3034 readerinput_free(readerinput, readerinput->baseuri);
3035 readerinput_free(readerinput, readerinput);
3036 if (imalloc) IMalloc_Release(imalloc);
3037 return hr;
3038 }
3039 IUnknown_QueryInterface(stream, &IID_IUnknown, (void**)&readerinput->input);
3040
3041 *ppInput = &readerinput->IXmlReaderInput_iface;
3042
3043 TRACE("returning iface %p\n", *ppInput);
3044
3045 return S_OK;
3046 }
Windows API implementation