?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
strmbase: Avoid a COM object to interface cast.
[wine.git] / dlls / webservices / writer.c
blob452ee46d673ab92bd9e57aff462f400c2c001469
1 /*
2 * Copyright 2015, 2016 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include <stdarg.h>
21 #include <stdio.h>
22 #include <math.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "webservices.h"
28
29 #include "wine/debug.h"
30 #include "wine/list.h"
31 #include "wine/unicode.h"
32 #include "webservices_private.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
35
36 static const struct prop_desc writer_props[] =
37 {
38 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_DEPTH */
39 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT */
40 { sizeof(ULONG), FALSE }, /* WS_XML_READER_PROPERTY_MAX_ATTRIBUTES */
41 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_WRITE_DECLARATION */
42 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_INDENT */
43 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE */
44 { sizeof(WS_CHARSET), FALSE }, /* WS_XML_WRITER_PROPERTY_CHARSET */
45 { sizeof(WS_BUFFERS), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFERS */
46 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE */
47 { sizeof(WS_BYTES), FALSE }, /* WS_XML_WRITER_PROPERTY_BYTES */
48 { sizeof(BOOL), TRUE }, /* WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE */
49 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE */
50 { sizeof(WS_BYTES), FALSE }, /* WS_XML_WRITER_PROPERTY_INITIAL_BUFFER */
51 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES */
52 { sizeof(ULONG), FALSE }, /* WS_XML_WRITER_PROPERTY_MAX_NAMESPACES */
53 { sizeof(ULONG), TRUE }, /* WS_XML_WRITER_PROPERTY_BYTES_WRITTEN */
54 { sizeof(ULONG), TRUE }, /* WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE */
55 { sizeof(BOOL), FALSE }, /* WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS */
56 { sizeof(BOOL), FALSE } /* WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS */
57 };
58
59 enum writer_state
60 {
61 WRITER_STATE_INITIAL,
62 WRITER_STATE_STARTELEMENT,
63 WRITER_STATE_STARTATTRIBUTE,
64 WRITER_STATE_STARTCDATA,
65 WRITER_STATE_ENDSTARTELEMENT,
66 WRITER_STATE_TEXT,
67 WRITER_STATE_COMMENT,
68 WRITER_STATE_ENDELEMENT,
69 WRITER_STATE_ENDCDATA
70 };
71
72 struct writer
73 {
74 ULONG write_pos;
75 unsigned char *write_bufptr;
76 enum writer_state state;
77 struct node *root;
78 struct node *current;
79 WS_XML_STRING *current_ns;
80 WS_XML_WRITER_OUTPUT_TYPE output_type;
81 struct xmlbuf *output_buf;
82 WS_HEAP *output_heap;
83 ULONG prop_count;
84 struct prop prop[sizeof(writer_props)/sizeof(writer_props[0])];
85 };
86
87 static struct writer *alloc_writer(void)
88 {
89 static const ULONG count = sizeof(writer_props)/sizeof(writer_props[0]);
90 struct writer *ret;
91 ULONG size = sizeof(*ret) + prop_size( writer_props, count );
92
93 if (!(ret = heap_alloc_zero( size ))) return NULL;
94 prop_init( writer_props, count, ret->prop, &ret[1] );
95 ret->prop_count = count;
96 return ret;
97 }
98
99 static void free_writer( struct writer *writer )
100 {
101 if (!writer) return;
102 destroy_nodes( writer->root );
103 heap_free( writer->current_ns );
104 WsFreeHeap( writer->output_heap );
105 heap_free( writer );
106 }
107
108 static void write_insert_eof( struct writer *writer, struct node *eof )
109 {
110 if (!writer->root) writer->root = eof;
111 else
112 {
113 eof->parent = writer->root;
114 list_add_tail( &writer->root->children, &eof->entry );
115 }
116 writer->current = eof;
117 }
118
119 static void write_insert_bof( struct writer *writer, struct node *bof )
120 {
121 writer->root->parent = bof;
122 list_add_tail( &bof->children, &writer->root->entry );
123 writer->current = writer->root = bof;
124 }
125
126 static void write_insert_node( struct writer *writer, struct node *parent, struct node *node )
127 {
128 node->parent = parent;
129 list_add_before( list_tail( &parent->children ), &node->entry );
130 writer->current = node;
131 }
132
133 static HRESULT write_init_state( struct writer *writer )
134 {
135 struct node *node;
136
137 heap_free( writer->current_ns );
138 writer->current_ns = NULL;
139 destroy_nodes( writer->root );
140 writer->root = NULL;
141
142 if (!(node = alloc_node( WS_XML_NODE_TYPE_EOF ))) return E_OUTOFMEMORY;
143 write_insert_eof( writer, node );
144 writer->state = WRITER_STATE_INITIAL;
145 return S_OK;
146 }
147
148 /**************************************************************************
149 * WsCreateWriter [webservices.@]
150 */
151 HRESULT WINAPI WsCreateWriter( const WS_XML_WRITER_PROPERTY *properties, ULONG count,
152 WS_XML_WRITER **handle, WS_ERROR *error )
153 {
154 struct writer *writer;
155 ULONG i, max_depth = 32, max_attrs = 128, trim_size = 4096, max_size = 65536, max_ns = 32;
156 WS_CHARSET charset = WS_CHARSET_UTF8;
157 HRESULT hr;
158
159 TRACE( "%p %u %p %p\n", properties, count, handle, error );
160 if (error) FIXME( "ignoring error parameter\n" );
161
162 if (!handle) return E_INVALIDARG;
163 if (!(writer = alloc_writer())) return E_OUTOFMEMORY;
164
165 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, sizeof(max_depth) );
166 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, sizeof(max_attrs) );
167 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, &trim_size, sizeof(trim_size) );
168 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_CHARSET, &charset, sizeof(charset) );
169 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, &max_size, sizeof(max_size) );
170 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, &max_size, sizeof(max_size) );
171 prop_set( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, &max_ns, sizeof(max_ns) );
172
173 for (i = 0; i < count; i++)
174 {
175 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
176 properties[i].valueSize );
177 if (hr != S_OK)
178 {
179 free_writer( writer );
180 return hr;
181 }
182 }
183
184 hr = prop_get( writer->prop, writer->prop_count, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE,
185 &max_size, sizeof(max_size) );
186 if (hr != S_OK)
187 {
188 free_writer( writer );
189 return hr;
190 }
191
192 hr = WsCreateHeap( max_size, 0, NULL, 0, &writer->output_heap, NULL );
193 if (hr != S_OK)
194 {
195 free_writer( writer );
196 return hr;
197 }
198
199 hr = write_init_state( writer );
200 if (hr != S_OK)
201 {
202 free_writer( writer );
203 return hr;
204 }
205
206 *handle = (WS_XML_WRITER *)writer;
207 return S_OK;
208 }
209
210 /**************************************************************************
211 * WsFreeWriter [webservices.@]
212 */
213 void WINAPI WsFreeWriter( WS_XML_WRITER *handle )
214 {
215 struct writer *writer = (struct writer *)handle;
216
217 TRACE( "%p\n", handle );
218 free_writer( writer );
219 }
220
221 #define XML_BUFFER_INITIAL_ALLOCATED_SIZE 256
222 static struct xmlbuf *alloc_xmlbuf( WS_HEAP *heap )
223 {
224 struct xmlbuf *ret;
225
226 if (!(ret = ws_alloc( heap, sizeof(*ret) ))) return NULL;
227 if (!(ret->ptr = ws_alloc( heap, XML_BUFFER_INITIAL_ALLOCATED_SIZE )))
228 {
229 ws_free( heap, ret );
230 return NULL;
231 }
232 ret->heap = heap;
233 ret->size_allocated = XML_BUFFER_INITIAL_ALLOCATED_SIZE;
234 ret->size = 0;
235 return ret;
236 }
237
238 static void free_xmlbuf( struct xmlbuf *xmlbuf )
239 {
240 if (!xmlbuf) return;
241 ws_free( xmlbuf->heap, xmlbuf->ptr );
242 ws_free( xmlbuf->heap, xmlbuf );
243 }
244
245 /**************************************************************************
246 * WsCreateXmlBuffer [webservices.@]
247 */
248 HRESULT WINAPI WsCreateXmlBuffer( WS_HEAP *heap, const WS_XML_BUFFER_PROPERTY *properties,
249 ULONG count, WS_XML_BUFFER **handle, WS_ERROR *error )
250 {
251 struct xmlbuf *xmlbuf;
252
253 if (!heap || !handle) return E_INVALIDARG;
254 if (count) FIXME( "properties not implemented\n" );
255
256 if (!(xmlbuf = alloc_xmlbuf( heap ))) return E_OUTOFMEMORY;
257
258 *handle = (WS_XML_BUFFER *)xmlbuf;
259 return S_OK;
260 }
261
262 /**************************************************************************
263 * WsGetWriterProperty [webservices.@]
264 */
265 HRESULT WINAPI WsGetWriterProperty( WS_XML_WRITER *handle, WS_XML_WRITER_PROPERTY_ID id,
266 void *buf, ULONG size, WS_ERROR *error )
267 {
268 struct writer *writer = (struct writer *)handle;
269
270 TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
271 if (error) FIXME( "ignoring error parameter\n" );
272
273 if (!writer->output_type) return WS_E_INVALID_OPERATION;
274
275 switch (id)
276 {
277 case WS_XML_WRITER_PROPERTY_BYTES:
278 {
279 WS_BYTES *bytes = buf;
280 if (size != sizeof(*bytes)) return E_INVALIDARG;
281 bytes->bytes = writer->output_buf->ptr;
282 bytes->length = writer->output_buf->size;
283 return S_OK;
284 }
285 default:
286 return prop_get( writer->prop, writer->prop_count, id, buf, size );
287 }
288 }
289
290 static void set_output_buffer( struct writer *writer, struct xmlbuf *xmlbuf )
291 {
292 /* free current buffer if it's ours */
293 if (writer->output_buf && writer->output_buf->heap == writer->output_heap)
294 {
295 free_xmlbuf( writer->output_buf );
296 }
297 writer->output_buf = xmlbuf;
298 writer->output_type = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
299 writer->write_bufptr = xmlbuf->ptr;
300 writer->write_pos = 0;
301 }
302
303 /**************************************************************************
304 * WsSetOutput [webservices.@]
305 */
306 HRESULT WINAPI WsSetOutput( WS_XML_WRITER *handle, const WS_XML_WRITER_ENCODING *encoding,
307 const WS_XML_WRITER_OUTPUT *output, const WS_XML_WRITER_PROPERTY *properties,
308 ULONG count, WS_ERROR *error )
309 {
310 struct writer *writer = (struct writer *)handle;
311 struct node *node;
312 HRESULT hr;
313 ULONG i;
314
315 TRACE( "%p %p %p %p %u %p\n", handle, encoding, output, properties, count, error );
316 if (error) FIXME( "ignoring error parameter\n" );
317
318 if (!writer) return E_INVALIDARG;
319
320 for (i = 0; i < count; i++)
321 {
322 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
323 properties[i].valueSize );
324 if (hr != S_OK) return hr;
325 }
326
327 if ((hr = write_init_state( writer )) != S_OK) return hr;
328
329 switch (encoding->encodingType)
330 {
331 case WS_XML_WRITER_ENCODING_TYPE_TEXT:
332 {
333 WS_XML_WRITER_TEXT_ENCODING *text = (WS_XML_WRITER_TEXT_ENCODING *)encoding;
334 if (text->charSet != WS_CHARSET_UTF8)
335 {
336 FIXME( "charset %u not supported\n", text->charSet );
337 return E_NOTIMPL;
338 }
339 break;
340 }
341 default:
342 FIXME( "encoding type %u not supported\n", encoding->encodingType );
343 return E_NOTIMPL;
344 }
345 switch (output->outputType)
346 {
347 case WS_XML_WRITER_OUTPUT_TYPE_BUFFER:
348 {
349 struct xmlbuf *xmlbuf;
350
351 if (!(xmlbuf = alloc_xmlbuf( writer->output_heap ))) return E_OUTOFMEMORY;
352 set_output_buffer( writer, xmlbuf );
353 break;
354 }
355 default:
356 FIXME( "output type %u not supported\n", output->outputType );
357 return E_NOTIMPL;
358 }
359
360 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
361 write_insert_bof( writer, node );
362 return S_OK;
363 }
364
365 /**************************************************************************
366 * WsSetOutputToBuffer [webservices.@]
367 */
368 HRESULT WINAPI WsSetOutputToBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer,
369 const WS_XML_WRITER_PROPERTY *properties, ULONG count,
370 WS_ERROR *error )
371 {
372 struct writer *writer = (struct writer *)handle;
373 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
374 struct node *node;
375 HRESULT hr;
376 ULONG i;
377
378 TRACE( "%p %p %p %u %p\n", handle, buffer, properties, count, error );
379 if (error) FIXME( "ignoring error parameter\n" );
380
381 if (!writer || !xmlbuf) return E_INVALIDARG;
382
383 for (i = 0; i < count; i++)
384 {
385 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
386 properties[i].valueSize );
387 if (hr != S_OK) return hr;
388 }
389
390 if ((hr = write_init_state( writer )) != S_OK) return hr;
391 set_output_buffer( writer, xmlbuf );
392
393 if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) return E_OUTOFMEMORY;
394 write_insert_bof( writer, node );
395 return S_OK;
396 }
397
398 static HRESULT write_grow_buffer( struct writer *writer, ULONG size )
399 {
400 struct xmlbuf *buf = writer->output_buf;
401 SIZE_T new_size;
402 void *tmp;
403
404 if (buf->size_allocated >= writer->write_pos + size)
405 {
406 buf->size = writer->write_pos + size;
407 return S_OK;
408 }
409 new_size = max( buf->size_allocated * 2, writer->write_pos + size );
410 if (!(tmp = ws_realloc( buf->heap, buf->ptr, new_size ))) return E_OUTOFMEMORY;
411 writer->write_bufptr = buf->ptr = tmp;
412 buf->size_allocated = new_size;
413 buf->size = writer->write_pos + size;
414 return S_OK;
415 }
416
417 static inline void write_char( struct writer *writer, unsigned char ch )
418 {
419 writer->write_bufptr[writer->write_pos++] = ch;
420 }
421
422 static inline void write_bytes( struct writer *writer, const BYTE *bytes, ULONG len )
423 {
424 memcpy( writer->write_bufptr + writer->write_pos, bytes, len );
425 writer->write_pos += len;
426 }
427
428 static HRESULT write_attribute( struct writer *writer, WS_XML_ATTRIBUTE *attr )
429 {
430 WS_XML_UTF8_TEXT *text = (WS_XML_UTF8_TEXT *)attr->value;
431 unsigned char quote = attr->singleQuote ? '\'' : '"';
432 const WS_XML_STRING *prefix;
433 ULONG size;
434 HRESULT hr;
435
436 if (attr->prefix) prefix = attr->prefix;
437 else prefix = writer->current->hdr.prefix;
438
439 /* ' prefix:attr="value"' */
440
441 size = attr->localName->length + 4 /* ' =""' */;
442 if (prefix) size += prefix->length + 1 /* ':' */;
443 if (text) size += text->value.length;
444 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
445
446 write_char( writer, ' ' );
447 if (prefix)
448 {
449 write_bytes( writer, prefix->bytes, prefix->length );
450 write_char( writer, ':' );
451 }
452 write_bytes( writer, attr->localName->bytes, attr->localName->length );
453 write_char( writer, '=' );
454 write_char( writer, quote );
455 if (text) write_bytes( writer, text->value.bytes, text->value.length );
456 write_char( writer, quote );
457
458 return S_OK;
459 }
460
461 static inline BOOL is_current_namespace( struct writer *writer, const WS_XML_STRING *ns )
462 {
463 return (WsXmlStringEquals( writer->current_ns, ns, NULL ) == S_OK);
464 }
465
466 /**************************************************************************
467 * WsGetPrefixFromNamespace [webservices.@]
468 */
469 HRESULT WINAPI WsGetPrefixFromNamespace( WS_XML_WRITER *handle, const WS_XML_STRING *ns,
470 BOOL required, const WS_XML_STRING **prefix,
471 WS_ERROR *error )
472 {
473 struct writer *writer = (struct writer *)handle;
474 WS_XML_ELEMENT_NODE *elem;
475 BOOL found = FALSE;
476
477 TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(ns), required, prefix, error );
478 if (error) FIXME( "ignoring error parameter\n" );
479
480 if (!writer || !ns || !prefix) return E_INVALIDARG;
481
482 elem = &writer->current->hdr;
483 if (elem->prefix && is_current_namespace( writer, ns ))
484 {
485 *prefix = elem->prefix;
486 found = TRUE;
487 }
488 if (!found)
489 {
490 if (required) return WS_E_INVALID_FORMAT;
491 *prefix = NULL;
492 return S_FALSE;
493 }
494 return S_OK;
495 }
496
497 static HRESULT set_current_namespace( struct writer *writer, const WS_XML_STRING *ns )
498 {
499 WS_XML_STRING *str;
500 if (!(str = alloc_xml_string( ns->bytes, ns->length ))) return E_OUTOFMEMORY;
501 heap_free( writer->current_ns );
502 writer->current_ns = str;
503 return S_OK;
504 }
505
506 static HRESULT write_namespace_attribute( struct writer *writer, WS_XML_ATTRIBUTE *attr )
507 {
508 unsigned char quote = attr->singleQuote ? '\'' : '"';
509 ULONG size;
510 HRESULT hr;
511
512 /* ' xmlns:prefix="namespace"' */
513
514 size = attr->ns->length + 9 /* ' xmlns=""' */;
515 if (attr->prefix) size += attr->prefix->length + 1 /* ':' */;
516 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
517
518 write_bytes( writer, (const BYTE *)" xmlns", 6 );
519 if (attr->prefix)
520 {
521 write_char( writer, ':' );
522 write_bytes( writer, attr->prefix->bytes, attr->prefix->length );
523 }
524 write_char( writer, '=' );
525 write_char( writer, quote );
526 write_bytes( writer, attr->ns->bytes, attr->ns->length );
527 write_char( writer, quote );
528
529 return S_OK;
530 }
531
532 static HRESULT write_add_namespace_attribute( struct writer *writer, const WS_XML_STRING *prefix,
533 const WS_XML_STRING *ns, BOOL single )
534 {
535 WS_XML_ATTRIBUTE *attr;
536 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
537 HRESULT hr;
538
539 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
540
541 attr->singleQuote = !!single;
542 attr->isXmlNs = 1;
543 if (prefix && !(attr->prefix = alloc_xml_string( prefix->bytes, prefix->length )))
544 {
545 free_attribute( attr );
546 return E_OUTOFMEMORY;
547 }
548 if (!(attr->ns = alloc_xml_string( ns->bytes, ns->length )))
549 {
550 free_attribute( attr );
551 return E_OUTOFMEMORY;
552 }
553 if ((hr = append_attribute( elem, attr )) != S_OK)
554 {
555 free_attribute( attr );
556 return hr;
557 }
558 return S_OK;
559 }
560
561 static BOOL namespace_in_scope( const WS_XML_ELEMENT_NODE *elem, const WS_XML_STRING *prefix,
562 const WS_XML_STRING *ns )
563 {
564 ULONG i;
565 const struct node *node;
566
567 for (node = (const struct node *)elem; node; node = node->parent)
568 {
569 if (node_type( node ) != WS_XML_NODE_TYPE_ELEMENT) break;
570
571 elem = &node->hdr;
572 for (i = 0; i < elem->attributeCount; i++)
573 {
574 if (!elem->attributes[i]->isXmlNs) continue;
575 if (WsXmlStringEquals( elem->attributes[i]->prefix, prefix, NULL ) == S_OK &&
576 WsXmlStringEquals( elem->attributes[i]->ns, ns, NULL ) == S_OK)
577 {
578 return TRUE;
579 }
580 }
581 }
582 return FALSE;
583 }
584
585 static HRESULT write_set_element_namespace( struct writer *writer )
586 {
587 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
588 HRESULT hr;
589
590 if (!elem->ns->length || is_current_namespace( writer, elem->ns ) ||
591 namespace_in_scope( elem, elem->prefix, elem->ns )) return S_OK;
592
593 if ((hr = write_add_namespace_attribute( writer, elem->prefix, elem->ns, FALSE )) != S_OK)
594 return hr;
595
596 return set_current_namespace( writer, elem->ns );
597 }
598
599 /**************************************************************************
600 * WsWriteEndAttribute [webservices.@]
601 */
602 HRESULT WINAPI WsWriteEndAttribute( WS_XML_WRITER *handle, WS_ERROR *error )
603 {
604 struct writer *writer = (struct writer *)handle;
605
606 TRACE( "%p %p\n", handle, error );
607 if (error) FIXME( "ignoring error parameter\n" );
608
609 if (!writer) return E_INVALIDARG;
610
611 writer->state = WRITER_STATE_STARTELEMENT;
612 return S_OK;
613 }
614
615 static HRESULT write_startelement( struct writer *writer )
616 {
617 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
618 ULONG size, i;
619 HRESULT hr;
620
621 /* '<prefix:localname prefix:attr="value"... xmlns:prefix="ns"'... */
622
623 size = elem->localName->length + 1 /* '<' */;
624 if (elem->prefix) size += elem->prefix->length + 1 /* ':' */;
625 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
626
627 write_char( writer, '<' );
628 if (elem->prefix)
629 {
630 write_bytes( writer, elem->prefix->bytes, elem->prefix->length );
631 write_char( writer, ':' );
632 }
633 write_bytes( writer, elem->localName->bytes, elem->localName->length );
634 for (i = 0; i < elem->attributeCount; i++)
635 {
636 if (elem->attributes[i]->isXmlNs) continue;
637 if ((hr = write_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
638 }
639 for (i = 0; i < elem->attributeCount; i++)
640 {
641 if (!elem->attributes[i]->isXmlNs || !elem->attributes[i]->prefix) continue;
642 if ((hr = write_namespace_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
643 }
644 for (i = 0; i < elem->attributeCount; i++)
645 {
646 if (!elem->attributes[i]->isXmlNs || elem->attributes[i]->prefix) continue;
647 if ((hr = write_namespace_attribute( writer, elem->attributes[i] )) != S_OK) return hr;
648 }
649 return S_OK;
650 }
651
652 static struct node *write_find_startelement( struct writer *writer )
653 {
654 struct node *node;
655 for (node = writer->current; node; node = node->parent)
656 {
657 if (node_type( node ) == WS_XML_NODE_TYPE_ELEMENT) return node;
658 }
659 return NULL;
660 }
661
662 static inline BOOL is_empty_element( const struct node *node )
663 {
664 const struct node *head = LIST_ENTRY( list_head( &node->children ), struct node, entry );
665 return node_type( head ) == WS_XML_NODE_TYPE_END_ELEMENT;
666 }
667
668 static HRESULT write_endelement( struct writer *writer, const WS_XML_ELEMENT_NODE *elem )
669 {
670 ULONG size;
671 HRESULT hr;
672
673 /* '/>' */
674
675 if (elem->isEmpty && writer->state != WRITER_STATE_ENDSTARTELEMENT)
676 {
677 if ((hr = write_grow_buffer( writer, 2 )) != S_OK) return hr;
678 write_char( writer, '/' );
679 write_char( writer, '>' );
680 return S_OK;
681 }
682
683 /* '</prefix:localname>' */
684
685 size = elem->localName->length + 3 /* '</>' */;
686 if (elem->prefix) size += elem->prefix->length + 1 /* ':' */;
687 if ((hr = write_grow_buffer( writer, size )) != S_OK) return hr;
688
689 write_char( writer, '<' );
690 write_char( writer, '/' );
691 if (elem->prefix)
692 {
693 write_bytes( writer, elem->prefix->bytes, elem->prefix->length );
694 write_char( writer, ':' );
695 }
696 write_bytes( writer, elem->localName->bytes, elem->localName->length );
697 write_char( writer, '>' );
698 return S_OK;
699 }
700
701 static HRESULT write_close_element( struct writer *writer, struct node *node )
702 {
703 WS_XML_ELEMENT_NODE *elem = &node->hdr;
704 elem->isEmpty = is_empty_element( node );
705 return write_endelement( writer, elem );
706 }
707
708 static HRESULT write_endelement_node( struct writer *writer )
709 {
710 struct node *node;
711 HRESULT hr;
712
713 if (!(node = write_find_startelement( writer ))) return WS_E_INVALID_FORMAT;
714 if (writer->state == WRITER_STATE_STARTELEMENT)
715 {
716 if ((hr = write_set_element_namespace( writer )) != S_OK) return hr;
717 if ((hr = write_startelement( writer )) != S_OK) return hr;
718 }
719 if ((hr = write_close_element( writer, node )) != S_OK) return hr;
720 writer->current = node->parent;
721 writer->state = WRITER_STATE_ENDELEMENT;
722 return S_OK;
723 }
724
725 /**************************************************************************
726 * WsWriteEndElement [webservices.@]
727 */
728 HRESULT WINAPI WsWriteEndElement( WS_XML_WRITER *handle, WS_ERROR *error )
729 {
730 struct writer *writer = (struct writer *)handle;
731
732 TRACE( "%p %p\n", handle, error );
733 if (error) FIXME( "ignoring error parameter\n" );
734
735 if (!writer) return E_INVALIDARG;
736 return write_endelement_node( writer );
737 }
738
739 static HRESULT write_endstartelement( struct writer *writer )
740 {
741 HRESULT hr;
742 if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr;
743 write_char( writer, '>' );
744 return S_OK;
745 }
746
747 /**************************************************************************
748 * WsWriteEndStartElement [webservices.@]
749 */
750 HRESULT WINAPI WsWriteEndStartElement( WS_XML_WRITER *handle, WS_ERROR *error )
751 {
752 struct writer *writer = (struct writer *)handle;
753 HRESULT hr;
754
755 TRACE( "%p %p\n", handle, error );
756 if (error) FIXME( "ignoring error parameter\n" );
757
758 if (!writer) return E_INVALIDARG;
759 if (writer->state != WRITER_STATE_STARTELEMENT) return WS_E_INVALID_OPERATION;
760
761 if ((hr = write_set_element_namespace( writer )) != S_OK) return hr;
762 if ((hr = write_startelement( writer )) != S_OK) return hr;
763 if ((hr = write_endstartelement( writer )) != S_OK) return hr;
764
765 writer->state = WRITER_STATE_ENDSTARTELEMENT;
766 return S_OK;
767 }
768
769 static HRESULT write_add_attribute( struct writer *writer, const WS_XML_STRING *prefix,
770 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
771 BOOL single )
772 {
773 WS_XML_ATTRIBUTE *attr;
774 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
775 HRESULT hr;
776
777 if (!(attr = heap_alloc_zero( sizeof(*attr) ))) return E_OUTOFMEMORY;
778
779 if (!prefix) prefix = elem->prefix;
780
781 attr->singleQuote = !!single;
782 if (prefix && !(attr->prefix = alloc_xml_string( prefix->bytes, prefix->length )))
783 {
784 free_attribute( attr );
785 return E_OUTOFMEMORY;
786 }
787 if (!(attr->localName = alloc_xml_string( localname->bytes, localname->length )))
788 {
789 free_attribute( attr );
790 return E_OUTOFMEMORY;
791 }
792 if (!(attr->ns = alloc_xml_string( ns->bytes, ns->length )))
793 {
794 free_attribute( attr );
795 return E_OUTOFMEMORY;
796 }
797 if ((hr = append_attribute( elem, attr )) != S_OK)
798 {
799 free_attribute( attr );
800 return hr;
801 }
802 return S_OK;
803 }
804
805 /**************************************************************************
806 * WsWriteStartAttribute [webservices.@]
807 */
808 HRESULT WINAPI WsWriteStartAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
809 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
810 BOOL single, WS_ERROR *error )
811 {
812 struct writer *writer = (struct writer *)handle;
813 HRESULT hr;
814
815 TRACE( "%p %s %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname),
816 debugstr_xmlstr(ns), single, error );
817 if (error) FIXME( "ignoring error parameter\n" );
818
819 if (!writer || !localname || !ns) return E_INVALIDARG;
820
821 if (writer->state != WRITER_STATE_STARTELEMENT) return WS_E_INVALID_OPERATION;
822
823 if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) != S_OK) return hr;
824 writer->state = WRITER_STATE_STARTATTRIBUTE;
825 return S_OK;
826 }
827
828 /* flush current start element if necessary */
829 static HRESULT write_flush( struct writer *writer )
830 {
831 if (writer->state == WRITER_STATE_STARTELEMENT)
832 {
833 HRESULT hr;
834 if ((hr = write_set_element_namespace( writer )) != S_OK) return hr;
835 if ((hr = write_startelement( writer )) != S_OK) return hr;
836 if ((hr = write_endstartelement( writer )) != S_OK) return hr;
837 writer->state = WRITER_STATE_ENDSTARTELEMENT;
838 }
839 return S_OK;
840 }
841
842 static HRESULT write_add_cdata_node( struct writer *writer )
843 {
844 struct node *node, *parent;
845 if (!(parent = find_parent( writer->current ))) return WS_E_INVALID_FORMAT;
846 if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY;
847 write_insert_node( writer, parent, node );
848 return S_OK;
849 }
850
851 static HRESULT write_add_endcdata_node( struct writer *writer )
852 {
853 struct node *node;
854 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_CDATA ))) return E_OUTOFMEMORY;
855 node->parent = writer->current;
856 list_add_tail( &node->parent->children, &node->entry );
857 return S_OK;
858 }
859
860 static HRESULT write_cdata( struct writer *writer )
861 {
862 HRESULT hr;
863 if ((hr = write_grow_buffer( writer, 9 )) != S_OK) return hr;
864 write_bytes( writer, (const BYTE *)"<![CDATA[", 9 );
865 return S_OK;
866 }
867
868 static HRESULT write_cdata_node( struct writer *writer )
869 {
870 HRESULT hr;
871 if ((hr = write_flush( writer )) != S_OK) return hr;
872 if ((hr = write_add_cdata_node( writer )) != S_OK) return hr;
873 if ((hr = write_add_endcdata_node( writer )) != S_OK) return hr;
874 if ((hr = write_cdata( writer )) != S_OK) return hr;
875 writer->state = WRITER_STATE_STARTCDATA;
876 return S_OK;
877 }
878
879 /**************************************************************************
880 * WsWriteStartCData [webservices.@]
881 */
882 HRESULT WINAPI WsWriteStartCData( WS_XML_WRITER *handle, WS_ERROR *error )
883 {
884 struct writer *writer = (struct writer *)handle;
885
886 TRACE( "%p %p\n", handle, error );
887 if (error) FIXME( "ignoring error parameter\n" );
888
889 if (!writer) return E_INVALIDARG;
890 return write_cdata_node( writer );
891 }
892
893 static HRESULT write_endcdata( struct writer *writer )
894 {
895 HRESULT hr;
896 if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr;
897 write_bytes( writer, (const BYTE *)"]]>", 3 );
898 return S_OK;
899 }
900
901 static HRESULT write_endcdata_node( struct writer *writer )
902 {
903 HRESULT hr;
904 if ((hr = write_endcdata( writer )) != S_OK) return hr;
905 writer->current = writer->current->parent;
906 writer->state = WRITER_STATE_ENDCDATA;
907 return S_OK;
908 }
909
910 /**************************************************************************
911 * WsWriteEndCData [webservices.@]
912 */
913 HRESULT WINAPI WsWriteEndCData( WS_XML_WRITER *handle, WS_ERROR *error )
914 {
915 struct writer *writer = (struct writer *)handle;
916
917 TRACE( "%p %p\n", handle, error );
918 if (error) FIXME( "ignoring error parameter\n" );
919
920 if (!writer) return E_INVALIDARG;
921 if (writer->state != WRITER_STATE_TEXT) return WS_E_INVALID_OPERATION;
922
923 return write_endcdata_node( writer );
924 }
925
926 static HRESULT write_add_element_node( struct writer *writer, const WS_XML_STRING *prefix,
927 const WS_XML_STRING *localname, const WS_XML_STRING *ns )
928 {
929 struct node *node, *parent;
930 WS_XML_ELEMENT_NODE *elem;
931
932 if (!(parent = find_parent( writer->current ))) return WS_E_INVALID_FORMAT;
933
934 if (!prefix && node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT)
935 {
936 elem = &parent->hdr;
937 if (WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK) prefix = elem->prefix;
938 }
939
940 if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return E_OUTOFMEMORY;
941 elem = &node->hdr;
942
943 if (prefix && !(elem->prefix = alloc_xml_string( prefix->bytes, prefix->length )))
944 {
945 free_node( node );
946 return E_OUTOFMEMORY;
947 }
948 if (!(elem->localName = alloc_xml_string( localname->bytes, localname->length )))
949 {
950 free_node( node );
951 return E_OUTOFMEMORY;
952 }
953 if (!(elem->ns = alloc_xml_string( ns->bytes, ns->length )))
954 {
955 free_node( node );
956 return E_OUTOFMEMORY;
957 }
958 write_insert_node( writer, parent, node );
959 return S_OK;
960 }
961
962 static HRESULT write_add_endelement_node( struct writer *writer, struct node *parent )
963 {
964 struct node *node;
965 if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY;
966 node->parent = parent;
967 list_add_tail( &parent->children, &node->entry );
968 return S_OK;
969 }
970
971 static HRESULT write_element_node( struct writer *writer, const WS_XML_STRING *prefix,
972 const WS_XML_STRING *localname, const WS_XML_STRING *ns )
973 {
974 HRESULT hr;
975 if ((hr = write_flush( writer )) != S_OK) return hr;
976 if ((hr = write_add_element_node( writer, prefix, localname, ns )) != S_OK) return hr;
977 if ((hr = write_add_endelement_node( writer, writer->current )) != S_OK) return hr;
978 writer->state = WRITER_STATE_STARTELEMENT;
979 return S_OK;
980 }
981
982 /**************************************************************************
983 * WsWriteStartElement [webservices.@]
984 */
985 HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
986 const WS_XML_STRING *localname, const WS_XML_STRING *ns,
987 WS_ERROR *error )
988 {
989 struct writer *writer = (struct writer *)handle;
990
991 TRACE( "%p %s %s %s %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname),
992 debugstr_xmlstr(ns), error );
993 if (error) FIXME( "ignoring error parameter\n" );
994
995 if (!writer || !localname || !ns) return E_INVALIDARG;
996 return write_element_node( writer, prefix, localname, ns );
997 }
998
999 static ULONG format_bool( const BOOL *ptr, unsigned char *buf )
1000 {
1001 static const unsigned char bool_true[] = {'t','r','u','e'}, bool_false[] = {'f','a','l','s','e'};
1002 if (*ptr)
1003 {
1004 memcpy( buf, bool_true, sizeof(bool_true) );
1005 return sizeof(bool_true);
1006 }
1007 memcpy( buf, bool_false, sizeof(bool_false) );
1008 return sizeof(bool_false);
1009 }
1010
1011 static ULONG format_int8( const INT8 *ptr, unsigned char *buf )
1012 {
1013 return wsprintfA( (char *)buf, "%d", *ptr );
1014 }
1015
1016 static ULONG format_int16( const INT16 *ptr, unsigned char *buf )
1017 {
1018 return wsprintfA( (char *)buf, "%d", *ptr );
1019 }
1020
1021 static ULONG format_int32( const INT32 *ptr, unsigned char *buf )
1022 {
1023 return wsprintfA( (char *)buf, "%d", *ptr );
1024 }
1025
1026 static ULONG format_int64( const INT64 *ptr, unsigned char *buf )
1027 {
1028 return wsprintfA( (char *)buf, "%I64d", *ptr );
1029 }
1030
1031 static ULONG format_uint8( const UINT8 *ptr, unsigned char *buf )
1032 {
1033 return wsprintfA( (char *)buf, "%u", *ptr );
1034 }
1035
1036 static ULONG format_uint16( const UINT16 *ptr, unsigned char *buf )
1037 {
1038 return wsprintfA( (char *)buf, "%u", *ptr );
1039 }
1040
1041 static ULONG format_uint32( const UINT32 *ptr, unsigned char *buf )
1042 {
1043 return wsprintfA( (char *)buf, "%u", *ptr );
1044 }
1045
1046 static ULONG format_uint64( const UINT64 *ptr, unsigned char *buf )
1047 {
1048 return wsprintfA( (char *)buf, "%I64u", *ptr );
1049 }
1050
1051 static ULONG format_double( const double *ptr, unsigned char *buf )
1052 {
1053 #ifdef HAVE_POWL
1054 static const long double precision = 0.0000000000000001;
1055 unsigned char *p = buf;
1056 long double val = *ptr;
1057 int neg, mag, mag2, use_exp;
1058
1059 if (isnan( val ))
1060 {
1061 memcpy( buf, "NaN", 3 );
1062 return 3;
1063 }
1064 if (isinf( val ))
1065 {
1066 if (val < 0)
1067 {
1068 memcpy( buf, "-INF", 4 );
1069 return 4;
1070 }
1071 memcpy( buf, "INF", 3 );
1072 return 3;
1073 }
1074 if (val == 0.0)
1075 {
1076 *p = '0';
1077 return 1;
1078 }
1079
1080 if ((neg = val < 0))
1081 {
1082 *p++ = '-';
1083 val = -val;
1084 }
1085
1086 mag = log10l( val );
1087 use_exp = (mag >= 15 || (neg && mag >= 1) || mag <= -1);
1088 if (use_exp)
1089 {
1090 if (mag < 0) mag -= 1;
1091 val = val / powl( 10.0, mag );
1092 mag2 = mag;
1093 mag = 0;
1094 }
1095 else if (mag < 1) mag = 0;
1096
1097 while (val > precision || mag >= 0)
1098 {
1099 long double weight = powl( 10.0, mag );
1100 if (weight > 0 && !isinf( weight ))
1101 {
1102 int digit = floorl( val / weight );
1103 val -= digit * weight;
1104 *(p++) = '0' + digit;
1105 }
1106 if (!mag && val > precision) *(p++) = '.';
1107 mag--;
1108 }
1109
1110 if (use_exp)
1111 {
1112 int i, j;
1113 *(p++) = 'E';
1114 if (mag2 > 0) *(p++) = '+';
1115 else
1116 {
1117 *(p++) = '-';
1118 mag2 = -mag2;
1119 }
1120 mag = 0;
1121 while (mag2 > 0)
1122 {
1123 *(p++) = '0' + mag2 % 10;
1124 mag2 /= 10;
1125 mag++;
1126 }
1127 for (i = -mag, j = -1; i < j; i++, j--)
1128 {
1129 p[i] ^= p[j];
1130 p[j] ^= p[i];
1131 p[i] ^= p[j];
1132 }
1133 }
1134
1135 return p - buf;
1136 #else
1137 FIXME( "powl not found at build time\n" );
1138 return 0;
1139 #endif
1140 }
1141
1142 static ULONG format_guid( const GUID *ptr, unsigned char *buf )
1143 {
1144 static const char fmt[] = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
1145 return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3,
1146 ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3],
1147 ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] );
1148 }
1149
1150 static ULONG format_urn( const GUID *ptr, unsigned char *buf )
1151 {
1152 static const char fmt[] = "urn:uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
1153 return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3,
1154 ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3],
1155 ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] );
1156 }
1157
1158 static HRESULT text_to_utf8text( const WS_XML_TEXT *text, WS_XML_UTF8_TEXT **ret )
1159 {
1160 switch (text->textType)
1161 {
1162 case WS_XML_TEXT_TYPE_UTF8:
1163 {
1164 const WS_XML_UTF8_TEXT *src = (const WS_XML_UTF8_TEXT *)text;
1165 if (!(*ret = alloc_utf8_text( src->value.bytes, src->value.length ))) return E_OUTOFMEMORY;
1166 return S_OK;
1167 }
1168 case WS_XML_TEXT_TYPE_UTF16:
1169 {
1170 const WS_XML_UTF16_TEXT *src = (const WS_XML_UTF16_TEXT *)text;
1171 const WCHAR *str = (const WCHAR *)src->bytes;
1172 ULONG len = src->byteCount / sizeof(WCHAR), len_utf8;
1173
1174 if (src->byteCount % sizeof(WCHAR)) return E_INVALIDARG;
1175 len_utf8 = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL );
1176 if (!(*ret = alloc_utf8_text( NULL, len_utf8 ))) return E_OUTOFMEMORY;
1177 WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)(*ret)->value.bytes, (*ret)->value.length, NULL, NULL );
1178 return S_OK;
1179 }
1180 case WS_XML_TEXT_TYPE_BOOL:
1181 {
1182 const WS_XML_BOOL_TEXT *bool_text = (const WS_XML_BOOL_TEXT *)text;
1183 if (!(*ret = alloc_utf8_text( NULL, 5 ))) return E_OUTOFMEMORY;
1184 (*ret)->value.length = format_bool( &bool_text->value, (*ret)->value.bytes );
1185 return S_OK;
1186 }
1187 case WS_XML_TEXT_TYPE_INT32:
1188 {
1189 const WS_XML_INT32_TEXT *int32_text = (const WS_XML_INT32_TEXT *)text;
1190 unsigned char buf[12]; /* "-2147483648" */
1191 ULONG len = format_int32( &int32_text->value, buf );
1192 if (!(*ret = alloc_utf8_text( buf, len ))) return E_OUTOFMEMORY;
1193 return S_OK;
1194 }
1195 case WS_XML_TEXT_TYPE_INT64:
1196 {
1197 const WS_XML_INT64_TEXT *int64_text = (const WS_XML_INT64_TEXT *)text;
1198 unsigned char buf[21]; /* "-9223372036854775808" */
1199 ULONG len = format_int64( &int64_text->value, buf );
1200 if (!(*ret = alloc_utf8_text( buf, len ))) return E_OUTOFMEMORY;
1201 return S_OK;
1202 }
1203 case WS_XML_TEXT_TYPE_UINT64:
1204 {
1205 const WS_XML_UINT64_TEXT *uint64_text = (const WS_XML_UINT64_TEXT *)text;
1206 unsigned char buf[21]; /* "18446744073709551615" */
1207 ULONG len = format_uint64( &uint64_text->value, buf );
1208 if (!(*ret = alloc_utf8_text( buf, len ))) return E_OUTOFMEMORY;
1209 return S_OK;
1210 }
1211 case WS_XML_TEXT_TYPE_DOUBLE:
1212 {
1213 const WS_XML_DOUBLE_TEXT *double_text = (const WS_XML_DOUBLE_TEXT *)text;
1214 unsigned char buf[24]; /* "-1.1111111111111111E-308" */
1215 unsigned short fpword;
1216 ULONG len;
1217
1218 if (!set_fp_rounding( &fpword )) return E_NOTIMPL;
1219 len = format_double( &double_text->value, buf );
1220 restore_fp_rounding( fpword );
1221 if (!len) return E_NOTIMPL;
1222 if (!(*ret = alloc_utf8_text( buf, len ))) return E_OUTOFMEMORY;
1223 return S_OK;
1224 }
1225 case WS_XML_TEXT_TYPE_GUID:
1226 {
1227 const WS_XML_GUID_TEXT *id = (const WS_XML_GUID_TEXT *)text;
1228 if (!(*ret = alloc_utf8_text( NULL, 37 ))) return E_OUTOFMEMORY;
1229 (*ret)->value.length = format_guid( &id->value, (*ret)->value.bytes );
1230 return S_OK;
1231 }
1232 case WS_XML_TEXT_TYPE_UNIQUE_ID:
1233 {
1234 const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text;
1235 if (!(*ret = alloc_utf8_text( NULL, 46 ))) return E_OUTOFMEMORY;
1236 (*ret)->value.length = format_urn( &id->value, (*ret)->value.bytes );
1237 return S_OK;
1238 }
1239 default:
1240 FIXME( "unhandled text type %u\n", text->textType );
1241 return E_NOTIMPL;
1242 }
1243 }
1244
1245 static HRESULT write_set_attribute_value( struct writer *writer, const WS_XML_TEXT *value )
1246 {
1247 WS_XML_ELEMENT_NODE *elem = &writer->current->hdr;
1248 WS_XML_UTF8_TEXT *utf8;
1249 HRESULT hr;
1250
1251 if ((hr = text_to_utf8text( value, &utf8 )) != S_OK) return hr;
1252 elem->attributes[elem->attributeCount - 1]->value = &utf8->text;
1253 return S_OK;
1254 }
1255
1256 static HRESULT write_add_text_node( struct writer *writer, const WS_XML_TEXT *value )
1257 {
1258 struct node *node;
1259 WS_XML_TEXT_NODE *text;
1260 WS_XML_UTF8_TEXT *utf8;
1261 HRESULT hr;
1262
1263 if (node_type( writer->current ) != WS_XML_NODE_TYPE_ELEMENT &&
1264 node_type( writer->current ) != WS_XML_NODE_TYPE_BOF &&
1265 node_type( writer->current ) != WS_XML_NODE_TYPE_CDATA) return WS_E_INVALID_FORMAT;
1266
1267 if (!(node = alloc_node( WS_XML_NODE_TYPE_TEXT ))) return E_OUTOFMEMORY;
1268 if ((hr = text_to_utf8text( value, &utf8 )) != S_OK)
1269 {
1270 heap_free( node );
1271 return hr;
1272 }
1273 text = (WS_XML_TEXT_NODE *)node;
1274 text->text = &utf8->text;
1275
1276 write_insert_node( writer, writer->current, node );
1277 return S_OK;
1278 }
1279
1280 static HRESULT write_text( struct writer *writer )
1281 {
1282 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)writer->current;
1283 const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text->text;
1284 HRESULT hr;
1285
1286 if ((hr = write_grow_buffer( writer, utf8->value.length )) != S_OK) return hr;
1287 write_bytes( writer, utf8->value.bytes, utf8->value.length );
1288 return S_OK;
1289 }
1290
1291 static HRESULT write_text_node( struct writer *writer, const WS_XML_TEXT *text )
1292 {
1293 HRESULT hr;
1294 if ((hr = write_flush( writer )) != S_OK) return hr;
1295 if ((hr = write_add_text_node( writer, text )) != S_OK) return hr;
1296 if ((hr = write_text( writer )) != S_OK) return hr;
1297 writer->state = WRITER_STATE_TEXT;
1298 return S_OK;
1299 }
1300
1301 /**************************************************************************
1302 * WsWriteText [webservices.@]
1303 */
1304 HRESULT WINAPI WsWriteText( WS_XML_WRITER *handle, const WS_XML_TEXT *text, WS_ERROR *error )
1305 {
1306 struct writer *writer = (struct writer *)handle;
1307
1308 TRACE( "%p %p %p\n", handle, text, error );
1309
1310 if (!writer || !text) return E_INVALIDARG;
1311
1312 if (writer->state == WRITER_STATE_STARTATTRIBUTE) return write_set_attribute_value( writer, text );
1313 return write_text_node( writer, text );
1314 }
1315
1316 static HRESULT write_type_text( struct writer *writer, WS_TYPE_MAPPING mapping, const WS_XML_TEXT *text )
1317 {
1318 switch (mapping)
1319 {
1320 case WS_ELEMENT_TYPE_MAPPING:
1321 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1322 return write_text_node( writer, text );
1323
1324 case WS_ATTRIBUTE_TYPE_MAPPING:
1325 return write_set_attribute_value( writer, text );
1326
1327 case WS_ANY_ELEMENT_TYPE_MAPPING:
1328 switch (writer->state)
1329 {
1330 case WRITER_STATE_STARTATTRIBUTE:
1331 return write_set_attribute_value( writer, text );
1332
1333 case WRITER_STATE_STARTELEMENT:
1334 return write_text_node( writer, text );
1335
1336 default:
1337 FIXME( "writer state %u not handled\n", writer->state );
1338 return E_NOTIMPL;
1339 }
1340
1341 default:
1342 FIXME( "mapping %u not implemented\n", mapping );
1343 return E_NOTIMPL;
1344 }
1345 }
1346
1347 static HRESULT write_type_bool( struct writer *writer, WS_TYPE_MAPPING mapping,
1348 const WS_BOOL_DESCRIPTION *desc, const BOOL *value )
1349 {
1350 WS_XML_UTF8_TEXT utf8;
1351 unsigned char buf[6]; /* "false" */
1352
1353 if (desc)
1354 {
1355 FIXME( "description not supported\n" );
1356 return E_NOTIMPL;
1357 }
1358 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1359 utf8.value.bytes = buf;
1360 utf8.value.length = format_bool( value, buf );
1361 return write_type_text( writer, mapping, &utf8.text );
1362 }
1363
1364 static HRESULT write_type_int8( struct writer *writer, WS_TYPE_MAPPING mapping,
1365 const WS_INT8_DESCRIPTION *desc, const INT8 *value )
1366 {
1367 WS_XML_UTF8_TEXT utf8;
1368 unsigned char buf[5]; /* "-128" */
1369
1370 if (desc)
1371 {
1372 FIXME( "description not supported\n" );
1373 return E_NOTIMPL;
1374 }
1375 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1376 utf8.value.bytes = buf;
1377 utf8.value.length = format_int8( value, buf );
1378 return write_type_text( writer, mapping, &utf8.text );
1379 }
1380
1381 static HRESULT write_type_int16( struct writer *writer, WS_TYPE_MAPPING mapping,
1382 const WS_INT16_DESCRIPTION *desc, const INT16 *value )
1383 {
1384 WS_XML_UTF8_TEXT utf8;
1385 unsigned char buf[7]; /* "-32768" */
1386
1387 if (desc)
1388 {
1389 FIXME( "description not supported\n" );
1390 return E_NOTIMPL;
1391 }
1392 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1393 utf8.value.bytes = buf;
1394 utf8.value.length = format_int16( value, buf );
1395 return write_type_text( writer, mapping, &utf8.text );
1396 }
1397
1398 static HRESULT write_type_int32( struct writer *writer, WS_TYPE_MAPPING mapping,
1399 const WS_INT32_DESCRIPTION *desc, const INT32 *value )
1400 {
1401 WS_XML_UTF8_TEXT utf8;
1402 unsigned char buf[12]; /* "-2147483648" */
1403
1404 if (desc)
1405 {
1406 FIXME( "description not supported\n" );
1407 return E_NOTIMPL;
1408 }
1409 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1410 utf8.value.bytes = buf;
1411 utf8.value.length = format_int32( value, buf );
1412 return write_type_text( writer, mapping, &utf8.text );
1413 }
1414
1415 static HRESULT write_type_int64( struct writer *writer, WS_TYPE_MAPPING mapping,
1416 const WS_INT64_DESCRIPTION *desc, const INT64 *value )
1417 {
1418 WS_XML_UTF8_TEXT utf8;
1419 unsigned char buf[21]; /* "-9223372036854775808" */
1420
1421 if (desc)
1422 {
1423 FIXME( "description not supported\n" );
1424 return E_NOTIMPL;
1425 }
1426 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1427 utf8.value.bytes = buf;
1428 utf8.value.length = format_int64( value, buf );
1429 return write_type_text( writer, mapping, &utf8.text );
1430 }
1431
1432 static HRESULT write_type_uint8( struct writer *writer, WS_TYPE_MAPPING mapping,
1433 const WS_UINT8_DESCRIPTION *desc, const UINT8 *value )
1434 {
1435 WS_XML_UTF8_TEXT utf8;
1436 unsigned char buf[4]; /* "255" */
1437
1438 if (desc)
1439 {
1440 FIXME( "description not supported\n" );
1441 return E_NOTIMPL;
1442 }
1443 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1444 utf8.value.bytes = buf;
1445 utf8.value.length = format_uint8( value, buf );
1446 return write_type_text( writer, mapping, &utf8.text );
1447 }
1448
1449 static HRESULT write_type_uint16( struct writer *writer, WS_TYPE_MAPPING mapping,
1450 const WS_UINT16_DESCRIPTION *desc, const UINT16 *value )
1451 {
1452 WS_XML_UTF8_TEXT utf8;
1453 unsigned char buf[6]; /* "65535" */
1454
1455 if (desc)
1456 {
1457 FIXME( "description not supported\n" );
1458 return E_NOTIMPL;
1459 }
1460 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1461 utf8.value.bytes = buf;
1462 utf8.value.length = format_uint16( value, buf );
1463 return write_type_text( writer, mapping, &utf8.text );
1464 }
1465
1466 static HRESULT write_type_uint32( struct writer *writer, WS_TYPE_MAPPING mapping,
1467 const WS_UINT32_DESCRIPTION *desc, const UINT32 *value )
1468 {
1469 WS_XML_UTF8_TEXT utf8;
1470 unsigned char buf[11]; /* "4294967295" */
1471
1472 if (desc)
1473 {
1474 FIXME( "description not supported\n" );
1475 return E_NOTIMPL;
1476 }
1477 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1478 utf8.value.bytes = buf;
1479 utf8.value.length = format_uint32( value, buf );
1480 return write_type_text( writer, mapping, &utf8.text );
1481 }
1482
1483 static HRESULT write_type_uint64( struct writer *writer, WS_TYPE_MAPPING mapping,
1484 const WS_UINT64_DESCRIPTION *desc, const UINT64 *value )
1485 {
1486 WS_XML_UTF8_TEXT utf8;
1487 unsigned char buf[21]; /* "18446744073709551615" */
1488
1489 if (desc)
1490 {
1491 FIXME( "description not supported\n" );
1492 return E_NOTIMPL;
1493 }
1494 utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1495 utf8.value.bytes = buf;
1496 utf8.value.length = format_uint64( value, buf );
1497 return write_type_text( writer, mapping, &utf8.text );
1498 }
1499
1500 static HRESULT write_type_wsz( struct writer *writer, WS_TYPE_MAPPING mapping,
1501 const WS_WSZ_DESCRIPTION *desc, const WCHAR *value )
1502 {
1503 WS_XML_UTF16_TEXT utf16;
1504
1505 if (desc)
1506 {
1507 FIXME( "description not supported\n" );
1508 return E_NOTIMPL;
1509 }
1510 utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
1511 utf16.bytes = (BYTE *)value;
1512 utf16.byteCount = strlenW( value ) * sizeof(WCHAR);
1513 return write_type_text( writer, mapping, &utf16.text );
1514 }
1515
1516 static HRESULT write_type( struct writer *, WS_TYPE_MAPPING, WS_TYPE, const void *, WS_WRITE_OPTION,
1517 const void *, ULONG );
1518
1519 static HRESULT write_type_struct_field( struct writer *writer, const WS_FIELD_DESCRIPTION *desc,
1520 const void *value, ULONG size )
1521 {
1522 HRESULT hr;
1523 WS_TYPE_MAPPING mapping;
1524 WS_WRITE_OPTION option;
1525
1526 if (!desc->options || desc->options == WS_FIELD_OPTIONAL) option = 0;
1527 else if (desc->options == WS_FIELD_POINTER) option = WS_WRITE_REQUIRED_POINTER;
1528 else
1529 {
1530 FIXME( "options 0x%x not supported\n", desc->options );
1531 return E_NOTIMPL;
1532 }
1533
1534 switch (desc->mapping)
1535 {
1536 case WS_ATTRIBUTE_FIELD_MAPPING:
1537 if (!desc->localName || !desc->ns) return E_INVALIDARG;
1538 if ((hr = write_add_attribute( writer, NULL, desc->localName, desc->ns, FALSE )) != S_OK)
1539 return hr;
1540 writer->state = WRITER_STATE_STARTATTRIBUTE;
1541
1542 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
1543 break;
1544
1545 case WS_ELEMENT_FIELD_MAPPING:
1546 if ((hr = write_element_node( writer, NULL, desc->localName, desc->ns )) != S_OK) return hr;
1547 mapping = WS_ELEMENT_TYPE_MAPPING;
1548 break;
1549
1550 case WS_TEXT_FIELD_MAPPING:
1551 switch (writer->state)
1552 {
1553 case WRITER_STATE_STARTELEMENT:
1554 mapping = WS_ELEMENT_CONTENT_TYPE_MAPPING;
1555 break;
1556
1557 case WRITER_STATE_STARTATTRIBUTE:
1558 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
1559 break;
1560
1561 default:
1562 FIXME( "unhandled writer state %u\n", writer->state );
1563 return E_NOTIMPL;
1564 }
1565 break;
1566
1567 default:
1568 FIXME( "field mapping %u not supported\n", desc->mapping );
1569 return E_NOTIMPL;
1570 }
1571
1572 if ((hr = write_type( writer, mapping, desc->type, desc->typeDescription, option, value, size )) != S_OK)
1573 return hr;
1574
1575 switch (mapping)
1576 {
1577 case WS_ATTRIBUTE_TYPE_MAPPING:
1578 writer->state = WRITER_STATE_STARTELEMENT;
1579 break;
1580
1581 case WS_ELEMENT_TYPE_MAPPING:
1582 if ((hr = write_endelement_node( writer )) != S_OK) return hr;
1583 break;
1584
1585 default: break;
1586 }
1587
1588 return S_OK;
1589 }
1590
1591 static ULONG get_field_size( const WS_STRUCT_DESCRIPTION *desc, ULONG index )
1592 {
1593 if (index < desc->fieldCount - 1) return desc->fields[index + 1]->offset - desc->fields[index]->offset;
1594 return desc->size - desc->fields[index]->offset;
1595 }
1596
1597 static HRESULT write_type_struct( struct writer *writer, WS_TYPE_MAPPING mapping,
1598 const WS_STRUCT_DESCRIPTION *desc, const void *value )
1599 {
1600 ULONG i, size;
1601 HRESULT hr;
1602 const char *ptr;
1603
1604 if (desc->structOptions)
1605 {
1606 FIXME( "struct options 0x%x not supported\n", desc->structOptions );
1607 return E_NOTIMPL;
1608 }
1609
1610 for (i = 0; i < desc->fieldCount; i++)
1611 {
1612 ptr = (const char *)value + desc->fields[i]->offset;
1613 size = get_field_size( desc, i );
1614 if ((hr = write_type_struct_field( writer, desc->fields[i], ptr, size )) != S_OK)
1615 return hr;
1616 }
1617
1618 return S_OK;
1619 }
1620
1621 static HRESULT get_value_ptr( WS_WRITE_OPTION option, const void *value, ULONG size, const void **ptr )
1622 {
1623 switch (option)
1624 {
1625 case WS_WRITE_REQUIRED_VALUE:
1626 if (!value || !size) return E_INVALIDARG;
1627 *ptr = value;
1628 return S_OK;
1629
1630 case WS_WRITE_REQUIRED_POINTER:
1631 if (size != sizeof(const void *) || !(*ptr = *(const void **)value)) return E_INVALIDARG;
1632 return S_OK;
1633
1634 default:
1635 FIXME( "option %08x not supported\n", option );
1636 return E_NOTIMPL;
1637 }
1638 }
1639
1640 static HRESULT write_type( struct writer *writer, WS_TYPE_MAPPING mapping, WS_TYPE type,
1641 const void *desc, WS_WRITE_OPTION option, const void *value,
1642 ULONG size )
1643 {
1644 HRESULT hr;
1645
1646 switch (type)
1647 {
1648 case WS_STRUCT_TYPE:
1649 {
1650 const void *ptr;
1651
1652 if (!desc || option == WS_WRITE_REQUIRED_VALUE) return E_INVALIDARG;
1653
1654 if (!option) option = WS_WRITE_REQUIRED_POINTER;
1655 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1656 return write_type_struct( writer, mapping, desc, ptr );
1657 }
1658 case WS_BOOL_TYPE:
1659 {
1660 const BOOL *ptr;
1661 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1662 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1663 return write_type_bool( writer, mapping, desc, ptr );
1664 }
1665 case WS_INT8_TYPE:
1666 {
1667 const INT8 *ptr = value;
1668 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1669 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1670 return write_type_int8( writer, mapping, desc, ptr );
1671 }
1672 case WS_INT16_TYPE:
1673 {
1674 const INT16 *ptr = value;
1675 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1676 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1677 return write_type_int16( writer, mapping, desc, ptr );
1678 }
1679 case WS_INT32_TYPE:
1680 {
1681 const INT32 *ptr;
1682 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1683 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1684 return write_type_int32( writer, mapping, desc, ptr );
1685 }
1686 case WS_INT64_TYPE:
1687 {
1688 const INT64 *ptr = value;
1689 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1690 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1691 return write_type_int64( writer, mapping, desc, ptr );
1692 }
1693 case WS_UINT8_TYPE:
1694 {
1695 const UINT8 *ptr = value;
1696 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1697 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1698 return write_type_uint8( writer, mapping, desc, ptr );
1699 }
1700 case WS_UINT16_TYPE:
1701 {
1702 const UINT16 *ptr = value;
1703 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1704 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1705 return write_type_uint16( writer, mapping, desc, ptr );
1706 }
1707 case WS_UINT32_TYPE:
1708 {
1709 const UINT32 *ptr = value;
1710 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1711 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1712 return write_type_uint32( writer, mapping, desc, ptr );
1713 }
1714 case WS_UINT64_TYPE:
1715 {
1716 const UINT64 *ptr = value;
1717 if (!option) option = WS_WRITE_REQUIRED_VALUE;
1718 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1719 return write_type_uint64( writer, mapping, desc, ptr );
1720 }
1721 case WS_WSZ_TYPE:
1722 {
1723 const WCHAR *ptr;
1724
1725 if (option == WS_WRITE_REQUIRED_VALUE) return E_INVALIDARG;
1726
1727 if (!option) option = WS_WRITE_REQUIRED_POINTER;
1728 if ((hr = get_value_ptr( option, value, size, (const void **)&ptr )) != S_OK) return hr;
1729 return write_type_wsz( writer, mapping, desc, ptr );
1730 }
1731 default:
1732 FIXME( "type %u not supported\n", type );
1733 return E_NOTIMPL;
1734 }
1735 }
1736
1737 /**************************************************************************
1738 * WsWriteAttribute [webservices.@]
1739 */
1740 HRESULT WINAPI WsWriteAttribute( WS_XML_WRITER *handle, const WS_ATTRIBUTE_DESCRIPTION *desc,
1741 WS_WRITE_OPTION option, const void *value, ULONG size,
1742 WS_ERROR *error )
1743 {
1744 struct writer *writer = (struct writer *)handle;
1745 HRESULT hr;
1746
1747 TRACE( "%p %p %u %p %u %p\n", handle, desc, option, value, size, error );
1748 if (error) FIXME( "ignoring error parameter\n" );
1749
1750 if (!writer || !desc || !desc->attributeLocalName || !desc->attributeNs || !value)
1751 return E_INVALIDARG;
1752
1753 if (writer->state != WRITER_STATE_STARTELEMENT) return WS_E_INVALID_OPERATION;
1754
1755 if ((hr = write_add_attribute( writer, NULL, desc->attributeLocalName, desc->attributeNs,
1756 FALSE )) != S_OK) return hr;
1757 writer->state = WRITER_STATE_STARTATTRIBUTE;
1758
1759 return write_type( writer, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->typeDescription,
1760 option, value, size );
1761 }
1762
1763 /**************************************************************************
1764 * WsWriteElement [webservices.@]
1765 */
1766 HRESULT WINAPI WsWriteElement( WS_XML_WRITER *handle, const WS_ELEMENT_DESCRIPTION *desc,
1767 WS_WRITE_OPTION option, const void *value, ULONG size,
1768 WS_ERROR *error )
1769 {
1770 struct writer *writer = (struct writer *)handle;
1771 HRESULT hr;
1772
1773 TRACE( "%p %p %u %p %u %p\n", handle, desc, option, value, size, error );
1774 if (error) FIXME( "ignoring error parameter\n" );
1775
1776 if (!writer || !desc || !desc->elementLocalName || !desc->elementNs || !value)
1777 return E_INVALIDARG;
1778
1779 if ((hr = write_element_node( writer, NULL, desc->elementLocalName, desc->elementNs )) != S_OK) return hr;
1780
1781 if ((hr = write_type( writer, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription,
1782 option, value, size )) != S_OK) return hr;
1783
1784 return write_endelement_node( writer );
1785 }
1786
1787 /**************************************************************************
1788 * WsWriteType [webservices.@]
1789 */
1790 HRESULT WINAPI WsWriteType( WS_XML_WRITER *handle, WS_TYPE_MAPPING mapping, WS_TYPE type,
1791 const void *desc, WS_WRITE_OPTION option, const void *value,
1792 ULONG size, WS_ERROR *error )
1793 {
1794 struct writer *writer = (struct writer *)handle;
1795 HRESULT hr;
1796
1797 TRACE( "%p %u %u %p %u %p %u %p\n", handle, mapping, type, desc, option, value,
1798 size, error );
1799 if (error) FIXME( "ignoring error parameter\n" );
1800
1801 if (!writer || !value) return E_INVALIDARG;
1802
1803 switch (mapping)
1804 {
1805 case WS_ATTRIBUTE_TYPE_MAPPING:
1806 if (writer->state != WRITER_STATE_STARTATTRIBUTE) return WS_E_INVALID_FORMAT;
1807 hr = write_type( writer, mapping, type, desc, option, value, size );
1808 break;
1809
1810 case WS_ELEMENT_TYPE_MAPPING:
1811 case WS_ELEMENT_CONTENT_TYPE_MAPPING:
1812 if (writer->state != WRITER_STATE_STARTELEMENT) return WS_E_INVALID_FORMAT;
1813 hr = write_type( writer, mapping, type, desc, option, value, size );
1814 break;
1815
1816 case WS_ANY_ELEMENT_TYPE_MAPPING:
1817 hr = write_type( writer, mapping, type, desc, option, value, size );
1818 break;
1819
1820 default:
1821 FIXME( "mapping %u not implemented\n", mapping );
1822 return E_NOTIMPL;
1823 }
1824
1825 return hr;
1826 }
1827
1828 WS_TYPE map_value_type( WS_VALUE_TYPE type )
1829 {
1830 switch (type)
1831 {
1832 case WS_BOOL_VALUE_TYPE: return WS_BOOL_TYPE;
1833 case WS_INT8_VALUE_TYPE: return WS_INT8_TYPE;
1834 case WS_INT16_VALUE_TYPE: return WS_INT16_TYPE;
1835 case WS_INT32_VALUE_TYPE: return WS_INT32_TYPE;
1836 case WS_INT64_VALUE_TYPE: return WS_INT64_TYPE;
1837 case WS_UINT8_VALUE_TYPE: return WS_UINT8_TYPE;
1838 case WS_UINT16_VALUE_TYPE: return WS_UINT16_TYPE;
1839 case WS_UINT32_VALUE_TYPE: return WS_UINT32_TYPE;
1840 case WS_UINT64_VALUE_TYPE: return WS_UINT64_TYPE;
1841 case WS_FLOAT_VALUE_TYPE: return WS_FLOAT_TYPE;
1842 case WS_DOUBLE_VALUE_TYPE: return WS_DOUBLE_TYPE;
1843 case WS_DECIMAL_VALUE_TYPE: return WS_DECIMAL_TYPE;
1844 case WS_DATETIME_VALUE_TYPE: return WS_DATETIME_TYPE;
1845 case WS_TIMESPAN_VALUE_TYPE: return WS_TIMESPAN_TYPE;
1846 case WS_GUID_VALUE_TYPE: return WS_GUID_TYPE;
1847 default:
1848 FIXME( "unhandled type %u\n", type );
1849 return ~0u;
1850 }
1851 }
1852
1853 /**************************************************************************
1854 * WsWriteValue [webservices.@]
1855 */
1856 HRESULT WINAPI WsWriteValue( WS_XML_WRITER *handle, WS_VALUE_TYPE value_type, const void *value,
1857 ULONG size, WS_ERROR *error )
1858 {
1859 struct writer *writer = (struct writer *)handle;
1860 WS_TYPE_MAPPING mapping;
1861 WS_TYPE type;
1862
1863 TRACE( "%p %u %p %u %p\n", handle, value_type, value, size, error );
1864 if (error) FIXME( "ignoring error parameter\n" );
1865
1866 if (!writer || !value || (type = map_value_type( value_type )) == ~0u) return E_INVALIDARG;
1867
1868 switch (writer->state)
1869 {
1870 case WRITER_STATE_STARTATTRIBUTE:
1871 mapping = WS_ATTRIBUTE_TYPE_MAPPING;
1872 break;
1873
1874 case WRITER_STATE_STARTELEMENT:
1875 mapping = WS_ELEMENT_TYPE_MAPPING;
1876 break;
1877
1878 default:
1879 return WS_E_INVALID_FORMAT;
1880 }
1881
1882 return write_type( writer, mapping, type, NULL, WS_WRITE_REQUIRED_VALUE, value, size );
1883 }
1884
1885 /**************************************************************************
1886 * WsWriteXmlBuffer [webservices.@]
1887 */
1888 HRESULT WINAPI WsWriteXmlBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer, WS_ERROR *error )
1889 {
1890 struct writer *writer = (struct writer *)handle;
1891 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
1892 HRESULT hr;
1893
1894 TRACE( "%p %p %p\n", handle, buffer, error );
1895 if (error) FIXME( "ignoring error parameter\n" );
1896
1897 if (!writer || !xmlbuf) return E_INVALIDARG;
1898
1899 if ((hr = write_grow_buffer( writer, xmlbuf->size )) != S_OK) return hr;
1900 write_bytes( writer, xmlbuf->ptr, xmlbuf->size );
1901 return S_OK;
1902 }
1903
1904 /**************************************************************************
1905 * WsWriteXmlBufferToBytes [webservices.@]
1906 */
1907 HRESULT WINAPI WsWriteXmlBufferToBytes( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer,
1908 const WS_XML_WRITER_ENCODING *encoding,
1909 const WS_XML_WRITER_PROPERTY *properties, ULONG count,
1910 WS_HEAP *heap, void **bytes, ULONG *size, WS_ERROR *error )
1911 {
1912 struct writer *writer = (struct writer *)handle;
1913 struct xmlbuf *xmlbuf = (struct xmlbuf *)buffer;
1914 HRESULT hr;
1915 char *buf;
1916 ULONG i;
1917
1918 TRACE( "%p %p %p %p %u %p %p %p %p\n", handle, buffer, encoding, properties, count, heap,
1919 bytes, size, error );
1920 if (error) FIXME( "ignoring error parameter\n" );
1921
1922 if (!writer || !xmlbuf || !heap || !bytes) return E_INVALIDARG;
1923
1924 if (encoding && encoding->encodingType != WS_XML_WRITER_ENCODING_TYPE_TEXT)
1925 {
1926 FIXME( "encoding type %u not supported\n", encoding->encodingType );
1927 return E_NOTIMPL;
1928 }
1929
1930 for (i = 0; i < count; i++)
1931 {
1932 hr = prop_set( writer->prop, writer->prop_count, properties[i].id, properties[i].value,
1933 properties[i].valueSize );
1934 if (hr != S_OK) return hr;
1935 }
1936
1937 if (!(buf = ws_alloc( heap, xmlbuf->size ))) return WS_E_QUOTA_EXCEEDED;
1938 memcpy( buf, xmlbuf->ptr, xmlbuf->size );
1939 *bytes = buf;
1940 *size = xmlbuf->size;
1941 return S_OK;
1942 }
1943
1944 /**************************************************************************
1945 * WsWriteXmlnsAttribute [webservices.@]
1946 */
1947 HRESULT WINAPI WsWriteXmlnsAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix,
1948 const WS_XML_STRING *ns, BOOL single, WS_ERROR *error )
1949 {
1950 struct writer *writer = (struct writer *)handle;
1951
1952 TRACE( "%p %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(ns),
1953 single, error );
1954 if (error) FIXME( "ignoring error parameter\n" );
1955
1956 if (!writer || !ns) return E_INVALIDARG;
1957 if (writer->state != WRITER_STATE_STARTELEMENT) return WS_E_INVALID_OPERATION;
1958
1959 if (namespace_in_scope( &writer->current->hdr, prefix, ns )) return S_OK;
1960 return write_add_namespace_attribute( writer, prefix, ns, single );
1961 }
1962
1963 static HRESULT write_move_to( struct writer *writer, WS_MOVE_TO move, BOOL *found )
1964 {
1965 BOOL success = FALSE;
1966 struct node *node = writer->current;
1967
1968 switch (move)
1969 {
1970 case WS_MOVE_TO_ROOT_ELEMENT:
1971 success = move_to_root_element( writer->root, &node );
1972 break;
1973
1974 case WS_MOVE_TO_NEXT_ELEMENT:
1975 success = move_to_next_element( &node );
1976 break;
1977
1978 case WS_MOVE_TO_PREVIOUS_ELEMENT:
1979 success = move_to_prev_element( &node );
1980 break;
1981
1982 case WS_MOVE_TO_CHILD_ELEMENT:
1983 success = move_to_child_element( &node );
1984 break;
1985
1986 case WS_MOVE_TO_END_ELEMENT:
1987 success = move_to_end_element( &node );
1988 break;
1989
1990 case WS_MOVE_TO_PARENT_ELEMENT:
1991 success = move_to_parent_element( &node );
1992 break;
1993
1994 case WS_MOVE_TO_FIRST_NODE:
1995 success = move_to_first_node( &node );
1996 break;
1997
1998 case WS_MOVE_TO_NEXT_NODE:
1999 success = move_to_next_node( &node );
2000 break;
2001
2002 case WS_MOVE_TO_PREVIOUS_NODE:
2003 success = move_to_prev_node( &node );
2004 break;
2005
2006 case WS_MOVE_TO_CHILD_NODE:
2007 success = move_to_child_node( &node );
2008 break;
2009
2010 case WS_MOVE_TO_BOF:
2011 success = move_to_bof( writer->root, &node );
2012 break;
2013
2014 case WS_MOVE_TO_EOF:
2015 success = move_to_eof( writer->root, &node );
2016 break;
2017
2018 default:
2019 FIXME( "unhandled move %u\n", move );
2020 return E_NOTIMPL;
2021 }
2022
2023 if (success && node == writer->root) return E_INVALIDARG;
2024 writer->current = node;
2025
2026 if (found)
2027 {
2028 *found = success;
2029 return S_OK;
2030 }
2031 return success ? S_OK : WS_E_INVALID_FORMAT;
2032 }
2033
2034 /**************************************************************************
2035 * WsMoveWriter [webservices.@]
2036 */
2037 HRESULT WINAPI WsMoveWriter( WS_XML_WRITER *handle, WS_MOVE_TO move, BOOL *found, WS_ERROR *error )
2038 {
2039 struct writer *writer = (struct writer *)handle;
2040
2041 TRACE( "%p %u %p %p\n", handle, move, found, error );
2042 if (error) FIXME( "ignoring error parameter\n" );
2043
2044 if (!writer) return E_INVALIDARG;
2045 if (!writer->output_type) return WS_E_INVALID_OPERATION;
2046
2047 return write_move_to( writer, move, found );
2048 }
2049
2050 /**************************************************************************
2051 * WsGetWriterPosition [webservices.@]
2052 */
2053 HRESULT WINAPI WsGetWriterPosition( WS_XML_WRITER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
2054 {
2055 struct writer *writer = (struct writer *)handle;
2056
2057 TRACE( "%p %p %p\n", handle, pos, error );
2058 if (error) FIXME( "ignoring error parameter\n" );
2059
2060 if (!writer || !pos) return E_INVALIDARG;
2061 if (!writer->output_type) return WS_E_INVALID_OPERATION;
2062
2063 pos->buffer = (WS_XML_BUFFER *)writer->output_buf;
2064 pos->node = writer->current;
2065 return S_OK;
2066 }
2067
2068 /**************************************************************************
2069 * WsSetWriterPosition [webservices.@]
2070 */
2071 HRESULT WINAPI WsSetWriterPosition( WS_XML_WRITER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
2072 {
2073 struct writer *writer = (struct writer *)handle;
2074
2075 TRACE( "%p %p %p\n", handle, pos, error );
2076 if (error) FIXME( "ignoring error parameter\n" );
2077
2078 if (!writer || !pos || (struct xmlbuf *)pos->buffer != writer->output_buf) return E_INVALIDARG;
2079 if (!writer->output_type) return WS_E_INVALID_OPERATION;
2080
2081 writer->current = pos->node;
2082 return S_OK;
2083 }
2084
2085 static HRESULT write_add_comment_node( struct writer *writer, const WS_XML_STRING *value )
2086 {
2087 struct node *node, *parent;
2088 WS_XML_COMMENT_NODE *comment;
2089
2090 if (!(parent = find_parent( writer->current ))) return WS_E_INVALID_FORMAT;
2091 if (!(node = alloc_node( WS_XML_NODE_TYPE_COMMENT ))) return E_OUTOFMEMORY;
2092 comment = (WS_XML_COMMENT_NODE *)node;
2093
2094 if (value->length && !(comment->value.bytes = heap_alloc( value->length )))
2095 {
2096 free_node( node );
2097 return E_OUTOFMEMORY;
2098 }
2099 memcpy( comment->value.bytes, value->bytes, value->length );
2100 comment->value.length = value->length;
2101
2102 write_insert_node( writer, parent, node );
2103 return S_OK;
2104 }
2105
2106 static HRESULT write_comment( struct writer *writer )
2107 {
2108 const WS_XML_COMMENT_NODE *comment = (const WS_XML_COMMENT_NODE *)writer->current;
2109 HRESULT hr;
2110
2111 if ((hr = write_grow_buffer( writer, comment->value.length + 7 )) != S_OK) return hr;
2112 write_bytes( writer, (const BYTE *)"<!--", 4 );
2113 write_bytes( writer, comment->value.bytes, comment->value.length );
2114 write_bytes( writer, (const BYTE *)"-->", 3 );
2115 return S_OK;
2116 }
2117
2118 static HRESULT write_comment_node( struct writer *writer, const WS_XML_STRING *value )
2119 {
2120 HRESULT hr;
2121 if ((hr = write_flush( writer )) != S_OK) return hr;
2122 if ((hr = write_add_comment_node( writer, value )) != S_OK) return hr;
2123 if ((hr = write_comment( writer )) != S_OK) return hr;
2124 writer->state = WRITER_STATE_COMMENT;
2125 return S_OK;
2126 }
2127
2128 static HRESULT write_set_attributes( struct writer *writer, WS_XML_ATTRIBUTE **attrs, ULONG count )
2129 {
2130 ULONG i;
2131 HRESULT hr;
2132
2133 for (i = 0; i < count; i++)
2134 {
2135 if ((hr = write_add_attribute( writer, attrs[i]->prefix, attrs[i]->localName, attrs[i]->ns,
2136 attrs[i]->singleQuote )) != S_OK) return hr;
2137 if ((hr = write_set_attribute_value( writer, attrs[i]->value )) != S_OK) return hr;
2138 }
2139 return S_OK;
2140 }
2141
2142 static HRESULT write_node( struct writer *writer, const WS_XML_NODE *node )
2143 {
2144 HRESULT hr;
2145
2146 switch (node->nodeType)
2147 {
2148 case WS_XML_NODE_TYPE_ELEMENT:
2149 {
2150 const WS_XML_ELEMENT_NODE *elem = (const WS_XML_ELEMENT_NODE *)node;
2151 if ((hr = write_element_node( writer, elem->prefix, elem->localName, elem->ns )) != S_OK) return hr;
2152 return write_set_attributes( writer, elem->attributes, elem->attributeCount );
2153 }
2154 case WS_XML_NODE_TYPE_TEXT:
2155 {
2156 const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node;
2157 return write_text_node( writer, text->text );
2158 }
2159 case WS_XML_NODE_TYPE_END_ELEMENT:
2160 return write_endelement_node( writer );
2161
2162 case WS_XML_NODE_TYPE_COMMENT:
2163 {
2164 const WS_XML_COMMENT_NODE *comment = (const WS_XML_COMMENT_NODE *)node;
2165 return write_comment_node( writer, &comment->value );
2166 }
2167 case WS_XML_NODE_TYPE_CDATA:
2168 return write_cdata_node( writer );
2169
2170 case WS_XML_NODE_TYPE_END_CDATA:
2171 return write_endcdata_node( writer );
2172
2173 case WS_XML_NODE_TYPE_EOF:
2174 case WS_XML_NODE_TYPE_BOF:
2175 return S_OK;
2176
2177 default:
2178 WARN( "unknown node type %u\n", node->nodeType );
2179 return E_INVALIDARG;
2180 }
2181 }
2182
2183 /**************************************************************************
2184 * WsWriteNode [webservices.@]
2185 */
2186 HRESULT WINAPI WsWriteNode( WS_XML_WRITER *handle, const WS_XML_NODE *node, WS_ERROR *error )
2187 {
2188 struct writer *writer = (struct writer *)handle;
2189
2190 TRACE( "%p %p %p\n", handle, node, error );
2191 if (error) FIXME( "ignoring error parameter\n" );
2192
2193 if (!writer || !node) return E_INVALIDARG;
2194 if (!writer->output_type) return WS_E_INVALID_OPERATION;
2195
2196 return write_node( writer, node );
2197 }
2198
2199 static HRESULT write_tree_node( struct writer *writer )
2200 {
2201 HRESULT hr;
2202
2203 switch (node_type( writer->current ))
2204 {
2205 case WS_XML_NODE_TYPE_ELEMENT:
2206 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
2207 return hr;
2208 if ((hr = write_startelement( writer )) != S_OK) return hr;
2209 writer->state = WRITER_STATE_STARTELEMENT;
2210 return S_OK;
2211
2212 case WS_XML_NODE_TYPE_TEXT:
2213 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
2214 return hr;
2215 if ((hr = write_text( writer )) != S_OK) return hr;
2216 writer->state = WRITER_STATE_TEXT;
2217 return S_OK;
2218
2219 case WS_XML_NODE_TYPE_END_ELEMENT:
2220 if ((hr = write_close_element( writer, writer->current->parent )) != S_OK) return hr;
2221 writer->state = WRITER_STATE_ENDELEMENT;
2222 return S_OK;
2223
2224 case WS_XML_NODE_TYPE_COMMENT:
2225 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
2226 return hr;
2227 if ((hr = write_comment( writer )) != S_OK) return hr;
2228 writer->state = WRITER_STATE_COMMENT;
2229 return S_OK;
2230
2231 case WS_XML_NODE_TYPE_CDATA:
2232 if (writer->state == WRITER_STATE_STARTELEMENT && (hr = write_endstartelement( writer )) != S_OK)
2233 return hr;
2234 if ((hr = write_cdata( writer )) != S_OK) return hr;
2235 writer->state = WRITER_STATE_STARTCDATA;
2236 return S_OK;
2237
2238 case WS_XML_NODE_TYPE_END_CDATA:
2239 if ((hr = write_endcdata( writer )) != S_OK) return hr;
2240 writer->state = WRITER_STATE_ENDCDATA;
2241 return S_OK;
2242
2243 case WS_XML_NODE_TYPE_EOF:
2244 case WS_XML_NODE_TYPE_BOF:
2245 return S_OK;
2246
2247 default:
2248 ERR( "unknown node type %u\n", node_type(writer->current) );
2249 return E_INVALIDARG;
2250 }
2251 }
2252
2253 static HRESULT write_tree( struct writer *writer )
2254 {
2255 HRESULT hr;
2256
2257 if ((hr = write_tree_node( writer )) != S_OK) return hr;
2258 for (;;)
2259 {
2260 if (node_type( writer->current ) == WS_XML_NODE_TYPE_EOF) break;
2261 if (move_to_child_node( &writer->current ))
2262 {
2263 if ((hr = write_tree_node( writer )) != S_OK) return hr;
2264 continue;
2265 }
2266 if (move_to_next_node( &writer->current ))
2267 {
2268 if ((hr = write_tree_node( writer )) != S_OK) return hr;
2269 continue;
2270 }
2271 if (!move_to_parent_node( &writer->current ) || !move_to_next_node( &writer->current ))
2272 {
2273 ERR( "invalid tree\n" );
2274 return WS_E_INVALID_FORMAT;
2275 }
2276 if ((hr = write_tree_node( writer )) != S_OK) return hr;
2277 }
2278 return S_OK;
2279 }
2280
2281 static void write_rewind( struct writer *writer )
2282 {
2283 writer->write_pos = 0;
2284 writer->current = writer->root;
2285 writer->state = WRITER_STATE_INITIAL;
2286 }
2287
2288 /**************************************************************************
2289 * WsCopyNode [webservices.@]
2290 */
2291 HRESULT WINAPI WsCopyNode( WS_XML_WRITER *handle, WS_XML_READER *reader, WS_ERROR *error )
2292 {
2293 struct writer *writer = (struct writer *)handle;
2294 struct node *parent, *current = writer->current, *node = NULL;
2295 HRESULT hr;
2296
2297 TRACE( "%p %p %p\n", handle, reader, error );
2298 if (error) FIXME( "ignoring error parameter\n" );
2299
2300 if (!writer) return E_INVALIDARG;
2301 if (!(parent = find_parent( writer->current ))) return WS_E_INVALID_FORMAT;
2302
2303 if ((hr = copy_node( reader, &node )) != S_OK) return hr;
2304 write_insert_node( writer, parent, node );
2305
2306 write_rewind( writer );
2307 if ((hr = write_tree( writer )) != S_OK) return hr;
2308
2309 writer->current = current;
2310 return S_OK;
2311 }
Windows API implementation