[PATCH 3/4] webservices: Trace return values.
Hans Leidekker
hans at codeweavers.com
Wed Oct 17 06:42:36 CDT 2018
Signed-off-by: Hans Leidekker <hans at codeweavers.com>
---
dlls/webservices/channel.c | 37 +++---
dlls/webservices/error.c | 15 ++-
dlls/webservices/heap.c | 5 +-
dlls/webservices/listener.c | 82 +++++++------
dlls/webservices/msg.c | 222 ++++++++++++++-------------------
dlls/webservices/proxy.c | 17 +--
dlls/webservices/reader.c | 264 +++++++++++++++++----------------------
dlls/webservices/writer.c | 293 +++++++++++++++++++-------------------------
8 files changed, 424 insertions(+), 511 deletions(-)
diff --git a/dlls/webservices/channel.c b/dlls/webservices/channel.c
index 5d3ca347da..464645b095 100644
--- a/dlls/webservices/channel.c
+++ b/dlls/webservices/channel.c
@@ -518,6 +518,7 @@ void WINAPI WsFreeChannel( WS_CHANNEL *handle )
HRESULT WINAPI WsResetChannel( WS_CHANNEL *handle, WS_ERROR *error )
{
struct channel *channel = (struct channel *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -533,15 +534,13 @@ HRESULT WINAPI WsResetChannel( WS_CHANNEL *handle, WS_ERROR *error )
}
if (channel->state != WS_CHANNEL_STATE_CREATED && channel->state != WS_CHANNEL_STATE_CLOSED)
- {
- LeaveCriticalSection( &channel->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- reset_channel( channel );
+ hr = WS_E_INVALID_OPERATION;
+ else
+ reset_channel( channel );
LeaveCriticalSection( &channel->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -583,6 +582,7 @@ HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID
}
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -611,6 +611,7 @@ HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID
hr = prop_set( channel->prop, channel->prop_count, id, value, size );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -653,15 +654,11 @@ HRESULT WINAPI WsOpenChannel( WS_CHANNEL *handle, const WS_ENDPOINT_ADDRESS *end
return E_INVALIDARG;
}
- if (channel->state != WS_CHANNEL_STATE_CREATED)
- {
- LeaveCriticalSection( &channel->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = open_channel( channel, endpoint );
+ if (channel->state != WS_CHANNEL_STATE_CREATED) hr = WS_E_INVALID_OPERATION;
+ else hr = open_channel( channel, endpoint );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -734,6 +731,7 @@ HRESULT WINAPI WsShutdownSessionChannel( WS_CHANNEL *handle, const WS_ASYNC_CONT
hr = shutdown_session( channel );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -749,6 +747,7 @@ static void close_channel( struct channel *channel )
HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
{
struct channel *channel = (struct channel *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, ctx, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -767,7 +766,8 @@ HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx,
close_channel( channel );
LeaveCriticalSection( &channel->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT parse_http_url( const WCHAR *url, ULONG len, URL_COMPONENTS *uc )
@@ -1348,6 +1348,7 @@ HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESS
done:
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1388,6 +1389,7 @@ HRESULT WINAPI WsSendReplyMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS
done:
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1959,6 +1961,7 @@ HRESULT WINAPI WsReceiveMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_M
hr = receive_message( channel, msg, desc, count, option, read_option, heap, value, size, index );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1991,6 +1994,7 @@ HRESULT WINAPI WsReadMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS
}
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2020,6 +2024,7 @@ HRESULT WINAPI WsReadMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_A
hr = WsReadEnvelopeEnd( msg, NULL );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2052,6 +2057,7 @@ HRESULT WINAPI WsWriteMessageStart( WS_CHANNEL *handle, WS_MESSAGE *msg, const W
done:
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2081,6 +2087,7 @@ HRESULT WINAPI WsWriteMessageEnd( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_
if ((hr = WsWriteEnvelopeEnd( msg, NULL )) == S_OK) hr = send_message( channel, msg );
LeaveCriticalSection( &channel->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/error.c b/dlls/webservices/error.c
index 970c12e1e3..03f71a6489 100644
--- a/dlls/webservices/error.c
+++ b/dlls/webservices/error.c
@@ -151,6 +151,7 @@ void WINAPI WsFreeError( WS_ERROR *handle )
HRESULT WINAPI WsResetError( WS_ERROR *handle )
{
struct error *error = (struct error *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p\n", handle );
@@ -167,7 +168,8 @@ HRESULT WINAPI WsResetError( WS_ERROR *handle )
reset_error( error );
LeaveCriticalSection( &error->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -194,6 +196,7 @@ HRESULT WINAPI WsGetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, vo
hr = prop_get( error->prop, error->prop_count, id, buf, size );
LeaveCriticalSection( &error->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -227,14 +230,10 @@ HRESULT WINAPI WsSetErrorProperty( WS_ERROR *handle, WS_ERROR_PROPERTY_ID id, co
return E_INVALIDARG;
}
- if (id == WS_ERROR_PROPERTY_LANGID)
- {
- LeaveCriticalSection( &error->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = prop_set( error->prop, error->prop_count, id, value, size );
+ if (id == WS_ERROR_PROPERTY_LANGID) hr = WS_E_INVALID_OPERATION;
+ else hr = prop_set( error->prop, error->prop_count, id, value, size );
LeaveCriticalSection( &error->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/heap.c b/dlls/webservices/heap.c
index 93c8c4499a..1e22a24b34 100644
--- a/dlls/webservices/heap.c
+++ b/dlls/webservices/heap.c
@@ -260,6 +260,7 @@ void WINAPI WsFreeHeap( WS_HEAP *handle )
HRESULT WINAPI WsResetHeap( WS_HEAP *handle, WS_ERROR *error )
{
struct heap *heap = (struct heap *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -277,7 +278,8 @@ HRESULT WINAPI WsResetHeap( WS_HEAP *handle, WS_ERROR *error )
reset_heap( heap );
LeaveCriticalSection( &heap->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -317,6 +319,7 @@ HRESULT WINAPI WsGetHeapProperty( WS_HEAP *handle, WS_HEAP_PROPERTY_ID id, void
}
LeaveCriticalSection( &heap->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/listener.c b/dlls/webservices/listener.c
index 2e8286e144..e06b39447f 100644
--- a/dlls/webservices/listener.c
+++ b/dlls/webservices/listener.c
@@ -469,15 +469,11 @@ HRESULT WINAPI WsOpenListener( WS_LISTENER *handle, WS_STRING *url, const WS_ASY
return E_INVALIDARG;
}
- if (listener->state != WS_LISTENER_STATE_CREATED)
- {
- LeaveCriticalSection( &listener->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = open_listener( listener, url );
+ if (listener->state != WS_LISTENER_STATE_CREATED) hr = WS_E_INVALID_OPERATION;
+ else hr = open_listener( listener, url );
LeaveCriticalSection( &listener->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -493,6 +489,7 @@ static void close_listener( struct listener *listener )
HRESULT WINAPI WsCloseListener( WS_LISTENER *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
{
struct listener *listener = (struct listener *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, ctx, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -511,7 +508,8 @@ HRESULT WINAPI WsCloseListener( WS_LISTENER *handle, const WS_ASYNC_CONTEXT *ctx
close_listener( listener );
LeaveCriticalSection( &listener->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -520,6 +518,7 @@ HRESULT WINAPI WsCloseListener( WS_LISTENER *handle, const WS_ASYNC_CONTEXT *ctx
HRESULT WINAPI WsResetListener( WS_LISTENER *handle, WS_ERROR *error )
{
struct listener *listener = (struct listener *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -535,15 +534,13 @@ HRESULT WINAPI WsResetListener( WS_LISTENER *handle, WS_ERROR *error )
}
if (listener->state != WS_LISTENER_STATE_CREATED && listener->state != WS_LISTENER_STATE_CLOSED)
- {
- LeaveCriticalSection( &listener->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- reset_listener( listener );
+ hr = WS_E_INVALID_OPERATION;
+ else
+ reset_listener( listener );
LeaveCriticalSection( &listener->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -590,6 +587,7 @@ HRESULT WINAPI WsGetListenerProperty( WS_LISTENER *handle, WS_LISTENER_PROPERTY_
}
LeaveCriticalSection( &listener->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -618,6 +616,7 @@ HRESULT WINAPI WsSetListenerProperty( WS_LISTENER *handle, WS_LISTENER_PROPERTY_
hr = prop_set( listener->prop, listener->prop_count, id, value, size );
LeaveCriticalSection( &listener->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -645,37 +644,40 @@ HRESULT WINAPI WsAcceptChannel( WS_LISTENER *handle, WS_CHANNEL *channel_handle,
return E_INVALIDARG;
}
- if (listener->state != WS_LISTENER_STATE_OPEN || listener->channel)
+ if (listener->state != WS_LISTENER_STATE_OPEN || listener->channel) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &listener->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- wait = listener->wait;
- cancel = listener->cancel;
- listener->channel = channel_handle;
+ wait = listener->wait;
+ cancel = listener->cancel;
+ listener->channel = channel_handle;
- switch (listener->binding)
- {
- case WS_TCP_CHANNEL_BINDING:
- {
- SOCKET socket = listener->u.tcp.socket;
+ switch (listener->binding)
+ {
+ case WS_TCP_CHANNEL_BINDING:
+ {
+ SOCKET socket = listener->u.tcp.socket;
- LeaveCriticalSection( &listener->cs );
- return channel_accept_tcp( socket, wait, cancel, channel_handle );
- }
- case WS_UDP_CHANNEL_BINDING:
- {
- SOCKET socket = listener->u.udp.socket;
+ LeaveCriticalSection( &listener->cs );
+ hr = channel_accept_tcp( socket, wait, cancel, channel_handle );
+ TRACE( "returning %08x\n", hr );
+ return hr;
+ }
+ case WS_UDP_CHANNEL_BINDING:
+ {
+ SOCKET socket = listener->u.udp.socket;
- LeaveCriticalSection( &listener->cs );
- return channel_accept_udp( socket, wait, cancel, channel_handle );
- }
- default:
- FIXME( "listener binding %u not supported\n", listener->binding );
- break;
+ LeaveCriticalSection( &listener->cs );
+ hr = channel_accept_udp( socket, wait, cancel, channel_handle );
+ TRACE( "returning %08x\n", hr );
+ return hr;
+ }
+ default:
+ FIXME( "listener binding %u not supported\n", listener->binding );
+ break;
+ }
}
LeaveCriticalSection( &listener->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/msg.c b/dlls/webservices/msg.c
index 48b4ec561d..4ccf82eacc 100644
--- a/dlls/webservices/msg.c
+++ b/dlls/webservices/msg.c
@@ -294,6 +294,7 @@ void WINAPI WsFreeMessage( WS_MESSAGE *handle )
HRESULT WINAPI WsResetMessage( WS_MESSAGE *handle, WS_ERROR *error )
{
struct msg *msg = (struct msg *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -311,7 +312,8 @@ HRESULT WINAPI WsResetMessage( WS_MESSAGE *handle, WS_ERROR *error )
reset_msg( msg );
LeaveCriticalSection( &msg->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -383,6 +385,7 @@ HRESULT WINAPI WsGetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID
}
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -423,6 +426,7 @@ HRESULT WINAPI WsSetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID
}
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -452,25 +456,23 @@ HRESULT WINAPI WsAddressMessage( WS_MESSAGE *handle, const WS_ENDPOINT_ADDRESS *
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED || msg->is_addressed)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (addr && addr->url.length)
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED || msg->is_addressed) hr = WS_E_INVALID_OPERATION;
+ else
{
- if (!(msg->addr.chars = heap_alloc( addr->url.length * sizeof(WCHAR) ))) hr = E_OUTOFMEMORY;
- else
+ if (addr && addr->url.length)
{
- memcpy( msg->addr.chars, addr->url.chars, addr->url.length * sizeof(WCHAR) );
- msg->addr.length = addr->url.length;
+ if (!(msg->addr.chars = heap_alloc( addr->url.length * sizeof(WCHAR) ))) hr = E_OUTOFMEMORY;
+ else
+ {
+ memcpy( msg->addr.chars, addr->url.chars, addr->url.length * sizeof(WCHAR) );
+ msg->addr.length = addr->url.length;
+ }
}
}
-
if (hr == S_OK) msg->is_addressed = TRUE;
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -743,20 +745,16 @@ HRESULT WINAPI WsWriteEnvelopeStart( WS_MESSAGE *handle, WS_XML_WRITER *writer,
return E_INVALIDARG;
}
- if (msg->state != WS_MESSAGE_STATE_INITIALIZED)
+ if (msg->state != WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = write_envelope( msg )) == S_OK &&
+ (hr = write_envelope_start( msg, writer )) == S_OK)
{
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
+ msg->writer_body = writer;
+ msg->state = WS_MESSAGE_STATE_WRITING;
}
- if ((hr = write_envelope( msg )) != S_OK) goto done;
- if ((hr = write_envelope_start( msg, writer )) != S_OK) goto done;
-
- msg->writer_body = writer;
- msg->state = WS_MESSAGE_STATE_WRITING;
-
-done:
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -781,15 +779,12 @@ HRESULT WINAPI WsWriteEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
return E_INVALIDARG;
}
- if (msg->state != WS_MESSAGE_STATE_WRITING)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = write_envelope_end( msg->writer_body )) == S_OK) msg->state = WS_MESSAGE_STATE_DONE;
+ if (msg->state != WS_MESSAGE_STATE_WRITING) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = write_envelope_end( msg->writer_body )) == S_OK)
+ msg->state = WS_MESSAGE_STATE_DONE;
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -817,8 +812,8 @@ HRESULT WINAPI WsWriteBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *de
if (msg->state != WS_MESSAGE_STATE_WRITING)
{
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
if (desc->elementLocalName &&
@@ -832,6 +827,7 @@ HRESULT WINAPI WsWriteBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *de
done:
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -917,20 +913,16 @@ HRESULT WINAPI WsReadEnvelopeStart( WS_MESSAGE *handle, WS_XML_READER *reader, W
return E_INVALIDARG;
}
- if (msg->state != WS_MESSAGE_STATE_EMPTY)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = read_envelope_start( msg, reader )) == S_OK &&
- (hr = create_header_buffer( reader, msg->heap, &msg->buf )) == S_OK)
+ if (msg->state != WS_MESSAGE_STATE_EMPTY) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = read_envelope_start( msg, reader )) == S_OK &&
+ (hr = create_header_buffer( reader, msg->heap, &msg->buf )) == S_OK)
{
msg->reader_body = reader;
msg->state = WS_MESSAGE_STATE_READING;
}
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -962,15 +954,12 @@ HRESULT WINAPI WsReadEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
return E_INVALIDARG;
}
- if (msg->state != WS_MESSAGE_STATE_READING)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = read_envelope_end( msg->reader_body )) == S_OK) msg->state = WS_MESSAGE_STATE_DONE;
+ if (msg->state != WS_MESSAGE_STATE_READING) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = read_envelope_end( msg->reader_body )) == S_OK)
+ msg->state = WS_MESSAGE_STATE_DONE;
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -996,15 +985,11 @@ HRESULT WINAPI WsReadBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *des
return E_INVALIDARG;
}
- if (msg->state != WS_MESSAGE_STATE_READING)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = WsReadElement( msg->reader_body, desc, option, heap, value, size, NULL );
+ if (msg->state != WS_MESSAGE_STATE_READING) hr = WS_E_INVALID_OPERATION;
+ else hr = WsReadElement( msg->reader_body, desc, option, heap, value, size, NULL );
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1035,19 +1020,15 @@ HRESULT WINAPI WsInitializeMessage( WS_MESSAGE *handle, WS_MESSAGE_INITIALIZATIO
return E_INVALIDARG;
}
- if (msg->state >= WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = write_envelope( msg )) == S_OK)
+ if (msg->state >= WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = write_envelope( msg )) == S_OK)
{
msg->init = init;
msg->state = WS_MESSAGE_STATE_INITIALIZED;
}
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1164,8 +1145,8 @@ HRESULT WINAPI WsSetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE val
if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
{
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
for (i = 0; i < msg->header_count; i++)
@@ -1194,6 +1175,7 @@ HRESULT WINAPI WsSetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE val
done:
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1256,15 +1238,11 @@ HRESULT WINAPI WsGetHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_TYPE val
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = get_standard_header( msg, type, value_type, option, heap, value, size );
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else hr = get_standard_header( msg, type, value_type, option, heap, value, size );
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1298,31 +1276,24 @@ HRESULT WINAPI WsRemoveHeader( WS_MESSAGE *handle, WS_HEADER_TYPE type, WS_ERROR
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER)
- {
- LeaveCriticalSection( &msg->cs );
- return E_INVALIDARG;
- }
-
- for (i = 0; i < msg->header_count; i++)
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else if (type < WS_ACTION_HEADER || type > WS_FAULT_TO_HEADER) hr = E_INVALIDARG;
+ else
{
- if (msg->header[i]->type == type)
+ for (i = 0; i < msg->header_count; i++)
{
- remove_header( msg, i );
- removed = TRUE;
- break;
+ if (msg->header[i]->type == type)
+ {
+ remove_header( msg, i );
+ removed = TRUE;
+ break;
+ }
}
+ if (removed) hr = write_envelope( msg );
}
- if (removed) hr = write_envelope( msg );
-
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1440,8 +1411,8 @@ HRESULT WINAPI WsAddMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name,
if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
{
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
for (i = 0; i < msg->header_count; i++)
@@ -1469,6 +1440,7 @@ HRESULT WINAPI WsAddMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name,
done:
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1478,6 +1450,7 @@ done:
HRESULT WINAPI WsRemoveMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *name, WS_ERROR *error )
{
struct msg *msg = (struct msg *)handle;
+ HRESULT hr = S_OK;
ULONG i;
TRACE( "%p %s %p\n", handle, debugstr_xmlstr(name), error );
@@ -1493,24 +1466,23 @@ HRESULT WINAPI WsRemoveMappedHeader( WS_MESSAGE *handle, const WS_XML_STRING *na
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- for (i = 0; i < msg->header_count; i++)
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else
{
- if (msg->header[i]->type || !msg->header[i]->mapped) continue;
- if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
+ for (i = 0; i < msg->header_count; i++)
{
- remove_header( msg, i );
- break;
+ if (msg->header[i]->type || !msg->header[i]->mapped) continue;
+ if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK)
+ {
+ remove_header( msg, i );
+ break;
+ }
}
}
LeaveCriticalSection( &msg->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT write_custom_header( WS_XML_WRITER *writer, const WS_XML_STRING *name, const WS_XML_STRING *ns,
@@ -1572,8 +1544,8 @@ HRESULT WINAPI WsAddCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTI
if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
{
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
if ((hr = grow_header_array( msg, msg->header_count + 1 )) != S_OK) goto done;
@@ -1584,6 +1556,7 @@ HRESULT WINAPI WsAddCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTI
done:
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1636,15 +1609,11 @@ HRESULT WINAPI WsGetCustomHeader( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTI
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = get_custom_header( msg, desc, option, heap, value, size );
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else hr = get_custom_header( msg, desc, option, heap, value, size );
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1672,27 +1641,25 @@ HRESULT WINAPI WsRemoveCustomHeader( WS_MESSAGE *handle, const WS_XML_STRING *na
return E_INVALIDARG;
}
- if (msg->state < WS_MESSAGE_STATE_INITIALIZED)
- {
- LeaveCriticalSection( &msg->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- for (i = 0; i < msg->header_count; i++)
+ if (msg->state < WS_MESSAGE_STATE_INITIALIZED) hr = WS_E_INVALID_OPERATION;
+ else
{
- if (msg->header[i]->type || msg->header[i]->mapped) continue;
- if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK &&
- WsXmlStringEquals( ns, &msg->header[i]->ns, NULL ) == S_OK)
+ for (i = 0; i < msg->header_count; i++)
{
- remove_header( msg, i );
- removed = TRUE;
- i--;
+ if (msg->header[i]->type || msg->header[i]->mapped) continue;
+ if (WsXmlStringEquals( name, &msg->header[i]->name, NULL ) == S_OK &&
+ WsXmlStringEquals( ns, &msg->header[i]->ns, NULL ) == S_OK)
+ {
+ remove_header( msg, i );
+ removed = TRUE;
+ i--;
+ }
}
+ if (removed) hr = write_envelope( msg );
}
- if (removed) hr = write_envelope( msg );
-
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1817,6 +1784,7 @@ HRESULT message_insert_http_headers( WS_MESSAGE *handle, HINTERNET req )
done:
heap_free( header );
LeaveCriticalSection( &msg->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/proxy.c b/dlls/webservices/proxy.c
index 92406f15df..811aa8d9ae 100644
--- a/dlls/webservices/proxy.c
+++ b/dlls/webservices/proxy.c
@@ -219,6 +219,7 @@ HRESULT WINAPI WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE channel_type,
HRESULT WINAPI WsResetServiceProxy( WS_SERVICE_PROXY *handle, WS_ERROR *error )
{
struct proxy *proxy = (struct proxy *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -234,15 +235,13 @@ HRESULT WINAPI WsResetServiceProxy( WS_SERVICE_PROXY *handle, WS_ERROR *error )
}
if (proxy->state != WS_SERVICE_PROXY_STATE_CREATED && proxy->state != WS_SERVICE_PROXY_STATE_CLOSED)
- {
- LeaveCriticalSection( &proxy->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- reset_proxy( proxy );
+ hr = WS_E_INVALID_OPERATION;
+ else
+ reset_proxy( proxy );
LeaveCriticalSection( &proxy->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -304,6 +303,7 @@ HRESULT WINAPI WsGetServiceProxyProperty( WS_SERVICE_PROXY *handle, WS_PROXY_PRO
}
LeaveCriticalSection( &proxy->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -334,6 +334,7 @@ HRESULT WINAPI WsOpenServiceProxy( WS_SERVICE_PROXY *handle, const WS_ENDPOINT_A
proxy->state = WS_SERVICE_PROXY_STATE_OPEN;
LeaveCriticalSection( &proxy->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -363,6 +364,7 @@ HRESULT WINAPI WsCloseServiceProxy( WS_SERVICE_PROXY *handle, const WS_ASYNC_CON
proxy->state = WS_SERVICE_PROXY_STATE_CLOSED;
LeaveCriticalSection( &proxy->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -544,5 +546,6 @@ HRESULT WINAPI WsCall( WS_SERVICE_PROXY *handle, const WS_OPERATION_DESCRIPTION
done:
WsFreeMessage( msg );
LeaveCriticalSection( &proxy->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c
index 7288c4b966..a5ff59a417 100644
--- a/dlls/webservices/reader.c
+++ b/dlls/webservices/reader.c
@@ -622,6 +622,7 @@ HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASY
WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %u %p %p\n", handle, min_size, ctx, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -641,7 +642,8 @@ HRESULT WINAPI WsFillReader( WS_XML_READER *handle, ULONG min_size, const WS_ASY
reader->read_pos = 0;
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -657,6 +659,7 @@ HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STR
static const WS_XML_STRING xmlns_ns = {29, (BYTE *)"http://www.w3.org/2000/xmlns/"};
struct reader *reader = (struct reader *)handle;
BOOL found = FALSE;
+ HRESULT hr = S_OK;
TRACE( "%p %s %d %p %p\n", handle, debugstr_xmlstr(prefix), required, ns, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -671,13 +674,8 @@ HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STR
return E_INVALIDARG;
}
- if (reader->state != READER_STATE_STARTELEMENT)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (!prefix->length)
+ if (reader->state != READER_STATE_STARTELEMENT) hr = WS_E_INVALID_OPERATION;
+ else if (!prefix->length)
{
*ns = &empty_ns;
found = TRUE;
@@ -711,14 +709,18 @@ HRESULT WINAPI WsGetNamespaceFromPrefix( WS_XML_READER *handle, const WS_XML_STR
LeaveCriticalSection( &reader->cs );
- if (!found)
+ if (hr == S_OK && !found)
{
- if (required) return WS_E_INVALID_FORMAT;
- *ns = NULL;
- return S_FALSE;
+ if (required) hr = WS_E_INVALID_FORMAT;
+ else
+ {
+ *ns = NULL;
+ hr = S_FALSE;
+ }
}
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -728,6 +730,7 @@ HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, node, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -745,6 +748,7 @@ HRESULT WINAPI WsGetReaderNode( WS_XML_READER *handle, const WS_XML_NODE **node,
*node = &reader->current->hdr.node;
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return S_OK;
}
@@ -778,16 +782,12 @@ HRESULT WINAPI WsGetReaderProperty( WS_XML_READER *handle, WS_XML_READER_PROPERT
return E_INVALIDARG;
}
- if (!reader->input_type)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (id == WS_XML_READER_PROPERTY_CHARSET) hr = get_charset( reader, buf, size );
+ if (!reader->input_type) hr = WS_E_INVALID_OPERATION;
+ else if (id == WS_XML_READER_PROPERTY_CHARSET) hr = get_charset( reader, buf, size );
else hr = prop_get( reader->prop, reader->prop_count, id, buf, size );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3098,6 +3098,7 @@ HRESULT WINAPI WsReadEndElement( WS_XML_READER *handle, WS_ERROR *error )
hr = read_endelement( reader );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3125,6 +3126,7 @@ HRESULT WINAPI WsReadNode( WS_XML_READER *handle, WS_ERROR *error )
hr = read_node( reader );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3171,6 +3173,7 @@ HRESULT WINAPI WsSkipNode( WS_XML_READER *handle, WS_ERROR *error )
hr = skip_node( reader );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3198,6 +3201,7 @@ HRESULT WINAPI WsReadStartElement( WS_XML_READER *handle, WS_ERROR *error )
hr = read_startelement( reader );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3227,6 +3231,7 @@ HRESULT WINAPI WsReadToStartElement( WS_XML_READER *handle, const WS_XML_STRING
hr = read_to_startelement( reader, found );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3523,15 +3528,11 @@ HRESULT WINAPI WsMoveReader( WS_XML_READER *handle, WS_MOVE_TO move, BOOL *found
return E_INVALIDARG;
}
- if (!reader->input_type)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = read_move_to( reader, move, found );
+ if (!reader->input_type) hr = WS_E_INVALID_OPERATION;
+ else hr = read_move_to( reader, move, found );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3542,6 +3543,7 @@ HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERRO
{
struct reader *reader = (struct reader *)handle;
const WS_XML_ELEMENT_NODE *elem;
+ HRESULT hr = S_OK;
TRACE( "%p %u %p\n", handle, index, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -3557,16 +3559,15 @@ HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERRO
}
elem = &reader->current->hdr;
- if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount)
+ if (reader->state != READER_STATE_STARTELEMENT || index >= elem->attributeCount) hr = WS_E_INVALID_FORMAT;
+ else
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_FORMAT;
+ reader->current_attr = index;
+ reader->state = READER_STATE_STARTATTRIBUTE;
}
- reader->current_attr = index;
- reader->state = READER_STATE_STARTATTRIBUTE;
-
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return S_OK;
}
@@ -3576,6 +3577,7 @@ HRESULT WINAPI WsReadStartAttribute( WS_XML_READER *handle, ULONG index, WS_ERRO
HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -3590,16 +3592,12 @@ HRESULT WINAPI WsReadEndAttribute( WS_XML_READER *handle, WS_ERROR *error )
return E_INVALIDARG;
}
- if (reader->state != READER_STATE_STARTATTRIBUTE)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_FORMAT;
- }
-
- reader->state = READER_STATE_STARTELEMENT;
+ if (reader->state != READER_STATE_STARTATTRIBUTE) hr = WS_E_INVALID_FORMAT;
+ else reader->state = READER_STATE_STARTELEMENT;
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT str_to_bool( const unsigned char *str, ULONG len, BOOL *ret )
@@ -4061,27 +4059,13 @@ HRESULT WINAPI WsReadQualifiedName( WS_XML_READER *handle, WS_HEAP *heap, WS_XML
return E_INVALIDARG;
}
- if (!reader->input_type)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (!localname)
- {
- LeaveCriticalSection( &reader->cs );
- return E_INVALIDARG;
- }
-
- if (reader->state != READER_STATE_TEXT)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_FORMAT;
- }
-
- hr = read_qualified_name( reader, heap, prefix, localname, ns );
+ if (!reader->input_type) hr = WS_E_INVALID_OPERATION;
+ else if (!localname) hr = E_INVALIDARG;
+ else if (reader->state != READER_STATE_TEXT) hr = WS_E_INVALID_FORMAT;
+ else hr = read_qualified_name( reader, heap, prefix, localname, ns );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4299,13 +4283,8 @@ HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *loca
return E_INVALIDARG;
}
- if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (!find_attribute( reader, localname, ns, index ))
+ if (node_type( reader->current ) != WS_XML_NODE_TYPE_ELEMENT) hr = WS_E_INVALID_OPERATION;
+ else if (!find_attribute( reader, localname, ns, index ))
{
if (required) hr = WS_E_INVALID_FORMAT;
else
@@ -4316,6 +4295,7 @@ HRESULT WINAPI WsFindAttribute( WS_XML_READER *handle, const WS_XML_STRING *loca
}
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -6701,25 +6681,22 @@ HRESULT WINAPI WsReadType( WS_XML_READER *handle, WS_TYPE_MAPPING mapping, WS_TY
return E_INVALIDARG;
}
- if ((hr = read_type( reader, mapping, type, NULL, NULL, desc, option, heap, value, size, &found )) != S_OK)
- {
- LeaveCriticalSection( &reader->cs );
- return hr;
- }
-
- switch (mapping)
+ if ((hr = read_type( reader, mapping, type, NULL, NULL, desc, option, heap, value, size, &found )) == S_OK)
{
- case WS_ELEMENT_TYPE_MAPPING:
- hr = read_node( reader );
- break;
+ switch (mapping)
+ {
+ case WS_ELEMENT_TYPE_MAPPING:
+ hr = read_node( reader );
+ break;
- default:
- break;
+ default:
+ break;
+ }
+ if (hr == S_OK && !read_end_of_data( reader )) hr = WS_E_INVALID_FORMAT;
}
- if (hr == S_OK && !read_end_of_data( reader )) hr = WS_E_INVALID_FORMAT;
-
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -6774,6 +6751,7 @@ HRESULT WINAPI WsReadElement( WS_XML_READER *handle, const WS_ELEMENT_DESCRIPTIO
desc->elementNs, desc->typeDescription, option, heap, value, size, &found );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -6805,6 +6783,7 @@ HRESULT WINAPI WsReadValue( WS_XML_READER *handle, WS_VALUE_TYPE value_type, voi
NULL, value, size, &found );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -6832,16 +6811,12 @@ HRESULT WINAPI WsReadAttribute( WS_XML_READER *handle, const WS_ATTRIBUTE_DESCRI
return E_INVALIDARG;
}
- if (!reader->input_type)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->attributeLocalName,
- desc->attributeNs, desc->typeDescription, option, heap, value, size, &found );
+ if (!reader->input_type) hr = WS_E_INVALID_OPERATION;
+ else hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->attributeLocalName,
+ desc->attributeNs, desc->typeDescription, option, heap, value, size, &found );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -6984,6 +6959,7 @@ HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING *
done:
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -7033,6 +7009,7 @@ HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer,
done:
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -7042,6 +7019,7 @@ done:
HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, pos, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -7056,17 +7034,16 @@ HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION
return E_INVALIDARG;
}
- if (!reader->input_buf)
+ if (!reader->input_buf) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
+ pos->buffer = (WS_XML_BUFFER *)reader->input_buf;
+ pos->node = reader->current;
}
- pos->buffer = (WS_XML_BUFFER *)reader->input_buf;
- pos->node = reader->current;
-
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -7075,6 +7052,7 @@ HRESULT WINAPI WsGetReaderPosition( WS_XML_READER *handle, WS_XML_NODE_POSITION
HRESULT WINAPI WsSetReaderPosition( WS_XML_READER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, pos, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -7089,16 +7067,12 @@ HRESULT WINAPI WsSetReaderPosition( WS_XML_READER *handle, const WS_XML_NODE_POS
return E_INVALIDARG;
}
- if (!reader->input_buf)
- {
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- reader->current = pos->node;
+ if (!reader->input_buf) hr = WS_E_INVALID_OPERATION;
+ else reader->current = pos->node;
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT utf8_to_base64( const WS_XML_UTF8_TEXT *utf8, WS_XML_BASE64_TEXT *base64 )
@@ -7115,7 +7089,7 @@ static HRESULT utf8_to_base64( const WS_XML_UTF8_TEXT *utf8, WS_XML_BASE64_TEXT
HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
- HRESULT hr;
+ HRESULT hr = S_OK;
TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -7132,14 +7106,13 @@ HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count,
if (!reader->input_type)
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
-
if (!count)
{
- LeaveCriticalSection( &reader->cs );
- return E_INVALIDARG;
+ hr = E_INVALIDARG;
+ goto done;
}
*count = 0;
@@ -7148,17 +7121,12 @@ HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count,
const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)reader->current;
WS_XML_BASE64_TEXT base64;
- if ((hr = utf8_to_base64( (const WS_XML_UTF8_TEXT *)text->text, &base64 )) != S_OK)
- {
- LeaveCriticalSection( &reader->cs );
- return hr;
- }
+ if ((hr = utf8_to_base64( (const WS_XML_UTF8_TEXT *)text->text, &base64 )) != S_OK) goto done;
if (reader->text_conv_offset == base64.length)
{
heap_free( base64.bytes );
hr = read_node( reader );
- LeaveCriticalSection( &reader->cs );
- return hr;
+ goto done;
}
*count = min( base64.length - reader->text_conv_offset, max_count );
memcpy( bytes, base64.bytes + reader->text_conv_offset, *count );
@@ -7166,8 +7134,10 @@ HRESULT WINAPI WsReadBytes( WS_XML_READER *handle, void *bytes, ULONG max_count,
heap_free( base64.bytes );
}
+done:
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT utf8_to_utf16( const WS_XML_UTF8_TEXT *utf8, WS_XML_UTF16_TEXT *utf16 )
@@ -7185,6 +7155,7 @@ static HRESULT utf8_to_utf16( const WS_XML_UTF8_TEXT *utf8, WS_XML_UTF16_TEXT *u
HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count, ULONG *count, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %u %p %p\n", handle, chars, max_count, count, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -7201,14 +7172,13 @@ HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count
if (!reader->input_type)
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
-
if (!count)
{
- LeaveCriticalSection( &reader->cs );
- return E_INVALIDARG;
+ hr = E_INVALIDARG;
+ goto done;
}
*count = 0;
@@ -7218,17 +7188,12 @@ HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count
WS_XML_UTF16_TEXT utf16;
HRESULT hr;
- if ((hr = utf8_to_utf16( (const WS_XML_UTF8_TEXT *)text->text, &utf16 )) != S_OK)
- {
- LeaveCriticalSection( &reader->cs );
- return hr;
- }
+ if ((hr = utf8_to_utf16( (const WS_XML_UTF8_TEXT *)text->text, &utf16 )) != S_OK) goto done;
if (reader->text_conv_offset == utf16.byteCount / sizeof(WCHAR))
{
heap_free( utf16.bytes );
hr = read_node( reader );
- LeaveCriticalSection( &reader->cs );
- return hr;
+ goto done;
}
*count = min( utf16.byteCount / sizeof(WCHAR) - reader->text_conv_offset, max_count );
memcpy( chars, utf16.bytes + reader->text_conv_offset * sizeof(WCHAR), *count * sizeof(WCHAR) );
@@ -7236,8 +7201,10 @@ HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count
heap_free( utf16.bytes );
}
+done:
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -7246,7 +7213,7 @@ HRESULT WINAPI WsReadChars( WS_XML_READER *handle, WCHAR *chars, ULONG max_count
HRESULT WINAPI WsReadCharsUtf8( WS_XML_READER *handle, BYTE *bytes, ULONG max_count, ULONG *count, WS_ERROR *error )
{
struct reader *reader = (struct reader *)handle;
- HRESULT hr;
+ HRESULT hr = S_OK;
TRACE( "%p %p %u %p %p\n", handle, bytes, max_count, count, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -7263,14 +7230,13 @@ HRESULT WINAPI WsReadCharsUtf8( WS_XML_READER *handle, BYTE *bytes, ULONG max_co
if (!reader->input_type)
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
-
if (!count)
{
- LeaveCriticalSection( &reader->cs );
- return E_INVALIDARG;
+ hr = E_INVALIDARG;
+ goto done;
}
*count = 0;
@@ -7282,16 +7248,17 @@ HRESULT WINAPI WsReadCharsUtf8( WS_XML_READER *handle, BYTE *bytes, ULONG max_co
if (reader->text_conv_offset == utf8->value.length)
{
hr = read_node( reader );
- LeaveCriticalSection( &reader->cs );
- return hr;
+ goto done;
}
*count = min( utf8->value.length - reader->text_conv_offset, max_count );
memcpy( bytes, utf8->value.bytes + reader->text_conv_offset, *count );
reader->text_conv_offset += *count;
}
+done:
LeaveCriticalSection( &reader->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT move_to_element( struct reader *reader )
@@ -7328,7 +7295,7 @@ HRESULT WINAPI WsReadXmlBuffer( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_BUF
{
struct reader *reader = (struct reader *)handle;
WS_XML_WRITER *writer = NULL;
- WS_XML_BUFFER *buffer;
+ WS_XML_BUFFER *buffer = NULL;
HRESULT hr;
TRACE( "%p %p %p %p\n", handle, heap, ret, error );
@@ -7345,21 +7312,20 @@ HRESULT WINAPI WsReadXmlBuffer( WS_XML_READER *handle, WS_HEAP *heap, WS_XML_BUF
return E_INVALIDARG;
}
- if (!reader->input_type)
+ if (!reader->input_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &reader->cs );
- return WS_E_INVALID_OPERATION;
+ if ((hr = WsCreateWriter( NULL, 0, &writer, NULL )) != S_OK) goto done;
+ if ((hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL )) != S_OK) goto done;
+ if ((hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL )) != S_OK) goto done;
+ if ((hr = copy_tree( reader, writer )) == S_OK) *ret = buffer;
}
- if ((hr = WsCreateWriter( NULL, 0, &writer, NULL )) != S_OK) goto done;
- if ((hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL )) != S_OK) goto done;
- if ((hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL )) != S_OK) goto done;
- if ((hr = copy_tree( reader, writer )) == S_OK) *ret = buffer;
-
done:
if (hr != S_OK) free_xmlbuf( (struct xmlbuf *)buffer );
WsFreeWriter( writer );
LeaveCriticalSection( &reader->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
diff --git a/dlls/webservices/writer.c b/dlls/webservices/writer.c
index 7631f4ebe8..ff633a656c 100644
--- a/dlls/webservices/writer.c
+++ b/dlls/webservices/writer.c
@@ -294,43 +294,42 @@ HRESULT WINAPI WsGetWriterProperty( WS_XML_WRITER *handle, WS_XML_WRITER_PROPERT
return E_INVALIDARG;
}
- if (!writer->output_type)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- switch (id)
- {
- case WS_XML_WRITER_PROPERTY_BYTES:
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- WS_BYTES *bytes = buf;
- if (size != sizeof(*bytes)) hr = E_INVALIDARG;
- else
+ switch (id)
{
- bytes->bytes = writer->output_buf->bytes.bytes;
- bytes->length = writer->output_buf->bytes.length;
- }
- break;
- }
- case WS_XML_WRITER_PROPERTY_BUFFERS:
- if (writer->output_buf->bytes.length)
+ case WS_XML_WRITER_PROPERTY_BYTES:
{
- WS_BUFFERS *buffers = buf;
- if (size != sizeof(*buffers)) hr = E_INVALIDARG;
+ WS_BYTES *bytes = buf;
+ if (size != sizeof(*bytes)) hr = E_INVALIDARG;
else
{
- buffers->bufferCount = 1;
- buffers->buffers = &writer->output_buf->bytes;
+ bytes->bytes = writer->output_buf->bytes.bytes;
+ bytes->length = writer->output_buf->bytes.length;
}
break;
}
- /* fall through */
- default:
- hr = prop_get( writer->prop, writer->prop_count, id, buf, size );
+ case WS_XML_WRITER_PROPERTY_BUFFERS:
+ if (writer->output_buf->bytes.length)
+ {
+ WS_BUFFERS *buffers = buf;
+ if (size != sizeof(*buffers)) hr = E_INVALIDARG;
+ else
+ {
+ buffers->bufferCount = 1;
+ buffers->buffers = &writer->output_buf->bytes;
+ }
+ break;
+ }
+ /* fall through */
+ default:
+ hr = prop_get( writer->prop, writer->prop_count, id, buf, size );
+ }
}
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -438,6 +437,7 @@ HRESULT WINAPI WsSetOutput( WS_XML_WRITER *handle, const WS_XML_WRITER_ENCODING
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -485,6 +485,7 @@ HRESULT WINAPI WsSetOutputToBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1476,6 +1477,7 @@ HRESULT WINAPI WsGetPrefixFromNamespace( WS_XML_WRITER *handle, const WS_XML_STR
}
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1654,6 +1656,7 @@ static HRESULT set_namespaces( struct writer *writer )
HRESULT WINAPI WsWriteEndAttribute( WS_XML_WRITER *handle, WS_ERROR *error )
{
struct writer *writer = (struct writer *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p\n", handle, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -1671,7 +1674,8 @@ HRESULT WINAPI WsWriteEndAttribute( WS_XML_WRITER *handle, WS_ERROR *error )
writer->state = WRITER_STATE_STARTELEMENT;
LeaveCriticalSection( &writer->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT write_attributes( struct writer *writer, const WS_XML_ELEMENT_NODE *elem )
@@ -1913,6 +1917,7 @@ HRESULT WINAPI WsWriteEndElement( WS_XML_WRITER *handle, WS_ERROR *error )
hr = write_endelement_node( writer );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -1957,19 +1962,18 @@ HRESULT WINAPI WsWriteEndStartElement( WS_XML_WRITER *handle, WS_ERROR *error )
return E_INVALIDARG;
}
- if (writer->state != WRITER_STATE_STARTELEMENT)
+ if (writer->state != WRITER_STATE_STARTELEMENT) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
+ if ((hr = set_namespaces( writer )) != S_OK) goto done;
+ if ((hr = write_startelement( writer )) != S_OK) goto done;
+ if ((hr = write_endstartelement( writer )) != S_OK) goto done;
+ writer->state = WRITER_STATE_ENDSTARTELEMENT;
}
- if ((hr = set_namespaces( writer )) != S_OK) goto done;
- if ((hr = write_startelement( writer )) != S_OK) goto done;
- if ((hr = write_endstartelement( writer )) != S_OK) goto done;
- writer->state = WRITER_STATE_ENDSTARTELEMENT;
-
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2033,16 +2037,12 @@ HRESULT WINAPI WsWriteStartAttribute( WS_XML_WRITER *handle, const WS_XML_STRING
return E_INVALIDARG;
}
- if (writer->state != WRITER_STATE_STARTELEMENT)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) == S_OK)
+ if (writer->state != WRITER_STATE_STARTELEMENT) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) == S_OK)
writer->state = WRITER_STATE_STARTATTRIBUTE;
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2121,6 +2121,7 @@ HRESULT WINAPI WsWriteStartCData( WS_XML_WRITER *handle, WS_ERROR *error )
hr = write_cdata_node( writer );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2162,15 +2163,11 @@ HRESULT WINAPI WsWriteEndCData( WS_XML_WRITER *handle, WS_ERROR *error )
return E_INVALIDARG;
}
- if (writer->state != WRITER_STATE_TEXT)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = write_endcdata_node( writer );
+ if (writer->state != WRITER_STATE_TEXT) hr = WS_E_INVALID_OPERATION;
+ else hr = write_endcdata_node( writer );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2257,6 +2254,7 @@ HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING *
hr = write_element_node( writer, prefix, localname, ns );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2892,6 +2890,7 @@ HRESULT WINAPI WsWriteText( WS_XML_WRITER *handle, const WS_XML_TEXT *text, WS_E
else hr = write_text_node( writer, text );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2917,20 +2916,19 @@ HRESULT WINAPI WsWriteBytes( WS_XML_WRITER *handle, const void *bytes, ULONG cou
return E_INVALIDARG;
}
- if (!writer->output_type)
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- base64.text.textType = WS_XML_TEXT_TYPE_BASE64;
- base64.bytes = (BYTE *)bytes;
- base64.length = count;
+ base64.text.textType = WS_XML_TEXT_TYPE_BASE64;
+ base64.bytes = (BYTE *)bytes;
+ base64.length = count;
- if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &base64.text );
- else hr = write_text_node( writer, &base64.text );
+ if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &base64.text );
+ else hr = write_text_node( writer, &base64.text );
+ }
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2956,20 +2954,19 @@ HRESULT WINAPI WsWriteChars( WS_XML_WRITER *handle, const WCHAR *chars, ULONG co
return E_INVALIDARG;
}
- if (!writer->output_type)
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
- utf16.bytes = (BYTE *)chars;
- utf16.byteCount = count * sizeof(WCHAR);
+ utf16.text.textType = WS_XML_TEXT_TYPE_UTF16;
+ utf16.bytes = (BYTE *)chars;
+ utf16.byteCount = count * sizeof(WCHAR);
- if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf16.text );
- else hr = write_text_node( writer, &utf16.text );
+ if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf16.text );
+ else hr = write_text_node( writer, &utf16.text );
+ }
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -2995,20 +2992,19 @@ HRESULT WINAPI WsWriteCharsUtf8( WS_XML_WRITER *handle, const BYTE *bytes, ULONG
return E_INVALIDARG;
}
- if (!writer->output_type)
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
- utf8.value.bytes = (BYTE *)bytes;
- utf8.value.length = count;
+ utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
+ utf8.value.bytes = (BYTE *)bytes;
+ utf8.value.length = count;
- if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf8.text );
- else hr = write_text_node( writer, &utf8.text );
+ if (writer->state == WRITER_STATE_STARTATTRIBUTE) hr = write_set_attribute_value( writer, &utf8.text );
+ else hr = write_text_node( writer, &utf8.text );
+ }
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3892,22 +3888,15 @@ HRESULT WINAPI WsWriteAttribute( WS_XML_WRITER *handle, const WS_ATTRIBUTE_DESCR
return E_INVALIDARG;
}
- if (writer->state != WRITER_STATE_STARTELEMENT)
+ if (writer->state != WRITER_STATE_STARTELEMENT) hr = WS_E_INVALID_OPERATION;
+ else if ((hr = write_add_attribute( writer, NULL, desc->attributeLocalName, desc->attributeNs, FALSE )) == S_OK)
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if ((hr = write_add_attribute( writer, NULL, desc->attributeLocalName, desc->attributeNs, FALSE )) != S_OK)
- {
- LeaveCriticalSection( &writer->cs );
- return hr;
+ writer->state = WRITER_STATE_STARTATTRIBUTE;
+ hr = write_type( writer, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->typeDescription, option, value, size );
}
- writer->state = WRITER_STATE_STARTATTRIBUTE;
-
- hr = write_type( writer, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->typeDescription, option, value, size );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3944,6 +3933,7 @@ HRESULT WINAPI WsWriteElement( WS_XML_WRITER *handle, const WS_ELEMENT_DESCRIPTI
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -3990,6 +3980,7 @@ HRESULT WINAPI WsWriteType( WS_XML_WRITER *handle, WS_TYPE_MAPPING mapping, WS_T
}
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4059,6 +4050,7 @@ HRESULT WINAPI WsWriteValue( WS_XML_WRITER *handle, WS_VALUE_TYPE value_type, co
if (hr == S_OK) hr = write_type( writer, mapping, type, NULL, WS_WRITE_REQUIRED_VALUE, value, size );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4090,21 +4082,21 @@ HRESULT WINAPI WsWriteArray( WS_XML_WRITER *handle, const WS_XML_STRING *localna
if (!writer->output_type)
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
+ hr = WS_E_INVALID_OPERATION;
+ goto done;
}
if (!localname || !ns || (type = map_value_type( value_type )) == ~0u)
{
- LeaveCriticalSection( &writer->cs );
- return E_INVALIDARG;
+ hr = E_INVALIDARG;
+ goto done;
}
type_size = get_type_size( type, NULL );
if (size % type_size || (offset + count) * type_size > size || (count && !array))
{
- LeaveCriticalSection( &writer->cs );
- return E_INVALIDARG;
+ hr = E_INVALIDARG;
+ goto done;
}
for (i = offset; i < count; i++)
@@ -4118,6 +4110,7 @@ HRESULT WINAPI WsWriteArray( WS_XML_WRITER *handle, const WS_XML_STRING *localna
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4156,6 +4149,7 @@ HRESULT WINAPI WsWriteXmlBuffer( WS_XML_WRITER *handle, WS_XML_BUFFER *buffer, W
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4210,6 +4204,7 @@ HRESULT WINAPI WsWriteXmlBufferToBytes( WS_XML_WRITER *handle, WS_XML_BUFFER *bu
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4236,16 +4231,12 @@ HRESULT WINAPI WsWriteXmlnsAttribute( WS_XML_WRITER *handle, const WS_XML_STRING
return E_INVALIDARG;
}
- if (writer->state != WRITER_STATE_STARTELEMENT)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (!namespace_in_scope( &writer->current->hdr, prefix, ns ))
+ if (writer->state != WRITER_STATE_STARTELEMENT) hr = WS_E_INVALID_OPERATION;
+ else if (!namespace_in_scope( &writer->current->hdr, prefix, ns ))
hr = add_namespace_attribute( writer, prefix, ns, single );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4290,27 +4281,13 @@ HRESULT WINAPI WsWriteQualifiedName( WS_XML_WRITER *handle, const WS_XML_STRING
return E_INVALIDARG;
}
- if (!writer->output_type)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- if (writer->state != WRITER_STATE_STARTELEMENT)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_FORMAT;
- }
-
- if (!localname || (!prefix && !ns))
- {
- LeaveCriticalSection( &writer->cs );
- return E_INVALIDARG;
- }
-
- hr = write_qualified_name( writer, prefix, localname, ns );
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else if (writer->state != WRITER_STATE_STARTELEMENT) hr = WS_E_INVALID_FORMAT;
+ else if (!localname || (!prefix && !ns)) hr = E_INVALIDARG;
+ else hr = write_qualified_name( writer, prefix, localname, ns );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4406,15 +4383,11 @@ HRESULT WINAPI WsMoveWriter( WS_XML_WRITER *handle, WS_MOVE_TO move, BOOL *found
return E_INVALIDARG;
}
- if (!writer->output_type)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = write_move_to( writer, move, found );
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else hr = write_move_to( writer, move, found );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4424,6 +4397,7 @@ HRESULT WINAPI WsMoveWriter( WS_XML_WRITER *handle, WS_MOVE_TO move, BOOL *found
HRESULT WINAPI WsGetWriterPosition( WS_XML_WRITER *handle, WS_XML_NODE_POSITION *pos, WS_ERROR *error )
{
struct writer *writer = (struct writer *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, pos, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -4438,17 +4412,16 @@ HRESULT WINAPI WsGetWriterPosition( WS_XML_WRITER *handle, WS_XML_NODE_POSITION
return E_INVALIDARG;
}
- if (!writer->output_type)
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
+ pos->buffer = (WS_XML_BUFFER *)writer->output_buf;
+ pos->node = writer->current;
}
- pos->buffer = (WS_XML_BUFFER *)writer->output_buf;
- pos->node = writer->current;
-
LeaveCriticalSection( &writer->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
/**************************************************************************
@@ -4457,6 +4430,7 @@ HRESULT WINAPI WsGetWriterPosition( WS_XML_WRITER *handle, WS_XML_NODE_POSITION
HRESULT WINAPI WsSetWriterPosition( WS_XML_WRITER *handle, const WS_XML_NODE_POSITION *pos, WS_ERROR *error )
{
struct writer *writer = (struct writer *)handle;
+ HRESULT hr = S_OK;
TRACE( "%p %p %p\n", handle, pos, error );
if (error) FIXME( "ignoring error parameter\n" );
@@ -4471,16 +4445,12 @@ HRESULT WINAPI WsSetWriterPosition( WS_XML_WRITER *handle, const WS_XML_NODE_POS
return E_INVALIDARG;
}
- if (!writer->output_type)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- writer->current = pos->node;
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else writer->current = pos->node;
LeaveCriticalSection( &writer->cs );
- return S_OK;
+ TRACE( "returning %08x\n", hr );
+ return hr;
}
static HRESULT write_add_comment_node( struct writer *writer, const WS_XML_STRING *value )
@@ -4635,15 +4605,11 @@ HRESULT WINAPI WsWriteNode( WS_XML_WRITER *handle, const WS_XML_NODE *node, WS_E
return E_INVALIDARG;
}
- if (!writer->output_type)
- {
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_OPERATION;
- }
-
- hr = write_node( writer, node );
+ if (!writer->output_type) hr = WS_E_INVALID_OPERATION;
+ else hr = write_node( writer, node );
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
@@ -4758,24 +4724,23 @@ HRESULT WINAPI WsCopyNode( WS_XML_WRITER *handle, WS_XML_READER *reader, WS_ERRO
return E_INVALIDARG;
}
- if (!(parent = find_parent( writer )))
+ if (!(parent = find_parent( writer ))) hr = WS_E_INVALID_FORMAT;
+ else
{
- LeaveCriticalSection( &writer->cs );
- return WS_E_INVALID_FORMAT;
- }
+ if ((hr = copy_node( reader, writer->output_enc, &node )) != S_OK) goto done;
+ current = writer->current;
+ write_insert_node( writer, parent, node );
- if ((hr = copy_node( reader, writer->output_enc, &node )) != S_OK) goto done;
- current = writer->current;
- write_insert_node( writer, parent, node );
-
- write_rewind( writer );
- if ((hr = write_tree( writer )) != S_OK) goto done;
- writer->current = current;
+ write_rewind( writer );
+ if ((hr = write_tree( writer )) != S_OK) goto done;
+ writer->current = current;
- WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
+ WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
+ }
done:
LeaveCriticalSection( &writer->cs );
+ TRACE( "returning %08x\n", hr );
return hr;
}
--
2.11.0
More information about the wine-devel
mailing list