?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winecfg: Constrain DPI values to the commonly supported ones.
[wine.git] / dlls / webservices / writer.c
blob9cba4e60a202a1e63e6e1717a807f89bceb63858
1 /*
2 * Copyright 2015, 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include <assert.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <math.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "webservices.h"
29
30 #include "wine/debug.h"
31 #include "wine/heap.h"
32 #include "wine/list.h"
33 #include "wine/unicode.h"
34 #include "webservices_private.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
37
38 static const struct prop_desc writer_props[] =
39 {
40 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_DEPTH */
41 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT */
42 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
43 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_WRITE_DECLARATION */
44 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_INDENT */
45 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE */
46 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_WRITER_PROPERTY_CHARSET */
47 { sizeof(WS_BUFFERS), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFERS */
48 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE */
49 { sizeof(WS_BYTES), FALSE }, /* WS_XML_WRITER_PROPERTY_BYTES */
50 { sizeof(BOOL), TRUE }, /* WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE */
51 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE */
52 { sizeof(WS_BYTES), FALSE }, /* WS_XML_WRITER_PROPERTY_INITIAL_BUFFER */
53 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
54 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_NAMESPACES */
55 { sizeof(ULONG), TRUE }, /* WS_XML_WRITER_PROPERTY_BYTES_WRITTEN */
56 { sizeof(ULONG), TRUE }, /* WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE */
57 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS */
58 { sizeof(BOOL), FALSE } /* WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS */
59 };
60
61 enum writer_state
62 {
63 WRITER_STATE_INITIAL,
64 WRITER_STATE_STARTELEMENT,
65 WRITER_STATE_STARTATTRIBUTE,
66 WRITER_STATE_STARTCDATA,
67 WRITER_STATE_ENDSTARTELEMENT,
68 WRITER_STATE_TEXT,
69 WRITER_STATE_COMMENT,
70 WRITER_STATE_ENDELEMENT,
71 WRITER_STATE_ENDCDATA
72 };
73
74 struct writer
75 {
76 ULONG magic;
77 CRITICAL_SECTION cs;
78 ULONG write_pos;
79 unsigned char *write_bufptr;
80 enum writer_state state;
81 struct node *root;
82 struct node *current;
83 WS_XML_STRING *current_ns;
84 WS_XML_WRITER_ENCODING_TYPE output_enc;
85 WS_CHARSET output_charset;
86 WS_XML_WRITER_OUTPUT_TYPE output_type;
87 struct xmlbuf *output_buf;
88 WS_HEAP *output_heap;
89 const WS_XML_DICTIONARY *dict;
90 BOOL dict_do_lookup;
91 WS_DYNAMIC_STRING_CALLBACK dict_cb;
92 void *dict_cb_state;
93 ULONG prop_count;
94 struct prop prop[sizeof(writer_props)/sizeof(writer_props[0])];
95 };
96
97 #define WRITER_MAGIC (('W' << 24) | ('R' << 16) | ('I' << 8) | 'T')
98
99 static struct writer *alloc_writer(void)
100 {
101 static const ULONG count = sizeof(writer_props)/sizeof(writer_props[0]);
102 struct writer *ret;
103 ULONG size = sizeof(*ret) + prop_size( writer_props, count );
104
105 if (!(ret = heap_alloc_zero( size ))) return NULL;
106
107 ret->magic = WRITER_MAGIC;
108 InitializeCriticalSection( &ret->cs );
109 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": writer.cs");
110
111 prop_init( writer_props, count, ret->prop, &ret[1] );
112 ret->prop_count = count;
113 return ret;
114 }
115
116 static void free_writer( struct writer *writer )
117 {
118 destroy_nodes( writer->root );
119 free_xml_string( writer->current_ns );
120 WsFreeHeap( writer->output_heap );
121
122 writer->cs.DebugInfo->Spare[0] = 0;
123 DeleteCriticalSection( &writer->cs );
124 heap_free( writer );
125 }
126
127 static void write_insert_eof( struct writer *writer, struct node *eof )
128 {
129 if (!writer->root) writer->root = eof;
130 else
131 {
132 eof->parent = writer->root;
133 list_add_tail( &writer->root->children, &eof->entry );
134 }
135 writer->current = eof;
136 }
137
138 static void write_insert_bof( struct writer *writer, struct node *bof )
139 {
140 writer->root->parent = bof;
141 list_add_tail( &bof->children, &writer->root->entry );
142 writer->current = writer->root = bof;
143 }
144
145 static void write_insert_node( struct writer *writer, struct node *parent, struct node *node )
146 {
147 node->parent = parent;
148 list_add_before( list_tail( &parent->children ), &node->entry );
149 writer->current = node;
150 }
151
152 static struct node *find_parent( struct writer *writer )
153 {
154 if (is_valid_parent( writer->current )) return writer->current;
155 if (is_valid_parent( writer->current->parent )) return writer->current->parent;
156 return NULL;
157 }
158
159 static HRESULT init_writer( struct writer *writer )
160 {
161 struct node *node;
162
163 writer->write_pos = 0;
164 writer->write_bufptr = NULL;
165 destroy_nodes( writer->root );
166 writer->root = writer->current = NULL;
167 free_xml_string( writer->current_ns );
168 writer->current_ns = NULL;
169
170 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
171 write_insert_eof( writer, node );
172 writer->state = WRITER_STATE_INITIAL;
173 writer->output_enc = WS_XML_WRITER_ENCODING_TYPE_TEXT;
174 writer->output_charset = WS_CHARSET_UTF8;
175 writer->dict = NULL;
176 writer->dict_do_lookup = FALSE;
177 writer->dict_cb = NULL;
178 writer->dict_cb_state = NULL;
179 return S_OK;
180 }
181
182 /**************************************************************************
183 * WsCreateWriter [webservices.@]
184 */
185 HRESULT WINAPI WsCreateWriter( const WS_XML_WRITER_PROPERTY *properties, ULONG count,
186 WS_XML_WRITER **handle, WS_ERROR *error )
187 {
188 struct writer *writer;
189 ULONG i, max_depth = 32, max_attrs = 128, trim_size = 4096, max_size = 65536, max_ns = 32;
190 WS_CHARSET charset = WS_CHARSET_UTF8;
191 HRESULT hr;
192
193 TRACE( "%p %u %p %p\n", properties, count, handle, error );
194 if (error) FIXME( "ignoring error parameter\n" );
195
196 if (!handle) return E_INVALIDARG;
197 if (!(writer = alloc_writer())) return E_OUTOFMEMORY;
198
199 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
200 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
201 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, &trim_size, sizeof(trim_size) );
202 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_CHARSET, &charset, sizeof(charset) );
203 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, &max_size, sizeof(max_size) );
204 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, &max_size, sizeof(max_size) );
205 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
206
207 for (i = 0; i < count; i++)
208 {
209 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
210 properties[i].valueSize );
211 if (hr != S_OK)
212 {
213 free_writer( writer );
214 return hr;
215 }
216 }
217
218 hr = prop_get( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE,
219 &max_size, sizeof(max_size) );
220 if (hr != S_OK)
221 {
222 free_writer( writer );
223 return hr;
224 }
225
226 hr = WsCreateHeap( max_size, 0, NULL, 0, &writer->output_heap, NULL );
227 if (hr != S_OK)
228 {
229 free_writer( writer );
230 return hr;
231 }
232
233 hr = init_writer( writer );
234 if (hr != S_OK)
235 {
236 free_writer( writer );
237 return hr;
238 }
239
240 TRACE( "created %p\n", writer );
241 *handle = (WS_XML_WRITER *)writer;
242 return S_OK;
243 }
244
245 /**************************************************************************
246 * WsFreeWriter [webservices.@]
247 */
248 void WINAPI WsFreeWriter( WS_XML_WRITER *handle )
249 {
250 struct writer *writer = (struct writer *)handle;
251
252 TRACE( "%p\n", handle );
253
254 if (!writer) return;
255
256 EnterCriticalSection( &writer->cs );
257
258 if (writer->magic != WRITER_MAGIC)
259 {
260 LeaveCriticalSection( &writer->cs );
261 return;
262 }
263
264 writer->magic = 0;
265
266 LeaveCriticalSection( &writer->cs );
267 free_writer( writer );
268 }
269
270 /**************************************************************************
271 * WsGetWriterProperty [webservices.@]
272 */
273 HRESULT WINAPI WsGetWriterProperty( WS_XML_WRITER *handle, WS_XML_WRITER_PROPERTY_ID id,
274 void *buf, ULONG size, WS_ERROR *error )
275 {
276 struct writer *writer = (struct writer *)handle;
277 HRESULT hr = S_OK;
278
279 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
280 if (error) FIXME( "ignoring error parameter\n" );
281
282 if (!writer) return E_INVALIDARG;
283
284 EnterCriticalSection( &writer->cs );
285
286 if (writer->magic != WRITER_MAGIC)
287 {
288 LeaveCriticalSection( &writer->cs );
289 return E_INVALIDARG;
290 }
291
292 if (!writer->output_type)
293 {
294 LeaveCriticalSection( &writer->cs );
295 return WS_E_INVALID_OPERATION;
296 }
297
298 switch (id)
299 {
300 case WS_XML_WRITER_PROPERTY_BYTES:
301 {
302 WS_BYTES *bytes = buf;
303 if (size != sizeof(*bytes)) hr = E_INVALIDARG;
304 else
305 {
306 bytes->bytes = writer->output_buf->bytes.bytes;
307 bytes->length = writer->output_buf->bytes.length;
308 }
309 break;
310 }
311 case WS_XML_WRITER_PROPERTY_BUFFERS:
312 if (writer->output_buf->bytes.length)
313 {
314 WS_BUFFERS *buffers = buf;
315 if (size != sizeof(*buffers)) hr = E_INVALIDARG;
316 else
317 {
318 buffers->bufferCount = 1;
319 buffers->buffers = &writer->output_buf->bytes;
320 }
321 break;
322 }
323 /* fall through */
324 default:
325 hr = prop_get( writer->prop, writer->prop_count, id, buf, size );
326 }
327
328 LeaveCriticalSection( &writer->cs );
329 return hr;
330 }
331
332 static void set_output_buffer( struct writer *writer, struct xmlbuf *xmlbuf )
333 {
334 /* free current buffer if it's ours */
335 if (writer->output_buf && writer->output_buf->heap == writer->output_heap)
336 {
337 free_xmlbuf( writer->output_buf );
338 }
339 writer->output_buf = xmlbuf;
340 writer->output_type = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
341 writer->write_bufptr = xmlbuf->bytes.bytes;
342 writer->write_pos = 0;
343 }
344
345 /**************************************************************************
346 * WsSetOutput [webservices.@]
347 */
348 HRESULT WINAPI WsSetOutput( WS_XML_WRITER *handle, const WS_XML_WRITER_ENCODING *encoding,
349 const WS_XML_WRITER_OUTPUT *output, const WS_XML_WRITER_PROPERTY *properties,
350 ULONG count, WS_ERROR *error )
351 {
352 struct writer *writer = (struct writer *)handle;
353 struct node *node;
354 HRESULT hr;
355 ULONG i;
356
357 TRACE( "%p %p %p %p %u %p\n", handle, encoding, output, properties, count, error );
358 if (error) FIXME( "ignoring error parameter\n" );
359
360 if (!writer) return E_INVALIDARG;
361
362 EnterCriticalSection( &writer->cs );
363
364 if (writer->magic != WRITER_MAGIC)
365 {
366 LeaveCriticalSection( &writer->cs );
367 return E_INVALIDARG;
368 }
369
370 for (i = 0; i < count; i++)
371 {
372 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
373 properties[i].valueSize );
374 if (hr != S_OK) goto done;
375 }
376
377 if ((hr = init_writer( writer )) != S_OK) goto done;
378
379 switch (encoding->encodingType)
380 {
381 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
382 {
383 WS_XML_WRITER_TEXT_ENCODING *text = (WS_XML_WRITER_TEXT_ENCODING *)encoding;
384 if (text->charSet != WS_CHARSET_UTF8)
385 {
386 FIXME( "charset %u not supported\n", text->charSet );
387 hr = E_NOTIMPL;
388 goto done;
389 }
390 writer->output_enc = WS_XML_WRITER_ENCODING_TYPE_TEXT;
391 writer->output_charset = WS_CHARSET_UTF8;
392 break;
393 }
394 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
395 {
396 WS_XML_WRITER_BINARY_ENCODING *bin = (WS_XML_WRITER_BINARY_ENCODING *)encoding;
397 writer->output_enc = WS_XML_WRITER_ENCODING_TYPE_BINARY;
398 writer->output_charset = 0;
399 writer->dict = bin->staticDictionary;
400 writer->dict_cb = bin->dynamicStringCallback;
401 writer->dict_cb_state = bin->dynamicStringCallbackState;
402 break;
403 }
404 default:
405 FIXME( "encoding type %u not supported\n", encoding->encodingType );
406 hr = E_NOTIMPL;
407 goto done;
408 }
409
410 switch (output->outputType)
411 {
412 case WS_XML_WRITER_OUTPUT_TYPE_BUFFER:
413 {
414 struct xmlbuf *xmlbuf;
415 if (!(xmlbuf = alloc_xmlbuf( writer->output_heap, 0, writer->output_enc, writer->output_charset,
416 writer->dict, NULL )))
417 {
418 hr = WS_E_QUOTA_EXCEEDED;
419 goto done;
420 }
421 set_output_buffer( writer, xmlbuf );
422 break;
423 }
424 default:
425 FIXME( "output type %u not supported\n", output->outputType );
426 hr = E_NOTIMPL;
427 goto done;
428 }
429
430 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
431 else write_insert_bof( writer, node );
432
433 done:
434 LeaveCriticalSection( &writer->cs );
435 return hr;
436 }
437
438 /**************************************************************************
439 * WsSetOutputToBuffer [webservices.@]
440 */
441 HRESULT WINAPI WsSetOutputToBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer,
442 const WS_XML_WRITER_PROPERTY *properties, ULONG count,
443 WS_ERROR *error )
444 {
445 struct writer *writer = (struct writer *)handle;
446 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
447 struct node *node;
448 HRESULT hr;
449 ULONG i;
450
451 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
452 if (error) FIXME( "ignoring error parameter\n" );
453
454 if (!writer || !xmlbuf) return E_INVALIDARG;
455
456 EnterCriticalSection( &writer->cs );
457
458 if (writer->magic != WRITER_MAGIC)
459 {
460 LeaveCriticalSection( &writer->cs );
461 return E_INVALIDARG;
462 }
463
464 for (i = 0; i < count; i++)
465 {
466 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
467 properties[i].valueSize );
468 if (hr != S_OK) goto done;
469 }
470
471 if ((hr = init_writer( writer )) != S_OK) goto done;
472 writer->output_enc = xmlbuf->encoding;
473 writer->output_charset = xmlbuf->charset;
474 set_output_buffer( writer, xmlbuf );
475
476 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY;
477 else write_insert_bof( writer, node );
478
479 done:
480 LeaveCriticalSection( &writer->cs );
481 return hr;
482 }
483
484 static HRESULT write_grow_buffer( struct writer *writer, ULONG size )
485 {
486 struct xmlbuf *buf = writer->output_buf;
487 SIZE_T new_size;
488 void *tmp;
489
490 if (buf->size >= writer->write_pos + size)
491 {
492 buf->bytes.length = writer->write_pos + size;
493 return S_OK;
494 }
495 new_size = max( buf->size * 2, writer->write_pos + size );
496 if (!(tmp = ws_realloc( buf->heap, buf->bytes.bytes, buf->size, new_size ))) return WS_E_QUOTA_EXCEEDED;
497 writer->write_bufptr = buf->bytes.bytes = tmp;
498 buf->size = new_size;
499 buf->bytes.length = writer->write_pos + size;
500 return S_OK;
501 }
502
503 static inline void write_char( struct writer *writer, unsigned char ch )
504 {
505 writer->write_bufptr[writer->write_pos++] = ch;
506 }
507
508 static inline void write_bytes( struct writer *writer, const BYTE *bytes, ULONG len )
509 {
510 memcpy( writer->write_bufptr + writer->write_pos, bytes, len );
511 writer->write_pos += len;
512 }
513
514 struct escape
515 {
516 char ch;
517 const char *entity;
518 ULONG len;
519 };
520 static const struct escape escape_lt = { '<', "&lt;", 4 };
521 static const struct escape escape_gt = { '>', "&gt;", 4 };
522 static const struct escape escape_amp = { '&', "&amp;", 5 };
523 static const struct escape escape_apos = { '\'', "&apos;", 6 };
524 static const struct escape escape_quot = { '"', "&quot;", 6 };
525
526 static HRESULT write_bytes_escape( struct writer *writer, const BYTE *bytes, ULONG len,
527 const struct escape **escapes, ULONG nb_escapes )
528 {
529 ULONG i, j, size;
530 const BYTE *ptr;
531 HRESULT hr;
532
533 for (i = 0; i < len; i++)
534 {
535 ptr = &bytes[i];
536 size = 1;
537 for (j = 0; j < nb_escapes; j++)
538 {
539 if (bytes[i] == escapes[j]->ch)
540 {
541 ptr = (const BYTE *)escapes[j]->entity;
542 size = escapes[j]->len;
543 break;
544 }
545 }
546 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
547 write_bytes( writer, ptr, size );
548 }
549
550 return S_OK;
551 }
552
553 static HRESULT write_attribute_value_text( struct writer *writer, const WS_XML_TEXT *text, BOOL single )
554 {
555 WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text;
556 const struct escape *escapes[3];
557
558 escapes[0] = single ? &escape_apos : &escape_quot;
559 escapes[1] = &escape_lt;
560 escapes[2] = &escape_amp;
561 return write_bytes_escape( writer, utf8->value.bytes, utf8->value.length, escapes, 3 );
562 }
563
564 static HRESULT write_attribute_text( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
565 {
566 unsigned char quote = attr->singleQuote ? '\'' : '"';
567 const WS_XML_STRING *prefix = NULL;
568 ULONG size;
569 HRESULT hr;
570
571 if (attr->prefix) prefix = attr->prefix;
572
573 /* ' prefix:attr="value"' */
574
575 size = attr->localName->length + 4 /* ' =""' */;
576 if (prefix && prefix->length) size += prefix->length + 1 /* ':' */;
577 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
578
579 write_char( writer, ' ' );
580 if (prefix && prefix->length)
581 {
582 write_bytes( writer, prefix->bytes, prefix->length );
583 write_char( writer, ':' );
584 }
585 write_bytes( writer, attr->localName->bytes, attr->localName->length );
586 write_char( writer, '=' );
587 write_char( writer, quote );
588 if (attr->value) hr = write_attribute_value_text( writer, attr->value, attr->singleQuote );
589 write_char( writer, quote );
590
591 return hr;
592 }
593
594 static HRESULT write_int31( struct writer *writer, ULONG len )
595 {
596 HRESULT hr;
597
598 if (len > 0x7fffffff) return E_INVALIDARG;
599
600 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
601 if (len < 0x80)
602 {
603 write_char( writer, len );
604 return S_OK;
605 }
606 write_char( writer, (len & 0x7f) | 0x80 );
607
608 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
609 if ((len >>= 7) < 0x80)
610 {
611 write_char( writer, len );
612 return S_OK;
613 }
614 write_char( writer, (len & 0x7f) | 0x80 );
615
616 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
617 if ((len >>= 7) < 0x80)
618 {
619 write_char( writer, len );
620 return S_OK;
621 }
622 write_char( writer, (len & 0x7f) | 0x80 );
623
624 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
625 if ((len >>= 7) < 0x80)
626 {
627 write_char( writer, len );
628 return S_OK;
629 }
630 write_char( writer, (len & 0x7f) | 0x80 );
631
632 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
633 if ((len >>= 7) < 0x08)
634 {
635 write_char( writer, len );
636 return S_OK;
637 }
638 return WS_E_INVALID_FORMAT;
639 }
640
641 static HRESULT write_string( struct writer *writer, const BYTE *bytes, ULONG len )
642 {
643 HRESULT hr;
644 if ((hr = write_int31( writer, len )) != S_OK) return hr;
645 if ((hr = write_grow_buffer( writer, len )) != S_OK) return hr;
646 write_bytes( writer, bytes, len );
647 return S_OK;
648 }
649
650 static HRESULT write_dict_string( struct writer *writer, ULONG id )
651 {
652 if (id > 0x7fffffff) return E_INVALIDARG;
653 return write_int31( writer, id );
654 }
655
656 static enum record_type get_attr_text_record_type( const WS_XML_TEXT *text, BOOL use_dict )
657 {
658 if (!text) return RECORD_CHARS8_TEXT;
659 switch (text->textType)
660 {
661 case WS_XML_TEXT_TYPE_UTF8:
662 {
663 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
664 if (use_dict) return RECORD_DICTIONARY_TEXT;
665 if (text_utf8->value.length <= MAX_UINT8) return RECORD_CHARS8_TEXT;
666 if (text_utf8->value.length <= MAX_UINT16) return RECORD_CHARS16_TEXT;
667 return RECORD_CHARS32_TEXT;
668 }
669 case WS_XML_TEXT_TYPE_UTF16:
670 {
671 const WS_XML_UTF16_TEXT *text_utf16 = (const WS_XML_UTF16_TEXT *)text;
672 int len = text_utf16->byteCount / sizeof(WCHAR);
673 int len_utf8 = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)text_utf16->bytes, len, NULL, 0, NULL, NULL );
674 if (len_utf8 <= MAX_UINT8) return RECORD_CHARS8_TEXT;
675 if (len_utf8 <= MAX_UINT16) return RECORD_CHARS16_TEXT;
676 return RECORD_CHARS32_TEXT;
677 }
678 case WS_XML_TEXT_TYPE_BASE64:
679 {
680 const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text;
681 if (text_base64->length <= MAX_UINT8) return RECORD_BYTES8_TEXT;
682 if (text_base64->length <= MAX_UINT16) return RECORD_BYTES16_TEXT;
683 return RECORD_BYTES32_TEXT;
684 }
685 case WS_XML_TEXT_TYPE_BOOL:
686 {
687 const WS_XML_BOOL_TEXT *text_bool = (const WS_XML_BOOL_TEXT *)text;
688 return text_bool->value ? RECORD_TRUE_TEXT : RECORD_FALSE_TEXT;
689 }
690 case WS_XML_TEXT_TYPE_INT32:
691 {
692 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
693 if (!text_int32->value) return RECORD_ZERO_TEXT;
694 if (text_int32->value == 1) return RECORD_ONE_TEXT;
695 if (text_int32->value >= MIN_INT8 && text_int32->value <= MAX_INT8) return RECORD_INT8_TEXT;
696 if (text_int32->value >= MIN_INT16 && text_int32->value <= MAX_INT16) return RECORD_INT16_TEXT;
697 return RECORD_INT32_TEXT;
698 }
699 case WS_XML_TEXT_TYPE_INT64:
700 {
701 const WS_XML_INT64_TEXT *text_int64 = (const WS_XML_INT64_TEXT *)text;
702 if (!text_int64->value) return RECORD_ZERO_TEXT;
703 if (text_int64->value == 1) return RECORD_ONE_TEXT;
704 if (text_int64->value >= MIN_INT8 && text_int64->value <= MAX_INT8) return RECORD_INT8_TEXT;
705 if (text_int64->value >= MIN_INT16 && text_int64->value <= MAX_INT16) return RECORD_INT16_TEXT;
706 if (text_int64->value >= MIN_INT32 && text_int64->value <= MAX_INT32) return RECORD_INT32_TEXT;
707 return RECORD_INT64_TEXT;
708 }
709 case WS_XML_TEXT_TYPE_UINT64:
710 {
711 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
712 if (!text_uint64->value) return RECORD_ZERO_TEXT;
713 if (text_uint64->value == 1) return RECORD_ONE_TEXT;
714 if (text_uint64->value <= MAX_INT8) return RECORD_INT8_TEXT;
715 if (text_uint64->value <= MAX_INT16) return RECORD_INT16_TEXT;
716 if (text_uint64->value <= MAX_INT32) return RECORD_INT32_TEXT;
717 if (text_uint64->value <= MAX_INT64) return RECORD_INT64_TEXT;
718 return RECORD_UINT64_TEXT;
719 }
720 case WS_XML_TEXT_TYPE_DOUBLE:
721 {
722 const WS_XML_DOUBLE_TEXT *text_double = (const WS_XML_DOUBLE_TEXT *)text;
723 if (!text_double->value) return RECORD_ZERO_TEXT;
724 if (text_double->value == 1) return RECORD_ONE_TEXT;
725 if (isinf( text_double->value ) || (INT64)text_double->value != text_double->value)
726 return RECORD_DOUBLE_TEXT;
727 if (text_double->value <= MAX_INT8) return RECORD_INT8_TEXT;
728 if (text_double->value <= MAX_INT16) return RECORD_INT16_TEXT;
729 if (text_double->value <= MAX_INT32) return RECORD_INT32_TEXT;
730 return RECORD_INT64_TEXT;
731 }
732 case WS_XML_TEXT_TYPE_GUID:
733 return RECORD_GUID_TEXT;
734
735 case WS_XML_TEXT_TYPE_UNIQUE_ID:
736 return RECORD_UNIQUE_ID_TEXT;
737
738 case WS_XML_TEXT_TYPE_DATETIME:
739 return RECORD_DATETIME_TEXT;
740
741 default:
742 FIXME( "unhandled text type %u\n", text->textType );
743 return 0;
744 }
745 }
746
747 static INT64 get_text_value_int( const WS_XML_TEXT *text )
748 {
749 switch (text->textType)
750 {
751 case WS_XML_TEXT_TYPE_INT32:
752 {
753 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
754 return text_int32->value;
755 }
756 case WS_XML_TEXT_TYPE_INT64:
757 {
758 const WS_XML_INT64_TEXT *text_int64 = (const WS_XML_INT64_TEXT *)text;
759 return text_int64->value;
760 }
761 case WS_XML_TEXT_TYPE_UINT64:
762 {
763 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
764 return text_uint64->value;
765 }
766 case WS_XML_TEXT_TYPE_DOUBLE:
767 {
768 const WS_XML_DOUBLE_TEXT *text_double = (const WS_XML_DOUBLE_TEXT *)text;
769 return text_double->value;
770 }
771 default:
772 ERR( "unhandled text type %u\n", text->textType );
773 assert(0);
774 return 0;
775 }
776 }
777
778 static BOOL get_string_id( struct writer *writer, const WS_XML_STRING *str, ULONG *id )
779 {
780 if (writer->dict && str->dictionary == writer->dict)
781 {
782 *id = str->id << 1;
783 return TRUE;
784 }
785 if (writer->dict_cb)
786 {
787 BOOL found = FALSE;
788 writer->dict_cb( writer->dict_cb_state, str, &found, id, NULL );
789 if (found) *id = (*id << 1) | 1;
790 return found;
791 }
792 return FALSE;
793 }
794
795 static ULONG format_bool( const BOOL *ptr, unsigned char *buf )
796 {
797 static const unsigned char bool_true[] = {'t','r','u','e'}, bool_false[] = {'f','a','l','s','e'};
798 if (*ptr)
799 {
800 memcpy( buf, bool_true, sizeof(bool_true) );
801 return sizeof(bool_true);
802 }
803 memcpy( buf, bool_false, sizeof(bool_false) );
804 return sizeof(bool_false);
805 }
806
807 static ULONG format_int32( const INT32 *ptr, unsigned char *buf )
808 {
809 return wsprintfA( (char *)buf, "%d", *ptr );
810 }
811
812 static ULONG format_int64( const INT64 *ptr, unsigned char *buf )
813 {
814 return wsprintfA( (char *)buf, "%I64d", *ptr );
815 }
816
817 static ULONG format_uint64( const UINT64 *ptr, unsigned char *buf )
818 {
819 return wsprintfA( (char *)buf, "%I64u", *ptr );
820 }
821
822 static ULONG format_double( const double *ptr, unsigned char *buf )
823 {
824 #ifdef HAVE_POWL
825 static const long double precision = 0.0000000000000001;
826 unsigned char *p = buf;
827 long double val = *ptr;
828 int neg, mag, mag2, use_exp;
829
830 if (isnan( val ))
831 {
832 memcpy( buf, "NaN", 3 );
833 return 3;
834 }
835 if (isinf( val ))
836 {
837 if (val < 0)
838 {
839 memcpy( buf, "-INF", 4 );
840 return 4;
841 }
842 memcpy( buf, "INF", 3 );
843 return 3;
844 }
845 if (val == 0.0)
846 {
847 *p = '0';
848 return 1;
849 }
850
851 if ((neg = val < 0))
852 {
853 *p++ = '-';
854 val = -val;
855 }
856
857 mag = log10l( val );
858 use_exp = (mag >= 15 || (neg && mag >= 1) || mag <= -1);
859 if (use_exp)
860 {
861 if (mag < 0) mag -= 1;
862 val = val / powl( 10.0, mag );
863 mag2 = mag;
864 mag = 0;
865 }
866 else if (mag < 1) mag = 0;
867
868 while (val > precision || mag >= 0)
869 {
870 long double weight = powl( 10.0, mag );
871 if (weight > 0 && !isinf( weight ))
872 {
873 int digit = floorl( val / weight );
874 val -= digit * weight;
875 *(p++) = '0' + digit;
876 }
877 if (!mag && val > precision) *(p++) = '.';
878 mag--;
879 }
880
881 if (use_exp)
882 {
883 int i, j;
884 *(p++) = 'E';
885 if (mag2 > 0) *(p++) = '+';
886 else
887 {
888 *(p++) = '-';
889 mag2 = -mag2;
890 }
891 mag = 0;
892 while (mag2 > 0)
893 {
894 *(p++) = '0' + mag2 % 10;
895 mag2 /= 10;
896 mag++;
897 }
898 for (i = -mag, j = -1; i < j; i++, j--)
899 {
900 p[i] ^= p[j];
901 p[j] ^= p[i];
902 p[i] ^= p[j];
903 }
904 }
905
906 return p - buf;
907 #else
908 FIXME( "powl not found at build time\n" );
909 return 0;
910 #endif
911 }
912
913 static inline int year_size( int year )
914 {
915 return leap_year( year ) ? 366 : 365;
916 }
917
918 #define TZ_OFFSET 8
919 static ULONG format_datetime( const WS_DATETIME *ptr, unsigned char *buf )
920 {
921 static const char fmt[] = "%04u-%02u-%02uT%02u:%02u:%02u";
922 int day, hour, min, sec, sec_frac, month = 0, year = 1, tz_hour;
923 unsigned __int64 ticks, day_ticks;
924 ULONG len;
925
926 if (ptr->format == WS_DATETIME_FORMAT_LOCAL &&
927 ptr->ticks >= TICKS_1601_01_01 + TZ_OFFSET * TICKS_PER_HOUR)
928 {
929 ticks = ptr->ticks - TZ_OFFSET * TICKS_PER_HOUR;
930 tz_hour = TZ_OFFSET;
931 }
932 else
933 {
934 ticks = ptr->ticks;
935 tz_hour = 0;
936 }
937 day = ticks / TICKS_PER_DAY;
938 day_ticks = ticks % TICKS_PER_DAY;
939 hour = day_ticks / TICKS_PER_HOUR;
940 min = (day_ticks % TICKS_PER_HOUR) / TICKS_PER_MIN;
941 sec = (day_ticks % TICKS_PER_MIN) / TICKS_PER_SEC;
942 sec_frac = day_ticks % TICKS_PER_SEC;
943
944 while (day >= year_size( year ))
945 {
946 day -= year_size( year );
947 year++;
948 }
949 while (day >= month_days[leap_year( year )][month])
950 {
951 day -= month_days[leap_year( year )][month];
952 month++;
953 }
954
955 len = sprintf( (char *)buf, fmt, year, month + 1, day + 1, hour, min, sec );
956 if (sec_frac)
957 {
958 static const char fmt_frac[] = ".%07u";
959 len += sprintf( (char *)buf + len, fmt_frac, sec_frac );
960 while (buf[len - 1] == '0') len--;
961 }
962 if (ptr->format == WS_DATETIME_FORMAT_UTC)
963 {
964 buf[len++] = 'Z';
965 }
966 else if (ptr->format == WS_DATETIME_FORMAT_LOCAL)
967 {
968 static const char fmt_tz[] = "%c%02u:00";
969 len += sprintf( (char *)buf + len, fmt_tz, tz_hour ? '-' : '+', tz_hour );
970 }
971
972 return len;
973 }
974
975 static ULONG format_guid( const GUID *ptr, unsigned char *buf )
976 {
977 static const char fmt[] = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
978 return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3,
979 ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3],
980 ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] );
981 }
982
983 static ULONG format_urn( const GUID *ptr, unsigned char *buf )
984 {
985 static const char fmt[] = "urn:uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
986 return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3,
987 ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3],
988 ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] );
989 }
990
991 static ULONG format_qname( const WS_XML_STRING *prefix, const WS_XML_STRING *localname, unsigned char *buf )
992 {
993 ULONG len = 0;
994 if (prefix && prefix->length)
995 {
996 memcpy( buf, prefix->bytes, prefix->length );
997 len += prefix->length;
998 buf[len++] = ':';
999 }
1000 memcpy( buf + len, localname->bytes, localname->length );
1001 return len + localname->length;
1002 }
1003
1004 static ULONG encode_base64( const unsigned char *bin, ULONG len, unsigned char *buf )
1005 {
1006 static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1007 ULONG i = 0, x;
1008
1009 while (len > 0)
1010 {
1011 buf[i++] = base64[(bin[0] & 0xfc) >> 2];
1012 x = (bin[0] & 3) << 4;
1013 if (len == 1)
1014 {
1015 buf[i++] = base64[x];
1016 buf[i++] = '=';
1017 buf[i++] = '=';
1018 break;
1019 }
1020 buf[i++] = base64[x | ((bin[1] & 0xf0) >> 4)];
1021 x = (bin[1] & 0x0f) << 2;
1022 if (len == 2)
1023 {
1024 buf[i++] = base64[x];
1025 buf[i++] = '=';
1026 break;
1027 }
1028 buf[i++] = base64[x | ((bin[2] & 0xc0) >> 6)];
1029 buf[i++] = base64[bin[2] & 0x3f];
1030 bin += 3;
1031 len -= 3;
1032 }
1033 return i;
1034 }
1035
1036 HRESULT text_to_utf8text( const WS_XML_TEXT *text, const WS_XML_UTF8_TEXT *old, ULONG *offset,
1037 WS_XML_UTF8_TEXT **ret )
1038 {
1039 ULONG len_old = old ? old->value.length : 0;
1040 if (offset) *offset = len_old;
1041
1042 switch (text->textType)
1043 {
1044 case WS_XML_TEXT_TYPE_UTF8:
1045 {
1046 const WS_XML_UTF8_TEXT *src = (const WS_XML_UTF8_TEXT *)text;
1047
1048 if (!(*ret = alloc_utf8_text( NULL, len_old + src->value.length ))) return E_OUTOFMEMORY;
1049 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1050 memcpy( (*ret)->value.bytes + len_old, src->value.bytes, src->value.length );
1051 return S_OK;
1052 }
1053 case WS_XML_TEXT_TYPE_UTF16:
1054 {
1055 const WS_XML_UTF16_TEXT *src = (const WS_XML_UTF16_TEXT *)text;
1056 const WCHAR *str = (const WCHAR *)src->bytes;
1057 ULONG len = src->byteCount / sizeof(WCHAR), len_utf8;
1058
1059 if (src->byteCount % sizeof(WCHAR)) return E_INVALIDARG;
1060 len_utf8 = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL );
1061 if (!(*ret = alloc_utf8_text( NULL, len_old + len_utf8 ))) return E_OUTOFMEMORY;
1062 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1063 WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)(*ret)->value.bytes + len_old, len_utf8, NULL, NULL );
1064 return S_OK;
1065 }
1066 case WS_XML_TEXT_TYPE_BASE64:
1067 {
1068 const WS_XML_BASE64_TEXT *base64 = (const WS_XML_BASE64_TEXT *)text;
1069 ULONG len = ((4 * base64->length / 3) + 3) & ~3;
1070
1071 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1072 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1073 (*ret)->value.length = encode_base64( base64->bytes, base64->length, (*ret)->value.bytes + len_old ) + len_old;
1074 return S_OK;
1075 }
1076 case WS_XML_TEXT_TYPE_BOOL:
1077 {
1078 const WS_XML_BOOL_TEXT *bool_text = (const WS_XML_BOOL_TEXT *)text;
1079
1080 if (!(*ret = alloc_utf8_text( NULL, len_old + 5 ))) return E_OUTOFMEMORY;
1081 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1082 (*ret)->value.length = format_bool( &bool_text->value, (*ret)->value.bytes + len_old ) + len_old;
1083 return S_OK;
1084 }
1085 case WS_XML_TEXT_TYPE_INT32:
1086 {
1087 const WS_XML_INT32_TEXT *int32_text = (const WS_XML_INT32_TEXT *)text;
1088 unsigned char buf[12]; /* "-2147483648" */
1089 ULONG len = format_int32( &int32_text->value, buf );
1090
1091 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1092 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1093 memcpy( (*ret)->value.bytes + len_old, buf, len );
1094 return S_OK;
1095 }
1096 case WS_XML_TEXT_TYPE_INT64:
1097 {
1098 const WS_XML_INT64_TEXT *int64_text = (const WS_XML_INT64_TEXT *)text;
1099 unsigned char buf[21]; /* "-9223372036854775808" */
1100 ULONG len = format_int64( &int64_text->value, buf );
1101
1102 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1103 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1104 memcpy( (*ret)->value.bytes + len_old, buf, len );
1105 return S_OK;
1106 }
1107 case WS_XML_TEXT_TYPE_UINT64:
1108 {
1109 const WS_XML_UINT64_TEXT *uint64_text = (const WS_XML_UINT64_TEXT *)text;
1110 unsigned char buf[21]; /* "18446744073709551615" */
1111 ULONG len = format_uint64( &uint64_text->value, buf );
1112
1113 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1114 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1115 memcpy( (*ret)->value.bytes + len_old, buf, len );
1116 return S_OK;
1117 }
1118 case WS_XML_TEXT_TYPE_DOUBLE:
1119 {
1120 const WS_XML_DOUBLE_TEXT *double_text = (const WS_XML_DOUBLE_TEXT *)text;
1121 unsigned char buf[32]; /* "-1.1111111111111111E-308", oversized to address Valgrind limitations */
1122 unsigned short fpword;
1123 ULONG len;
1124
1125 if (!set_fpword( 0x37f, &fpword )) return E_NOTIMPL;
1126 len = format_double( &double_text->value, buf );
1127 restore_fpword( fpword );
1128 if (!len) return E_NOTIMPL;
1129
1130 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1131 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1132 memcpy( (*ret)->value.bytes + len_old, buf, len );
1133 return S_OK;
1134 }
1135 case WS_XML_TEXT_TYPE_GUID:
1136 {
1137 const WS_XML_GUID_TEXT *id = (const WS_XML_GUID_TEXT *)text;
1138
1139 if (!(*ret = alloc_utf8_text( NULL, len_old + 37 ))) return E_OUTOFMEMORY;
1140 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1141 (*ret)->value.length = format_guid( &id->value, (*ret)->value.bytes + len_old ) + len_old;
1142 return S_OK;
1143 }
1144 case WS_XML_TEXT_TYPE_UNIQUE_ID:
1145 {
1146 const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text;
1147
1148 if (!(*ret = alloc_utf8_text( NULL, len_old + 46 ))) return E_OUTOFMEMORY;
1149 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1150 (*ret)->value.length = format_urn( &id->value, (*ret)->value.bytes + len_old ) + len_old;
1151 return S_OK;
1152 }
1153 case WS_XML_TEXT_TYPE_DATETIME:
1154 {
1155 const WS_XML_DATETIME_TEXT *dt = (const WS_XML_DATETIME_TEXT *)text;
1156
1157 if (!(*ret = alloc_utf8_text( NULL, len_old + 34 ))) return E_OUTOFMEMORY;
1158 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1159 (*ret)->value.length = format_datetime( &dt->value, (*ret)->value.bytes + len_old ) + len_old;
1160 return S_OK;
1161 }
1162 case WS_XML_TEXT_TYPE_QNAME:
1163 {
1164 const WS_XML_QNAME_TEXT *qn = (const WS_XML_QNAME_TEXT *)text;
1165 ULONG len = qn->localName->length;
1166
1167 if (qn->prefix && qn->prefix->length) len += qn->prefix->length + 1;
1168 if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
1169 if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old );
1170 (*ret)->value.length = format_qname( qn->prefix, qn->localName, (*ret)->value.bytes + len_old ) + len_old;
1171 return S_OK;
1172 }
1173 default:
1174 FIXME( "unhandled text type %u\n", text->textType );
1175 return E_NOTIMPL;
1176 }
1177 }
1178
1179 static HRESULT write_attribute_value_bin( struct writer *writer, const WS_XML_TEXT *text )
1180 {
1181 enum record_type type;
1182 BOOL use_dict = FALSE;
1183 HRESULT hr;
1184 ULONG id;
1185
1186 if (text && text->textType == WS_XML_TEXT_TYPE_UTF8)
1187 {
1188 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
1189 use_dict = get_string_id( writer, &utf8->value, &id );
1190 }
1191 type = get_attr_text_record_type( text, use_dict );
1192
1193 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1194 write_char( writer, type );
1195
1196 switch (type)
1197 {
1198 case RECORD_CHARS8_TEXT:
1199 {
1200 const WS_XML_UTF8_TEXT *text_utf8;
1201 WS_XML_UTF8_TEXT *new = NULL;
1202 UINT8 len;
1203
1204 if (!text)
1205 {
1206 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1207 write_char( writer, 0 );
1208 return S_OK;
1209 }
1210 if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text;
1211 else
1212 {
1213 if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr;
1214 text_utf8 = new;
1215 }
1216 len = text_utf8->value.length;
1217 if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK)
1218 {
1219 heap_free( new );
1220 return hr;
1221 }
1222 write_char( writer, len );
1223 write_bytes( writer, text_utf8->value.bytes, len );
1224 heap_free( new );
1225 return S_OK;
1226 }
1227 case RECORD_CHARS16_TEXT:
1228 {
1229 const WS_XML_UTF8_TEXT *text_utf8;
1230 WS_XML_UTF8_TEXT *new = NULL;
1231 UINT16 len;
1232
1233 if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text;
1234 else
1235 {
1236 if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr;
1237 text_utf8 = new;
1238 }
1239 len = text_utf8->value.length;
1240 if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK)
1241 {
1242 heap_free( new );
1243 return hr;
1244 }
1245 write_bytes( writer, (const BYTE *)&len, sizeof(len) );
1246 write_bytes( writer, text_utf8->value.bytes, len );
1247 heap_free( new );
1248 return S_OK;
1249 }
1250 case RECORD_BYTES8_TEXT:
1251 {
1252 WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text;
1253 if ((hr = write_grow_buffer( writer, 1 + text_base64->length )) != S_OK) return hr;
1254 write_char( writer, text_base64->length );
1255 write_bytes( writer, text_base64->bytes, text_base64->length );
1256 return S_OK;
1257 }
1258 case RECORD_BYTES16_TEXT:
1259 {
1260 WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text;
1261 UINT16 len = text_base64->length;
1262 if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) return hr;
1263 write_bytes( writer, (const BYTE *)&len, sizeof(len) );
1264 write_bytes( writer, text_base64->bytes, len );
1265 return S_OK;
1266 }
1267 case RECORD_ZERO_TEXT:
1268 case RECORD_ONE_TEXT:
1269 case RECORD_FALSE_TEXT:
1270 case RECORD_TRUE_TEXT:
1271 return S_OK;
1272
1273 case RECORD_INT8_TEXT:
1274 {
1275 INT8 val = get_text_value_int( text );
1276 if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr;
1277 write_char( writer, val );
1278 return S_OK;
1279 }
1280 case RECORD_INT16_TEXT:
1281 {
1282 INT16 val = get_text_value_int( text );
1283 if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr;
1284 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
1285 return S_OK;
1286 }
1287 case RECORD_INT32_TEXT:
1288 {
1289 INT32 val = get_text_value_int( text );
1290 if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr;
1291 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
1292 return S_OK;
1293 }
1294 case RECORD_INT64_TEXT:
1295 {
1296 INT64 val = get_text_value_int( text );
1297 if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr;
1298 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
1299 return S_OK;
1300 }
1301 case RECORD_UINT64_TEXT:
1302 {
1303 WS_XML_UINT64_TEXT *text_uint64 = (WS_XML_UINT64_TEXT *)text;
1304 if ((hr = write_grow_buffer( writer, sizeof(text_uint64->value) )) != S_OK) return hr;
1305 write_bytes( writer, (const BYTE *)&text_uint64->value, sizeof(text_uint64->value) );
1306 return S_OK;
1307 }
1308 case RECORD_DOUBLE_TEXT:
1309 {
1310 WS_XML_DOUBLE_TEXT *text_double = (WS_XML_DOUBLE_TEXT *)text;
1311 if ((hr = write_grow_buffer( writer, sizeof(text_double->value) )) != S_OK) return hr;
1312 write_bytes( writer, (const BYTE *)&text_double->value, sizeof(text_double->value) );
1313 return S_OK;
1314 }
1315 case RECORD_GUID_TEXT:
1316 {
1317 WS_XML_GUID_TEXT *text_guid = (WS_XML_GUID_TEXT *)text;
1318 if ((hr = write_grow_buffer( writer, sizeof(text_guid->value) )) != S_OK) return hr;
1319 write_bytes( writer, (const BYTE *)&text_guid->value, sizeof(text_guid->value) );
1320 return S_OK;
1321 }
1322 case RECORD_UNIQUE_ID_TEXT:
1323 {
1324 WS_XML_UNIQUE_ID_TEXT *text_unique_id = (WS_XML_UNIQUE_ID_TEXT *)text;
1325 if ((hr = write_grow_buffer( writer, sizeof(text_unique_id->value) )) != S_OK) return hr;
1326 write_bytes( writer, (const BYTE *)&text_unique_id->value, sizeof(text_unique_id->value) );
1327 return S_OK;
1328 }
1329 case RECORD_DATETIME_TEXT:
1330 {
1331 WS_XML_DATETIME_TEXT *text_datetime = (WS_XML_DATETIME_TEXT *)text;
1332 UINT64 val = text_datetime->value.ticks;
1333
1334 assert( val <= TICKS_MAX );
1335 if (text_datetime->value.format == WS_DATETIME_FORMAT_UTC) val |= (UINT64)1 << 62;
1336 else if (text_datetime->value.format == WS_DATETIME_FORMAT_LOCAL) val |= (UINT64)1 << 63;
1337
1338 if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr;
1339 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
1340 return S_OK;
1341 }
1342 default:
1343 FIXME( "unhandled record type %02x\n", type );
1344 return E_NOTIMPL;
1345 }
1346 }
1347
1348 static enum record_type get_attr_record_type( const WS_XML_ATTRIBUTE *attr, BOOL use_dict )
1349 {
1350 if (!attr->prefix || !attr->prefix->length)
1351 {
1352 if (use_dict) return RECORD_SHORT_DICTIONARY_ATTRIBUTE;
1353 return RECORD_SHORT_ATTRIBUTE;
1354 }
1355 if (attr->prefix->length == 1 && attr->prefix->bytes[0] >= 'a' && attr->prefix->bytes[0] <= 'z')
1356 {
1357 if (use_dict) return RECORD_PREFIX_DICTIONARY_ATTRIBUTE_A + attr->prefix->bytes[0] - 'a';
1358 return RECORD_PREFIX_ATTRIBUTE_A + attr->prefix->bytes[0] - 'a';
1359 }
1360 if (use_dict) return RECORD_DICTIONARY_ATTRIBUTE;
1361 return RECORD_ATTRIBUTE;
1362 };
1363
1364 static HRESULT write_attribute_bin( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
1365 {
1366 ULONG id;
1367 enum record_type type = get_attr_record_type( attr, get_string_id(writer, attr->localName, &id) );
1368 HRESULT hr;
1369
1370 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1371 write_char( writer, type );
1372
1373 if (type >= RECORD_PREFIX_ATTRIBUTE_A && type <= RECORD_PREFIX_ATTRIBUTE_Z)
1374 {
1375 if ((hr = write_string( writer, attr->localName->bytes, attr->localName->length )) != S_OK) return hr;
1376 return write_attribute_value_bin( writer, attr->value );
1377 }
1378 if (type >= RECORD_PREFIX_DICTIONARY_ATTRIBUTE_A && type <= RECORD_PREFIX_DICTIONARY_ATTRIBUTE_Z)
1379 {
1380 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1381 return write_attribute_value_bin( writer, attr->value );
1382 }
1383
1384 switch (type)
1385 {
1386 case RECORD_SHORT_ATTRIBUTE:
1387 if ((hr = write_string( writer, attr->localName->bytes, attr->localName->length )) != S_OK) return hr;
1388 break;
1389
1390 case RECORD_ATTRIBUTE:
1391 if ((hr = write_string( writer, attr->prefix->bytes, attr->prefix->length )) != S_OK) return hr;
1392 if ((hr = write_string( writer, attr->localName->bytes, attr->localName->length )) != S_OK) return hr;
1393 break;
1394
1395 case RECORD_SHORT_DICTIONARY_ATTRIBUTE:
1396 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1397 break;
1398
1399 case RECORD_DICTIONARY_ATTRIBUTE:
1400 if ((hr = write_string( writer, attr->prefix->bytes, attr->prefix->length )) != S_OK) return hr;
1401 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1402 break;
1403
1404 default:
1405 ERR( "unhandled record type %02x\n", type );
1406 return WS_E_NOT_SUPPORTED;
1407 }
1408
1409 return write_attribute_value_bin( writer, attr->value );
1410 }
1411
1412 static HRESULT write_attribute( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
1413 {
1414 switch (writer->output_enc)
1415 {
1416 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_attribute_text( writer, attr );
1417 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_attribute_bin( writer, attr );
1418 default:
1419 ERR( "unhandled encoding %u\n", writer->output_enc );
1420 return WS_E_NOT_SUPPORTED;
1421 }
1422 }
1423
1424 static inline BOOL is_current_namespace( struct writer *writer, const WS_XML_STRING *ns )
1425 {
1426 return (WsXmlStringEquals( writer->current_ns, ns, NULL ) == S_OK);
1427 }
1428
1429 /**************************************************************************
1430 * WsGetPrefixFromNamespace [webservices.@]
1431 */
1432 HRESULT WINAPI WsGetPrefixFromNamespace( WS_XML_WRITER *handle, const WS_XML_STRING *ns,
1433 BOOL required, const WS_XML_STRING **prefix,
1434 WS_ERROR *error )
1435 {
1436 struct writer *writer = (struct writer *)handle;
1437 WS_XML_ELEMENT_NODE *elem;
1438 BOOL found = FALSE;
1439 HRESULT hr = S_OK;
1440
1441 TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(ns), required, prefix, error );
1442 if (error) FIXME( "ignoring error parameter\n" );
1443
1444 if (!writer || !ns || !prefix) return E_INVALIDARG;
1445
1446 EnterCriticalSection( &writer->cs );
1447
1448 if (writer->magic != WRITER_MAGIC)
1449 {
1450 LeaveCriticalSection( &writer->cs );
1451 return E_INVALIDARG;
1452 }
1453
1454 elem = &writer->current->hdr;
1455 if (elem->prefix && is_current_namespace( writer, ns ))
1456 {
1457 *prefix = elem->prefix;
1458 found = TRUE;
1459 }
1460
1461 if (!found)
1462 {
1463 if (required) hr = WS_E_INVALID_FORMAT;
1464 else
1465 {
1466 *prefix = NULL;
1467 hr = S_FALSE;
1468 }
1469 }
1470
1471 LeaveCriticalSection( &writer->cs );
1472 return hr;
1473 }
1474
1475 static HRESULT write_namespace_attribute_text( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
1476 {
1477 unsigned char quote = attr->singleQuote ? '\'' : '"';
1478 ULONG size;
1479 HRESULT hr;
1480
1481 /* ' xmlns:prefix="namespace"' */
1482
1483 size = attr->ns->length + 9 /* ' xmlns=""' */;
1484 if (attr->prefix && attr->prefix->length) size += attr->prefix->length + 1 /* ':' */;
1485 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
1486
1487 write_bytes( writer, (const BYTE *)" xmlns", 6 );
1488 if (attr->prefix && attr->prefix->length)
1489 {
1490 write_char( writer, ':' );
1491 write_bytes( writer, attr->prefix->bytes, attr->prefix->length );
1492 }
1493 write_char( writer, '=' );
1494 write_char( writer, quote );
1495 write_bytes( writer, attr->ns->bytes, attr->ns->length );
1496 write_char( writer, quote );
1497
1498 return S_OK;
1499 }
1500
1501 static enum record_type get_xmlns_record_type( const WS_XML_ATTRIBUTE *attr, BOOL use_dict )
1502 {
1503 if (!attr->prefix || !attr->prefix->length)
1504 {
1505 if (use_dict) return RECORD_SHORT_DICTIONARY_XMLNS_ATTRIBUTE;
1506 return RECORD_SHORT_XMLNS_ATTRIBUTE;
1507 }
1508 if (use_dict) return RECORD_DICTIONARY_XMLNS_ATTRIBUTE;
1509 return RECORD_XMLNS_ATTRIBUTE;
1510 };
1511
1512 static HRESULT write_namespace_attribute_bin( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
1513 {
1514 ULONG id;
1515 enum record_type type = get_xmlns_record_type( attr, get_string_id(writer, attr->ns, &id) );
1516 HRESULT hr;
1517
1518 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1519 write_char( writer, type );
1520
1521 switch (type)
1522 {
1523 case RECORD_SHORT_XMLNS_ATTRIBUTE:
1524 break;
1525
1526 case RECORD_XMLNS_ATTRIBUTE:
1527 if ((hr = write_string( writer, attr->prefix->bytes, attr->prefix->length )) != S_OK) return hr;
1528 break;
1529
1530 case RECORD_SHORT_DICTIONARY_XMLNS_ATTRIBUTE:
1531 return write_dict_string( writer, id );
1532
1533 case RECORD_DICTIONARY_XMLNS_ATTRIBUTE:
1534 if ((hr = write_string( writer, attr->prefix->bytes, attr->prefix->length )) != S_OK) return hr;
1535 return write_dict_string( writer, id );
1536
1537 default:
1538 ERR( "unhandled record type %02x\n", type );
1539 return WS_E_NOT_SUPPORTED;
1540 }
1541
1542 return write_string( writer, attr->ns->bytes, attr->ns->length );
1543 }
1544
1545 static HRESULT write_namespace_attribute( struct writer *writer, const WS_XML_ATTRIBUTE *attr )
1546 {
1547 switch (writer->output_enc)
1548 {
1549 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_namespace_attribute_text( writer, attr );
1550 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_namespace_attribute_bin( writer, attr );
1551 default:
1552 ERR( "unhandled encoding %u\n", writer->output_enc );
1553 return WS_E_NOT_SUPPORTED;
1554 }
1555 }
1556
1557 static HRESULT add_namespace_attribute( struct writer *writer, const WS_XML_STRING *prefix,
1558 const WS_XML_STRING *ns, BOOL single )
1559 {
1560 WS_XML_ATTRIBUTE *attr;
1561 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1562 HRESULT hr;
1563
1564 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1565
1566 attr->singleQuote = !!single;
1567 attr->isXmlNs = 1;
1568 if (prefix && !(attr->prefix = dup_xml_string( prefix, writer->dict_do_lookup )))
1569 {
1570 free_attribute( attr );
1571 return E_OUTOFMEMORY;
1572 }
1573 if (!(attr->ns = dup_xml_string( ns, writer->dict_do_lookup )))
1574 {
1575 free_attribute( attr );
1576 return E_OUTOFMEMORY;
1577 }
1578 if ((hr = append_attribute( elem, attr )) != S_OK)
1579 {
1580 free_attribute( attr );
1581 return hr;
1582 }
1583 return S_OK;
1584 }
1585
1586 static inline BOOL str_equal( const WS_XML_STRING *str1, const WS_XML_STRING *str2 )
1587 {
1588 if (!str1 && !str2) return TRUE;
1589 return WsXmlStringEquals( str1, str2, NULL ) == S_OK;
1590 }
1591
1592 static BOOL namespace_in_scope( const WS_XML_ELEMENT_NODE *elem, const WS_XML_STRING *prefix,
1593 const WS_XML_STRING *ns )
1594 {
1595 ULONG i;
1596 const struct node *node;
1597
1598 for (node = (const struct node *)elem; node; node = node->parent)
1599 {
1600 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) break;
1601
1602 elem = &node->hdr;
1603 for (i = 0; i < elem->attributeCount; i++)
1604 {
1605 if (!elem->attributes[i]->isXmlNs) continue;
1606 if (str_equal( elem->attributes[i]->prefix, prefix ) &&
1607 str_equal( elem->attributes[i]->ns, ns )) return TRUE;
1608 }
1609 }
1610 return FALSE;
1611 }
1612
1613 static HRESULT set_current_namespace( struct writer *writer, const WS_XML_STRING *ns )
1614 {
1615 WS_XML_STRING *str;
1616 if (!(str = dup_xml_string( ns, writer->dict_do_lookup ))) return E_OUTOFMEMORY;
1617 free_xml_string( writer->current_ns );
1618 writer->current_ns = str;
1619 return S_OK;
1620 }
1621
1622 static HRESULT set_namespaces( struct writer *writer )
1623 {
1624 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1625 HRESULT hr;
1626 ULONG i;
1627
1628 if (elem->ns->length && !namespace_in_scope( elem, elem->prefix, elem->ns ))
1629 {
1630 if ((hr = add_namespace_attribute( writer, elem->prefix, elem->ns, FALSE )) != S_OK) return hr;
1631 if ((hr = set_current_namespace( writer, elem->ns )) != S_OK) return hr;
1632 }
1633
1634 for (i = 0; i < elem->attributeCount; i++)
1635 {
1636 const WS_XML_ATTRIBUTE *attr = elem->attributes[i];
1637 if (!attr->ns->length || namespace_in_scope( elem, attr->prefix, attr->ns )) continue;
1638 if ((hr = add_namespace_attribute( writer, attr->prefix, attr->ns, FALSE )) != S_OK) return hr;
1639 }
1640
1641 return S_OK;
1642 }
1643
1644 /**************************************************************************
1645 * WsWriteEndAttribute [webservices.@]
1646 */
1647 HRESULT WINAPI WsWriteEndAttribute( WS_XML_WRITER *handle, WS_ERROR *error )
1648 {
1649 struct writer *writer = (struct writer *)handle;
1650
1651 TRACE( "%p %p\n", handle, error );
1652 if (error) FIXME( "ignoring error parameter\n" );
1653
1654 if (!writer) return E_INVALIDARG;
1655
1656 EnterCriticalSection( &writer->cs );
1657
1658 if (writer->magic != WRITER_MAGIC)
1659 {
1660 LeaveCriticalSection( &writer->cs );
1661 return E_INVALIDARG;
1662 }
1663
1664 writer->state = WRITER_STATE_STARTELEMENT;
1665
1666 LeaveCriticalSection( &writer->cs );
1667 return S_OK;
1668 }
1669
1670 static HRESULT write_attributes( struct writer *writer, const WS_XML_ELEMENT_NODE *elem )
1671 {
1672 ULONG i;
1673 HRESULT hr;
1674 for (i = 0; i < elem->attributeCount; i++)
1675 {
1676 if (elem->attributes[i]->isXmlNs) continue;
1677 if ((hr = write_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
1678 }
1679 for (i = 0; i < elem->attributeCount; i++)
1680 {
1681 if (!elem->attributes[i]->isXmlNs || !elem->attributes[i]->prefix) continue;
1682 if ((hr = write_namespace_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
1683 }
1684 for (i = 0; i < elem->attributeCount; i++)
1685 {
1686 if (!elem->attributes[i]->isXmlNs || elem->attributes[i]->prefix) continue;
1687 if ((hr = write_namespace_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
1688 }
1689 return S_OK;
1690 }
1691
1692 static HRESULT write_startelement_text( struct writer *writer )
1693 {
1694 const WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1695 ULONG size;
1696 HRESULT hr;
1697
1698 /* '<prefix:localname prefix:attr="value"... xmlns:prefix="ns"'... */
1699
1700 size = elem->localName->length + 1 /* '<' */;
1701 if (elem->prefix && elem->prefix->length) size += elem->prefix->length + 1 /* ':' */;
1702 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
1703
1704 write_char( writer, '<' );
1705 if (elem->prefix && elem->prefix->length)
1706 {
1707 write_bytes( writer, elem->prefix->bytes, elem->prefix->length );
1708 write_char( writer, ':' );
1709 }
1710 write_bytes( writer, elem->localName->bytes, elem->localName->length );
1711 return write_attributes( writer, elem );
1712 }
1713
1714 static enum record_type get_elem_record_type( const WS_XML_ELEMENT_NODE *elem, BOOL use_dict )
1715 {
1716 if (!elem->prefix || !elem->prefix->length)
1717 {
1718 if (use_dict) return RECORD_SHORT_DICTIONARY_ELEMENT;
1719 return RECORD_SHORT_ELEMENT;
1720 }
1721 if (elem->prefix->length == 1 && elem->prefix->bytes[0] >= 'a' && elem->prefix->bytes[0] <= 'z')
1722 {
1723 if (use_dict) return RECORD_PREFIX_DICTIONARY_ELEMENT_A + elem->prefix->bytes[0] - 'a';
1724 return RECORD_PREFIX_ELEMENT_A + elem->prefix->bytes[0] - 'a';
1725 }
1726 if (use_dict) return RECORD_DICTIONARY_ELEMENT;
1727 return RECORD_ELEMENT;
1728 };
1729
1730 static HRESULT write_startelement_bin( struct writer *writer )
1731 {
1732 const WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1733 ULONG id;
1734 enum record_type type = get_elem_record_type( elem, get_string_id(writer, elem->localName, &id) );
1735 HRESULT hr;
1736
1737 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1738 write_char( writer, type );
1739
1740 if (type >= RECORD_PREFIX_ELEMENT_A && type <= RECORD_PREFIX_ELEMENT_Z)
1741 {
1742 if ((hr = write_string( writer, elem->localName->bytes, elem->localName->length )) != S_OK) return hr;
1743 return write_attributes( writer, elem );
1744 }
1745 if (type >= RECORD_PREFIX_DICTIONARY_ELEMENT_A && type <= RECORD_PREFIX_DICTIONARY_ELEMENT_Z)
1746 {
1747 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1748 return write_attributes( writer, elem );
1749 }
1750
1751 switch (type)
1752 {
1753 case RECORD_SHORT_ELEMENT:
1754 if ((hr = write_string( writer, elem->localName->bytes, elem->localName->length )) != S_OK) return hr;
1755 break;
1756
1757 case RECORD_ELEMENT:
1758 if ((hr = write_string( writer, elem->prefix->bytes, elem->prefix->length )) != S_OK) return hr;
1759 if ((hr = write_string( writer, elem->localName->bytes, elem->localName->length )) != S_OK) return hr;
1760 break;
1761
1762 case RECORD_SHORT_DICTIONARY_ELEMENT:
1763 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1764 break;
1765
1766 case RECORD_DICTIONARY_ELEMENT:
1767 if ((hr = write_string( writer, elem->prefix->bytes, elem->prefix->length )) != S_OK) return hr;
1768 if ((hr = write_dict_string( writer, id )) != S_OK) return hr;
1769 break;
1770
1771 default:
1772 ERR( "unhandled record type %02x\n", type );
1773 return WS_E_NOT_SUPPORTED;
1774 }
1775
1776 return write_attributes( writer, elem );
1777 }
1778
1779 static HRESULT write_startelement( struct writer *writer )
1780 {
1781 switch (writer->output_enc)
1782 {
1783 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_startelement_text( writer );
1784 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_startelement_bin( writer );
1785 default:
1786 ERR( "unhandled encoding %u\n", writer->output_enc );
1787 return WS_E_NOT_SUPPORTED;
1788 }
1789 }
1790
1791 static struct node *write_find_startelement( struct writer *writer )
1792 {
1793 struct node *node;
1794 for (node = writer->current; node; node = node->parent)
1795 {
1796 if (node_type( node ) == WS_XML_NODE_TYPE_ELEMENT) return node;
1797 }
1798 return NULL;
1799 }
1800
1801 static inline BOOL is_empty_element( const struct node *node )
1802 {
1803 const struct node *head = LIST_ENTRY( list_head( &node->children ), struct node, entry );
1804 return node_type( head ) == WS_XML_NODE_TYPE_END_ELEMENT;
1805 }
1806
1807 static HRESULT write_endelement_text( struct writer *writer, const WS_XML_ELEMENT_NODE *elem )
1808 {
1809 ULONG size;
1810 HRESULT hr;
1811
1812 /* '/>' */
1813
1814 if (elem->isEmpty && writer->state != WRITER_STATE_ENDSTARTELEMENT)
1815 {
1816 if ((hr = write_grow_buffer( writer, 2 )) != S_OK) return hr;
1817 write_char( writer, '/' );
1818 write_char( writer, '>' );
1819 return S_OK;
1820 }
1821
1822 /* '</prefix:localname>' */
1823
1824 size = elem->localName->length + 3 /* '</>' */;
1825 if (elem->prefix && elem->prefix->length) size += elem->prefix->length + 1 /* ':' */;
1826 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
1827
1828 write_char( writer, '<' );
1829 write_char( writer, '/' );
1830 if (elem->prefix && elem->prefix->length)
1831 {
1832 write_bytes( writer, elem->prefix->bytes, elem->prefix->length );
1833 write_char( writer, ':' );
1834 }
1835 write_bytes( writer, elem->localName->bytes, elem->localName->length );
1836 write_char( writer, '>' );
1837 return S_OK;
1838 }
1839
1840 static HRESULT write_endelement_bin( struct writer *writer )
1841 {
1842 HRESULT hr;
1843 if (node_type( writer->current ) == WS_XML_NODE_TYPE_TEXT) return S_OK;
1844 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1845 write_char( writer, RECORD_ENDELEMENT );
1846 return S_OK;
1847 }
1848
1849 static HRESULT write_endelement( struct writer *writer, const WS_XML_ELEMENT_NODE *elem )
1850 {
1851 switch (writer->output_enc)
1852 {
1853 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_endelement_text( writer, elem );
1854 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_endelement_bin( writer );
1855 default:
1856 ERR( "unhandled encoding %u\n", writer->output_enc );
1857 return WS_E_NOT_SUPPORTED;
1858 }
1859 }
1860
1861 static HRESULT write_close_element( struct writer *writer, struct node *node )
1862 {
1863 WS_XML_ELEMENT_NODE *elem = &node->hdr;
1864 elem->isEmpty = is_empty_element( node );
1865 return write_endelement( writer, elem );
1866 }
1867
1868 static HRESULT write_endelement_node( struct writer *writer )
1869 {
1870 struct node *node;
1871 HRESULT hr;
1872
1873 if (!(node = write_find_startelement( writer ))) return WS_E_INVALID_FORMAT;
1874 if (writer->state == WRITER_STATE_STARTELEMENT)
1875 {
1876 if ((hr = set_namespaces( writer )) != S_OK) return hr;
1877 if ((hr = write_startelement( writer )) != S_OK) return hr;
1878 }
1879 if ((hr = write_close_element( writer, node )) != S_OK) return hr;
1880 writer->current = node->parent;
1881 writer->state = WRITER_STATE_ENDELEMENT;
1882 return S_OK;
1883 }
1884
1885 /**************************************************************************
1886 * WsWriteEndElement [webservices.@]
1887 */
1888 HRESULT WINAPI WsWriteEndElement( WS_XML_WRITER *handle, WS_ERROR *error )
1889 {
1890 struct writer *writer = (struct writer *)handle;
1891 HRESULT hr;
1892
1893 TRACE( "%p %p\n", handle, error );
1894 if (error) FIXME( "ignoring error parameter\n" );
1895
1896 if (!writer) return E_INVALIDARG;
1897
1898 EnterCriticalSection( &writer->cs );
1899
1900 if (writer->magic != WRITER_MAGIC)
1901 {
1902 LeaveCriticalSection( &writer->cs );
1903 return E_INVALIDARG;
1904 }
1905
1906 hr = write_endelement_node( writer );
1907
1908 LeaveCriticalSection( &writer->cs );
1909 return hr;
1910 }
1911
1912 static HRESULT write_endstartelement_text( struct writer *writer )
1913 {
1914 HRESULT hr;
1915 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
1916 write_char( writer, '>' );
1917 return S_OK;
1918 }
1919
1920 static HRESULT write_endstartelement( struct writer *writer )
1921 {
1922 switch (writer->output_enc)
1923 {
1924 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_endstartelement_text( writer );
1925 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return S_OK;
1926 default:
1927 ERR( "unhandled encoding %u\n", writer->output_enc );
1928 return WS_E_NOT_SUPPORTED;
1929 }
1930 }
1931
1932 /**************************************************************************
1933 * WsWriteEndStartElement [webservices.@]
1934 */
1935 HRESULT WINAPI WsWriteEndStartElement( WS_XML_WRITER *handle, WS_ERROR *error )
1936 {
1937 struct writer *writer = (struct writer *)handle;
1938 HRESULT hr;
1939
1940 TRACE( "%p %p\n", handle, error );
1941 if (error) FIXME( "ignoring error parameter\n" );
1942
1943 if (!writer) return E_INVALIDARG;
1944
1945 EnterCriticalSection( &writer->cs );
1946
1947 if (writer->magic != WRITER_MAGIC)
1948 {
1949 LeaveCriticalSection( &writer->cs );
1950 return E_INVALIDARG;
1951 }
1952
1953 if (writer->state != WRITER_STATE_STARTELEMENT)
1954 {
1955 LeaveCriticalSection( &writer->cs );
1956 return WS_E_INVALID_OPERATION;
1957 }
1958
1959 if ((hr = set_namespaces( writer )) != S_OK) goto done;
1960 if ((hr = write_startelement( writer )) != S_OK) goto done;
1961 if ((hr = write_endstartelement( writer )) != S_OK) goto done;
1962 writer->state = WRITER_STATE_ENDSTARTELEMENT;
1963
1964 done:
1965 LeaveCriticalSection( &writer->cs );
1966 return hr;
1967 }
1968
1969 static HRESULT write_add_attribute( struct writer *writer, const WS_XML_STRING *prefix,
1970 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
1971 BOOL single )
1972 {
1973 WS_XML_ATTRIBUTE *attr;
1974 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1975 HRESULT hr;
1976
1977 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
1978
1979 if (!prefix && ns->length) prefix = elem->prefix;
1980
1981 attr->singleQuote = !!single;
1982 if (prefix && !(attr->prefix = dup_xml_string( prefix, writer->dict_do_lookup )))
1983 {
1984 free_attribute( attr );
1985 return E_OUTOFMEMORY;
1986 }
1987 if (!(attr->localName = dup_xml_string( localname, writer->dict_do_lookup )))
1988 {
1989 free_attribute( attr );
1990 return E_OUTOFMEMORY;
1991 }
1992 if (!(attr->ns = dup_xml_string( ns, writer->dict_do_lookup )))
1993 {
1994 free_attribute( attr );
1995 return E_OUTOFMEMORY;
1996 }
1997 if ((hr = append_attribute( elem, attr )) != S_OK)
1998 {
1999 free_attribute( attr );
2000 return hr;
2001 }
2002 return S_OK;
2003 }
2004
2005 /**************************************************************************
2006 * WsWriteStartAttribute [webservices.@]
2007 */
2008 HRESULT WINAPI WsWriteStartAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
2009 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2010 BOOL single, WS_ERROR *error )
2011 {
2012 struct writer *writer = (struct writer *)handle;
2013 HRESULT hr;
2014
2015 TRACE( "%p %s %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname),
2016 debugstr_xmlstr(ns), single, error );
2017 if (error) FIXME( "ignoring error parameter\n" );
2018
2019 if (!writer || !localname || !ns) return E_INVALIDARG;
2020
2021 EnterCriticalSection( &writer->cs );
2022
2023 if (writer->magic != WRITER_MAGIC)
2024 {
2025 LeaveCriticalSection( &writer->cs );
2026 return E_INVALIDARG;
2027 }
2028
2029 if (writer->state != WRITER_STATE_STARTELEMENT)
2030 {
2031 LeaveCriticalSection( &writer->cs );
2032 return WS_E_INVALID_OPERATION;
2033 }
2034
2035 if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) == S_OK)
2036 writer->state = WRITER_STATE_STARTATTRIBUTE;
2037
2038 LeaveCriticalSection( &writer->cs );
2039 return hr;
2040 }
2041
2042 /* flush current start element if necessary */
2043 static HRESULT write_flush( struct writer *writer )
2044 {
2045 if (writer->state == WRITER_STATE_STARTELEMENT)
2046 {
2047 HRESULT hr;
2048 if ((hr = set_namespaces( writer )) != S_OK) return hr;
2049 if ((hr = write_startelement( writer )) != S_OK) return hr;
2050 if ((hr = write_endstartelement( writer )) != S_OK) return hr;
2051 writer->state = WRITER_STATE_ENDSTARTELEMENT;
2052 }
2053 return S_OK;
2054 }
2055
2056 static HRESULT write_add_cdata_node( struct writer *writer )
2057 {
2058 struct node *node, *parent;
2059 if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT;
2060 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
2061 write_insert_node( writer, parent, node );
2062 return S_OK;
2063 }
2064
2065 static HRESULT write_add_endcdata_node( struct writer *writer )
2066 {
2067 struct node *node;
2068 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_CDATA ))) return E_OUTOFMEMORY;
2069 node->parent = writer->current;
2070 list_add_tail( &node->parent->children, &node->entry );
2071 return S_OK;
2072 }
2073
2074 static HRESULT write_cdata( struct writer *writer )
2075 {
2076 HRESULT hr;
2077 if ((hr = write_grow_buffer( writer, 9 )) != S_OK) return hr;
2078 write_bytes( writer, (const BYTE *)"<![CDATA[", 9 );
2079 return S_OK;
2080 }
2081
2082 static HRESULT write_cdata_node( struct writer *writer )
2083 {
2084 HRESULT hr;
2085 if ((hr = write_flush( writer )) != S_OK) return hr;
2086 if ((hr = write_add_cdata_node( writer )) != S_OK) return hr;
2087 if ((hr = write_add_endcdata_node( writer )) != S_OK) return hr;
2088 if ((hr = write_cdata( writer )) != S_OK) return hr;
2089 writer->state = WRITER_STATE_STARTCDATA;
2090 return S_OK;
2091 }
2092
2093 /**************************************************************************
2094 * WsWriteStartCData [webservices.@]
2095 */
2096 HRESULT WINAPI WsWriteStartCData( WS_XML_WRITER *handle, WS_ERROR *error )
2097 {
2098 struct writer *writer = (struct writer *)handle;
2099 HRESULT hr;
2100
2101 TRACE( "%p %p\n", handle, error );
2102 if (error) FIXME( "ignoring error parameter\n" );
2103
2104 if (!writer) return E_INVALIDARG;
2105
2106 EnterCriticalSection( &writer->cs );
2107
2108 if (writer->magic != WRITER_MAGIC)
2109 {
2110 LeaveCriticalSection( &writer->cs );
2111 return E_INVALIDARG;
2112 }
2113
2114 hr = write_cdata_node( writer );
2115
2116 LeaveCriticalSection( &writer->cs );
2117 return hr;
2118 }
2119
2120 static HRESULT write_endcdata( struct writer *writer )
2121 {
2122 HRESULT hr;
2123 if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr;
2124 write_bytes( writer, (const BYTE *)"]]>", 3 );
2125 return S_OK;
2126 }
2127
2128 static HRESULT write_endcdata_node( struct writer *writer )
2129 {
2130 HRESULT hr;
2131 if ((hr = write_endcdata( writer )) != S_OK) return hr;
2132 writer->current = writer->current->parent;
2133 writer->state = WRITER_STATE_ENDCDATA;
2134 return S_OK;
2135 }
2136
2137 /**************************************************************************
2138 * WsWriteEndCData [webservices.@]
2139 */
2140 HRESULT WINAPI WsWriteEndCData( WS_XML_WRITER *handle, WS_ERROR *error )
2141 {
2142 struct writer *writer = (struct writer *)handle;
2143 HRESULT hr;
2144
2145 TRACE( "%p %p\n", handle, error );
2146 if (error) FIXME( "ignoring error parameter\n" );
2147
2148 if (!writer) return E_INVALIDARG;
2149
2150 EnterCriticalSection( &writer->cs );
2151
2152 if (writer->magic != WRITER_MAGIC)
2153 {
2154 LeaveCriticalSection( &writer->cs );
2155 return E_INVALIDARG;
2156 }
2157
2158 if (writer->state != WRITER_STATE_TEXT)
2159 {
2160 LeaveCriticalSection( &writer->cs );
2161 return WS_E_INVALID_OPERATION;
2162 }
2163
2164 hr = write_endcdata_node( writer );
2165
2166 LeaveCriticalSection( &writer->cs );
2167 return hr;
2168 }
2169
2170 static HRESULT write_add_element_node( struct writer *writer, const WS_XML_STRING *prefix,
2171 const WS_XML_STRING *localname, const WS_XML_STRING *ns )
2172 {
2173 struct node *node, *parent;
2174 WS_XML_ELEMENT_NODE *elem;
2175
2176 if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT;
2177
2178 if (!prefix && node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT)
2179 {
2180 elem = &parent->hdr;
2181 if (WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK) prefix = elem->prefix;
2182 }
2183
2184 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return E_OUTOFMEMORY;
2185 elem = &node->hdr;
2186
2187 if (prefix && !(elem->prefix = dup_xml_string( prefix, writer->dict_do_lookup )))
2188 {
2189 free_node( node );
2190 return E_OUTOFMEMORY;
2191 }
2192 if (!(elem->localName = dup_xml_string( localname, writer->dict_do_lookup )))
2193 {
2194 free_node( node );
2195 return E_OUTOFMEMORY;
2196 }
2197 if (!(elem->ns = dup_xml_string( ns, writer->dict_do_lookup )))
2198 {
2199 free_node( node );
2200 return E_OUTOFMEMORY;
2201 }
2202 write_insert_node( writer, parent, node );
2203 return S_OK;
2204 }
2205
2206 static HRESULT write_add_endelement_node( struct writer *writer, struct node *parent )
2207 {
2208 struct node *node;
2209 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY;
2210 node->parent = parent;
2211 list_add_tail( &parent->children, &node->entry );
2212 return S_OK;
2213 }
2214
2215 static HRESULT write_element_node( struct writer *writer, const WS_XML_STRING *prefix,
2216 const WS_XML_STRING *localname, const WS_XML_STRING *ns )
2217 {
2218 HRESULT hr;
2219 if ((hr = write_flush( writer )) != S_OK) return hr;
2220 if ((hr = write_add_element_node( writer, prefix, localname, ns )) != S_OK) return hr;
2221 if ((hr = write_add_endelement_node( writer, writer->current )) != S_OK) return hr;
2222 writer->state = WRITER_STATE_STARTELEMENT;
2223 return S_OK;
2224 }
2225
2226 /**************************************************************************
2227 * WsWriteStartElement [webservices.@]
2228 */
2229 HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
2230 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
2231 WS_ERROR *error )
2232 {
2233 struct writer *writer = (struct writer *)handle;
2234 HRESULT hr;
2235
2236 TRACE( "%p %s %s %s %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname),
2237 debugstr_xmlstr(ns), error );
2238 if (error) FIXME( "ignoring error parameter\n" );
2239
2240 if (!writer || !localname || !ns) return E_INVALIDARG;
2241
2242 EnterCriticalSection( &writer->cs );
2243
2244 if (writer->magic != WRITER_MAGIC)
2245 {
2246 LeaveCriticalSection( &writer->cs );
2247 return E_INVALIDARG;
2248 }
2249
2250 hr = write_element_node( writer, prefix, localname, ns );
2251
2252 LeaveCriticalSection( &writer->cs );
2253 return hr;
2254 }
2255
2256 HRESULT text_to_text( const WS_XML_TEXT *text, const WS_XML_TEXT *old, ULONG *offset, WS_XML_TEXT **ret )
2257 {
2258 if (offset) *offset = 0;
2259 switch (text->textType)
2260 {
2261 case WS_XML_TEXT_TYPE_UTF8:
2262 {
2263 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
2264 const WS_XML_UTF8_TEXT *utf8_old = (const WS_XML_UTF8_TEXT *)old;
2265 WS_XML_UTF8_TEXT *new;
2266 ULONG len = utf8->value.length, len_old = utf8_old ? utf8_old->value.length : 0;
2267
2268 if (!(new = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
2269 if (utf8_old) memcpy( new->value.bytes, utf8_old->value.bytes, len_old );
2270 memcpy( new->value.bytes + len_old, utf8->value.bytes, len );
2271 if (offset) *offset = len_old;
2272 *ret = &new->text;
2273 return S_OK;
2274 }
2275 case WS_XML_TEXT_TYPE_UTF16:
2276 {
2277 const WS_XML_UTF16_TEXT *utf16 = (const WS_XML_UTF16_TEXT *)text;
2278 const WS_XML_UTF16_TEXT *utf16_old = (const WS_XML_UTF16_TEXT *)old;
2279 WS_XML_UTF16_TEXT *new;
2280 ULONG len = utf16->byteCount, len_old = utf16_old ? utf16_old->byteCount : 0;
2281
2282 if (utf16->byteCount % sizeof(WCHAR)) return E_INVALIDARG;
2283 if (!(new = alloc_utf16_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
2284 if (utf16_old) memcpy( new->bytes, utf16_old->bytes, len_old );
2285 memcpy( new->bytes + len_old, utf16->bytes, len );
2286 if (offset) *offset = len_old;
2287 *ret = &new->text;
2288 return S_OK;
2289 }
2290 case WS_XML_TEXT_TYPE_BASE64:
2291 {
2292 const WS_XML_BASE64_TEXT *base64 = (const WS_XML_BASE64_TEXT *)text;
2293 const WS_XML_BASE64_TEXT *base64_old = (const WS_XML_BASE64_TEXT *)old;
2294 WS_XML_BASE64_TEXT *new;
2295 ULONG len = base64->length, len_old = base64_old ? base64_old->length : 0;
2296
2297 if (!(new = alloc_base64_text( NULL, len_old + len ))) return E_OUTOFMEMORY;
2298 if (base64_old) memcpy( new->bytes, base64_old->bytes, len_old );
2299 memcpy( new->bytes + len_old, base64->bytes, len );
2300 if (offset) *offset = len_old;
2301 *ret = &new->text;
2302 return S_OK;
2303 }
2304 case WS_XML_TEXT_TYPE_BOOL:
2305 {
2306 const WS_XML_BOOL_TEXT *bool_text = (const WS_XML_BOOL_TEXT *)text;
2307 WS_XML_BOOL_TEXT *new;
2308
2309 if (!(new = alloc_bool_text( bool_text->value ))) return E_OUTOFMEMORY;
2310 *ret = &new->text;
2311 return S_OK;
2312 }
2313 case WS_XML_TEXT_TYPE_INT32:
2314 {
2315 const WS_XML_INT32_TEXT *int32_text = (const WS_XML_INT32_TEXT *)text;
2316 WS_XML_INT32_TEXT *new;
2317
2318 if (!(new = alloc_int32_text( int32_text->value ))) return E_OUTOFMEMORY;
2319 *ret = &new->text;
2320 return S_OK;
2321 }
2322 case WS_XML_TEXT_TYPE_INT64:
2323 {
2324 const WS_XML_INT64_TEXT *int64_text = (const WS_XML_INT64_TEXT *)text;
2325 WS_XML_INT64_TEXT *new;
2326
2327 if (!(new = alloc_int64_text( int64_text->value ))) return E_OUTOFMEMORY;
2328 *ret = &new->text;
2329 return S_OK;
2330 }
2331 case WS_XML_TEXT_TYPE_UINT64:
2332 {
2333 const WS_XML_UINT64_TEXT *uint64_text = (const WS_XML_UINT64_TEXT *)text;
2334 WS_XML_UINT64_TEXT *new;
2335
2336 if (!(new = alloc_uint64_text( uint64_text->value ))) return E_OUTOFMEMORY;
2337 *ret = &new->text;
2338 return S_OK;
2339 }
2340 case WS_XML_TEXT_TYPE_DOUBLE:
2341 {
2342 const WS_XML_DOUBLE_TEXT *double_text = (const WS_XML_DOUBLE_TEXT *)text;
2343 WS_XML_DOUBLE_TEXT *new;
2344
2345 if (!(new = alloc_double_text( double_text->value ))) return E_OUTOFMEMORY;
2346 *ret = &new->text;
2347 return S_OK;
2348 }
2349 case WS_XML_TEXT_TYPE_GUID:
2350 {
2351 const WS_XML_GUID_TEXT *id = (const WS_XML_GUID_TEXT *)text;
2352 WS_XML_GUID_TEXT *new;
2353
2354 if (!(new = alloc_guid_text( &id->value ))) return E_OUTOFMEMORY;
2355 *ret = &new->text;
2356 return S_OK;
2357 }
2358 case WS_XML_TEXT_TYPE_UNIQUE_ID:
2359 {
2360 const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text;
2361 WS_XML_UNIQUE_ID_TEXT *new;
2362
2363 if (!(new = alloc_unique_id_text( &id->value ))) return E_OUTOFMEMORY;
2364 *ret = &new->text;
2365 return S_OK;
2366 }
2367 case WS_XML_TEXT_TYPE_DATETIME:
2368 {
2369 const WS_XML_DATETIME_TEXT *dt = (const WS_XML_DATETIME_TEXT *)text;
2370 WS_XML_DATETIME_TEXT *new;
2371
2372 if (!(new = alloc_datetime_text( &dt->value ))) return E_OUTOFMEMORY;
2373 *ret = &new->text;
2374 return S_OK;
2375 }
2376 default:
2377 FIXME( "unhandled text type %u\n", text->textType );
2378 return E_NOTIMPL;
2379 }
2380 }
2381
2382 static HRESULT write_set_attribute_value( struct writer *writer, const WS_XML_TEXT *value )
2383 {
2384 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
2385 HRESULT hr;
2386
2387 switch (value->textType)
2388 {
2389 case WS_XML_TEXT_TYPE_UTF8:
2390 case WS_XML_TEXT_TYPE_UTF16:
2391 case WS_XML_TEXT_TYPE_BASE64:
2392 break;
2393
2394 case WS_XML_TEXT_TYPE_BOOL:
2395 case WS_XML_TEXT_TYPE_INT32:
2396 case WS_XML_TEXT_TYPE_INT64:
2397 case WS_XML_TEXT_TYPE_UINT64:
2398 case WS_XML_TEXT_TYPE_DOUBLE:
2399 case WS_XML_TEXT_TYPE_GUID:
2400 case WS_XML_TEXT_TYPE_UNIQUE_ID:
2401 case WS_XML_TEXT_TYPE_DATETIME:
2402 if (elem->attributes[elem->attributeCount - 1]->value) return WS_E_INVALID_OPERATION;
2403 break;
2404
2405 default:
2406 FIXME( "unhandled text type %u\n", value->textType );
2407 return E_NOTIMPL;
2408 }
2409
2410 switch (writer->output_enc)
2411 {
2412 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
2413 {
2414 WS_XML_UTF8_TEXT *new, *old = (WS_XML_UTF8_TEXT *)elem->attributes[elem->attributeCount - 1]->value;
2415 if ((hr = text_to_utf8text( value, old, NULL, &new )) != S_OK) return hr;
2416 heap_free( old );
2417 elem->attributes[elem->attributeCount - 1]->value = &new->text;
2418 break;
2419 }
2420 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
2421 {
2422 WS_XML_TEXT *new, *old = elem->attributes[elem->attributeCount - 1]->value;
2423 if ((hr = text_to_text( value, old, NULL, &new )) != S_OK) return hr;
2424 heap_free( old );
2425 elem->attributes[elem->attributeCount - 1]->value = new;
2426 break;
2427 }
2428 default:
2429 FIXME( "unhandled output encoding %u\n", writer->output_enc );
2430 return E_NOTIMPL;
2431 }
2432
2433 return S_OK;
2434 }
2435
2436 static HRESULT write_add_text_node( struct writer *writer, const WS_XML_TEXT *value )
2437 {
2438 struct node *node;
2439 WS_XML_TEXT_NODE *text;
2440 HRESULT hr;
2441
2442 if (node_type( writer->current ) != WS_XML_NODE_TYPE_ELEMENT &&
2443 node_type( writer->current ) != WS_XML_NODE_TYPE_BOF &&
2444 node_type( writer->current ) != WS_XML_NODE_TYPE_CDATA) return WS_E_INVALID_FORMAT;
2445
2446 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
2447 text = (WS_XML_TEXT_NODE *)node;
2448
2449 switch (writer->output_enc)
2450 {
2451 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
2452 {
2453 WS_XML_UTF8_TEXT *new;
2454 if ((hr = text_to_utf8text( value, NULL, NULL, &new )) != S_OK)
2455 {
2456 heap_free( node );
2457 return hr;
2458 }
2459 text->text = &new->text;
2460 break;
2461 }
2462 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
2463 {
2464 WS_XML_TEXT *new;
2465 if ((hr = text_to_text( value, NULL, NULL, &new )) != S_OK)
2466 {
2467 heap_free( node );
2468 return hr;
2469 }
2470 text->text = new;
2471 break;
2472 }
2473 default:
2474 FIXME( "unhandled output encoding %u\n", writer->output_enc );
2475 heap_free( node );
2476 return E_NOTIMPL;
2477 }
2478
2479 write_insert_node( writer, writer->current, node );
2480 return S_OK;
2481 }
2482
2483 static HRESULT write_text_text( struct writer *writer, const WS_XML_TEXT *text, ULONG offset )
2484 {
2485 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
2486 HRESULT hr;
2487
2488 if (node_type( writer->current->parent ) == WS_XML_NODE_TYPE_ELEMENT)
2489 {
2490 const struct escape *escapes[3] = { &escape_lt, &escape_gt, &escape_amp };
2491 return write_bytes_escape( writer, utf8->value.bytes + offset, utf8->value.length - offset, escapes, 3 );
2492 }
2493 else if (node_type( writer->current->parent ) == WS_XML_NODE_TYPE_CDATA)
2494 {
2495 if ((hr = write_grow_buffer( writer, utf8->value.length - offset )) != S_OK) return hr;
2496 write_bytes( writer, utf8->value.bytes + offset, utf8->value.length - offset );
2497 return S_OK;
2498 }
2499
2500 return WS_E_INVALID_FORMAT;
2501 }
2502
2503 static enum record_type get_text_record_type( const WS_XML_TEXT *text, BOOL use_dict )
2504 {
2505 switch (text->textType)
2506 {
2507 case WS_XML_TEXT_TYPE_UTF8:
2508 {
2509 const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text;
2510 if (use_dict) return RECORD_DICTIONARY_TEXT_WITH_ENDELEMENT;
2511 if (text_utf8->value.length <= MAX_UINT8) return RECORD_CHARS8_TEXT_WITH_ENDELEMENT;
2512 if (text_utf8->value.length <= MAX_UINT16) return RECORD_CHARS16_TEXT_WITH_ENDELEMENT;
2513 return RECORD_CHARS32_TEXT_WITH_ENDELEMENT;
2514 }
2515 case WS_XML_TEXT_TYPE_UTF16:
2516 {
2517 const WS_XML_UTF16_TEXT *text_utf16 = (const WS_XML_UTF16_TEXT *)text;
2518 int len = text_utf16->byteCount / sizeof(WCHAR);
2519 int len_utf8 = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)text_utf16->bytes, len, NULL, 0, NULL, NULL );
2520 if (len_utf8 <= MAX_UINT8) return RECORD_CHARS8_TEXT_WITH_ENDELEMENT;
2521 if (len_utf8 <= MAX_UINT16) return RECORD_CHARS16_TEXT_WITH_ENDELEMENT;
2522 return RECORD_CHARS32_TEXT_WITH_ENDELEMENT;
2523 }
2524 case WS_XML_TEXT_TYPE_BASE64:
2525 {
2526 const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text;
2527 ULONG rem = text_base64->length % 3, len = text_base64->length - rem;
2528 if (len <= MAX_UINT8) return RECORD_BYTES8_TEXT;
2529 if (len <= MAX_UINT16) return RECORD_BYTES16_TEXT;
2530 return RECORD_BYTES32_TEXT;
2531 }
2532 case WS_XML_TEXT_TYPE_BOOL:
2533 {
2534 const WS_XML_BOOL_TEXT *text_bool = (const WS_XML_BOOL_TEXT *)text;
2535 return text_bool->value ? RECORD_TRUE_TEXT_WITH_ENDELEMENT : RECORD_FALSE_TEXT_WITH_ENDELEMENT;
2536 }
2537 case WS_XML_TEXT_TYPE_INT32:
2538 {
2539 const WS_XML_INT32_TEXT *text_int32 = (const WS_XML_INT32_TEXT *)text;
2540 if (!text_int32->value) return RECORD_ZERO_TEXT_WITH_ENDELEMENT;
2541 if (text_int32->value == 1) return RECORD_ONE_TEXT_WITH_ENDELEMENT;
2542 if (text_int32->value >= MIN_INT8 && text_int32->value <= MAX_INT8) return RECORD_INT8_TEXT_WITH_ENDELEMENT;
2543 if (text_int32->value >= MIN_INT16 && text_int32->value <= MAX_INT16) return RECORD_INT16_TEXT_WITH_ENDELEMENT;
2544 return RECORD_INT32_TEXT_WITH_ENDELEMENT;
2545 }
2546 case WS_XML_TEXT_TYPE_INT64:
2547 {
2548 const WS_XML_INT64_TEXT *text_int64 = (const WS_XML_INT64_TEXT *)text;
2549 if (!text_int64->value) return RECORD_ZERO_TEXT_WITH_ENDELEMENT;
2550 if (text_int64->value == 1) return RECORD_ONE_TEXT_WITH_ENDELEMENT;
2551 if (text_int64->value >= MIN_INT8 && text_int64->value <= MAX_INT8) return RECORD_INT8_TEXT_WITH_ENDELEMENT;
2552 if (text_int64->value >= MIN_INT16 && text_int64->value <= MAX_INT16) return RECORD_INT16_TEXT_WITH_ENDELEMENT;
2553 if (text_int64->value >= MIN_INT32 && text_int64->value <= MAX_INT32) return RECORD_INT32_TEXT_WITH_ENDELEMENT;
2554 return RECORD_INT64_TEXT_WITH_ENDELEMENT;
2555 }
2556 case WS_XML_TEXT_TYPE_UINT64:
2557 {
2558 const WS_XML_UINT64_TEXT *text_uint64 = (const WS_XML_UINT64_TEXT *)text;
2559 if (!text_uint64->value) return RECORD_ZERO_TEXT_WITH_ENDELEMENT;
2560 if (text_uint64->value == 1) return RECORD_ONE_TEXT_WITH_ENDELEMENT;
2561 if (text_uint64->value <= MAX_INT8) return RECORD_INT8_TEXT_WITH_ENDELEMENT;
2562 if (text_uint64->value <= MAX_INT16) return RECORD_INT16_TEXT_WITH_ENDELEMENT;
2563 if (text_uint64->value <= MAX_INT32) return RECORD_INT32_TEXT_WITH_ENDELEMENT;
2564 if (text_uint64->value <= MAX_INT64) return RECORD_INT64_TEXT_WITH_ENDELEMENT;
2565 return RECORD_UINT64_TEXT_WITH_ENDELEMENT;
2566 }
2567 case WS_XML_TEXT_TYPE_DOUBLE:
2568 {
2569 const WS_XML_DOUBLE_TEXT *text_double = (const WS_XML_DOUBLE_TEXT *)text;
2570 if (!text_double->value) return RECORD_ZERO_TEXT_WITH_ENDELEMENT;
2571 if (text_double->value == 1) return RECORD_ONE_TEXT_WITH_ENDELEMENT;
2572 if (isinf( text_double->value ) || (INT64)text_double->value != text_double->value)
2573 return RECORD_DOUBLE_TEXT_WITH_ENDELEMENT;
2574 if (text_double->value <= MAX_INT8) return RECORD_INT8_TEXT_WITH_ENDELEMENT;
2575 if (text_double->value <= MAX_INT16) return RECORD_INT16_TEXT_WITH_ENDELEMENT;
2576 if (text_double->value <= MAX_INT32) return RECORD_INT32_TEXT_WITH_ENDELEMENT;
2577 return RECORD_INT64_TEXT_WITH_ENDELEMENT;
2578 }
2579 case WS_XML_TEXT_TYPE_GUID:
2580 return RECORD_GUID_TEXT_WITH_ENDELEMENT;
2581
2582 case WS_XML_TEXT_TYPE_UNIQUE_ID:
2583 return RECORD_UNIQUE_ID_TEXT_WITH_ENDELEMENT;
2584
2585 case WS_XML_TEXT_TYPE_DATETIME:
2586 return RECORD_DATETIME_TEXT_WITH_ENDELEMENT;
2587
2588 default:
2589 FIXME( "unhandled text type %u\n", text->textType );
2590 return 0;
2591 }
2592 }
2593
2594 static HRESULT write_text_bin( struct writer *writer, const WS_XML_TEXT *text, ULONG offset )
2595 {
2596 enum record_type type;
2597 BOOL use_dict = FALSE;
2598 HRESULT hr;
2599 ULONG id;
2600
2601 if (offset)
2602 {
2603 FIXME( "no support for appending text in binary mode\n" );
2604 return E_NOTIMPL;
2605 }
2606
2607 if (text->textType == WS_XML_TEXT_TYPE_UTF8)
2608 {
2609 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text;
2610 use_dict = get_string_id( writer, &utf8->value, &id );
2611 }
2612
2613 switch ((type = get_text_record_type( text, use_dict )))
2614 {
2615 case RECORD_CHARS8_TEXT_WITH_ENDELEMENT:
2616 {
2617 const WS_XML_UTF8_TEXT *text_utf8;
2618 WS_XML_UTF8_TEXT *new = NULL;
2619 UINT8 len;
2620
2621 if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text;
2622 else
2623 {
2624 if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr;
2625 text_utf8 = new;
2626 }
2627 len = text_utf8->value.length;
2628 if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK)
2629 {
2630 heap_free( new );
2631 return hr;
2632 }
2633 write_char( writer, type );
2634 write_char( writer, len );
2635 write_bytes( writer, text_utf8->value.bytes, len );
2636 heap_free( new );
2637 return S_OK;
2638 }
2639 case RECORD_CHARS16_TEXT_WITH_ENDELEMENT:
2640 {
2641 const WS_XML_UTF8_TEXT *text_utf8;
2642 WS_XML_UTF8_TEXT *new = NULL;
2643 UINT16 len;
2644
2645 if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text;
2646 else
2647 {
2648 if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr;
2649 text_utf8 = new;
2650 }
2651 len = text_utf8->value.length;
2652 if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK)
2653 {
2654 heap_free( new );
2655 return hr;
2656 }
2657 write_char( writer, type );
2658 write_bytes( writer, (const BYTE *)&len, sizeof(len) );
2659 write_bytes( writer, text_utf8->value.bytes, len );
2660 heap_free( new );
2661 return S_OK;
2662 }
2663 case RECORD_BYTES8_TEXT:
2664 {
2665 const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text;
2666 UINT8 rem = text_base64->length % 3, len = text_base64->length - rem;
2667
2668 if (len)
2669 {
2670 if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) return hr;
2671 write_char( writer, rem ? RECORD_BYTES8_TEXT : RECORD_BYTES8_TEXT_WITH_ENDELEMENT );
2672 write_char( writer, len );
2673 write_bytes( writer, text_base64->bytes, len );
2674 }
2675 if (rem)
2676 {
2677 if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr;
2678 write_char( writer, RECORD_BYTES8_TEXT_WITH_ENDELEMENT );
2679 write_char( writer, rem );
2680 write_bytes( writer, (const BYTE *)text_base64->bytes + len, rem );
2681 }
2682 return S_OK;
2683 }
2684 case RECORD_BYTES16_TEXT:
2685 {
2686 const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text;
2687 UINT16 rem = text_base64->length % 3, len = text_base64->length - rem;
2688
2689 if (len)
2690 {
2691 if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) return hr;
2692 write_char( writer, rem ? RECORD_BYTES16_TEXT : RECORD_BYTES16_TEXT_WITH_ENDELEMENT );
2693 write_bytes( writer, (const BYTE *)&len, sizeof(len) );
2694 write_bytes( writer, text_base64->bytes, len );
2695 }
2696 if (rem)
2697 {
2698 if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr;
2699 write_char( writer, RECORD_BYTES8_TEXT_WITH_ENDELEMENT );
2700 write_char( writer, rem );
2701 write_bytes( writer, (const BYTE *)text_base64->bytes + len, rem );
2702 }
2703 return S_OK;
2704 }
2705 case RECORD_ZERO_TEXT_WITH_ENDELEMENT:
2706 case RECORD_ONE_TEXT_WITH_ENDELEMENT:
2707 case RECORD_FALSE_TEXT_WITH_ENDELEMENT:
2708 case RECORD_TRUE_TEXT_WITH_ENDELEMENT:
2709 {
2710 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
2711 write_char( writer, type );
2712 return S_OK;
2713 }
2714 case RECORD_INT8_TEXT_WITH_ENDELEMENT:
2715 {
2716 INT8 val = get_text_value_int( text );
2717 if ((hr = write_grow_buffer( writer, 1 + sizeof(val) )) != S_OK) return hr;
2718 write_char( writer, type );
2719 write_char( writer, val );
2720 return S_OK;
2721 }
2722 case RECORD_INT16_TEXT_WITH_ENDELEMENT:
2723 {
2724 INT16 val = get_text_value_int( text );
2725 if ((hr = write_grow_buffer( writer, 1 + sizeof(val) )) != S_OK) return hr;
2726 write_char( writer, type );
2727 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
2728 return S_OK;
2729 }
2730 case RECORD_INT32_TEXT_WITH_ENDELEMENT:
2731 {
2732 INT32 val = get_text_value_int( text );
2733 if ((hr = write_grow_buffer( writer, 1 + sizeof(val) )) != S_OK) return hr;
2734 write_char( writer, type );
2735 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
2736 return S_OK;
2737 }
2738 case RECORD_INT64_TEXT_WITH_ENDELEMENT:
2739 {
2740 INT64 val = get_text_value_int( text );
2741 if ((hr = write_grow_buffer( writer, 1 + sizeof(val) )) != S_OK) return hr;
2742 write_char( writer, type );
2743 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
2744 return S_OK;
2745 }
2746 case RECORD_UINT64_TEXT_WITH_ENDELEMENT:
2747 {
2748 WS_XML_UINT64_TEXT *text_uint64 = (WS_XML_UINT64_TEXT *)text;
2749 if ((hr = write_grow_buffer( writer, 1 + sizeof(text_uint64->value) )) != S_OK) return hr;
2750 write_char( writer, type );
2751 write_bytes( writer, (const BYTE *)&text_uint64->value, sizeof(text_uint64->value) );
2752 return S_OK;
2753 }
2754 case RECORD_DOUBLE_TEXT_WITH_ENDELEMENT:
2755 {
2756 WS_XML_DOUBLE_TEXT *text_double = (WS_XML_DOUBLE_TEXT *)text;
2757 if ((hr = write_grow_buffer( writer, 1 + sizeof(text_double->value) )) != S_OK) return hr;
2758 write_char( writer, type );
2759 write_bytes( writer, (const BYTE *)&text_double->value, sizeof(text_double->value) );
2760 return S_OK;
2761 }
2762 case RECORD_GUID_TEXT_WITH_ENDELEMENT:
2763 {
2764 WS_XML_GUID_TEXT *text_guid = (WS_XML_GUID_TEXT *)text;
2765 if ((hr = write_grow_buffer( writer, 1 + sizeof(text_guid->value) )) != S_OK) return hr;
2766 write_char( writer, type );
2767 write_bytes( writer, (const BYTE *)&text_guid->value, sizeof(text_guid->value) );
2768 return S_OK;
2769 }
2770 case RECORD_UNIQUE_ID_TEXT_WITH_ENDELEMENT:
2771 {
2772 WS_XML_UNIQUE_ID_TEXT *text_unique_id = (WS_XML_UNIQUE_ID_TEXT *)text;
2773 if ((hr = write_grow_buffer( writer, 1 + sizeof(text_unique_id->value) )) != S_OK) return hr;
2774 write_char( writer, type );
2775 write_bytes( writer, (const BYTE *)&text_unique_id->value, sizeof(text_unique_id->value) );
2776 return S_OK;
2777 }
2778 case RECORD_DATETIME_TEXT_WITH_ENDELEMENT:
2779 {
2780 WS_XML_DATETIME_TEXT *text_datetime = (WS_XML_DATETIME_TEXT *)text;
2781 UINT64 val = text_datetime->value.ticks;
2782
2783 assert( val <= TICKS_MAX );
2784 if (text_datetime->value.format == WS_DATETIME_FORMAT_UTC) val |= (UINT64)1 << 62;
2785 else if (text_datetime->value.format == WS_DATETIME_FORMAT_LOCAL) val |= (UINT64)1 << 63;
2786
2787 if ((hr = write_grow_buffer( writer, 1 + sizeof(val) )) != S_OK) return hr;
2788 write_char( writer, type );
2789 write_bytes( writer, (const BYTE *)&val, sizeof(val) );
2790 return S_OK;
2791 }
2792 case RECORD_DICTIONARY_TEXT_WITH_ENDELEMENT:
2793 {
2794 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
2795 write_char( writer, type );
2796 return write_dict_string( writer, id );
2797 }
2798 default:
2799 FIXME( "unhandled record type %02x\n", type );
2800 return E_NOTIMPL;
2801 }
2802 }
2803
2804 static HRESULT write_text( struct writer *writer, const WS_XML_TEXT *text, ULONG offset )
2805 {
2806 if (!writer->current->parent) return WS_E_INVALID_FORMAT;
2807
2808 switch (writer->output_enc)
2809 {
2810 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_text_text( writer, text, offset );
2811 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_text_bin( writer, text, offset );
2812 default:
2813 ERR( "unhandled encoding %u\n", writer->output_enc );
2814 return WS_E_NOT_SUPPORTED;
2815 }
2816 }
2817
2818 static HRESULT write_text_node( struct writer *writer, const WS_XML_TEXT *text )
2819 {
2820 WS_XML_TEXT_NODE *node = (WS_XML_TEXT_NODE *)writer->current;
2821 ULONG offset = 0;
2822 HRESULT hr;
2823
2824 if ((hr = write_flush( writer )) != S_OK) return hr;
2825 if (node_type( writer->current ) != WS_XML_NODE_TYPE_TEXT)
2826 {
2827 if ((hr = write_add_text_node( writer, text )) != S_OK) return hr;
2828 node = (WS_XML_TEXT_NODE *)writer->current;
2829 }
2830 else
2831 {
2832 switch (writer->output_enc)
2833 {
2834 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
2835 {
2836 WS_XML_UTF8_TEXT *new, *old = (WS_XML_UTF8_TEXT *)node->text;
2837 offset = old->value.length;
2838 if ((hr = text_to_utf8text( text, old, &offset, &new )) != S_OK) return hr;
2839 heap_free( old );
2840 node->text = &new->text;
2841 break;
2842 }
2843 case WS_XML_WRITER_ENCODING_TYPE_BINARY:
2844 {
2845 WS_XML_TEXT *new, *old = node->text;
2846 if ((hr = text_to_text( text, old, &offset, &new )) != S_OK) return hr;
2847 heap_free( old );
2848 node->text = new;
2849 break;
2850 }
2851 default:
2852 FIXME( "unhandled output encoding %u\n", writer->output_enc );
2853 return E_NOTIMPL;
2854 }
2855 }
2856
2857 if ((hr = write_text( writer, node->text, offset )) != S_OK) return hr;
2858
2859 writer->state = WRITER_STATE_TEXT;
2860 return S_OK;
2861 }
2862
2863 /**************************************************************************
2864 * WsWriteText [webservices.@]
2865 */
2866 HRESULT WINAPI WsWriteText( WS_XML_WRITER *handle, const WS_XML_TEXT *text, WS_ERROR *error )
2867 {
2868 struct writer *writer = (struct writer *)handle;
2869 HRESULT hr;
2870
2871 TRACE( "%p %p %p\n", handle, text, error );
2872 if (error) FIXME( "ignoring error parameter\n" );
2873
2874 if (!writer || !text) return E_INVALIDARG;
2875
2876 EnterCriticalSection( &writer->cs );
2877
2878 if (writer->magic != WRITER_MAGIC)
2879 {
2880 LeaveCriticalSection( &writer->cs );
2881 return E_INVALIDARG;
2882 }
2883
2884 if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, text );
2885 else hr = write_text_node( writer, text );
2886
2887 LeaveCriticalSection( &writer->cs );
2888 return hr;
2889 }
2890
2891 /**************************************************************************
2892 * WsWriteBytes [webservices.@]
2893 */
2894 HRESULT WINAPI WsWriteBytes( WS_XML_WRITER *handle, const void *bytes, ULONG count, WS_ERROR *error )
2895 {
2896 struct writer *writer = (struct writer *)handle;
2897 WS_XML_BASE64_TEXT base64;
2898 HRESULT hr;
2899
2900 TRACE( "%p %p %u %p\n", handle, bytes, count, error );
2901 if (error) FIXME( "ignoring error parameter\n" );
2902
2903 if (!writer) return E_INVALIDARG;
2904
2905 EnterCriticalSection( &writer->cs );
2906
2907 if (writer->magic != WRITER_MAGIC)
2908 {
2909 LeaveCriticalSection( &writer->cs );
2910 return E_INVALIDARG;
2911 }
2912
2913 if (!writer->output_type)
2914 {
2915 LeaveCriticalSection( &writer->cs );
2916 return WS_E_INVALID_OPERATION;
2917 }
2918
2919 base64.text.textType = WS_XML_TEXT_TYPE_BASE64;
2920 base64.bytes = (BYTE *)bytes;
2921 base64.length = count;
2922
2923 if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &base64.text );
2924 else hr = write_text_node( writer, &base64.text );
2925
2926 LeaveCriticalSection( &writer->cs );
2927 return hr;
2928 }
2929
2930 /**************************************************************************
2931 * WsWriteChars [webservices.@]
2932 */
2933 HRESULT WINAPI WsWriteChars( WS_XML_WRITER *handle, const WCHAR *chars, ULONG count, WS_ERROR *error )
2934 {
2935 struct writer *writer = (struct writer *)handle;
2936 WS_XML_UTF16_TEXT utf16;
2937 HRESULT hr;
2938
2939 TRACE( "%p %s %u %p\n", handle, debugstr_wn(chars, count), count, error );
2940 if (error) FIXME( "ignoring error parameter\n" );
2941
2942 if (!writer) return E_INVALIDARG;
2943
2944 EnterCriticalSection( &writer->cs );
2945
2946 if (writer->magic != WRITER_MAGIC)
2947 {
2948 LeaveCriticalSection( &writer->cs );
2949 return E_INVALIDARG;
2950 }
2951
2952 if (!writer->output_type)
2953 {
2954 LeaveCriticalSection( &writer->cs );
2955 return WS_E_INVALID_OPERATION;
2956 }
2957
2958 utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
2959 utf16.bytes = (BYTE *)chars;
2960 utf16.byteCount = count * sizeof(WCHAR);
2961
2962 if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf16.text );
2963 else hr = write_text_node( writer, &utf16.text );
2964
2965 LeaveCriticalSection( &writer->cs );
2966 return hr;
2967 }
2968
2969 /**************************************************************************
2970 * WsWriteCharsUtf8 [webservices.@]
2971 */
2972 HRESULT WINAPI WsWriteCharsUtf8( WS_XML_WRITER *handle, const BYTE *bytes, ULONG count, WS_ERROR *error )
2973 {
2974 struct writer *writer = (struct writer *)handle;
2975 WS_XML_UTF8_TEXT utf8;
2976 HRESULT hr;
2977
2978 TRACE( "%p %s %u %p\n", handle, debugstr_an((const char *)bytes, count), count, error );
2979 if (error) FIXME( "ignoring error parameter\n" );
2980
2981 if (!writer) return E_INVALIDARG;
2982
2983 EnterCriticalSection( &writer->cs );
2984
2985 if (writer->magic != WRITER_MAGIC)
2986 {
2987 LeaveCriticalSection( &writer->cs );
2988 return E_INVALIDARG;
2989 }
2990
2991 if (!writer->output_type)
2992 {
2993 LeaveCriticalSection( &writer->cs );
2994 return WS_E_INVALID_OPERATION;
2995 }
2996
2997 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
2998 utf8.value.bytes = (BYTE *)bytes;
2999 utf8.value.length = count;
3000
3001 if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf8.text );
3002 else hr = write_text_node( writer, &utf8.text );
3003
3004 LeaveCriticalSection( &writer->cs );
3005 return hr;
3006 }
3007
3008 static HRESULT write_type_text( struct writer *writer, WS_TYPE_MAPPING mapping, const WS_XML_TEXT *text )
3009 {
3010 switch (mapping)
3011 {
3012 case WS_ELEMENT_TYPE_MAPPING:
3013 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
3014 return write_text_node( writer, text );
3015
3016 case WS_ATTRIBUTE_TYPE_MAPPING:
3017 return write_set_attribute_value( writer, text );
3018
3019 case WS_ANY_ELEMENT_TYPE_MAPPING:
3020 switch (writer->state)
3021 {
3022 case WRITER_STATE_STARTATTRIBUTE:
3023 return write_set_attribute_value( writer, text );
3024
3025 case WRITER_STATE_STARTELEMENT:
3026 return write_text_node( writer, text );
3027
3028 default:
3029 FIXME( "writer state %u not handled\n", writer->state );
3030 return E_NOTIMPL;
3031 }
3032
3033 default:
3034 FIXME( "mapping %u not implemented\n", mapping );
3035 return E_NOTIMPL;
3036 }
3037 }
3038
3039 static HRESULT write_add_nil_attribute( struct writer *writer )
3040 {
3041 static const WS_XML_STRING prefix = {1, (BYTE *)"a"};
3042 static const WS_XML_STRING localname = {3, (BYTE *)"nil"};
3043 static const WS_XML_STRING ns = {41, (BYTE *)"http://www.w3.org/2001/XMLSchema-instance"};
3044 static const WS_XML_UTF8_TEXT value = {{WS_XML_TEXT_TYPE_UTF8}, {4, (BYTE *)"true"}};
3045 HRESULT hr;
3046
3047 if ((hr = write_add_attribute( writer, &prefix, &localname, &ns, FALSE )) != S_OK) return hr;
3048 if ((hr = write_set_attribute_value( writer, &value.text )) != S_OK) return hr;
3049 return add_namespace_attribute( writer, &prefix, &ns, FALSE );
3050 }
3051
3052 static HRESULT get_value_ptr( WS_WRITE_OPTION option, const void *value, ULONG size, ULONG expected_size,
3053 const void **ptr )
3054 {
3055 switch (option)
3056 {
3057 case WS_WRITE_REQUIRED_VALUE:
3058 case WS_WRITE_NILLABLE_VALUE:
3059 if (!value || size != expected_size) return E_INVALIDARG;
3060 *ptr = value;
3061 return S_OK;
3062
3063 case WS_WRITE_REQUIRED_POINTER:
3064 if (size != sizeof(const void *) || !(*ptr = *(const void **)value)) return E_INVALIDARG;
3065 return S_OK;
3066
3067 case WS_WRITE_NILLABLE_POINTER:
3068 if (size != sizeof(const void *)) return E_INVALIDARG;
3069 *ptr = *(const void **)value;
3070 return S_OK;
3071
3072 default:
3073 return E_INVALIDARG;
3074 }
3075 }
3076
3077 static HRESULT write_type_bool( struct writer *writer, WS_TYPE_MAPPING mapping,
3078 const WS_BOOL_DESCRIPTION *desc, WS_WRITE_OPTION option,
3079 const BOOL *value, ULONG size )
3080 {
3081 WS_XML_BOOL_TEXT text_bool;
3082 const BOOL *ptr;
3083 HRESULT hr;
3084
3085 if (desc)
3086 {
3087 FIXME( "description not supported\n" );
3088 return E_NOTIMPL;
3089 }
3090
3091 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3092 if ((hr = get_value_ptr( option, value, size, sizeof(BOOL), (const void **)&ptr )) != S_OK) return hr;
3093 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3094
3095 text_bool.text.textType = WS_XML_TEXT_TYPE_BOOL;
3096 text_bool.value = *ptr;
3097 return write_type_text( writer, mapping, &text_bool.text );
3098 }
3099
3100 static HRESULT write_type_int8( struct writer *writer, WS_TYPE_MAPPING mapping,
3101 const WS_INT8_DESCRIPTION *desc, WS_WRITE_OPTION option,
3102 const BOOL *value, ULONG size )
3103 {
3104 WS_XML_INT32_TEXT text_int32;
3105 const INT8 *ptr;
3106 HRESULT hr;
3107
3108 if (desc)
3109 {
3110 FIXME( "description not supported\n" );
3111 return E_NOTIMPL;
3112 }
3113
3114 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3115 if ((hr = get_value_ptr( option, value, size, sizeof(INT8), (const void **)&ptr )) != S_OK) return hr;
3116 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3117
3118 text_int32.text.textType = WS_XML_TEXT_TYPE_INT32;
3119 text_int32.value = *ptr;
3120 return write_type_text( writer, mapping, &text_int32.text );
3121 }
3122
3123 static HRESULT write_type_int16( struct writer *writer, WS_TYPE_MAPPING mapping,
3124 const WS_INT16_DESCRIPTION *desc, WS_WRITE_OPTION option,
3125 const BOOL *value, ULONG size )
3126 {
3127 WS_XML_INT32_TEXT text_int32;
3128 const INT16 *ptr;
3129 HRESULT hr;
3130
3131 if (desc)
3132 {
3133 FIXME( "description not supported\n" );
3134 return E_NOTIMPL;
3135 }
3136
3137 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3138 if ((hr = get_value_ptr( option, value, size, sizeof(INT16), (const void **)&ptr )) != S_OK) return hr;
3139 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3140
3141 text_int32.text.textType = WS_XML_TEXT_TYPE_INT32;
3142 text_int32.value = *ptr;
3143 return write_type_text( writer, mapping, &text_int32.text );
3144 }
3145
3146 static HRESULT write_type_int32( struct writer *writer, WS_TYPE_MAPPING mapping,
3147 const WS_INT32_DESCRIPTION *desc, WS_WRITE_OPTION option,
3148 const void *value, ULONG size )
3149 {
3150 WS_XML_INT32_TEXT text_int32;
3151 const INT32 *ptr;
3152 HRESULT hr;
3153
3154 if (desc)
3155 {
3156 FIXME( "description not supported\n" );
3157 return E_NOTIMPL;
3158 }
3159
3160 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3161 if ((hr = get_value_ptr( option, value, size, sizeof(INT32), (const void **)&ptr )) != S_OK) return hr;
3162 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3163
3164 text_int32.text.textType = WS_XML_TEXT_TYPE_INT32;
3165 text_int32.value = *ptr;
3166 return write_type_text( writer, mapping, &text_int32.text );
3167 }
3168
3169 static HRESULT write_type_int64( struct writer *writer, WS_TYPE_MAPPING mapping,
3170 const WS_INT64_DESCRIPTION *desc, WS_WRITE_OPTION option,
3171 const void *value, ULONG size )
3172 {
3173 WS_XML_INT64_TEXT text_int64;
3174 const INT64 *ptr;
3175 HRESULT hr;
3176
3177 if (desc)
3178 {
3179 FIXME( "description not supported\n" );
3180 return E_NOTIMPL;
3181 }
3182
3183 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3184 if ((hr = get_value_ptr( option, value, size, sizeof(INT64), (const void **)&ptr )) != S_OK) return hr;
3185 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3186
3187 text_int64.text.textType = WS_XML_TEXT_TYPE_INT64;
3188 text_int64.value = *ptr;
3189 return write_type_text( writer, mapping, &text_int64.text );
3190 }
3191
3192 static HRESULT write_type_uint8( struct writer *writer, WS_TYPE_MAPPING mapping,
3193 const WS_UINT8_DESCRIPTION *desc, WS_WRITE_OPTION option,
3194 const void *value, ULONG size )
3195 {
3196 WS_XML_UINT64_TEXT text_uint64;
3197 const UINT8 *ptr;
3198 HRESULT hr;
3199
3200 if (desc)
3201 {
3202 FIXME( "description not supported\n" );
3203 return E_NOTIMPL;
3204 }
3205
3206 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3207 if ((hr = get_value_ptr( option, value, size, sizeof(UINT8), (const void **)&ptr )) != S_OK) return hr;
3208 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3209
3210 text_uint64.text.textType = WS_XML_TEXT_TYPE_UINT64;
3211 text_uint64.value = *ptr;
3212 return write_type_text( writer, mapping, &text_uint64.text );
3213 }
3214
3215 static HRESULT write_type_uint16( struct writer *writer, WS_TYPE_MAPPING mapping,
3216 const WS_UINT16_DESCRIPTION *desc, WS_WRITE_OPTION option,
3217 const void *value, ULONG size )
3218 {
3219 WS_XML_UINT64_TEXT text_uint64;
3220 const UINT16 *ptr;
3221 HRESULT hr;
3222
3223 if (desc)
3224 {
3225 FIXME( "description not supported\n" );
3226 return E_NOTIMPL;
3227 }
3228
3229 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3230 if ((hr = get_value_ptr( option, value, size, sizeof(UINT16), (const void **)&ptr )) != S_OK) return hr;
3231 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3232
3233 text_uint64.text.textType = WS_XML_TEXT_TYPE_UINT64;
3234 text_uint64.value = *ptr;
3235 return write_type_text( writer, mapping, &text_uint64.text );
3236 }
3237
3238 static HRESULT write_type_uint32( struct writer *writer, WS_TYPE_MAPPING mapping,
3239 const WS_UINT32_DESCRIPTION *desc, WS_WRITE_OPTION option,
3240 const void *value, ULONG size )
3241 {
3242 WS_XML_UINT64_TEXT text_uint64;
3243 const UINT32 *ptr;
3244 HRESULT hr;
3245
3246 if (desc)
3247 {
3248 FIXME( "description not supported\n" );
3249 return E_NOTIMPL;
3250 }
3251
3252 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3253 if ((hr = get_value_ptr( option, value, size, sizeof(UINT32), (const void **)&ptr )) != S_OK) return hr;
3254 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3255
3256 text_uint64.text.textType = WS_XML_TEXT_TYPE_UINT64;
3257 text_uint64.value = *ptr;
3258 return write_type_text( writer, mapping, &text_uint64.text );
3259 }
3260
3261 static HRESULT write_type_uint64( struct writer *writer, WS_TYPE_MAPPING mapping,
3262 const WS_UINT64_DESCRIPTION *desc, WS_WRITE_OPTION option,
3263 const void *value, ULONG size )
3264 {
3265 WS_XML_UINT64_TEXT text_uint64;
3266 const UINT64 *ptr;
3267 HRESULT hr;
3268
3269 if (desc)
3270 {
3271 FIXME( "description not supported\n" );
3272 return E_NOTIMPL;
3273 }
3274
3275 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3276 if ((hr = get_value_ptr( option, value, size, sizeof(UINT64), (const void **)&ptr )) != S_OK) return hr;
3277 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3278
3279 text_uint64.text.textType = WS_XML_TEXT_TYPE_UINT64;
3280 text_uint64.value = *ptr;
3281 return write_type_text( writer, mapping, &text_uint64.text );
3282 }
3283
3284 static HRESULT write_type_double( struct writer *writer, WS_TYPE_MAPPING mapping,
3285 const WS_DOUBLE_DESCRIPTION *desc, WS_WRITE_OPTION option,
3286 const void *value, ULONG size )
3287 {
3288 WS_XML_DOUBLE_TEXT text_double;
3289 const double *ptr;
3290 HRESULT hr;
3291
3292 if (desc)
3293 {
3294 FIXME( "description not supported\n" );
3295 return E_NOTIMPL;
3296 }
3297
3298 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3299 if ((hr = get_value_ptr( option, value, size, sizeof(double), (const void **)&ptr )) != S_OK) return hr;
3300 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3301
3302 text_double.text.textType = WS_XML_TEXT_TYPE_DOUBLE;
3303 text_double.value = *ptr;
3304 return write_type_text( writer, mapping, &text_double.text );
3305 }
3306
3307 static HRESULT write_type_datetime( struct writer *writer, WS_TYPE_MAPPING mapping,
3308 const WS_DATETIME_DESCRIPTION *desc, WS_WRITE_OPTION option,
3309 const void *value, ULONG size )
3310 {
3311 WS_XML_DATETIME_TEXT text_datetime;
3312 const WS_DATETIME *ptr;
3313 HRESULT hr;
3314
3315 if (desc)
3316 {
3317 FIXME( "description not supported\n" );
3318 return E_NOTIMPL;
3319 }
3320
3321 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3322 if ((hr = get_value_ptr( option, value, size, sizeof(WS_DATETIME), (const void **)&ptr )) != S_OK) return hr;
3323 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3324 if (ptr->ticks > TICKS_MAX || ptr->format > WS_DATETIME_FORMAT_NONE) return WS_E_INVALID_FORMAT;
3325
3326 text_datetime.text.textType = WS_XML_TEXT_TYPE_DATETIME;
3327 text_datetime.value = *ptr;
3328 return write_type_text( writer, mapping, &text_datetime.text );
3329 }
3330
3331 static HRESULT write_type_guid( struct writer *writer, WS_TYPE_MAPPING mapping,
3332 const WS_GUID_DESCRIPTION *desc, WS_WRITE_OPTION option,
3333 const void *value, ULONG size )
3334 {
3335 WS_XML_GUID_TEXT text_guid;
3336 const GUID *ptr;
3337 HRESULT hr;
3338
3339 if (desc)
3340 {
3341 FIXME( "description not supported\n" );
3342 return E_NOTIMPL;
3343 }
3344
3345 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3346 if ((hr = get_value_ptr( option, value, size, sizeof(GUID), (const void **)&ptr )) != S_OK) return hr;
3347 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3348
3349 text_guid.text.textType = WS_XML_TEXT_TYPE_GUID;
3350 text_guid.value = *ptr;
3351 return write_type_text( writer, mapping, &text_guid.text );
3352 }
3353
3354 static HRESULT write_type_unique_id( struct writer *writer, WS_TYPE_MAPPING mapping,
3355 const WS_UNIQUE_ID_DESCRIPTION *desc, WS_WRITE_OPTION option,
3356 const void *value, ULONG size )
3357 {
3358 WS_XML_UNIQUE_ID_TEXT text_unique_id;
3359 WS_XML_UTF16_TEXT text_utf16;
3360 const WS_UNIQUE_ID *ptr;
3361 HRESULT hr;
3362
3363 if (desc)
3364 {
3365 FIXME( "description not supported\n" );
3366 return E_NOTIMPL;
3367 }
3368
3369 if (!option || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3370 if ((hr = get_value_ptr( option, value, size, sizeof(*ptr), (const void **)&ptr )) != S_OK) return hr;
3371 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3372
3373 if (ptr->uri.length)
3374 {
3375 text_utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
3376 text_utf16.bytes = (BYTE *)ptr->uri.chars;
3377 text_utf16.byteCount = ptr->uri.length * sizeof(WCHAR);
3378 return write_type_text( writer, mapping, &text_utf16.text );
3379 }
3380
3381 text_unique_id.text.textType = WS_XML_TEXT_TYPE_UNIQUE_ID;
3382 text_unique_id.value = ptr->guid;
3383 return write_type_text( writer, mapping, &text_unique_id.text );
3384 }
3385
3386 static HRESULT write_type_string( struct writer *writer, WS_TYPE_MAPPING mapping,
3387 const WS_STRING_DESCRIPTION *desc, WS_WRITE_OPTION option,
3388 const void *value, ULONG size )
3389 {
3390 WS_XML_UTF16_TEXT utf16;
3391 const WS_STRING *ptr;
3392 HRESULT hr;
3393
3394 if (desc)
3395 {
3396 FIXME( "description not supported\n" );
3397 return E_NOTIMPL;
3398 }
3399
3400 if (!option) return E_INVALIDARG;
3401 if ((hr = get_value_ptr( option, value, size, sizeof(WS_STRING), (const void **)&ptr )) != S_OK) return hr;
3402 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3403 if (!ptr->length) return S_OK;
3404
3405 utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
3406 utf16.bytes = (BYTE *)ptr->chars;
3407 utf16.byteCount = ptr->length * sizeof(WCHAR);
3408 return write_type_text( writer, mapping, &utf16.text );
3409 }
3410
3411 static HRESULT write_type_wsz( struct writer *writer, WS_TYPE_MAPPING mapping,
3412 const WS_WSZ_DESCRIPTION *desc, WS_WRITE_OPTION option,
3413 const void *value, ULONG size )
3414 {
3415 WS_XML_UTF16_TEXT utf16;
3416 const WCHAR *ptr;
3417 HRESULT hr;
3418 int len;
3419
3420 if (desc)
3421 {
3422 FIXME( "description not supported\n" );
3423 return E_NOTIMPL;
3424 }
3425
3426 if (!option || option == WS_WRITE_REQUIRED_VALUE || option == WS_WRITE_NILLABLE_VALUE) return E_INVALIDARG;
3427 if ((hr = get_value_ptr( option, value, size, 0, (const void **)&ptr )) != S_OK) return hr;
3428 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3429 if (!(len = strlenW( ptr ))) return S_OK;
3430
3431 utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
3432 utf16.bytes = (BYTE *)ptr;
3433 utf16.byteCount = len * sizeof(WCHAR);
3434 return write_type_text( writer, mapping, &utf16.text );
3435 }
3436
3437 static HRESULT write_type_bytes( struct writer *writer, WS_TYPE_MAPPING mapping,
3438 const WS_BYTES_DESCRIPTION *desc, WS_WRITE_OPTION option,
3439 const void *value, ULONG size )
3440 {
3441 WS_XML_BASE64_TEXT base64;
3442 const WS_BYTES *ptr;
3443 HRESULT hr;
3444
3445 if (desc)
3446 {
3447 FIXME( "description not supported\n" );
3448 return E_NOTIMPL;
3449 }
3450
3451 if (!option) return E_INVALIDARG;
3452 if ((hr = get_value_ptr( option, value, size, sizeof(WS_BYTES), (const void **)&ptr )) != S_OK) return hr;
3453 if ((option == WS_WRITE_NILLABLE_VALUE && is_nil_value( value, size )) ||
3454 (option == WS_WRITE_NILLABLE_POINTER && !ptr)) return write_add_nil_attribute( writer );
3455 if (!ptr->length) return S_OK;
3456
3457 base64.text.textType = WS_XML_TEXT_TYPE_BASE64;
3458 base64.bytes = ptr->bytes;
3459 base64.length = ptr->length;
3460 return write_type_text( writer, mapping, &base64.text );
3461 }
3462
3463 static HRESULT write_type_xml_string( struct writer *writer, WS_TYPE_MAPPING mapping,
3464 const WS_XML_STRING_DESCRIPTION *desc, WS_WRITE_OPTION option,
3465 const void *value, ULONG size )
3466 {
3467 WS_XML_UTF8_TEXT utf8;
3468 const WS_XML_STRING *ptr;
3469 HRESULT hr;
3470
3471 if (desc)
3472 {
3473 FIXME( "description not supported\n" );
3474 return E_NOTIMPL;
3475 }
3476
3477 if (!option) return E_INVALIDARG;
3478 if ((hr = get_value_ptr( option, value, size, sizeof(WS_XML_STRING), (const void **)&ptr )) != S_OK) return hr;
3479 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3480 if (option == WS_WRITE_NILLABLE_VALUE && is_nil_value( value, size )) return write_add_nil_attribute( writer );
3481 if (!ptr->length) return S_OK;
3482
3483 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
3484 utf8.value.bytes = ptr->bytes;
3485 utf8.value.length = ptr->length;
3486 return write_type_text( writer, mapping, &utf8.text );
3487 }
3488
3489 static HRESULT find_prefix( struct writer *writer, const WS_XML_STRING *ns, const WS_XML_STRING **prefix )
3490 {
3491 const struct node *node;
3492 for (node = writer->current; node_type( node ) == WS_XML_NODE_TYPE_ELEMENT; node = node->parent)
3493 {
3494 const WS_XML_ELEMENT_NODE *elem = &node->hdr;
3495 ULONG i;
3496 for (i = 0; i < elem->attributeCount; i++)
3497 {
3498 if (!elem->attributes[i]->isXmlNs) continue;
3499 if (WsXmlStringEquals( elem->attributes[i]->ns, ns, NULL ) != S_OK) continue;
3500 *prefix = elem->attributes[i]->prefix;
3501 return S_OK;
3502 }
3503 }
3504 return WS_E_INVALID_FORMAT;
3505 }
3506
3507 static HRESULT write_type_qname( struct writer *writer, WS_TYPE_MAPPING mapping,
3508 const WS_XML_QNAME_DESCRIPTION *desc, WS_WRITE_OPTION option,
3509 const void *value, ULONG size )
3510 {
3511 WS_XML_QNAME_TEXT qname;
3512 const WS_XML_QNAME *ptr;
3513 const WS_XML_STRING *prefix;
3514 HRESULT hr;
3515
3516 if (desc)
3517 {
3518 FIXME( "description not supported\n" );
3519 return E_NOTIMPL;
3520 }
3521
3522 if (!option) return E_INVALIDARG;
3523 if ((hr = get_value_ptr( option, value, size, sizeof(*ptr), (const void **)&ptr )) != S_OK) return hr;
3524 if (option == WS_WRITE_NILLABLE_POINTER && !ptr) return write_add_nil_attribute( writer );
3525 if (option == WS_WRITE_NILLABLE_VALUE && is_nil_value( value, size )) return write_add_nil_attribute( writer );
3526
3527 if (((hr = find_prefix( writer, &ptr->ns, &prefix )) != S_OK)) return hr;
3528
3529 qname.text.textType = WS_XML_TEXT_TYPE_QNAME;
3530 qname.prefix = (WS_XML_STRING *)prefix;
3531 qname.localName = (WS_XML_STRING *)&ptr->localName;
3532 qname.ns = (WS_XML_STRING *)&ptr->ns;
3533 return write_type_text( writer, mapping, &qname.text );
3534 }
3535
3536 static WS_WRITE_OPTION get_field_write_option( WS_TYPE type, ULONG options )
3537 {
3538 if (options & WS_FIELD_POINTER)
3539 {
3540 if (options & (WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE)) return WS_WRITE_NILLABLE_POINTER;
3541 return WS_WRITE_REQUIRED_POINTER;
3542 }
3543
3544 switch (type)
3545 {
3546 case WS_BOOL_TYPE:
3547 case WS_INT8_TYPE:
3548 case WS_INT16_TYPE:
3549 case WS_INT32_TYPE:
3550 case WS_INT64_TYPE:
3551 case WS_UINT8_TYPE:
3552 case WS_UINT16_TYPE:
3553 case WS_UINT32_TYPE:
3554 case WS_UINT64_TYPE:
3555 case WS_DOUBLE_TYPE:
3556 case WS_DATETIME_TYPE:
3557 case WS_GUID_TYPE:
3558 case WS_UNIQUE_ID_TYPE:
3559 case WS_STRING_TYPE:
3560 case WS_BYTES_TYPE:
3561 case WS_XML_STRING_TYPE:
3562 case WS_XML_QNAME_TYPE:
3563 case WS_STRUCT_TYPE:
3564 case WS_ENUM_TYPE:
3565 case WS_UNION_TYPE:
3566 if (options & (WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE)) return WS_WRITE_NILLABLE_VALUE;
3567 return WS_WRITE_REQUIRED_VALUE;
3568
3569 case WS_WSZ_TYPE:
3570 case WS_DESCRIPTION_TYPE:
3571 if (options & (WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE)) return WS_WRITE_NILLABLE_POINTER;
3572 return WS_WRITE_REQUIRED_POINTER;
3573
3574 default:
3575 FIXME( "unhandled type %u\n", type );
3576 return 0;
3577 }
3578 }
3579
3580 static HRESULT write_type_field( struct writer *, const WS_FIELD_DESCRIPTION *, const char *, ULONG );
3581
3582 static HRESULT write_type( struct writer *, WS_TYPE_MAPPING, WS_TYPE, const void *, WS_WRITE_OPTION,
3583 const void *, ULONG );
3584
3585 static HRESULT write_type_union( struct writer *writer, const WS_UNION_DESCRIPTION *desc, WS_WRITE_OPTION option,
3586 const void *value, ULONG size )
3587 {
3588 ULONG i, offset;
3589 const void *ptr;
3590 int enum_value;
3591 HRESULT hr;
3592
3593 if ((hr = get_value_ptr( option, value, size, desc->size, &ptr )) != S_OK) return hr;
3594
3595 if (size < sizeof(enum_value)) return E_INVALIDARG;
3596 if ((enum_value = *(int *)(char *)ptr + desc->enumOffset) == desc->noneEnumValue)
3597 {
3598 switch (option)
3599 {
3600 case WS_WRITE_REQUIRED_VALUE:
3601 return WS_E_INVALID_FORMAT;
3602
3603 case WS_WRITE_NILLABLE_VALUE:
3604 return S_OK;
3605
3606 default:
3607 ERR( "unhandled write option %u\n", option );
3608 return E_INVALIDARG;
3609 }
3610 }
3611
3612 for (i = 0; i < desc->fieldCount; i++)
3613 {
3614 if (desc->fields[i]->value == enum_value)
3615 {
3616 offset = desc->fields[i]->field.offset;
3617 return write_type_field( writer, &desc->fields[i]->field, ptr, offset );
3618 }
3619 }
3620
3621 return E_INVALIDARG;
3622 }
3623
3624 static HRESULT write_type_array( struct writer *writer, const WS_FIELD_DESCRIPTION *desc, const char *buf,
3625 ULONG count )
3626 {
3627 HRESULT hr = S_OK;
3628 ULONG i, size, offset = 0;
3629 WS_WRITE_OPTION option;
3630
3631 if (!(option = get_field_write_option( desc->type, desc->options ))) return E_INVALIDARG;
3632
3633 /* wrapper element */
3634 if (desc->localName && ((hr = write_element_node( writer, NULL, desc->localName, desc->ns )) != S_OK))
3635 return hr;
3636
3637 if (option == WS_WRITE_REQUIRED_VALUE || option == WS_WRITE_NILLABLE_VALUE)
3638 size = get_type_size( desc->type, desc->typeDescription );
3639 else
3640 size = sizeof(const void *);
3641
3642 for (i = 0; i < count; i++)
3643 {
3644 if (desc->type == WS_UNION_TYPE)
3645 {
3646 if ((hr = write_type_union( writer, desc->typeDescription, option, buf + offset, size )) != S_OK)
3647 return hr;
3648 }
3649 else
3650 {
3651 if ((hr = write_element_node( writer, NULL, desc->itemLocalName, desc->itemNs )) != S_OK) return hr;
3652 if ((hr = write_type( writer, WS_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription, option,
3653 buf + offset, size )) != S_OK) return hr;
3654 if ((hr = write_endelement_node( writer )) != S_OK) return hr;
3655 }
3656 offset += size;
3657 }
3658
3659 if (desc->localName) hr = write_endelement_node( writer );
3660 return hr;
3661 }
3662
3663 static HRESULT write_type_field( struct writer *writer, const WS_FIELD_DESCRIPTION *desc, const char *buf,
3664 ULONG offset )
3665 {
3666 HRESULT hr;
3667 WS_TYPE_MAPPING mapping;
3668 WS_WRITE_OPTION option;
3669 ULONG count, size, field_options = desc->options;
3670 const char *ptr = buf + offset;
3671
3672 if (field_options & ~(WS_FIELD_POINTER|WS_FIELD_OPTIONAL|WS_FIELD_NILLABLE))
3673 {
3674 FIXME( "options 0x%x not supported\n", desc->options );
3675 return E_NOTIMPL;
3676 }
3677
3678 /* zero-terminated strings are always pointers */
3679 if (desc->type == WS_WSZ_TYPE) field_options |= WS_FIELD_POINTER;
3680
3681 if (field_options & WS_FIELD_POINTER)
3682 size = sizeof(const void *);
3683 else
3684 size = get_type_size( desc->type, desc->typeDescription );
3685
3686 if (is_nil_value( ptr, size ))
3687 {
3688 if (field_options & WS_FIELD_OPTIONAL) return S_OK;
3689 if (field_options & WS_FIELD_NILLABLE)
3690 {
3691 if (field_options & WS_FIELD_POINTER) option = WS_WRITE_NILLABLE_POINTER;
3692 else option = WS_WRITE_NILLABLE_VALUE;
3693 }
3694 else
3695 {
3696 if (field_options & WS_FIELD_POINTER) option = WS_WRITE_REQUIRED_POINTER;
3697 else option = WS_WRITE_REQUIRED_VALUE;
3698 }
3699 }
3700 else
3701 {
3702 if (field_options & WS_FIELD_POINTER) option = WS_WRITE_REQUIRED_POINTER;
3703 else option = WS_WRITE_REQUIRED_VALUE;
3704 }
3705
3706 switch (desc->mapping)
3707 {
3708 case WS_ATTRIBUTE_FIELD_MAPPING:
3709 if (!desc->localName || !desc->ns) return E_INVALIDARG;
3710 if ((hr = write_add_attribute( writer, NULL, desc->localName, desc->ns, FALSE )) != S_OK)
3711 return hr;
3712 writer->state = WRITER_STATE_STARTATTRIBUTE;
3713
3714 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
3715 break;
3716
3717 case WS_ELEMENT_FIELD_MAPPING:
3718 if ((hr = write_element_node( writer, NULL, desc->localName, desc->ns )) != S_OK) return hr;
3719 mapping = WS_ELEMENT_TYPE_MAPPING;
3720 break;
3721
3722 case WS_ELEMENT_CHOICE_FIELD_MAPPING:
3723 if (desc->type != WS_UNION_TYPE || !desc->typeDescription) return E_INVALIDARG;
3724 option = (field_options & WS_FIELD_OPTIONAL) ? WS_WRITE_NILLABLE_VALUE : WS_WRITE_REQUIRED_VALUE;
3725 return write_type_union( writer, desc->typeDescription, option, ptr, size );
3726
3727 case WS_REPEATING_ELEMENT_FIELD_MAPPING:
3728 case WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING:
3729 count = *(const ULONG *)(buf + desc->countOffset);
3730 return write_type_array( writer, desc, *(const char **)ptr, count );
3731
3732 case WS_TEXT_FIELD_MAPPING:
3733 switch (writer->state)
3734 {
3735 case WRITER_STATE_STARTELEMENT:
3736 mapping = WS_ELEMENT_CONTENT_TYPE_MAPPING;
3737 break;
3738
3739 case WRITER_STATE_STARTATTRIBUTE:
3740 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
3741 break;
3742
3743 default:
3744 FIXME( "unhandled writer state %u\n", writer->state );
3745 return E_NOTIMPL;
3746 }
3747 break;
3748
3749 default:
3750 FIXME( "field mapping %u not supported\n", desc->mapping );
3751 return E_NOTIMPL;
3752 }
3753
3754 if ((hr = write_type( writer, mapping, desc->type, desc->typeDescription, option, ptr, size )) != S_OK)
3755 return hr;
3756
3757 switch (mapping)
3758 {
3759 case WS_ATTRIBUTE_TYPE_MAPPING:
3760 writer->state = WRITER_STATE_STARTELEMENT;
3761 break;
3762
3763 case WS_ELEMENT_TYPE_MAPPING:
3764 if ((hr = write_endelement_node( writer )) != S_OK) return hr;
3765 break;
3766
3767 default: break;
3768 }
3769
3770 return S_OK;
3771 }
3772
3773 static HRESULT write_type_struct( struct writer *writer, WS_TYPE_MAPPING mapping,
3774 const WS_STRUCT_DESCRIPTION *desc, WS_WRITE_OPTION option,
3775 const void *value, ULONG size )
3776 {
3777 ULONG i, offset;
3778 const void *ptr;
3779 HRESULT hr;
3780
3781 if (!desc) return E_INVALIDARG;
3782 if (desc->structOptions) FIXME( "struct options 0x%x not supported\n", desc->structOptions );
3783
3784 if ((hr = get_value_ptr( option, value, size, desc->size, &ptr )) != S_OK) return hr;
3785
3786 for (i = 0; i < desc->fieldCount; i++)
3787 {
3788 offset = desc->fields[i]->offset;
3789 if ((hr = write_type_field( writer, desc->fields[i], ptr, offset )) != S_OK) return hr;
3790 }
3791
3792 return S_OK;
3793 }
3794
3795 static HRESULT write_type( struct writer *writer, WS_TYPE_MAPPING mapping, WS_TYPE type,
3796 const void *desc, WS_WRITE_OPTION option, const void *value,
3797 ULONG size )
3798 {
3799 switch (type)
3800 {
3801 case WS_BOOL_TYPE:
3802 return write_type_bool( writer, mapping, desc, option, value, size );
3803
3804 case WS_INT8_TYPE:
3805 return write_type_int8( writer, mapping, desc, option, value, size );
3806
3807 case WS_INT16_TYPE:
3808 return write_type_int16( writer, mapping, desc, option, value, size );
3809
3810 case WS_INT32_TYPE:
3811 return write_type_int32( writer, mapping, desc, option, value, size );
3812
3813 case WS_INT64_TYPE:
3814 return write_type_int64( writer, mapping, desc, option, value, size );
3815
3816 case WS_UINT8_TYPE:
3817 return write_type_uint8( writer, mapping, desc, option, value, size );
3818
3819 case WS_UINT16_TYPE:
3820 return write_type_uint16( writer, mapping, desc, option, value, size );
3821
3822 case WS_UINT32_TYPE:
3823 return write_type_uint32( writer, mapping, desc, option, value, size );
3824
3825 case WS_UINT64_TYPE:
3826 return write_type_uint64( writer, mapping, desc, option, value, size );
3827
3828 case WS_DOUBLE_TYPE:
3829 return write_type_double( writer, mapping, desc, option, value, size );
3830
3831 case WS_DATETIME_TYPE:
3832 return write_type_datetime( writer, mapping, desc, option, value, size );
3833
3834 case WS_GUID_TYPE:
3835 return write_type_guid( writer, mapping, desc, option, value, size );
3836
3837 case WS_UNIQUE_ID_TYPE:
3838 return write_type_unique_id( writer, mapping, desc, option, value, size );
3839
3840 case WS_STRING_TYPE:
3841 return write_type_string( writer, mapping, desc, option, value, size );
3842
3843 case WS_WSZ_TYPE:
3844 return write_type_wsz( writer, mapping, desc, option, value, size );
3845
3846 case WS_BYTES_TYPE:
3847 return write_type_bytes( writer, mapping, desc, option, value, size );
3848
3849 case WS_XML_STRING_TYPE:
3850 return write_type_xml_string( writer, mapping, desc, option, value, size );
3851
3852 case WS_XML_QNAME_TYPE:
3853 return write_type_qname( writer, mapping, desc, option, value, size );
3854
3855 case WS_STRUCT_TYPE:
3856 return write_type_struct( writer, mapping, desc, option, value, size );
3857
3858 default:
3859 FIXME( "type %u not supported\n", type );
3860 return E_NOTIMPL;
3861 }
3862 }
3863
3864 /**************************************************************************
3865 * WsWriteAttribute [webservices.@]
3866 */
3867 HRESULT WINAPI WsWriteAttribute( WS_XML_WRITER *handle, const WS_ATTRIBUTE_DESCRIPTION *desc,
3868 WS_WRITE_OPTION option, const void *value, ULONG size,
3869 WS_ERROR *error )
3870 {
3871 struct writer *writer = (struct writer *)handle;
3872 HRESULT hr;
3873
3874 TRACE( "%p %p %u %p %u %p\n", handle, desc, option, value, size, error );
3875 if (error) FIXME( "ignoring error parameter\n" );
3876
3877 if (!writer || !desc || !desc->attributeLocalName || !desc->attributeNs || !value)
3878 return E_INVALIDARG;
3879
3880 EnterCriticalSection( &writer->cs );
3881
3882 if (writer->magic != WRITER_MAGIC)
3883 {
3884 LeaveCriticalSection( &writer->cs );
3885 return E_INVALIDARG;
3886 }
3887
3888 if (writer->state != WRITER_STATE_STARTELEMENT)
3889 {
3890 LeaveCriticalSection( &writer->cs );
3891 return WS_E_INVALID_OPERATION;
3892 }
3893
3894 if ((hr = write_add_attribute( writer, NULL, desc->attributeLocalName, desc->attributeNs, FALSE )) != S_OK)
3895 {
3896 LeaveCriticalSection( &writer->cs );
3897 return hr;
3898 }
3899 writer->state = WRITER_STATE_STARTATTRIBUTE;
3900
3901 hr = write_type( writer, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->typeDescription, option, value, size );
3902
3903 LeaveCriticalSection( &writer->cs );
3904 return hr;
3905 }
3906
3907 /**************************************************************************
3908 * WsWriteElement [webservices.@]
3909 */
3910 HRESULT WINAPI WsWriteElement( WS_XML_WRITER *handle, const WS_ELEMENT_DESCRIPTION *desc,
3911 WS_WRITE_OPTION option, const void *value, ULONG size,
3912 WS_ERROR *error )
3913 {
3914 struct writer *writer = (struct writer *)handle;
3915 HRESULT hr;
3916
3917 TRACE( "%p %p %u %p %u %p\n", handle, desc, option, value, size, error );
3918 if (error) FIXME( "ignoring error parameter\n" );
3919
3920 if (!writer || !desc || !desc->elementLocalName || !desc->elementNs || !value)
3921 return E_INVALIDARG;
3922
3923 EnterCriticalSection( &writer->cs );
3924
3925 if (writer->magic != WRITER_MAGIC)
3926 {
3927 LeaveCriticalSection( &writer->cs );
3928 return E_INVALIDARG;
3929 }
3930
3931 if ((hr = write_element_node( writer, NULL, desc->elementLocalName, desc->elementNs )) != S_OK) goto done;
3932
3933 if ((hr = write_type( writer, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription,
3934 option, value, size )) != S_OK) goto done;
3935
3936 hr = write_endelement_node( writer );
3937
3938 done:
3939 LeaveCriticalSection( &writer->cs );
3940 return hr;
3941 }
3942
3943 /**************************************************************************
3944 * WsWriteType [webservices.@]
3945 */
3946 HRESULT WINAPI WsWriteType( WS_XML_WRITER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
3947 const void *desc, WS_WRITE_OPTION option, const void *value,
3948 ULONG size, WS_ERROR *error )
3949 {
3950 struct writer *writer = (struct writer *)handle;
3951 HRESULT hr;
3952
3953 TRACE( "%p %u %u %p %u %p %u %p\n", handle, mapping, type, desc, option, value,
3954 size, error );
3955 if (error) FIXME( "ignoring error parameter\n" );
3956
3957 if (!writer || !value) return E_INVALIDARG;
3958
3959 EnterCriticalSection( &writer->cs );
3960
3961 if (writer->magic != WRITER_MAGIC)
3962 {
3963 LeaveCriticalSection( &writer->cs );
3964 return E_INVALIDARG;
3965 }
3966
3967 switch (mapping)
3968 {
3969 case WS_ATTRIBUTE_TYPE_MAPPING:
3970 if (writer->state != WRITER_STATE_STARTATTRIBUTE) hr = WS_E_INVALID_FORMAT;
3971 else hr = write_type( writer, mapping, type, desc, option, value, size );
3972 break;
3973
3974 case WS_ELEMENT_TYPE_MAPPING:
3975 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
3976 case WS_ANY_ELEMENT_TYPE_MAPPING:
3977 hr = write_type( writer, mapping, type, desc, option, value, size );
3978 break;
3979
3980 default:
3981 FIXME( "mapping %u not implemented\n", mapping );
3982 hr = E_NOTIMPL;
3983 }
3984
3985 LeaveCriticalSection( &writer->cs );
3986 return hr;
3987 }
3988
3989 WS_TYPE map_value_type( WS_VALUE_TYPE type )
3990 {
3991 switch (type)
3992 {
3993 case WS_BOOL_VALUE_TYPE: return WS_BOOL_TYPE;
3994 case WS_INT8_VALUE_TYPE: return WS_INT8_TYPE;
3995 case WS_INT16_VALUE_TYPE: return WS_INT16_TYPE;
3996 case WS_INT32_VALUE_TYPE: return WS_INT32_TYPE;
3997 case WS_INT64_VALUE_TYPE: return WS_INT64_TYPE;
3998 case WS_UINT8_VALUE_TYPE: return WS_UINT8_TYPE;
3999 case WS_UINT16_VALUE_TYPE: return WS_UINT16_TYPE;
4000 case WS_UINT32_VALUE_TYPE: return WS_UINT32_TYPE;
4001 case WS_UINT64_VALUE_TYPE: return WS_UINT64_TYPE;
4002 case WS_FLOAT_VALUE_TYPE: return WS_FLOAT_TYPE;
4003 case WS_DOUBLE_VALUE_TYPE: return WS_DOUBLE_TYPE;
4004 case WS_DECIMAL_VALUE_TYPE: return WS_DECIMAL_TYPE;
4005 case WS_DATETIME_VALUE_TYPE: return WS_DATETIME_TYPE;
4006 case WS_TIMESPAN_VALUE_TYPE: return WS_TIMESPAN_TYPE;
4007 case WS_GUID_VALUE_TYPE: return WS_GUID_TYPE;
4008 default:
4009 FIXME( "unhandled type %u\n", type );
4010 return ~0u;
4011 }
4012 }
4013
4014 /**************************************************************************
4015 * WsWriteValue [webservices.@]
4016 */
4017 HRESULT WINAPI WsWriteValue( WS_XML_WRITER *handle, WS_VALUE_TYPE value_type, const void *value,
4018 ULONG size, WS_ERROR *error )
4019 {
4020 struct writer *writer = (struct writer *)handle;
4021 WS_TYPE_MAPPING mapping;
4022 HRESULT hr = S_OK;
4023 WS_TYPE type;
4024
4025 TRACE( "%p %u %p %u %p\n", handle, value_type, value, size, error );
4026 if (error) FIXME( "ignoring error parameter\n" );
4027
4028 if (!writer || !value || (type = map_value_type( value_type )) == ~0u) return E_INVALIDARG;
4029
4030 EnterCriticalSection( &writer->cs );
4031
4032 if (writer->magic != WRITER_MAGIC)
4033 {
4034 LeaveCriticalSection( &writer->cs );
4035 return E_INVALIDARG;
4036 }
4037
4038 switch (writer->state)
4039 {
4040 case WRITER_STATE_STARTATTRIBUTE:
4041 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
4042 break;
4043
4044 case WRITER_STATE_STARTELEMENT:
4045 mapping = WS_ELEMENT_TYPE_MAPPING;
4046 break;
4047
4048 default:
4049 hr = WS_E_INVALID_FORMAT;
4050 }
4051
4052 if (hr == S_OK) hr = write_type( writer, mapping, type, NULL, WS_WRITE_REQUIRED_VALUE, value, size );
4053
4054 LeaveCriticalSection( &writer->cs );
4055 return hr;
4056 }
4057
4058 /**************************************************************************
4059 * WsWriteArray [webservices.@]
4060 */
4061 HRESULT WINAPI WsWriteArray( WS_XML_WRITER *handle, const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4062 WS_VALUE_TYPE value_type, const void *array, ULONG size, ULONG offset,
4063 ULONG count, WS_ERROR *error )
4064 {
4065 struct writer *writer = (struct writer *)handle;
4066 WS_TYPE type;
4067 ULONG type_size, i;
4068 HRESULT hr = S_OK;
4069
4070 TRACE( "%p %s %s %u %p %u %u %u %p\n", handle, debugstr_xmlstr(localname), debugstr_xmlstr(ns),
4071 value_type, array, size, offset, count, error );
4072 if (error) FIXME( "ignoring error parameter\n" );
4073
4074 if (!writer) return E_INVALIDARG;
4075
4076 EnterCriticalSection( &writer->cs );
4077
4078 if (writer->magic != WRITER_MAGIC)
4079 {
4080 LeaveCriticalSection( &writer->cs );
4081 return E_INVALIDARG;
4082 }
4083
4084 if (!writer->output_type)
4085 {
4086 LeaveCriticalSection( &writer->cs );
4087 return WS_E_INVALID_OPERATION;
4088 }
4089
4090 if (!localname || !ns || (type = map_value_type( value_type )) == ~0u)
4091 {
4092 LeaveCriticalSection( &writer->cs );
4093 return E_INVALIDARG;
4094 }
4095
4096 type_size = get_type_size( type, NULL );
4097 if (size % type_size || (offset + count) * type_size > size || (count && !array))
4098 {
4099 LeaveCriticalSection( &writer->cs );
4100 return E_INVALIDARG;
4101 }
4102
4103 for (i = offset; i < count; i++)
4104 {
4105 const char *ptr = (const char *)array + (offset + i) * type_size;
4106 if ((hr = write_element_node( writer, NULL, localname, ns )) != S_OK) goto done;
4107 if ((hr = write_type( writer, WS_ELEMENT_TYPE_MAPPING, type, NULL, WS_WRITE_REQUIRED_POINTER,
4108 &ptr, sizeof(ptr) )) != S_OK) goto done;
4109 if ((hr = write_endelement_node( writer )) != S_OK) goto done;
4110 }
4111
4112 done:
4113 LeaveCriticalSection( &writer->cs );
4114 return hr;
4115 }
4116
4117 /**************************************************************************
4118 * WsWriteXmlBuffer [webservices.@]
4119 */
4120 HRESULT WINAPI WsWriteXmlBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer, WS_ERROR *error )
4121 {
4122 struct writer *writer = (struct writer *)handle;
4123 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
4124 HRESULT hr;
4125
4126 TRACE( "%p %p %p\n", handle, buffer, error );
4127 if (error) FIXME( "ignoring error parameter\n" );
4128
4129 if (!writer || !xmlbuf) return E_INVALIDARG;
4130
4131 EnterCriticalSection( &writer->cs );
4132
4133 if (writer->magic != WRITER_MAGIC)
4134 {
4135 LeaveCriticalSection( &writer->cs );
4136 return E_INVALIDARG;
4137 }
4138
4139 if (xmlbuf->encoding != writer->output_enc || xmlbuf->charset != writer->output_charset)
4140 {
4141 FIXME( "no support for different encoding and/or charset\n" );
4142 hr = E_NOTIMPL;
4143 goto done;
4144 }
4145
4146 if ((hr = write_flush( writer )) != S_OK) goto done;
4147 if ((hr = write_grow_buffer( writer, xmlbuf->bytes.length )) != S_OK) goto done;
4148 write_bytes( writer, xmlbuf->bytes.bytes, xmlbuf->bytes.length );
4149
4150 done:
4151 LeaveCriticalSection( &writer->cs );
4152 return hr;
4153 }
4154
4155 /**************************************************************************
4156 * WsWriteXmlBufferToBytes [webservices.@]
4157 */
4158 HRESULT WINAPI WsWriteXmlBufferToBytes( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer,
4159 const WS_XML_WRITER_ENCODING *encoding,
4160 const WS_XML_WRITER_PROPERTY *properties, ULONG count,
4161 WS_HEAP *heap, void **bytes, ULONG *size, WS_ERROR *error )
4162 {
4163 struct writer *writer = (struct writer *)handle;
4164 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
4165 HRESULT hr = S_OK;
4166 char *buf;
4167 ULONG i;
4168
4169 TRACE( "%p %p %p %p %u %p %p %p %p\n", handle, buffer, encoding, properties, count, heap,
4170 bytes, size, error );
4171 if (error) FIXME( "ignoring error parameter\n" );
4172
4173 if (!writer || !xmlbuf || !heap || !bytes) return E_INVALIDARG;
4174
4175 if (encoding && encoding->encodingType != WS_XML_WRITER_ENCODING_TYPE_TEXT)
4176 {
4177 FIXME( "encoding type %u not supported\n", encoding->encodingType );
4178 return E_NOTIMPL;
4179 }
4180
4181 EnterCriticalSection( &writer->cs );
4182
4183 if (writer->magic != WRITER_MAGIC)
4184 {
4185 LeaveCriticalSection( &writer->cs );
4186 return E_INVALIDARG;
4187 }
4188
4189 for (i = 0; i < count; i++)
4190 {
4191 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
4192 properties[i].valueSize );
4193 if (hr != S_OK) goto done;
4194 }
4195
4196 if (!(buf = ws_alloc( heap, xmlbuf->bytes.length ))) hr = WS_E_QUOTA_EXCEEDED;
4197 else
4198 {
4199 memcpy( buf, xmlbuf->bytes.bytes, xmlbuf->bytes.length );
4200 *bytes = buf;
4201 *size = xmlbuf->bytes.length;
4202 }
4203
4204 done:
4205 LeaveCriticalSection( &writer->cs );
4206 return hr;
4207 }
4208
4209 /**************************************************************************
4210 * WsWriteXmlnsAttribute [webservices.@]
4211 */
4212 HRESULT WINAPI WsWriteXmlnsAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
4213 const WS_XML_STRING *ns, BOOL single, WS_ERROR *error )
4214 {
4215 struct writer *writer = (struct writer *)handle;
4216 HRESULT hr = S_OK;
4217
4218 TRACE( "%p %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(ns),
4219 single, error );
4220 if (error) FIXME( "ignoring error parameter\n" );
4221
4222 if (!writer || !ns) return E_INVALIDARG;
4223
4224 EnterCriticalSection( &writer->cs );
4225
4226 if (writer->magic != WRITER_MAGIC)
4227 {
4228 LeaveCriticalSection( &writer->cs );
4229 return E_INVALIDARG;
4230 }
4231
4232 if (writer->state != WRITER_STATE_STARTELEMENT)
4233 {
4234 LeaveCriticalSection( &writer->cs );
4235 return WS_E_INVALID_OPERATION;
4236 }
4237
4238 if (!namespace_in_scope( &writer->current->hdr, prefix, ns ))
4239 hr = add_namespace_attribute( writer, prefix, ns, single );
4240
4241 LeaveCriticalSection( &writer->cs );
4242 return hr;
4243 }
4244
4245 static HRESULT write_qualified_name( struct writer *writer, const WS_XML_STRING *prefix,
4246 const WS_XML_STRING *localname, const WS_XML_STRING *ns )
4247 {
4248 WS_XML_QNAME_TEXT qname = {{WS_XML_TEXT_TYPE_QNAME}};
4249 HRESULT hr;
4250
4251 if ((hr = write_flush( writer )) != S_OK) return hr;
4252 if (!prefix && ((hr = find_prefix( writer, ns, &prefix )) != S_OK)) return hr;
4253
4254 qname.prefix = (WS_XML_STRING *)prefix;
4255 qname.localName = (WS_XML_STRING *)localname;
4256 qname.ns = (WS_XML_STRING *)ns;
4257
4258 if ((hr = write_add_text_node( writer, &qname.text )) != S_OK) return hr;
4259 return write_text( writer, ((const WS_XML_TEXT_NODE *)writer->current)->text, 0 );
4260 }
4261
4262 /**************************************************************************
4263 * WsWriteQualifiedName [webservices.@]
4264 */
4265 HRESULT WINAPI WsWriteQualifiedName( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
4266 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
4267 WS_ERROR *error )
4268 {
4269 struct writer *writer = (struct writer *)handle;
4270 HRESULT hr;
4271
4272 TRACE( "%p %s %s %s %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname),
4273 debugstr_xmlstr(ns), error );
4274 if (error) FIXME( "ignoring error parameter\n" );
4275
4276 if (!writer) return E_INVALIDARG;
4277
4278 EnterCriticalSection( &writer->cs );
4279
4280 if (writer->magic != WRITER_MAGIC)
4281 {
4282 LeaveCriticalSection( &writer->cs );
4283 return E_INVALIDARG;
4284 }
4285
4286 if (!writer->output_type)
4287 {
4288 LeaveCriticalSection( &writer->cs );
4289 return WS_E_INVALID_OPERATION;
4290 }
4291
4292 if (writer->state != WRITER_STATE_STARTELEMENT)
4293 {
4294 LeaveCriticalSection( &writer->cs );
4295 return WS_E_INVALID_FORMAT;
4296 }
4297
4298 if (!localname || (!prefix && !ns))
4299 {
4300 LeaveCriticalSection( &writer->cs );
4301 return E_INVALIDARG;
4302 }
4303
4304 hr = write_qualified_name( writer, prefix, localname, ns );
4305
4306 LeaveCriticalSection( &writer->cs );
4307 return hr;
4308 }
4309
4310 static HRESULT write_move_to( struct writer *writer, WS_MOVE_TO move, BOOL *found )
4311 {
4312 BOOL success = FALSE;
4313 struct node *node = writer->current;
4314
4315 switch (move)
4316 {
4317 case WS_MOVE_TO_ROOT_ELEMENT:
4318 success = move_to_root_element( writer->root, &node );
4319 break;
4320
4321 case WS_MOVE_TO_NEXT_ELEMENT:
4322 success = move_to_next_element( &node );
4323 break;
4324
4325 case WS_MOVE_TO_PREVIOUS_ELEMENT:
4326 success = move_to_prev_element( &node );
4327 break;
4328
4329 case WS_MOVE_TO_CHILD_ELEMENT:
4330 success = move_to_child_element( &node );
4331 break;
4332
4333 case WS_MOVE_TO_END_ELEMENT:
4334 success = move_to_end_element( &node );
4335 break;
4336
4337 case WS_MOVE_TO_PARENT_ELEMENT:
4338 success = move_to_parent_element( &node );
4339 break;
4340
4341 case WS_MOVE_TO_FIRST_NODE:
4342 success = move_to_first_node( &node );
4343 break;
4344
4345 case WS_MOVE_TO_NEXT_NODE:
4346 success = move_to_next_node( &node );
4347 break;
4348
4349 case WS_MOVE_TO_PREVIOUS_NODE:
4350 success = move_to_prev_node( &node );
4351 break;
4352
4353 case WS_MOVE_TO_CHILD_NODE:
4354 success = move_to_child_node( &node );
4355 break;
4356
4357 case WS_MOVE_TO_BOF:
4358 success = move_to_bof( writer->root, &node );
4359 break;
4360
4361 case WS_MOVE_TO_EOF:
4362 success = move_to_eof( writer->root, &node );
4363 break;
4364
4365 default:
4366 FIXME( "unhandled move %u\n", move );
4367 return E_NOTIMPL;
4368 }
4369
4370 if (success && node == writer->root) return E_INVALIDARG;
4371 writer->current = node;
4372
4373 if (found)
4374 {
4375 *found = success;
4376 return S_OK;
4377 }
4378 return success ? S_OK : WS_E_INVALID_FORMAT;
4379 }
4380
4381 /**************************************************************************
4382 * WsMoveWriter [webservices.@]
4383 */
4384 HRESULT WINAPI WsMoveWriter( WS_XML_WRITER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
4385 {
4386 struct writer *writer = (struct writer *)handle;
4387 HRESULT hr;
4388
4389 TRACE( "%p %u %p %p\n", handle, move, found, error );
4390 if (error) FIXME( "ignoring error parameter\n" );
4391
4392 if (!writer) return E_INVALIDARG;
4393
4394 EnterCriticalSection( &writer->cs );
4395
4396 if (writer->magic != WRITER_MAGIC)
4397 {
4398 LeaveCriticalSection( &writer->cs );
4399 return E_INVALIDARG;
4400 }
4401
4402 if (!writer->output_type)
4403 {
4404 LeaveCriticalSection( &writer->cs );
4405 return WS_E_INVALID_OPERATION;
4406 }
4407
4408 hr = write_move_to( writer, move, found );
4409
4410 LeaveCriticalSection( &writer->cs );
4411 return hr;
4412 }
4413
4414 /**************************************************************************
4415 * WsGetWriterPosition [webservices.@]
4416 */
4417 HRESULT WINAPI WsGetWriterPosition( WS_XML_WRITER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
4418 {
4419 struct writer *writer = (struct writer *)handle;
4420
4421 TRACE( "%p %p %p\n", handle, pos, error );
4422 if (error) FIXME( "ignoring error parameter\n" );
4423
4424 if (!writer || !pos) return E_INVALIDARG;
4425
4426 EnterCriticalSection( &writer->cs );
4427
4428 if (writer->magic != WRITER_MAGIC)
4429 {
4430 LeaveCriticalSection( &writer->cs );
4431 return E_INVALIDARG;
4432 }
4433
4434 if (!writer->output_type)
4435 {
4436 LeaveCriticalSection( &writer->cs );
4437 return WS_E_INVALID_OPERATION;
4438 }
4439
4440 pos->buffer = (WS_XML_BUFFER *)writer->output_buf;
4441 pos->node = writer->current;
4442
4443 LeaveCriticalSection( &writer->cs );
4444 return S_OK;
4445 }
4446
4447 /**************************************************************************
4448 * WsSetWriterPosition [webservices.@]
4449 */
4450 HRESULT WINAPI WsSetWriterPosition( WS_XML_WRITER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
4451 {
4452 struct writer *writer = (struct writer *)handle;
4453
4454 TRACE( "%p %p %p\n", handle, pos, error );
4455 if (error) FIXME( "ignoring error parameter\n" );
4456
4457 if (!writer || !pos) return E_INVALIDARG;
4458
4459 EnterCriticalSection( &writer->cs );
4460
4461 if (writer->magic != WRITER_MAGIC || (struct xmlbuf *)pos->buffer != writer->output_buf)
4462 {
4463 LeaveCriticalSection( &writer->cs );
4464 return E_INVALIDARG;
4465 }
4466
4467 if (!writer->output_type)
4468 {
4469 LeaveCriticalSection( &writer->cs );
4470 return WS_E_INVALID_OPERATION;
4471 }
4472
4473 writer->current = pos->node;
4474
4475 LeaveCriticalSection( &writer->cs );
4476 return S_OK;
4477 }
4478
4479 static HRESULT write_add_comment_node( struct writer *writer, const WS_XML_STRING *value )
4480 {
4481 struct node *node, *parent;
4482 WS_XML_COMMENT_NODE *comment;
4483
4484 if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT;
4485 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
4486 comment = (WS_XML_COMMENT_NODE *)node;
4487
4488 if (value->length && !(comment->value.bytes = heap_alloc( value->length )))
4489 {
4490 free_node( node );
4491 return E_OUTOFMEMORY;
4492 }
4493 memcpy( comment->value.bytes, value->bytes, value->length );
4494 comment->value.length = value->length;
4495
4496 write_insert_node( writer, parent, node );
4497 return S_OK;
4498 }
4499
4500 static HRESULT write_comment_text( struct writer *writer )
4501 {
4502 const WS_XML_COMMENT_NODE *comment = (const WS_XML_COMMENT_NODE *)writer->current;
4503 HRESULT hr;
4504
4505 if ((hr = write_grow_buffer( writer, comment->value.length + 7 )) != S_OK) return hr;
4506 write_bytes( writer, (const BYTE *)"<!--", 4 );
4507 write_bytes( writer, comment->value.bytes, comment->value.length );
4508 write_bytes( writer, (const BYTE *)"-->", 3 );
4509 return S_OK;
4510 }
4511
4512 static HRESULT write_comment_bin( struct writer *writer )
4513 {
4514 const WS_XML_COMMENT_NODE *comment = (const WS_XML_COMMENT_NODE *)writer->current;
4515 HRESULT hr;
4516
4517 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
4518 write_char( writer, RECORD_COMMENT );
4519 return write_string( writer, comment->value.bytes, comment->value.length );
4520 }
4521
4522 static HRESULT write_comment( struct writer *writer )
4523 {
4524 switch (writer->output_enc)
4525 {
4526 case WS_XML_WRITER_ENCODING_TYPE_TEXT: return write_comment_text( writer );
4527 case WS_XML_WRITER_ENCODING_TYPE_BINARY: return write_comment_bin( writer );
4528 default:
4529 ERR( "unhandled encoding %u\n", writer->output_enc );
4530 return WS_E_NOT_SUPPORTED;
4531 }
4532 }
4533
4534 static HRESULT write_comment_node( struct writer *writer, const WS_XML_STRING *value )
4535 {
4536 HRESULT hr;
4537 if ((hr = write_flush( writer )) != S_OK) return hr;
4538 if ((hr = write_add_comment_node( writer, value )) != S_OK) return hr;
4539 if ((hr = write_comment( writer )) != S_OK) return hr;
4540 writer->state = WRITER_STATE_COMMENT;
4541 return S_OK;
4542 }
4543
4544 static HRESULT write_set_attributes( struct writer *writer, WS_XML_ATTRIBUTE **attrs, ULONG count )
4545 {
4546 ULONG i;
4547 HRESULT hr;
4548
4549 for (i = 0; i < count; i++)
4550 {
4551 const WS_XML_STRING *prefix = attrs[i]->prefix;
4552 const WS_XML_STRING *localname = attrs[i]->localName;
4553 const WS_XML_STRING *ns = attrs[i]->ns;
4554 BOOL single = attrs[i]->singleQuote;
4555
4556 if (attrs[i]->isXmlNs)
4557 {
4558 if ((hr = add_namespace_attribute( writer, prefix, ns, single )) != S_OK) return hr;
4559 }
4560 else
4561 {
4562 if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) != S_OK) return hr;
4563 if ((hr = write_set_attribute_value( writer, attrs[i]->value )) != S_OK) return hr;
4564 }
4565 }
4566 return S_OK;
4567 }
4568
4569 static HRESULT write_node( struct writer *writer, const WS_XML_NODE *node )
4570 {
4571 HRESULT hr;
4572
4573 switch (node->nodeType)
4574 {
4575 case WS_XML_NODE_TYPE_ELEMENT:
4576 {
4577 const WS_XML_ELEMENT_NODE *elem = (const WS_XML_ELEMENT_NODE *)node;
4578 if ((hr = write_element_node( writer, elem->prefix, elem->localName, elem->ns )) != S_OK) return hr;
4579 return write_set_attributes( writer, elem->attributes, elem->attributeCount );
4580 }
4581 case WS_XML_NODE_TYPE_TEXT:
4582 {
4583 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node;
4584 return write_text_node( writer, text->text );
4585 }
4586 case WS_XML_NODE_TYPE_END_ELEMENT:
4587 return write_endelement_node( writer );
4588
4589 case WS_XML_NODE_TYPE_COMMENT:
4590 {
4591 const WS_XML_COMMENT_NODE *comment = (const WS_XML_COMMENT_NODE *)node;
4592 return write_comment_node( writer, &comment->value );
4593 }
4594 case WS_XML_NODE_TYPE_CDATA:
4595 return write_cdata_node( writer );
4596
4597 case WS_XML_NODE_TYPE_END_CDATA:
4598 return write_endcdata_node( writer );
4599
4600 case WS_XML_NODE_TYPE_EOF:
4601 case WS_XML_NODE_TYPE_BOF:
4602 return S_OK;
4603
4604 default:
4605 WARN( "unknown node type %u\n", node->nodeType );
4606 return E_INVALIDARG;
4607 }
4608 }
4609
4610 /**************************************************************************
4611 * WsWriteNode [webservices.@]
4612 */
4613 HRESULT WINAPI WsWriteNode( WS_XML_WRITER *handle, const WS_XML_NODE *node, WS_ERROR *error )
4614 {
4615 struct writer *writer = (struct writer *)handle;
4616 HRESULT hr;
4617
4618 TRACE( "%p %p %p\n", handle, node, error );
4619 if (error) FIXME( "ignoring error parameter\n" );
4620
4621 if (!writer || !node) return E_INVALIDARG;
4622
4623 EnterCriticalSection( &writer->cs );
4624
4625 if (writer->magic != WRITER_MAGIC)
4626 {
4627 LeaveCriticalSection( &writer->cs );
4628 return E_INVALIDARG;
4629 }
4630
4631 if (!writer->output_type)
4632 {
4633 LeaveCriticalSection( &writer->cs );
4634 return WS_E_INVALID_OPERATION;
4635 }
4636
4637 hr = write_node( writer, node );
4638
4639 LeaveCriticalSection( &writer->cs );
4640 return hr;
4641 }
4642
4643 static HRESULT write_tree_node( struct writer *writer )
4644 {
4645 HRESULT hr;
4646
4647 switch (node_type( writer->current ))
4648 {
4649 case WS_XML_NODE_TYPE_ELEMENT:
4650 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
4651 return hr;
4652 if ((hr = write_startelement( writer )) != S_OK) return hr;
4653 writer->state = WRITER_STATE_STARTELEMENT;
4654 return S_OK;
4655
4656 case WS_XML_NODE_TYPE_TEXT:
4657 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
4658 return hr;
4659 if ((hr = write_text( writer, ((const WS_XML_TEXT_NODE *)writer->current)->text, 0 )) != S_OK) return hr;
4660 writer->state = WRITER_STATE_TEXT;
4661 return S_OK;
4662
4663 case WS_XML_NODE_TYPE_END_ELEMENT:
4664 if ((hr = write_close_element( writer, writer->current->parent )) != S_OK) return hr;
4665 writer->state = WRITER_STATE_ENDELEMENT;
4666 return S_OK;
4667
4668 case WS_XML_NODE_TYPE_COMMENT:
4669 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
4670 return hr;
4671 if ((hr = write_comment( writer )) != S_OK) return hr;
4672 writer->state = WRITER_STATE_COMMENT;
4673 return S_OK;
4674
4675 case WS_XML_NODE_TYPE_CDATA:
4676 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
4677 return hr;
4678 if ((hr = write_cdata( writer )) != S_OK) return hr;
4679 writer->state = WRITER_STATE_STARTCDATA;
4680 return S_OK;
4681
4682 case WS_XML_NODE_TYPE_END_CDATA:
4683 if ((hr = write_endcdata( writer )) != S_OK) return hr;
4684 writer->state = WRITER_STATE_ENDCDATA;
4685 return S_OK;
4686
4687 case WS_XML_NODE_TYPE_EOF:
4688 case WS_XML_NODE_TYPE_BOF:
4689 return S_OK;
4690
4691 default:
4692 ERR( "unknown node type %u\n", node_type(writer->current) );
4693 return E_INVALIDARG;
4694 }
4695 }
4696
4697 static HRESULT write_tree( struct writer *writer )
4698 {
4699 HRESULT hr;
4700
4701 if ((hr = write_tree_node( writer )) != S_OK) return hr;
4702 for (;;)
4703 {
4704 if (node_type( writer->current ) == WS_XML_NODE_TYPE_EOF) break;
4705 if (move_to_child_node( &writer->current ))
4706 {
4707 if ((hr = write_tree_node( writer )) != S_OK) return hr;
4708 continue;
4709 }
4710 if (move_to_next_node( &writer->current ))
4711 {
4712 if ((hr = write_tree_node( writer )) != S_OK) return hr;
4713 continue;
4714 }
4715 if (!move_to_parent_node( &writer->current ) || !move_to_next_node( &writer->current ))
4716 {
4717 ERR( "invalid tree\n" );
4718 return WS_E_INVALID_FORMAT;
4719 }
4720 if ((hr = write_tree_node( writer )) != S_OK) return hr;
4721 }
4722 return S_OK;
4723 }
4724
4725 static void write_rewind( struct writer *writer )
4726 {
4727 writer->write_pos = 0;
4728 writer->current = writer->root;
4729 writer->state = WRITER_STATE_INITIAL;
4730 }
4731
4732 /**************************************************************************
4733 * WsCopyNode [webservices.@]
4734 */
4735 HRESULT WINAPI WsCopyNode( WS_XML_WRITER *handle, WS_XML_READER *reader, WS_ERROR *error )
4736 {
4737 struct writer *writer = (struct writer *)handle;
4738 struct node *parent, *current, *node = NULL;
4739 HRESULT hr;
4740
4741 TRACE( "%p %p %p\n", handle, reader, error );
4742 if (error) FIXME( "ignoring error parameter\n" );
4743
4744 if (!writer) return E_INVALIDARG;
4745
4746 EnterCriticalSection( &writer->cs );
4747
4748 if (writer->magic != WRITER_MAGIC)
4749 {
4750 LeaveCriticalSection( &writer->cs );
4751 return E_INVALIDARG;
4752 }
4753
4754 if (!(parent = find_parent( writer )))
4755 {
4756 LeaveCriticalSection( &writer->cs );
4757 return WS_E_INVALID_FORMAT;
4758 }
4759
4760 if ((hr = copy_node( reader, writer->output_enc, &node )) != S_OK) goto done;
4761 current = writer->current;
4762 write_insert_node( writer, parent, node );
4763
4764 write_rewind( writer );
4765 if ((hr = write_tree( writer )) != S_OK) goto done;
4766 writer->current = current;
4767
4768 WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
4769
4770 done:
4771 LeaveCriticalSection( &writer->cs );
4772 return hr;
4773 }
4774
4775 static HRESULT write_param( struct writer *writer, const WS_FIELD_DESCRIPTION *desc, const void *value )
4776 {
4777 return write_type_field( writer, desc, value, 0 );
4778 }
4779
4780 static ULONG get_array_len( const WS_PARAMETER_DESCRIPTION *params, ULONG count, ULONG index, const void **args )
4781 {
4782 ULONG i, ret = 0;
4783 for (i = 0; i < count; i++)
4784 {
4785 if (params[i].inputMessageIndex != index || params[i].parameterType != WS_PARAMETER_TYPE_ARRAY_COUNT)
4786 continue;
4787 if (args[i]) ret = *(const ULONG *)args[i];
4788 break;
4789 }
4790 return ret;
4791 }
4792
4793 static HRESULT write_param_array( struct writer *writer, const WS_FIELD_DESCRIPTION *desc, const void *value,
4794 ULONG len )
4795 {
4796 return write_type_array( writer, desc, value, len );
4797 }
4798
4799 HRESULT write_input_params( WS_XML_WRITER *handle, const WS_ELEMENT_DESCRIPTION *desc,
4800 const WS_PARAMETER_DESCRIPTION *params, ULONG count, const void **args )
4801 {
4802 struct writer *writer = (struct writer *)handle;
4803 const WS_STRUCT_DESCRIPTION *desc_struct;
4804 const WS_FIELD_DESCRIPTION *desc_field;
4805 HRESULT hr;
4806 ULONG i;
4807
4808 if (desc->type != WS_STRUCT_TYPE || !(desc_struct = desc->typeDescription)) return E_INVALIDARG;
4809
4810 EnterCriticalSection( &writer->cs );
4811
4812 if (writer->magic != WRITER_MAGIC)
4813 {
4814 LeaveCriticalSection( &writer->cs );
4815 return E_INVALIDARG;
4816 }
4817
4818 if ((hr = write_element_node( writer, NULL, desc->elementLocalName, desc->elementNs )) != S_OK) goto done;
4819
4820 for (i = 0; i < count; i++)
4821 {
4822 if (params[i].inputMessageIndex == INVALID_PARAMETER_INDEX) continue;
4823 if (params[i].parameterType == WS_PARAMETER_TYPE_MESSAGES)
4824 {
4825 FIXME( "messages type not supported\n" );
4826 hr = E_NOTIMPL;
4827 goto done;
4828 }
4829 if ((hr = get_param_desc( desc_struct, params[i].inputMessageIndex, &desc_field )) != S_OK) goto done;
4830 if (params[i].parameterType == WS_PARAMETER_TYPE_NORMAL)
4831 {
4832 if ((hr = write_param( writer, desc_field, args[i] )) != S_OK) goto done;
4833 }
4834 else if (params[i].parameterType == WS_PARAMETER_TYPE_ARRAY)
4835 {
4836 const void *ptr = *(const void **)args[i];
4837 ULONG len = get_array_len( params, count, params[i].inputMessageIndex, args );
4838 if ((hr = write_param_array( writer, desc_field, ptr, len )) != S_OK) goto done;
4839 }
4840 }
4841
4842 hr = write_endelement_node( writer );
4843
4844 done:
4845 LeaveCriticalSection( &writer->cs );
4846 return hr;
4847 }
4848
4849 HRESULT writer_enable_lookup( WS_XML_WRITER *handle )
4850 {
4851 struct writer *writer = (struct writer *)handle;
4852
4853 EnterCriticalSection( &writer->cs );
4854
4855 if (writer->magic != WRITER_MAGIC)
4856 {
4857 LeaveCriticalSection( &writer->cs );
4858 return E_INVALIDARG;
4859 }
4860
4861 writer->dict_do_lookup = TRUE;
4862
4863 LeaveCriticalSection( &writer->cs );
4864 return S_OK;
4865 }
Windows API implementation