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