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