[PATCH 2/3] rpcrt4: Use publicly defined NDR constants.
Zebediah Figura
z.figura12 at gmail.com
Tue Jun 12 21:19:10 CDT 2018
Signed-off-by: Zebediah Figura <z.figura12 at gmail.com>
---
All types defined in wine/rpcfc.h have equivalent types in ndrtypes.h, with
the exception of RPC_FC_BIND_EXPLICIT, which I have replaced with 0.
dlls/rpcrt4/ndr_contexthandle.c | 2 -
dlls/rpcrt4/ndr_es.c | 15 +-
dlls/rpcrt4/ndr_marshall.c | 1420 +++++++++++++++++++--------------------
dlls/rpcrt4/ndr_ole.c | 6 +-
dlls/rpcrt4/ndr_stubless.c | 241 ++++---
dlls/rpcrt4/ndr_stubless.h | 16 +-
6 files changed, 846 insertions(+), 854 deletions(-)
diff --git a/dlls/rpcrt4/ndr_contexthandle.c b/dlls/rpcrt4/ndr_contexthandle.c
index 3b26285..a5e1ffc 100644
--- a/dlls/rpcrt4/ndr_contexthandle.c
+++ b/dlls/rpcrt4/ndr_contexthandle.c
@@ -23,8 +23,6 @@
#include "rpc_assoc.h"
#include "rpcndr.h"
-#include "wine/rpcfc.h"
-
#include "wine/debug.h"
#include "wine/list.h"
diff --git a/dlls/rpcrt4/ndr_es.c b/dlls/rpcrt4/ndr_es.c
index 59ea816..158bc7c 100644
--- a/dlls/rpcrt4/ndr_es.c
+++ b/dlls/rpcrt4/ndr_es.c
@@ -32,7 +32,6 @@
#include "ndr_stubless.h"
#include "wine/debug.h"
-#include "wine/rpcfc.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
@@ -424,7 +423,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu
client_interface = pStubDesc->RpcInterfaceInformation;
pEsMsg->InterfaceId = client_interface->InterfaceId;
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
{
const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
stack_size = header_rpc->stack_size;
@@ -438,17 +437,17 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu
pFormat += sizeof(NDR_PROC_HEADER);
}
- if (pProcHeader->handle_type == RPC_FC_BIND_EXPLICIT)
+ if (pProcHeader->handle_type == 0)
{
switch (*pFormat) /* handle_type */
{
- case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
+ case FC_BIND_PRIMITIVE: /* explicit primitive */
pFormat += sizeof(NDR_EHD_PRIMITIVE);
break;
- case RPC_FC_BIND_GENERIC: /* explicit generic */
+ case FC_BIND_GENERIC: /* explicit generic */
pFormat += sizeof(NDR_EHD_GENERIC);
break;
- case RPC_FC_BIND_CONTEXT: /* explicit context */
+ case FC_BIND_CONTEXT: /* explicit context */
pFormat += sizeof(NDR_EHD_CONTEXT);
break;
default:
@@ -467,7 +466,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu
pEsMsg->StubMsg.pfnFree = pStubDesc->pfnFree;
/* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
pEsMsg->StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
@@ -510,7 +509,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu
return;
}
/* free the full pointer translation tables */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
NdrFullPointerXlatFree(pEsMsg->StubMsg.FullPtrXlatTables);
}
diff --git a/dlls/rpcrt4/ndr_marshall.c b/dlls/rpcrt4/ndr_marshall.c
index 6356fb9..52e2716 100644
--- a/dlls/rpcrt4/ndr_marshall.c
+++ b/dlls/rpcrt4/ndr_marshall.c
@@ -43,8 +43,6 @@
#include "ndrtypes.h"
#include "wine/unicode.h"
-#include "wine/rpcfc.h"
-
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
@@ -554,15 +552,15 @@ PFORMAT_STRING ComputeConformanceOrVariance(
}
switch (pFormat[0] & 0xf0) {
- case RPC_FC_NORMAL_CONFORMANCE:
+ case FC_NORMAL_CONFORMANCE:
TRACE("normal conformance, ofs=%d\n", ofs);
ptr = pMemory;
break;
- case RPC_FC_POINTER_CONFORMANCE:
+ case FC_POINTER_CONFORMANCE:
TRACE("pointer conformance, ofs=%d\n", ofs);
ptr = pStubMsg->Memory;
break;
- case RPC_FC_TOP_LEVEL_CONFORMANCE:
+ case FC_TOP_LEVEL_CONFORMANCE:
TRACE("toplevel conformance, ofs=%d\n", ofs);
if (pStubMsg->StackTop) {
ptr = pStubMsg->StackTop;
@@ -572,12 +570,12 @@ PFORMAT_STRING ComputeConformanceOrVariance(
goto finish_conf;
}
break;
- case RPC_FC_CONSTANT_CONFORMANCE:
+ case FC_CONSTANT_CONFORMANCE:
data = ofs | ((DWORD)pFormat[1] << 16);
TRACE("constant conformance, val=%ld\n", data);
*pCount = data;
goto finish_conf;
- case RPC_FC_TOP_LEVEL_MULTID_CONFORMANCE:
+ case FC_TOP_LEVEL_MULTID_CONFORMANCE:
FIXME("toplevel multidimensional conformance, ofs=%d\n", ofs);
if (pStubMsg->StackTop) {
ptr = pStubMsg->StackTop;
@@ -593,10 +591,10 @@ PFORMAT_STRING ComputeConformanceOrVariance(
}
switch (pFormat[1]) {
- case RPC_FC_DEREFERENCE:
+ case FC_DEREFERENCE:
ptr = *(LPVOID*)((char *)ptr + ofs);
break;
- case RPC_FC_CALLBACK:
+ case FC_CALLBACK:
{
unsigned char *old_stack_top = pStubMsg->StackTop;
ULONG_PTR max_count, old_max_count = pStubMsg->MaxCount;
@@ -621,25 +619,25 @@ PFORMAT_STRING ComputeConformanceOrVariance(
}
switch (dtype) {
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
+ case FC_LONG:
+ case FC_ULONG:
data = *(DWORD*)ptr;
break;
- case RPC_FC_SHORT:
+ case FC_SHORT:
data = *(SHORT*)ptr;
break;
- case RPC_FC_USHORT:
+ case FC_USHORT:
data = *(USHORT*)ptr;
break;
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
+ case FC_CHAR:
+ case FC_SMALL:
data = *(CHAR*)ptr;
break;
- case RPC_FC_BYTE:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_USMALL:
data = *(UCHAR*)ptr;
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
data = *(ULONGLONG *)ptr;
break;
default:
@@ -650,20 +648,20 @@ PFORMAT_STRING ComputeConformanceOrVariance(
done_conf_grab:
switch (pFormat[1]) {
- case RPC_FC_DEREFERENCE: /* already handled */
+ case FC_DEREFERENCE: /* already handled */
case 0: /* no op */
*pCount = data;
break;
- case RPC_FC_ADD_1:
+ case FC_ADD_1:
*pCount = data + 1;
break;
- case RPC_FC_SUB_1:
+ case FC_SUB_1:
*pCount = data - 1;
break;
- case RPC_FC_MULT_2:
+ case FC_MULT_2:
*pCount = data * 2;
break;
- case RPC_FC_DIV_2:
+ case FC_DIV_2:
*pCount = data / 2;
break;
default:
@@ -779,16 +777,16 @@ static void validate_string_data(MIDL_STUB_MESSAGE *pStubMsg, ULONG bufsize, ULO
static inline void dump_pointer_attr(unsigned char attr)
{
- if (attr & RPC_FC_P_ALLOCALLNODES)
- TRACE(" RPC_FC_P_ALLOCALLNODES");
- if (attr & RPC_FC_P_DONTFREE)
- TRACE(" RPC_FC_P_DONTFREE");
- if (attr & RPC_FC_P_ONSTACK)
- TRACE(" RPC_FC_P_ONSTACK");
- if (attr & RPC_FC_P_SIMPLEPOINTER)
- TRACE(" RPC_FC_P_SIMPLEPOINTER");
- if (attr & RPC_FC_P_DEREF)
- TRACE(" RPC_FC_P_DEREF");
+ if (attr & FC_ALLOCATE_ALL_NODES)
+ TRACE(" FC_ALLOCATE_ALL_NODES");
+ if (attr & FC_DONT_FREE)
+ TRACE(" FC_DONT_FREE");
+ if (attr & FC_ALLOCED_ON_STACK)
+ TRACE(" FC_ALLOCED_ON_STACK");
+ if (attr & FC_SIMPLE_POINTER)
+ TRACE(" FC_SIMPLE_POINTER");
+ if (attr & FC_POINTER_DEREF)
+ TRACE(" FC_POINTER_DEREF");
TRACE("\n");
}
@@ -809,11 +807,11 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%p)\n", pStubMsg, Buffer, Pointer, pFormat);
TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
pFormat += 2;
- if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
+ if (attr & FC_SIMPLE_POINTER) desc = pFormat;
else desc = pFormat + *(const SHORT*)pFormat;
switch (type) {
- case RPC_FC_RP: /* ref pointer (always non-null) */
+ case FC_RP: /* ref pointer (always non-null) */
if (!Pointer)
{
ERR("NULL ref pointer is not allowed\n");
@@ -821,8 +819,8 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
}
pointer_needs_marshaling = TRUE;
break;
- case RPC_FC_UP: /* unique pointer */
- case RPC_FC_OP: /* object pointer - same as unique here */
+ case FC_UP: /* unique pointer */
+ case FC_OP: /* object pointer - same as unique here */
if (Pointer)
pointer_needs_marshaling = TRUE;
else
@@ -831,7 +829,7 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("writing 0x%08x to buffer\n", pointer_id);
NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id);
break;
- case RPC_FC_FP:
+ case FC_FP:
pointer_needs_marshaling = !NdrFullPointerQueryPointer(
pStubMsg->FullPtrXlatTables, Pointer, 1, &pointer_id);
TRACE("writing 0x%08x to buffer\n", pointer_id);
@@ -846,7 +844,7 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("calling marshaller for type 0x%x\n", (int)*desc);
if (pointer_needs_marshaling) {
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
Pointer = *(unsigned char**)Pointer;
TRACE("deref => %p\n", Pointer);
}
@@ -877,14 +875,14 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%p,%p,%d)\n", pStubMsg, Buffer, pPointer, pSrcPointer, pFormat, fMustAlloc);
TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
pFormat += 2;
- if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
+ if (attr & FC_SIMPLE_POINTER) desc = pFormat;
else desc = pFormat + *(const SHORT*)pFormat;
switch (type) {
- case RPC_FC_RP: /* ref pointer (always non-null) */
+ case FC_RP: /* ref pointer (always non-null) */
pointer_needs_unmarshaling = TRUE;
break;
- case RPC_FC_UP: /* unique pointer */
+ case FC_UP: /* unique pointer */
pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
TRACE("pointer_id is 0x%08x\n", pointer_id);
if (pointer_id)
@@ -894,7 +892,7 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pointer_needs_unmarshaling = FALSE;
}
break;
- case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
+ case FC_OP: /* object pointer - we must free data before overwriting it */
pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
TRACE("pointer_id is 0x%08x\n", pointer_id);
if (!fMustAlloc && pSrcPointer)
@@ -910,7 +908,7 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pointer_needs_unmarshaling = FALSE;
}
break;
- case RPC_FC_FP:
+ case FC_FP:
pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
TRACE("pointer_id is 0x%08x\n", pointer_id);
pointer_needs_unmarshaling = !NdrFullPointerQueryRefId(
@@ -945,17 +943,17 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
* whether we have to initialise it so we can use the optimisation of
* setting the pointer to the buffer, if possible, or set fMustAlloc to
* TRUE. */
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
fMustAlloc = TRUE;
} else {
*current_ptr = NULL;
}
}
- if (attr & RPC_FC_P_ALLOCALLNODES)
- FIXME("RPC_FC_P_ALLOCALLNODES not implemented\n");
+ if (attr & FC_ALLOCATE_ALL_NODES)
+ FIXME("FC_ALLOCATE_ALL_NODES not implemented\n");
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
if (fMustAlloc) {
unsigned char *base_ptr_val = NdrAllocate(pStubMsg, sizeof(void *));
*pPointer = base_ptr_val;
@@ -969,7 +967,7 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (m) m(pStubMsg, current_ptr, desc, fMustAlloc);
else FIXME("no unmarshaller for data type=%02x\n", *desc);
- if (type == RPC_FC_FP)
+ if (type == FC_FP)
NdrFullPointerInsertRefId(pStubMsg->FullPtrXlatTables, pointer_id,
*pPointer);
}
@@ -993,24 +991,24 @@ static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
pFormat += 2;
- if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
+ if (attr & FC_SIMPLE_POINTER) desc = pFormat;
else desc = pFormat + *(const SHORT*)pFormat;
switch (type) {
- case RPC_FC_RP: /* ref pointer (always non-null) */
+ case FC_RP: /* ref pointer (always non-null) */
if (!Pointer)
{
ERR("NULL ref pointer is not allowed\n");
RpcRaiseException(RPC_X_NULL_REF_POINTER);
}
break;
- case RPC_FC_OP:
- case RPC_FC_UP:
+ case FC_OP:
+ case FC_UP:
/* NULL pointer has no further representation */
if (!Pointer)
return;
break;
- case RPC_FC_FP:
+ case FC_FP:
pointer_needs_sizing = !NdrFullPointerQueryPointer(
pStubMsg->FullPtrXlatTables, Pointer, 0, &pointer_id);
if (!pointer_needs_sizing)
@@ -1022,7 +1020,7 @@ static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
return;
}
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
Pointer = *(unsigned char**)Pointer;
TRACE("deref => %p\n", Pointer);
}
@@ -1047,15 +1045,15 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, Buffer, pFormat);
TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
pFormat += 2;
- if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
+ if (attr & FC_SIMPLE_POINTER) desc = pFormat;
else desc = pFormat + *(const SHORT*)pFormat;
switch (type) {
- case RPC_FC_RP: /* ref pointer (always non-null) */
+ case FC_RP: /* ref pointer (always non-null) */
pointer_needs_sizing = TRUE;
break;
- case RPC_FC_UP: /* unique pointer */
- case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
+ case FC_UP: /* unique pointer */
+ case FC_OP: /* object pointer - we must free data before overwriting it */
pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
TRACE("pointer_id is 0x%08x\n", pointer_id);
if (pointer_id)
@@ -1063,7 +1061,7 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
else
pointer_needs_sizing = FALSE;
break;
- case RPC_FC_FP:
+ case FC_FP:
{
void *pointer;
pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
@@ -1078,7 +1076,7 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
return 0;
}
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
align_length(&pStubMsg->MemorySize, sizeof(void*));
pStubMsg->MemorySize += sizeof(void*);
TRACE("deref\n");
@@ -1107,21 +1105,21 @@ static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
- if (attr & RPC_FC_P_DONTFREE) return;
+ if (attr & FC_DONT_FREE) return;
pFormat += 2;
- if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
+ if (attr & FC_SIMPLE_POINTER) desc = pFormat;
else desc = pFormat + *(const SHORT*)pFormat;
if (!Pointer) return;
- if (type == RPC_FC_FP) {
+ if (type == FC_FP) {
int pointer_needs_freeing = NdrFullPointerFree(
pStubMsg->FullPtrXlatTables, Pointer);
if (!pointer_needs_freeing)
return;
}
- if (attr & RPC_FC_P_DEREF) {
+ if (attr & FC_POINTER_DEREF) {
current_pointer = *(unsigned char**)Pointer;
TRACE("deref => %p\n", current_pointer);
}
@@ -1138,7 +1136,7 @@ static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
if (Pointer >= pStubMsg->BufferStart && Pointer <= pStubMsg->BufferEnd)
goto notfree;
- if (attr & RPC_FC_P_ONSTACK) {
+ if (attr & FC_ALLOCED_ON_STACK) {
TRACE("not freeing stack ptr %p\n", Pointer);
return;
}
@@ -1163,7 +1161,7 @@ static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (*pFormat != RPC_FC_PP) return NULL;
+ if (*pFormat != FC_PP) return NULL;
pFormat += 2;
if (pStubMsg->PointerBufferMark)
@@ -1173,25 +1171,25 @@ static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
}
- while (pFormat[0] != RPC_FC_END) {
+ while (pFormat[0] != FC_END) {
switch (pFormat[0]) {
default:
FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
/* fallthrough */
- case RPC_FC_NO_REPEAT:
+ case FC_NO_REPEAT:
rep = 1;
stride = 0;
count = 1;
pFormat += 2;
break;
- case RPC_FC_FIXED_REPEAT:
+ case FC_FIXED_REPEAT:
rep = *(const WORD*)&pFormat[2];
stride = *(const WORD*)&pFormat[4];
count = *(const WORD*)&pFormat[8];
pFormat += 10;
break;
- case RPC_FC_VARIABLE_REPEAT:
- rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
+ case FC_VARIABLE_REPEAT:
+ rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
stride = *(const WORD*)&pFormat[2];
count = *(const WORD*)&pFormat[6];
pFormat += 8;
@@ -1243,7 +1241,7 @@ static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, pDstBuffer, pSrcMemoryPtrs, pFormat, fMustAlloc);
- if (*pFormat != RPC_FC_PP) return NULL;
+ if (*pFormat != FC_PP) return NULL;
pFormat += 2;
if (pStubMsg->PointerBufferMark)
@@ -1253,26 +1251,26 @@ static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
}
- while (pFormat[0] != RPC_FC_END) {
+ while (pFormat[0] != FC_END) {
TRACE("pFormat[0] = 0x%x\n", pFormat[0]);
switch (pFormat[0]) {
default:
FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
/* fallthrough */
- case RPC_FC_NO_REPEAT:
+ case FC_NO_REPEAT:
rep = 1;
stride = 0;
count = 1;
pFormat += 2;
break;
- case RPC_FC_FIXED_REPEAT:
+ case FC_FIXED_REPEAT:
rep = *(const WORD*)&pFormat[2];
stride = *(const WORD*)&pFormat[4];
count = *(const WORD*)&pFormat[8];
pFormat += 10;
break;
- case RPC_FC_VARIABLE_REPEAT:
- rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
+ case FC_VARIABLE_REPEAT:
+ rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
stride = *(const WORD*)&pFormat[2];
count = *(const WORD*)&pFormat[6];
pFormat += 8;
@@ -1319,7 +1317,7 @@ static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
if (pStubMsg->IgnoreEmbeddedPointers) return;
- if (*pFormat != RPC_FC_PP) return;
+ if (*pFormat != FC_PP) return;
pFormat += 2;
if (pStubMsg->PointerLength)
@@ -1329,25 +1327,25 @@ static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerLength = 0;
}
- while (pFormat[0] != RPC_FC_END) {
+ while (pFormat[0] != FC_END) {
switch (pFormat[0]) {
default:
FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
/* fallthrough */
- case RPC_FC_NO_REPEAT:
+ case FC_NO_REPEAT:
rep = 1;
stride = 0;
count = 1;
pFormat += 2;
break;
- case RPC_FC_FIXED_REPEAT:
+ case FC_FIXED_REPEAT:
rep = *(const WORD*)&pFormat[2];
stride = *(const WORD*)&pFormat[4];
count = *(const WORD*)&pFormat[8];
pFormat += 10;
break;
- case RPC_FC_VARIABLE_REPEAT:
- rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
+ case FC_VARIABLE_REPEAT:
+ rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
stride = *(const WORD*)&pFormat[2];
count = *(const WORD*)&pFormat[6];
pFormat += 8;
@@ -1399,28 +1397,28 @@ static ULONG EmbeddedPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
}
- if (*pFormat != RPC_FC_PP) return 0;
+ if (*pFormat != FC_PP) return 0;
pFormat += 2;
- while (pFormat[0] != RPC_FC_END) {
+ while (pFormat[0] != FC_END) {
switch (pFormat[0]) {
default:
FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
/* fallthrough */
- case RPC_FC_NO_REPEAT:
+ case FC_NO_REPEAT:
rep = 1;
stride = 0;
count = 1;
pFormat += 2;
break;
- case RPC_FC_FIXED_REPEAT:
+ case FC_FIXED_REPEAT:
rep = *(const WORD*)&pFormat[2];
stride = *(const WORD*)&pFormat[4];
count = *(const WORD*)&pFormat[8];
pFormat += 10;
break;
- case RPC_FC_VARIABLE_REPEAT:
- rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
+ case FC_VARIABLE_REPEAT:
+ rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
stride = *(const WORD*)&pFormat[2];
count = *(const WORD*)&pFormat[6];
pFormat += 8;
@@ -1458,28 +1456,28 @@ static void EmbeddedPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
unsigned i;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (*pFormat != RPC_FC_PP) return;
+ if (*pFormat != FC_PP) return;
pFormat += 2;
- while (pFormat[0] != RPC_FC_END) {
+ while (pFormat[0] != FC_END) {
switch (pFormat[0]) {
default:
FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
/* fallthrough */
- case RPC_FC_NO_REPEAT:
+ case FC_NO_REPEAT:
rep = 1;
stride = 0;
count = 1;
pFormat += 2;
break;
- case RPC_FC_FIXED_REPEAT:
+ case FC_FIXED_REPEAT:
rep = *(const WORD*)&pFormat[2];
stride = *(const WORD*)&pFormat[4];
count = *(const WORD*)&pFormat[8];
pFormat += 10;
break;
- case RPC_FC_VARIABLE_REPEAT:
- rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
+ case FC_VARIABLE_REPEAT:
+ rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
stride = *(const WORD*)&pFormat[2];
count = *(const WORD*)&pFormat[6];
pFormat += 8;
@@ -1517,7 +1515,7 @@ unsigned char * WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
/* Increment the buffer here instead of in PointerMarshall,
* as that is used by embedded pointers which already handle the incrementing
* the buffer, and shouldn't write any additional pointer data to the wire */
- if (*pFormat != RPC_FC_RP)
+ if (*pFormat != FC_RP)
{
align_pointer_clear(&pStubMsg->Buffer, 4);
Buffer = pStubMsg->Buffer;
@@ -1543,7 +1541,7 @@ unsigned char * WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (*pFormat == RPC_FC_RP)
+ if (*pFormat == FC_RP)
{
Buffer = pStubMsg->Buffer;
/* Do the NULL ref pointer check here because embedded pointers can be
@@ -1583,7 +1581,7 @@ void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
/* Increment the buffer length here instead of in PointerBufferSize,
* as that is used by embedded pointers which already handle the buffer
* length, and shouldn't write anything more to the wire */
- if (*pFormat != RPC_FC_RP)
+ if (*pFormat != FC_RP)
{
align_length(&pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4);
@@ -1599,7 +1597,7 @@ ULONG WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
unsigned char *Buffer = pStubMsg->Buffer;
- if (*pFormat != RPC_FC_RP)
+ if (*pFormat != FC_RP)
{
align_pointer(&pStubMsg->Buffer, 4);
safe_buffer_increment(pStubMsg, 4);
@@ -1648,39 +1646,39 @@ void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char*
switch(FormatChar)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
BASE_TYPE_UNMARSHALL(UCHAR);
TRACE("value: 0x%02x\n", *pMemory);
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
BASE_TYPE_UNMARSHALL(USHORT);
TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ERROR_STATUS_T:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ERROR_STATUS_T:
+ case FC_ENUM32:
BASE_TYPE_UNMARSHALL(ULONG);
TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
break;
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
BASE_TYPE_UNMARSHALL(float);
TRACE("value: %f\n", *(float *)pMemory);
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
BASE_TYPE_UNMARSHALL(double);
TRACE("value: %f\n", *(double *)pMemory);
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
BASE_TYPE_UNMARSHALL(ULONGLONG);
TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG *)pMemory));
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
TRACE("pMemory: %p\n", pMemory);
/* 16-bits on the wire, but int in memory */
@@ -1688,21 +1686,21 @@ void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char*
pStubMsg->Buffer += sizeof(USHORT);
TRACE("value: 0x%08x\n", *(UINT *)pMemory);
break;
- case RPC_FC_INT3264:
+ case FC_INT3264:
align_pointer(&pStubMsg->Buffer, sizeof(INT));
/* 32-bits on the wire, but int_ptr in memory */
*(INT_PTR *)pMemory = *(INT *)pStubMsg->Buffer;
pStubMsg->Buffer += sizeof(INT);
TRACE("value: 0x%08lx\n", *(INT_PTR *)pMemory);
break;
- case RPC_FC_UINT3264:
+ case FC_UINT3264:
align_pointer(&pStubMsg->Buffer, sizeof(UINT));
/* 32-bits on the wire, but int_ptr in memory */
*(UINT_PTR *)pMemory = *(UINT *)pStubMsg->Buffer;
pStubMsg->Buffer += sizeof(UINT);
TRACE("value: 0x%08lx\n", *(UINT_PTR *)pMemory);
break;
- case RPC_FC_IGNORE:
+ case FC_IGNORE:
break;
default:
FIXME("Unhandled base type: 0x%02x\n", FormatChar);
@@ -1725,7 +1723,7 @@ unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->BufferMark = pStubMsg->Buffer;
safe_copy_to_buffer(pStubMsg, pMemory, size);
- if (pFormat[0] != RPC_FC_STRUCT)
+ if (pFormat[0] != FC_STRUCT)
EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
return NULL;
@@ -1756,7 +1754,7 @@ unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, size);
- if (pFormat[0] == RPC_FC_PSTRUCT)
+ if (pFormat[0] == FC_PSTRUCT)
EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat+4, fMustAlloc);
TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
@@ -1779,7 +1777,7 @@ void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
align_length(&pStubMsg->BufferLength, pFormat[1] + 1);
safe_buffer_length_increment(pStubMsg, size);
- if (pFormat[0] != RPC_FC_STRUCT)
+ if (pFormat[0] != FC_STRUCT)
EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4);
}
@@ -1797,7 +1795,7 @@ ULONG WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->MemorySize += size;
safe_buffer_increment(pStubMsg, size);
- if (pFormat[0] != RPC_FC_STRUCT)
+ if (pFormat[0] != FC_STRUCT)
EmbeddedPointerMemorySize(pStubMsg, pFormat+4);
return pStubMsg->MemorySize;
}
@@ -1810,7 +1808,7 @@ void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_STRUCT)
+ if (pFormat[0] != FC_STRUCT)
EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4);
}
@@ -1824,18 +1822,18 @@ static inline void array_compute_and_size_conformance(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
SizeConformance(pStubMsg);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
SizeConformance(pStubMsg);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
{
TRACE("string=%s\n", debugstr_a((const char *)pMemory));
pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
@@ -1846,14 +1844,14 @@ static inline void array_compute_and_size_conformance(
pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1;
}
- if (pFormat[1] == RPC_FC_STRING_SIZED)
+ if (pFormat[1] == FC_STRING_SIZED)
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
else
pStubMsg->MaxCount = pStubMsg->ActualCount;
SizeConformance(pStubMsg);
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
count = *(const WORD *)(pFormat + 2);
pFormat += 4;
if (IsConformanceOrVariancePresent(pFormat)) SizeConformance(pStubMsg);
@@ -1876,7 +1874,7 @@ static inline void array_buffer_size(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -1891,7 +1889,7 @@ static inline void array_buffer_size(
if (fHasPointers)
EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -1908,9 +1906,9 @@ static inline void array_buffer_size(
if (fHasPointers)
EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
esize = 1;
else
esize = 2;
@@ -1920,7 +1918,7 @@ static inline void array_buffer_size(
size = safe_multiply(esize, pStubMsg->ActualCount);
safe_buffer_length_increment(pStubMsg, size);
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
alignment = pFormat[1] + 1;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
if (IsConformanceOrVariancePresent(pFormat)) SizeVariance(pStubMsg);
@@ -1947,18 +1945,18 @@ static inline void array_compute_and_write_conformance(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
WriteConformance(pStubMsg);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
WriteConformance(pStubMsg);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
{
TRACE("string=%s\n", debugstr_a((const char *)pMemory));
pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
@@ -1968,14 +1966,14 @@ static inline void array_compute_and_write_conformance(
TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory));
pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1;
}
- if (pFormat[1] == RPC_FC_STRING_SIZED)
+ if (pFormat[1] == FC_STRING_SIZED)
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
else
pStubMsg->MaxCount = pStubMsg->ActualCount;
pStubMsg->Offset = 0;
WriteConformance(pStubMsg);
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
def = *(const WORD *)(pFormat + 2);
pFormat += 4;
conformance_present = IsConformanceOrVariancePresent(pFormat);
@@ -1999,7 +1997,7 @@ static inline void array_write_variance_and_marshall(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2015,7 +2013,7 @@ static inline void array_write_variance_and_marshall(
if (fHasPointers)
EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2035,9 +2033,9 @@ static inline void array_write_variance_and_marshall(
if (fHasPointers)
EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
esize = 1;
else
esize = 2;
@@ -2047,7 +2045,7 @@ static inline void array_write_variance_and_marshall(
size = safe_multiply(esize, pStubMsg->ActualCount);
safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
alignment = pFormat[1] + 1;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
if (IsConformanceOrVariancePresent(pFormat)) WriteVariance(pStubMsg);
@@ -2072,27 +2070,27 @@ static inline ULONG array_read_conformance(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
esize = *(const WORD*)(pFormat+2);
pFormat = ReadConformance(pStubMsg, pFormat+4);
return safe_multiply(esize, pStubMsg->MaxCount);
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
esize = *(const WORD*)(pFormat+2);
pFormat = ReadConformance(pStubMsg, pFormat+4);
return safe_multiply(esize, pStubMsg->MaxCount);
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
esize = 1;
else
esize = 2;
- if (pFormat[1] == RPC_FC_STRING_SIZED)
+ if (pFormat[1] == FC_STRING_SIZED)
ReadConformance(pStubMsg, pFormat + 2);
else
ReadConformance(pStubMsg, NULL);
return safe_multiply(esize, pStubMsg->MaxCount);
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
def = *(const WORD *)(pFormat + 2);
pFormat += 4;
if (IsConformanceOrVariancePresent(pFormat)) pFormat = ReadConformance(pStubMsg, pFormat);
@@ -2124,7 +2122,7 @@ static inline ULONG array_read_variance_and_unmarshall(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2156,7 +2154,7 @@ static inline ULONG array_read_variance_and_unmarshall(
memcpy(*ppMemory, saved_buffer, bufsize);
}
return bufsize;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2187,16 +2185,16 @@ static inline ULONG array_read_variance_and_unmarshall(
memcpy(*ppMemory + offset, saved_buffer, bufsize);
}
return bufsize;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
esize = 1;
else
esize = 2;
ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
- if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
+ if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
{
ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
pStubMsg->ActualCount, pStubMsg->MaxCount);
@@ -2233,14 +2231,14 @@ static inline ULONG array_read_variance_and_unmarshall(
else
safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
- if (*pFormat == RPC_FC_C_CSTRING)
+ if (*pFormat == FC_C_CSTRING)
TRACE("string=%s\n", debugstr_a((char*)*ppMemory));
else
TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory));
}
return bufsize;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
alignment = pFormat[1] + 1;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
@@ -2281,7 +2279,7 @@ static inline void array_memory_size(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2298,7 +2296,7 @@ static inline void array_memory_size(
if (fHasPointers)
EmbeddedPointerMemorySize(pStubMsg, pFormat);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
@@ -2318,16 +2316,16 @@ static inline void array_memory_size(
if (fHasPointers)
EmbeddedPointerMemorySize(pStubMsg, pFormat);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (fc == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (fc == FC_C_CSTRING)
esize = 1;
else
esize = 2;
ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
- if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
+ if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
{
ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
pStubMsg->ActualCount, pStubMsg->MaxCount);
@@ -2347,7 +2345,7 @@ static inline void array_memory_size(
safe_buffer_increment(pStubMsg, bufsize);
pStubMsg->MemorySize += memsize;
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
alignment = pFormat[1] + 1;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
@@ -2379,22 +2377,22 @@ static inline void array_free(
switch (fc)
{
- case RPC_FC_CARRAY:
+ case FC_CARRAY:
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
if (fHasPointers)
EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_CVARRAY:
+ case FC_CVARRAY:
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
if (fHasPointers)
EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
/* No embedded pointers so nothing to do */
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
count = *(const WORD *)(pFormat + 2);
pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, count);
pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
@@ -2434,22 +2432,22 @@ unsigned char *WINAPI NdrConformantStringMarshall(MIDL_STUB_MESSAGE *pStubMsg,
{
TRACE("(pStubMsg == ^%p, pszMessage == ^%p, pFormat == ^%p)\n", pStubMsg, pszMessage, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
+ if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) {
ERR("Unhandled string type: %#x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
/* allow compiler to optimise inline function by passing constant into
* these functions */
- if (pFormat[0] == RPC_FC_C_CSTRING) {
- array_compute_and_write_conformance(RPC_FC_C_CSTRING, pStubMsg, pszMessage,
+ if (pFormat[0] == FC_C_CSTRING) {
+ array_compute_and_write_conformance(FC_C_CSTRING, pStubMsg, pszMessage,
pFormat);
- array_write_variance_and_marshall(RPC_FC_C_CSTRING, pStubMsg, pszMessage,
+ array_write_variance_and_marshall(FC_C_CSTRING, pStubMsg, pszMessage,
pFormat, TRUE /* fHasPointers */);
} else {
- array_compute_and_write_conformance(RPC_FC_C_WSTRING, pStubMsg, pszMessage,
+ array_compute_and_write_conformance(FC_C_WSTRING, pStubMsg, pszMessage,
pFormat);
- array_write_variance_and_marshall(RPC_FC_C_WSTRING, pStubMsg, pszMessage,
+ array_write_variance_and_marshall(FC_C_WSTRING, pStubMsg, pszMessage,
pFormat, TRUE /* fHasPointers */);
}
@@ -2464,22 +2462,22 @@ void WINAPI NdrConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
+ if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) {
ERR("Unhandled string type: %#x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
/* allow compiler to optimise inline function by passing constant into
* these functions */
- if (pFormat[0] == RPC_FC_C_CSTRING) {
- array_compute_and_size_conformance(RPC_FC_C_CSTRING, pStubMsg, pMemory,
+ if (pFormat[0] == FC_C_CSTRING) {
+ array_compute_and_size_conformance(FC_C_CSTRING, pStubMsg, pMemory,
pFormat);
- array_buffer_size(RPC_FC_C_CSTRING, pStubMsg, pMemory, pFormat,
+ array_buffer_size(FC_C_CSTRING, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
} else {
- array_compute_and_size_conformance(RPC_FC_C_WSTRING, pStubMsg, pMemory,
+ array_compute_and_size_conformance(FC_C_WSTRING, pStubMsg, pMemory,
pFormat);
- array_buffer_size(RPC_FC_C_WSTRING, pStubMsg, pMemory, pFormat,
+ array_buffer_size(FC_C_WSTRING, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
}
}
@@ -2492,20 +2490,20 @@ ULONG WINAPI NdrConformantStringMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
+ if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) {
ERR("Unhandled string type: %#x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
/* allow compiler to optimise inline function by passing constant into
* these functions */
- if (pFormat[0] == RPC_FC_C_CSTRING) {
- array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat);
- array_memory_size(RPC_FC_C_CSTRING, pStubMsg, pFormat,
+ if (pFormat[0] == FC_C_CSTRING) {
+ array_read_conformance(FC_C_CSTRING, pStubMsg, pFormat);
+ array_memory_size(FC_C_CSTRING, pStubMsg, pFormat,
TRUE /* fHasPointers */);
} else {
- array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat);
- array_memory_size(RPC_FC_C_WSTRING, pStubMsg, pFormat,
+ array_read_conformance(FC_C_WSTRING, pStubMsg, pFormat);
+ array_memory_size(FC_C_WSTRING, pStubMsg, pFormat,
TRUE /* fHasPointers */);
}
@@ -2521,22 +2519,22 @@ unsigned char *WINAPI NdrConformantStringUnmarshall( PMIDL_STUB_MESSAGE pStubMsg
TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
pStubMsg, *ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
+ if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) {
ERR("Unhandled string type: %#x\n", *pFormat);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
/* allow compiler to optimise inline function by passing constant into
* these functions */
- if (pFormat[0] == RPC_FC_C_CSTRING) {
- array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_C_CSTRING, pStubMsg, ppMemory,
+ if (pFormat[0] == FC_C_CSTRING) {
+ array_read_conformance(FC_C_CSTRING, pStubMsg, pFormat);
+ array_read_variance_and_unmarshall(FC_C_CSTRING, pStubMsg, ppMemory,
pFormat, fMustAlloc,
TRUE /* fUseBufferMemoryServer */,
TRUE /* fUnmarshall */);
} else {
- array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_C_WSTRING, pStubMsg, ppMemory,
+ array_read_conformance(FC_C_WSTRING, pStubMsg, pFormat);
+ array_read_variance_and_unmarshall(FC_C_WSTRING, pStubMsg, ppMemory,
pFormat, fMustAlloc,
TRUE /* fUseBufferMemoryServer */,
TRUE /* fUnmarshall */);
@@ -2558,7 +2556,7 @@ unsigned char * WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubM
maxsize = *(const USHORT *)&pFormat[2];
- if (*pFormat == RPC_FC_CSTRING)
+ if (*pFormat == FC_CSTRING)
{
ULONG i = 0;
const char *str = (const char *)pMemory;
@@ -2567,7 +2565,7 @@ unsigned char * WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubM
pStubMsg->ActualCount = i + 1;
esize = 1;
}
- else if (*pFormat == RPC_FC_WSTRING)
+ else if (*pFormat == FC_WSTRING)
{
ULONG i = 0;
const WCHAR *str = (const WCHAR *)pMemory;
@@ -2613,8 +2611,8 @@ unsigned char * WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStu
RpcRaiseException(RPC_S_INVALID_BOUND);
}
- if (*pFormat == RPC_FC_CSTRING) esize = 1;
- else if (*pFormat == RPC_FC_WSTRING) esize = 2;
+ if (*pFormat == FC_CSTRING) esize = 1;
+ else if (*pFormat == FC_WSTRING) esize = 2;
else
{
ERR("Unhandled string type: %#x\n", *pFormat);
@@ -2633,10 +2631,10 @@ unsigned char * WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStu
safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
- if (*pFormat == RPC_FC_CSTRING) {
+ if (*pFormat == FC_CSTRING) {
TRACE("string=%s\n", debugstr_an((char*)*ppMemory, pStubMsg->ActualCount));
}
- else if (*pFormat == RPC_FC_WSTRING) {
+ else if (*pFormat == FC_WSTRING) {
TRACE("string=%s\n", debugstr_wn((LPWSTR)*ppMemory, pStubMsg->ActualCount));
}
@@ -2658,7 +2656,7 @@ void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
SizeVariance(pStubMsg);
- if (*pFormat == RPC_FC_CSTRING)
+ if (*pFormat == FC_CSTRING)
{
ULONG i = 0;
const char *str = (const char *)pMemory;
@@ -2667,7 +2665,7 @@ void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->ActualCount = i + 1;
esize = 1;
}
- else if (*pFormat == RPC_FC_WSTRING)
+ else if (*pFormat == FC_WSTRING)
{
ULONG i = 0;
const WCHAR *str = (const WCHAR *)pMemory;
@@ -2705,8 +2703,8 @@ ULONG WINAPI NdrNonConformantStringMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
RpcRaiseException(RPC_S_INVALID_BOUND);
}
- if (*pFormat == RPC_FC_CSTRING) esize = 1;
- else if (*pFormat == RPC_FC_WSTRING) esize = 2;
+ if (*pFormat == FC_CSTRING) esize = 1;
+ else if (*pFormat == FC_WSTRING) esize = 2;
else
{
ERR("Unhandled string type: %#x\n", *pFormat);
@@ -2740,54 +2738,54 @@ static ULONG EmbeddedComplexSize(MIDL_STUB_MESSAGE *pStubMsg,
PFORMAT_STRING pFormat)
{
switch (*pFormat) {
- case RPC_FC_STRUCT:
- case RPC_FC_PSTRUCT:
- case RPC_FC_CSTRUCT:
- case RPC_FC_BOGUS_STRUCT:
- case RPC_FC_SMFARRAY:
- case RPC_FC_SMVARRAY:
- case RPC_FC_CSTRING:
+ case FC_STRUCT:
+ case FC_PSTRUCT:
+ case FC_CSTRUCT:
+ case FC_BOGUS_STRUCT:
+ case FC_SMFARRAY:
+ case FC_SMVARRAY:
+ case FC_CSTRING:
return *(const WORD*)&pFormat[2];
- case RPC_FC_USER_MARSHAL:
+ case FC_USER_MARSHAL:
return *(const WORD*)&pFormat[4];
- case RPC_FC_RANGE: {
+ case FC_RANGE: {
switch (((const NDR_RANGE *)pFormat)->flags_type & 0xf) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
return sizeof(UCHAR);
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
return sizeof(USHORT);
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
+ case FC_INT3264:
+ case FC_UINT3264:
return sizeof(ULONG);
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
return sizeof(float);
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
return sizeof(double);
- case RPC_FC_HYPER:
+ case FC_HYPER:
return sizeof(ULONGLONG);
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
return sizeof(UINT);
default:
ERR("unknown type 0x%x\n", ((const NDR_RANGE *)pFormat)->flags_type & 0xf);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
}
- case RPC_FC_NON_ENCAPSULATED_UNION:
+ case FC_NON_ENCAPSULATED_UNION:
pFormat += 2;
pFormat = SkipConformance(pStubMsg, pFormat);
pFormat += *(const SHORT*)pFormat;
return *(const SHORT*)pFormat;
- case RPC_FC_IP:
+ case FC_IP:
return sizeof(void *);
- case RPC_FC_WSTRING:
+ case FC_WSTRING:
return *(const WORD*)&pFormat[2] * 2;
default:
FIXME("unhandled embedded type %02x\n", *pFormat);
@@ -2820,24 +2818,24 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
NDR_MARSHALL m;
ULONG size;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, 1);
pMemory += 1;
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, 2);
pMemory += 2;
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
{
USHORT val = *(DWORD *)pMemory;
TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory);
@@ -2847,15 +2845,15 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += 4;
break;
}
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, 4);
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
{
UINT val = *(UINT_PTR *)pMemory;
TRACE("int3264=%ld <= %p\n", *(UINT_PTR *)pMemory, pMemory);
@@ -2863,34 +2861,34 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += sizeof(UINT_PTR);
break;
}
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
TRACE("float=%f <= %p\n", *(float*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
pMemory += sizeof(float);
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, 8);
pMemory += 8;
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
TRACE("double=%f <= %p\n", *(double*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
pMemory += sizeof(double);
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
{
unsigned char *saved_buffer;
BOOL pointer_buffer_mark_set = FALSE;
TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
TRACE("pStubMsg->Buffer before %p\n", pStubMsg->Buffer);
- if (*pFormat != RPC_FC_POINTER)
+ if (*pFormat != FC_POINTER)
pPointer = pFormat;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
align_pointer_clear(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
@@ -2899,7 +2897,7 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
pointer_buffer_mark_set = TRUE;
}
- else if (*pPointer != RPC_FC_RP)
+ else if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
PointerMarshall(pStubMsg, saved_buffer, *(unsigned char**)pMemory, pPointer);
if (pointer_buffer_mark_set)
@@ -2907,36 +2905,36 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
STD_OVERFLOW_CHECK(pStubMsg);
pStubMsg->PointerBufferMark = pStubMsg->Buffer;
pStubMsg->Buffer = saved_buffer;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
}
TRACE("pStubMsg->Buffer after %p\n", pStubMsg->Buffer);
- if (*pFormat == RPC_FC_POINTER)
+ if (*pFormat == FC_POINTER)
pPointer += 4;
else
pFormat += 4;
pMemory += sizeof(void *);
break;
}
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_pointer(&pMemory, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_pointer(&pMemory, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_pointer(&pMemory, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ pMemory += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
pMemory += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
@@ -2946,10 +2944,10 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (m)
{
/* for some reason interface pointers aren't generated as
- * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
+ * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
* they still need the dereferencing treatment that pointers are
* given */
- if (*desc == RPC_FC_IP)
+ if (*desc == FC_IP)
m(pStubMsg, *(unsigned char **)pMemory, desc);
else
m(pStubMsg, pMemory, desc);
@@ -2958,7 +2956,7 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += size;
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format 0x%02x\n", *pFormat);
@@ -2979,24 +2977,24 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
NDR_UNMARSHALL m;
ULONG size;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
safe_copy_from_buffer(pStubMsg, pMemory, 1);
TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory);
pMemory += 1;
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
safe_copy_from_buffer(pStubMsg, pMemory, 2);
TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
pMemory += 2;
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
{
WORD val;
safe_copy_from_buffer(pStubMsg, &val, 2);
@@ -3007,14 +3005,14 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += 4;
break;
}
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
safe_copy_from_buffer(pStubMsg, pMemory, 4);
TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
pMemory += 4;
break;
- case RPC_FC_INT3264:
+ case FC_INT3264:
{
INT val;
safe_copy_from_buffer(pStubMsg, &val, 4);
@@ -3023,7 +3021,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += sizeof(INT_PTR);
break;
}
- case RPC_FC_UINT3264:
+ case FC_UINT3264:
{
UINT val;
safe_copy_from_buffer(pStubMsg, &val, 4);
@@ -3032,33 +3030,33 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += sizeof(UINT_PTR);
break;
}
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
safe_copy_from_buffer(pStubMsg, pMemory, sizeof(float));
TRACE("float=%f => %p\n", *(float*)pMemory, pMemory);
pMemory += sizeof(float);
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
safe_copy_from_buffer(pStubMsg, pMemory, 8);
TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
pMemory += 8;
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
safe_copy_from_buffer(pStubMsg, pMemory, sizeof(double));
TRACE("double=%f => %p\n", *(double*)pMemory, pMemory);
pMemory += sizeof(double);
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
{
unsigned char *saved_buffer;
BOOL pointer_buffer_mark_set = FALSE;
TRACE("pointer => %p\n", pMemory);
- if (*pFormat != RPC_FC_POINTER)
+ if (*pFormat != FC_POINTER)
pPointer = pFormat;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
align_pointer(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
@@ -3067,7 +3065,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
pointer_buffer_mark_set = TRUE;
}
- else if (*pPointer != RPC_FC_RP)
+ else if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
PointerUnmarshall(pStubMsg, saved_buffer, (unsigned char**)pMemory, *(unsigned char**)pMemory, pPointer, fMustAlloc);
@@ -3076,36 +3074,36 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
STD_OVERFLOW_CHECK(pStubMsg);
pStubMsg->PointerBufferMark = pStubMsg->Buffer;
pStubMsg->Buffer = saved_buffer;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
}
- if (*pFormat == RPC_FC_POINTER)
+ if (*pFormat == FC_POINTER)
pPointer += 4;
else
pFormat += 4;
pMemory += sizeof(void *);
break;
}
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_pointer_clear(&pMemory, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_pointer_clear(&pMemory, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_pointer_clear(&pMemory, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- memset(pMemory, 0, *pFormat - RPC_FC_STRUCTPAD1 + 1);
- pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ memset(pMemory, 0, *pFormat - FC_STRUCTPAD1 + 1);
+ pMemory += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
pMemory += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
@@ -3122,10 +3120,10 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (m)
{
/* for some reason interface pointers aren't generated as
- * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
+ * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
* they still need the dereferencing treatment that pointers are
* given */
- if (*desc == RPC_FC_IP)
+ if (*desc == FC_IP)
m(pStubMsg, (unsigned char **)pMemory, desc, FALSE);
else
m(pStubMsg, &pMemory, desc, FALSE);
@@ -3134,7 +3132,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += size;
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format %d\n", *pFormat);
@@ -3154,48 +3152,48 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
NDR_BUFFERSIZE m;
ULONG size;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
safe_buffer_length_increment(pStubMsg, 1);
pMemory += 1;
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
safe_buffer_length_increment(pStubMsg, 2);
pMemory += 2;
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
safe_buffer_length_increment(pStubMsg, 2);
pMemory += 4;
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
- case RPC_FC_FLOAT:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
+ case FC_FLOAT:
safe_buffer_length_increment(pStubMsg, 4);
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
safe_buffer_length_increment(pStubMsg, 4);
pMemory += sizeof(INT_PTR);
break;
- case RPC_FC_HYPER:
- case RPC_FC_DOUBLE:
+ case FC_HYPER:
+ case FC_DOUBLE:
safe_buffer_length_increment(pStubMsg, 8);
pMemory += 8;
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
- if (*pFormat != RPC_FC_POINTER)
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
+ if (*pFormat != FC_POINTER)
pPointer = pFormat;
if (!pStubMsg->IgnoreEmbeddedPointers)
{
@@ -3208,36 +3206,36 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerLength = pStubMsg->BufferLength;
pStubMsg->BufferLength = saved_buffer_length;
}
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
{
align_length(&pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4);
}
- if (*pFormat == RPC_FC_POINTER)
+ if (*pFormat == FC_POINTER)
pPointer += 4;
else
pFormat += 4;
pMemory += sizeof(void*);
break;
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_pointer(&pMemory, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_pointer(&pMemory, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_pointer(&pMemory, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ pMemory += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
pMemory += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
@@ -3246,10 +3244,10 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
if (m)
{
/* for some reason interface pointers aren't generated as
- * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
+ * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
* they still need the dereferencing treatment that pointers are
* given */
- if (*desc == RPC_FC_IP)
+ if (*desc == FC_IP)
m(pStubMsg, *(unsigned char **)pMemory, desc);
else
m(pStubMsg, pMemory, desc);
@@ -3258,7 +3256,7 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += size;
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format 0x%02x\n", *pFormat);
@@ -3278,67 +3276,67 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
NDR_FREE m;
ULONG size;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
pMemory += 1;
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
pMemory += 2;
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM16:
- case RPC_FC_ENUM32:
- case RPC_FC_FLOAT:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM16:
+ case FC_ENUM32:
+ case FC_FLOAT:
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
pMemory += sizeof(INT_PTR);
break;
- case RPC_FC_HYPER:
- case RPC_FC_DOUBLE:
+ case FC_HYPER:
+ case FC_DOUBLE:
pMemory += 8;
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
- if (*pFormat != RPC_FC_POINTER)
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
+ if (*pFormat != FC_POINTER)
pPointer = pFormat;
NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
- if (*pFormat == RPC_FC_POINTER)
+ if (*pFormat == FC_POINTER)
pPointer += 4;
else
pFormat += 4;
pMemory += sizeof(void *);
break;
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_pointer(&pMemory, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_pointer(&pMemory, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_pointer(&pMemory, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ pMemory += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
pMemory += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
@@ -3347,10 +3345,10 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
if (m)
{
/* for some reason interface pointers aren't generated as
- * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
+ * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
* they still need the dereferencing treatment that pointers are
* given */
- if (*desc == RPC_FC_IP)
+ if (*desc == FC_IP)
m(pStubMsg, *(unsigned char **)pMemory, desc);
else
m(pStubMsg, pMemory, desc);
@@ -3358,7 +3356,7 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
pMemory += size;
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format 0x%02x\n", *pFormat);
@@ -3376,53 +3374,53 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING desc;
ULONG size = 0;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
size += 1;
safe_buffer_increment(pStubMsg, 1);
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
size += 2;
safe_buffer_increment(pStubMsg, 2);
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
size += 4;
safe_buffer_increment(pStubMsg, 2);
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
- case RPC_FC_FLOAT:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
+ case FC_FLOAT:
size += 4;
safe_buffer_increment(pStubMsg, 4);
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
size += sizeof(INT_PTR);
safe_buffer_increment(pStubMsg, 4);
break;
- case RPC_FC_HYPER:
- case RPC_FC_DOUBLE:
+ case FC_HYPER:
+ case FC_DOUBLE:
size += 8;
safe_buffer_increment(pStubMsg, 8);
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
{
unsigned char *saved_buffer;
BOOL pointer_buffer_mark_set = FALSE;
- if (*pFormat != RPC_FC_POINTER)
+ if (*pFormat != FC_POINTER)
pPointer = pFormat;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
align_pointer(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
@@ -3431,7 +3429,7 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->PointerBufferMark = NULL;
pointer_buffer_mark_set = TRUE;
}
- else if (*pPointer != RPC_FC_RP)
+ else if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
if (!pStubMsg->IgnoreEmbeddedPointers)
@@ -3441,42 +3439,42 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
STD_OVERFLOW_CHECK(pStubMsg);
pStubMsg->PointerBufferMark = pStubMsg->Buffer;
pStubMsg->Buffer = saved_buffer;
- if (*pPointer != RPC_FC_RP)
+ if (*pPointer != FC_RP)
safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
}
- if (*pFormat == RPC_FC_POINTER)
+ if (*pFormat == FC_POINTER)
pPointer += 4;
else
pFormat += 4;
size += sizeof(void *);
break;
}
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_length(&size, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_length(&size, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_length(&size, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ size += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
size += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
size += EmbeddedComplexMemorySize(pStubMsg, desc);
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format 0x%02x\n", *pFormat);
@@ -3492,69 +3490,69 @@ ULONG ComplexStructSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
PFORMAT_STRING desc;
ULONG size = 0;
- while (*pFormat != RPC_FC_END) {
+ while (*pFormat != FC_END) {
switch (*pFormat) {
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
size += 1;
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
size += 2;
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM16:
- case RPC_FC_ENUM32:
- case RPC_FC_FLOAT:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM16:
+ case FC_ENUM32:
+ case FC_FLOAT:
size += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
size += sizeof(INT_PTR);
break;
- case RPC_FC_HYPER:
- case RPC_FC_DOUBLE:
+ case FC_HYPER:
+ case FC_DOUBLE:
size += 8;
break;
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
- case RPC_FC_POINTER:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
+ case FC_POINTER:
size += sizeof(void *);
- if (*pFormat != RPC_FC_POINTER)
+ if (*pFormat != FC_POINTER)
pFormat += 4;
break;
- case RPC_FC_ALIGNM2:
+ case FC_ALIGNM2:
align_length(&size, 2);
break;
- case RPC_FC_ALIGNM4:
+ case FC_ALIGNM4:
align_length(&size, 4);
break;
- case RPC_FC_ALIGNM8:
+ case FC_ALIGNM8:
align_length(&size, 8);
break;
- case RPC_FC_STRUCTPAD1:
- case RPC_FC_STRUCTPAD2:
- case RPC_FC_STRUCTPAD3:
- case RPC_FC_STRUCTPAD4:
- case RPC_FC_STRUCTPAD5:
- case RPC_FC_STRUCTPAD6:
- case RPC_FC_STRUCTPAD7:
- size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
+ case FC_STRUCTPAD1:
+ case FC_STRUCTPAD2:
+ case FC_STRUCTPAD3:
+ case FC_STRUCTPAD4:
+ case FC_STRUCTPAD5:
+ case FC_STRUCTPAD6:
+ case FC_STRUCTPAD7:
+ size += *pFormat - FC_STRUCTPAD1 + 1;
break;
- case RPC_FC_EMBEDDED_COMPLEX:
+ case FC_EMBEDDED_COMPLEX:
size += pFormat[1];
pFormat += 2;
desc = pFormat + *(const SHORT*)pFormat;
size += EmbeddedComplexSize(pStubMsg, desc);
pFormat += 2;
continue;
- case RPC_FC_PAD:
+ case FC_PAD:
break;
default:
FIXME("unhandled format 0x%02x\n", *pFormat);
@@ -3904,15 +3902,15 @@ unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CARRAY)
+ if (pFormat[0] != FC_CARRAY)
{
ERR("invalid format = 0x%x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- array_compute_and_write_conformance(RPC_FC_CARRAY, pStubMsg, pMemory,
+ array_compute_and_write_conformance(FC_CARRAY, pStubMsg, pMemory,
pFormat);
- array_write_variance_and_marshall(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
+ array_write_variance_and_marshall(FC_CARRAY, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
return NULL;
@@ -3927,14 +3925,14 @@ unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
unsigned char fMustAlloc)
{
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_CARRAY)
+ if (pFormat[0] != FC_CARRAY)
{
ERR("invalid format = 0x%x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_CARRAY, pStubMsg, ppMemory, pFormat,
+ array_read_conformance(FC_CARRAY, pStubMsg, pFormat);
+ array_read_variance_and_unmarshall(FC_CARRAY, pStubMsg, ppMemory, pFormat,
fMustAlloc,
TRUE /* fUseBufferMemoryServer */,
TRUE /* fUnmarshall */);
@@ -3950,14 +3948,14 @@ void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CARRAY)
+ if (pFormat[0] != FC_CARRAY)
{
ERR("invalid format = 0x%x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- array_compute_and_size_conformance(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat);
- array_buffer_size(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
+ array_compute_and_size_conformance(FC_CARRAY, pStubMsg, pMemory, pFormat);
+ array_buffer_size(FC_CARRAY, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
}
@@ -3968,14 +3966,14 @@ ULONG WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
TRACE("(%p,%p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_CARRAY)
+ if (pFormat[0] != FC_CARRAY)
{
ERR("invalid format = 0x%x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat);
- array_memory_size(RPC_FC_CARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
+ array_read_conformance(FC_CARRAY, pStubMsg, pFormat);
+ array_memory_size(FC_CARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
return pStubMsg->MemorySize;
}
@@ -3988,13 +3986,13 @@ void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CARRAY)
+ if (pFormat[0] != FC_CARRAY)
{
ERR("invalid format = 0x%x\n", pFormat[0]);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- array_free(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
+ array_free(FC_CARRAY, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
}
@@ -4008,16 +4006,16 @@ unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStu
{
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY)
+ if (pFormat[0] != FC_CVARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return NULL;
}
- array_compute_and_write_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory,
+ array_compute_and_write_conformance(FC_CVARRAY, pStubMsg, pMemory,
pFormat);
- array_write_variance_and_marshall(RPC_FC_CVARRAY, pStubMsg, pMemory,
+ array_write_variance_and_marshall(FC_CVARRAY, pStubMsg, pMemory,
pFormat, TRUE /* fHasPointers */);
return NULL;
@@ -4034,15 +4032,15 @@ unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pS
{
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_CVARRAY)
+ if (pFormat[0] != FC_CVARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return NULL;
}
- array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_CVARRAY, pStubMsg, ppMemory,
+ array_read_conformance(FC_CVARRAY, pStubMsg, pFormat);
+ array_read_variance_and_unmarshall(FC_CVARRAY, pStubMsg, ppMemory,
pFormat, fMustAlloc,
TRUE /* fUseBufferMemoryServer */,
TRUE /* fUnmarshall */);
@@ -4060,14 +4058,14 @@ void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY)
+ if (pFormat[0] != FC_CVARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return;
}
- array_free(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat,
+ array_free(FC_CVARRAY, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
}
@@ -4080,16 +4078,16 @@ void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY)
+ if (pFormat[0] != FC_CVARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return;
}
- array_compute_and_size_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory,
+ array_compute_and_size_conformance(FC_CVARRAY, pStubMsg, pMemory,
pFormat);
- array_buffer_size(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat,
+ array_buffer_size(FC_CVARRAY, pStubMsg, pMemory, pFormat,
TRUE /* fHasPointers */);
}
@@ -4102,15 +4100,15 @@ ULONG WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY)
+ if (pFormat[0] != FC_CVARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return pStubMsg->MemorySize;
}
- array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat);
- array_memory_size(RPC_FC_CVARRAY, pStubMsg, pFormat,
+ array_read_conformance(FC_CVARRAY, pStubMsg, pFormat);
+ array_memory_size(FC_CVARRAY, pStubMsg, pFormat,
TRUE /* fHasPointers */);
return pStubMsg->MemorySize;
@@ -4128,7 +4126,7 @@ unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
+ if (pFormat[0] != FC_BOGUS_ARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4164,8 +4162,8 @@ unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->BufferLength = saved_buffer_length;
}
- array_compute_and_write_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
- array_write_variance_and_marshall(RPC_FC_BOGUS_ARRAY, pStubMsg,
+ array_compute_and_write_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
+ array_write_variance_and_marshall(FC_BOGUS_ARRAY, pStubMsg,
pMemory, pFormat, TRUE /* fHasPointers */);
STD_OVERFLOW_CHECK(pStubMsg);
@@ -4193,7 +4191,7 @@ unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
+ if (pFormat[0] != FC_BOGUS_ARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4220,8 +4218,8 @@ unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
/* restore the original buffer */
pStubMsg->Buffer = saved_buffer;
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_BOGUS_ARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc,
+ array_read_conformance(FC_BOGUS_ARRAY, pStubMsg, pFormat);
+ array_read_variance_and_unmarshall(FC_BOGUS_ARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc,
TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */);
if (pointer_buffer_mark_set)
@@ -4244,7 +4242,7 @@ void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
+ if (pFormat[0] != FC_BOGUS_ARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4278,8 +4276,8 @@ void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->BufferLength = saved_buffer_length;
}
- array_compute_and_size_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
- array_buffer_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
+ array_compute_and_size_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
+ array_buffer_size(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
if(pointer_length_set)
{
@@ -4296,15 +4294,15 @@ ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
{
TRACE("(%p,%p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
+ if (pFormat[0] != FC_BOGUS_ARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return 0;
}
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat);
- array_memory_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
+ array_read_conformance(FC_BOGUS_ARRAY, pStubMsg, pFormat);
+ array_memory_size(FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
return pStubMsg->MemorySize;
}
@@ -4319,7 +4317,7 @@ void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
+ if (pFormat[0] != FC_BOGUS_ARRAY)
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4678,7 +4676,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT);
- if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
+ if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT))
{
ERR("invalid format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4687,7 +4685,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
pCStructFormat->offset_to_array_description;
- if (*pCArrayFormat != RPC_FC_CARRAY)
+ if (*pCArrayFormat != FC_CARRAY)
{
ERR("invalid array format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4715,7 +4713,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->BufferMark = pStubMsg->Buffer;
safe_copy_to_buffer(pStubMsg, pMemory, pCStructFormat->memory_size + bufsize);
- if (pCStructFormat->type == RPC_FC_CPSTRUCT)
+ if (pCStructFormat->type == FC_CPSTRUCT)
EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
return NULL;
@@ -4737,7 +4735,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
pFormat += sizeof(NDR_CSTRUCT_FORMAT);
- if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
+ if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT))
{
ERR("invalid format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4745,7 +4743,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs
}
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
pCStructFormat->offset_to_array_description;
- if (*pCArrayFormat != RPC_FC_CARRAY)
+ if (*pCArrayFormat != FC_CARRAY)
{
ERR("invalid array format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4781,7 +4779,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs
saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, pCStructFormat->memory_size + bufsize);
- if (pCStructFormat->type == RPC_FC_CPSTRUCT)
+ if (pCStructFormat->type == FC_CPSTRUCT)
EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
@@ -4805,7 +4803,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT);
- if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
+ if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT))
{
ERR("invalid format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4813,7 +4811,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
}
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
pCStructFormat->offset_to_array_description;
- if (*pCArrayFormat != RPC_FC_CARRAY)
+ if (*pCArrayFormat != FC_CARRAY)
{
ERR("invalid array format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4831,7 +4829,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
safe_buffer_length_increment(pStubMsg, pCStructFormat->memory_size);
safe_buffer_length_increment(pStubMsg, safe_multiply(pStubMsg->MaxCount, esize));
- if (pCStructFormat->type == RPC_FC_CPSTRUCT)
+ if (pCStructFormat->type == FC_CPSTRUCT)
EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
}
@@ -4858,7 +4856,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT);
- if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
+ if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT))
{
ERR("invalid format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4867,7 +4865,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
pCStructFormat->offset_to_array_description;
- if (*pCArrayFormat != RPC_FC_CARRAY)
+ if (*pCArrayFormat != FC_CARRAY)
{
ERR("invalid array format type %x\n", pCStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4882,7 +4880,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
/* copy constant sized part of struct */
pStubMsg->BufferMark = pStubMsg->Buffer;
- if (pCStructFormat->type == RPC_FC_CPSTRUCT)
+ if (pCStructFormat->type == FC_CPSTRUCT)
EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
}
@@ -4899,7 +4897,7 @@ unsigned char * WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pS
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
- if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
+ if (pCVStructFormat->type != FC_CVSTRUCT)
{
ERR("invalid format type %x\n", pCVStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -4948,7 +4946,7 @@ unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
- if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
+ if (pCVStructFormat->type != FC_CVSTRUCT)
{
ERR("invalid format type %x\n", pCVStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5001,9 +4999,9 @@ unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE
memcpy(*ppMemory + pCVStructFormat->memory_size + offset,
saved_array_buffer, bufsize);
- if (*pCVArrayFormat == RPC_FC_C_CSTRING)
+ if (*pCVArrayFormat == FC_C_CSTRING)
TRACE("string=%s\n", debugstr_a((char *)(*ppMemory + pCVStructFormat->memory_size)));
- else if (*pCVArrayFormat == RPC_FC_C_WSTRING)
+ else if (*pCVArrayFormat == FC_C_WSTRING)
TRACE("string=%s\n", debugstr_w((WCHAR *)(*ppMemory + pCVStructFormat->memory_size)));
return NULL;
@@ -5022,7 +5020,7 @@ void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
- if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
+ if (pCVStructFormat->type != FC_CVSTRUCT)
{
ERR("invalid format type %x\n", pCVStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5060,7 +5058,7 @@ ULONG WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p)\n", pStubMsg, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
- if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
+ if (pCVStructFormat->type != FC_CVSTRUCT)
{
ERR("invalid format type %x\n", pCVStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5099,7 +5097,7 @@ void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
- if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
+ if (pCVStructFormat->type != FC_CVSTRUCT)
{
ERR("invalid format type %x\n", pCVStructFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5145,8 +5143,8 @@ unsigned char * WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
- (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
+ if ((pSmFArrayFormat->type != FC_SMFARRAY) &&
+ (pSmFArrayFormat->type != FC_LGFARRAY))
{
ERR("invalid format type %x\n", pSmFArrayFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5155,7 +5153,7 @@ unsigned char * WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer_clear(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
+ if (pSmFArrayFormat->type == FC_SMFARRAY)
{
total_size = pSmFArrayFormat->total_size;
pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
@@ -5189,8 +5187,8 @@ unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
- (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
+ if ((pSmFArrayFormat->type != FC_SMFARRAY) &&
+ (pSmFArrayFormat->type != FC_LGFARRAY))
{
ERR("invalid format type %x\n", pSmFArrayFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5199,7 +5197,7 @@ unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
+ if (pSmFArrayFormat->type == FC_SMFARRAY)
{
total_size = pSmFArrayFormat->total_size;
pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
@@ -5243,8 +5241,8 @@ void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
- (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
+ if ((pSmFArrayFormat->type != FC_SMFARRAY) &&
+ (pSmFArrayFormat->type != FC_LGFARRAY))
{
ERR("invalid format type %x\n", pSmFArrayFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5253,7 +5251,7 @@ void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
align_length(&pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
+ if (pSmFArrayFormat->type == FC_SMFARRAY)
{
total_size = pSmFArrayFormat->total_size;
pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
@@ -5280,8 +5278,8 @@ ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
- (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
+ if ((pSmFArrayFormat->type != FC_SMFARRAY) &&
+ (pSmFArrayFormat->type != FC_LGFARRAY))
{
ERR("invalid format type %x\n", pSmFArrayFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5290,7 +5288,7 @@ ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
+ if (pSmFArrayFormat->type == FC_SMFARRAY)
{
total_size = pSmFArrayFormat->total_size;
pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
@@ -5321,15 +5319,15 @@ void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
- (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
+ if ((pSmFArrayFormat->type != FC_SMFARRAY) &&
+ (pSmFArrayFormat->type != FC_LGFARRAY))
{
ERR("invalid format type %x\n", pSmFArrayFormat->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return;
}
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
+ if (pSmFArrayFormat->type == FC_SMFARRAY)
pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
else
{
@@ -5353,8 +5351,8 @@ unsigned char * WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) &&
- (pFormat[0] != RPC_FC_LGVARRAY))
+ if ((pFormat[0] != FC_SMVARRAY) &&
+ (pFormat[0] != FC_LGVARRAY))
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5363,7 +5361,7 @@ unsigned char * WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY)
+ if (pFormat[0] == FC_SMVARRAY)
{
pFormat += 2;
pFormat += sizeof(WORD);
@@ -5418,8 +5416,8 @@ unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if ((pFormat[0] != RPC_FC_SMVARRAY) &&
- (pFormat[0] != RPC_FC_LGVARRAY))
+ if ((pFormat[0] != FC_SMVARRAY) &&
+ (pFormat[0] != FC_LGVARRAY))
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5428,7 +5426,7 @@ unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY)
+ if (pFormat[0] == FC_SMVARRAY)
{
pFormat += 2;
size = *(const WORD*)pFormat;
@@ -5481,8 +5479,8 @@ void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) &&
- (pFormat[0] != RPC_FC_LGVARRAY))
+ if ((pFormat[0] != FC_SMVARRAY) &&
+ (pFormat[0] != FC_LGVARRAY))
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5491,7 +5489,7 @@ void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY)
+ if (pFormat[0] == FC_SMVARRAY)
{
pFormat += 2;
pFormat += sizeof(WORD);
@@ -5537,8 +5535,8 @@ ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) &&
- (pFormat[0] != RPC_FC_LGVARRAY))
+ if ((pFormat[0] != FC_SMVARRAY) &&
+ (pFormat[0] != FC_LGVARRAY))
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -5547,7 +5545,7 @@ ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY)
+ if (pFormat[0] == FC_SMVARRAY)
{
pFormat += 2;
size = *(const WORD*)pFormat;
@@ -5590,15 +5588,15 @@ void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) &&
- (pFormat[0] != RPC_FC_LGVARRAY))
+ if ((pFormat[0] != FC_SMVARRAY) &&
+ (pFormat[0] != FC_LGVARRAY))
{
ERR("invalid format type %x\n", pFormat[0]);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
return;
}
- if (pFormat[0] == RPC_FC_SMVARRAY)
+ if (pFormat[0] == FC_SMVARRAY)
{
pFormat += 2;
pFormat += sizeof(WORD);
@@ -5630,22 +5628,22 @@ static ULONG get_discriminant(unsigned char fc, const unsigned char *pMemory)
{
switch (fc)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
return *pMemory;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
- case RPC_FC_ENUM16:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
+ case FC_ENUM16:
return *(const USHORT *)pMemory;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
return *(const ULONG *)pMemory;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
return *(const ULONG_PTR *)pMemory;
default:
FIXME("Unhandled base type: 0x%02x\n", fc);
@@ -5716,10 +5714,10 @@ static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned c
BOOL pointer_buffer_mark_set = FALSE;
switch(*desc)
{
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
align_pointer_clear(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
@@ -5745,7 +5743,7 @@ static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned c
pStubMsg->Buffer = saved_buffer + 4;
}
break;
- case RPC_FC_IP:
+ case FC_IP:
/* must be dereferenced first */
m(pStubMsg, *(unsigned char **)pMemory, desc);
break;
@@ -5789,10 +5787,10 @@ static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg,
BOOL pointer_buffer_mark_set = FALSE;
switch(*desc)
{
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
align_pointer(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
@@ -5819,7 +5817,7 @@ static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->Buffer = saved_buffer + 4;
}
break;
- case RPC_FC_IP:
+ case FC_IP:
/* must be dereferenced first */
m(pStubMsg, *(unsigned char ***)ppMemory, desc, fMustAlloc);
break;
@@ -5860,10 +5858,10 @@ static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg,
{
switch(*desc)
{
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
align_length(&pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4); /* for pointer ID */
if (!pStubMsg->IgnoreEmbeddedPointers)
@@ -5878,7 +5876,7 @@ static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg,
pStubMsg->BufferLength = saved_buffer_length;
}
break;
- case RPC_FC_IP:
+ case FC_IP:
/* must be dereferenced first */
m(pStubMsg, *(unsigned char **)pMemory, desc);
break;
@@ -5919,10 +5917,10 @@ static ULONG union_arm_memory_size(PMIDL_STUB_MESSAGE pStubMsg,
{
switch(*desc)
{
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
align_pointer(&pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, 4);
@@ -5965,13 +5963,13 @@ static void union_arm_free(PMIDL_STUB_MESSAGE pStubMsg,
{
switch(*desc)
{
- case RPC_FC_RP:
- case RPC_FC_UP:
- case RPC_FC_OP:
- case RPC_FC_FP:
+ case FC_RP:
+ case FC_UP:
+ case FC_OP:
+ case FC_FP:
PointerFree(pStubMsg, *(unsigned char **)pMemory, desc);
break;
- case RPC_FC_IP:
+ case FC_IP:
/* must be dereferenced first */
m(pStubMsg, *(unsigned char **)pMemory, desc);
break;
@@ -6164,20 +6162,20 @@ static LONG unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
switch(**ppFormat)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
{
UCHAR d;
safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
discriminant = d;
break;
}
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
- case RPC_FC_ENUM16:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
+ case FC_ENUM16:
{
USHORT d;
align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
@@ -6185,8 +6183,8 @@ static LONG unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
discriminant = d;
break;
}
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
+ case FC_LONG:
+ case FC_ULONG:
{
ULONG d;
align_pointer(&pStubMsg->Buffer, sizeof(ULONG));
@@ -6416,7 +6414,7 @@ static unsigned char *WINAPI NdrRangeMarshall(
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (pRange->type != RPC_FC_RANGE)
+ if (pRange->type != FC_RANGE)
{
ERR("invalid format type %x\n", pRange->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6442,7 +6440,7 @@ unsigned char *WINAPI NdrRangeUnmarshall(
TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
- if (pRange->type != RPC_FC_RANGE)
+ if (pRange->type != FC_RANGE)
{
ERR("invalid format type %x\n", pRange->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6483,41 +6481,41 @@ unsigned char *WINAPI NdrRangeUnmarshall(
switch(base_type)
{
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
+ case FC_CHAR:
+ case FC_SMALL:
RANGE_UNMARSHALL(UCHAR, UCHAR, "%d");
TRACE("value: 0x%02x\n", **ppMemory);
break;
- case RPC_FC_BYTE:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_USMALL:
RANGE_UNMARSHALL(CHAR, CHAR, "%u");
TRACE("value: 0x%02x\n", **ppMemory);
break;
- case RPC_FC_WCHAR: /* FIXME: valid? */
- case RPC_FC_USHORT:
+ case FC_WCHAR: /* FIXME: valid? */
+ case FC_USHORT:
RANGE_UNMARSHALL(USHORT, USHORT, "%u");
TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
break;
- case RPC_FC_SHORT:
+ case FC_SHORT:
RANGE_UNMARSHALL(SHORT, SHORT, "%d");
TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
break;
- case RPC_FC_LONG:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ENUM32:
RANGE_UNMARSHALL(LONG, LONG, "%d");
TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
break;
- case RPC_FC_ULONG:
+ case FC_ULONG:
RANGE_UNMARSHALL(ULONG, ULONG, "%u");
TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
RANGE_UNMARSHALL(UINT, USHORT, "%u");
TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
break;
- case RPC_FC_FLOAT:
- case RPC_FC_DOUBLE:
- case RPC_FC_HYPER:
+ case FC_FLOAT:
+ case FC_DOUBLE:
+ case FC_HYPER:
default:
ERR("invalid range base type: 0x%02x\n", base_type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6539,7 +6537,7 @@ static void WINAPI NdrRangeBufferSize(
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (pRange->type != RPC_FC_RANGE)
+ if (pRange->type != FC_RANGE)
{
ERR("invalid format type %x\n", pRange->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6559,7 +6557,7 @@ static ULONG WINAPI NdrRangeMemorySize(
const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat;
unsigned char base_type;
- if (pRange->type != RPC_FC_RANGE)
+ if (pRange->type != FC_RANGE)
{
ERR("invalid format type %x\n", pRange->type);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6594,42 +6592,42 @@ static unsigned char *WINAPI NdrBaseTypeMarshall(
switch(*pFormat)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(UCHAR));
TRACE("value: 0x%02x\n", *pMemory);
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT));
TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ERROR_STATUS_T:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ERROR_STATUS_T:
+ case FC_ENUM32:
align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONG));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG));
TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
break;
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
align_pointer_clear(&pStubMsg->Buffer, sizeof(float));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
align_pointer_clear(&pStubMsg->Buffer, sizeof(double));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONGLONG));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG));
TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
{
USHORT val = *(UINT *)pMemory;
/* only 16-bits on the wire, so do a sanity check */
@@ -6640,15 +6638,15 @@ static unsigned char *WINAPI NdrBaseTypeMarshall(
TRACE("value: 0x%04x\n", *(UINT *)pMemory);
break;
}
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
{
UINT val = *(UINT_PTR *)pMemory;
align_pointer_clear(&pStubMsg->Buffer, sizeof(UINT));
safe_copy_to_buffer(pStubMsg, &val, sizeof(val));
break;
}
- case RPC_FC_IGNORE:
+ case FC_IGNORE:
break;
default:
FIXME("Unhandled base type: 0x%02x\n", *pFormat);
@@ -6688,39 +6686,39 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall(
switch(*pFormat)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
BASE_TYPE_UNMARSHALL(UCHAR);
TRACE("value: 0x%02x\n", **ppMemory);
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
BASE_TYPE_UNMARSHALL(USHORT);
TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ERROR_STATUS_T:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ERROR_STATUS_T:
+ case FC_ENUM32:
BASE_TYPE_UNMARSHALL(ULONG);
TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
break;
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
BASE_TYPE_UNMARSHALL(float);
TRACE("value: %f\n", **(float **)ppMemory);
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
BASE_TYPE_UNMARSHALL(double);
TRACE("value: %f\n", **(double **)ppMemory);
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
BASE_TYPE_UNMARSHALL(ULONGLONG);
TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
break;
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
{
USHORT val;
align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
@@ -6734,7 +6732,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall(
TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
break;
}
- case RPC_FC_INT3264:
+ case FC_INT3264:
if (sizeof(INT_PTR) == sizeof(INT)) BASE_TYPE_UNMARSHALL(INT);
else
{
@@ -6749,7 +6747,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall(
TRACE("value: 0x%08lx\n", **(INT_PTR **)ppMemory);
}
break;
- case RPC_FC_UINT3264:
+ case FC_UINT3264:
if (sizeof(UINT_PTR) == sizeof(UINT)) BASE_TYPE_UNMARSHALL(UINT);
else
{
@@ -6764,7 +6762,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall(
TRACE("value: 0x%08lx\n", **(UINT_PTR **)ppMemory);
}
break;
- case RPC_FC_IGNORE:
+ case FC_IGNORE:
break;
default:
FIXME("Unhandled base type: 0x%02x\n", *pFormat);
@@ -6788,44 +6786,44 @@ static void WINAPI NdrBaseTypeBufferSize(
switch(*pFormat)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
safe_buffer_length_increment(pStubMsg, sizeof(UCHAR));
break;
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
- case RPC_FC_ENUM16:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
+ case FC_ENUM16:
align_length(&pStubMsg->BufferLength, sizeof(USHORT));
safe_buffer_length_increment(pStubMsg, sizeof(USHORT));
break;
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
+ case FC_INT3264:
+ case FC_UINT3264:
align_length(&pStubMsg->BufferLength, sizeof(ULONG));
safe_buffer_length_increment(pStubMsg, sizeof(ULONG));
break;
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
align_length(&pStubMsg->BufferLength, sizeof(float));
safe_buffer_length_increment(pStubMsg, sizeof(float));
break;
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
align_length(&pStubMsg->BufferLength, sizeof(double));
safe_buffer_length_increment(pStubMsg, sizeof(double));
break;
- case RPC_FC_HYPER:
+ case FC_HYPER:
align_length(&pStubMsg->BufferLength, sizeof(ULONGLONG));
safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG));
break;
- case RPC_FC_ERROR_STATUS_T:
+ case FC_ERROR_STATUS_T:
align_length(&pStubMsg->BufferLength, sizeof(error_status_t));
safe_buffer_length_increment(pStubMsg, sizeof(error_status_t));
break;
- case RPC_FC_IGNORE:
+ case FC_IGNORE:
break;
default:
FIXME("Unhandled base type: 0x%02x\n", *pFormat);
@@ -6843,67 +6841,67 @@ static ULONG WINAPI NdrBaseTypeMemorySize(
switch(*pFormat)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
safe_buffer_increment(pStubMsg, sizeof(UCHAR));
pStubMsg->MemorySize += sizeof(UCHAR);
return sizeof(UCHAR);
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
safe_buffer_increment(pStubMsg, sizeof(USHORT));
align_length(&pStubMsg->MemorySize, sizeof(USHORT));
pStubMsg->MemorySize += sizeof(USHORT);
return sizeof(USHORT);
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_ENUM32:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_ENUM32:
align_pointer(&pStubMsg->Buffer, sizeof(ULONG));
safe_buffer_increment(pStubMsg, sizeof(ULONG));
align_length(&pStubMsg->MemorySize, sizeof(ULONG));
pStubMsg->MemorySize += sizeof(ULONG);
return sizeof(ULONG);
- case RPC_FC_FLOAT:
+ case FC_FLOAT:
align_pointer(&pStubMsg->Buffer, sizeof(float));
safe_buffer_increment(pStubMsg, sizeof(float));
align_length(&pStubMsg->MemorySize, sizeof(float));
pStubMsg->MemorySize += sizeof(float);
return sizeof(float);
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
align_pointer(&pStubMsg->Buffer, sizeof(double));
safe_buffer_increment(pStubMsg, sizeof(double));
align_length(&pStubMsg->MemorySize, sizeof(double));
pStubMsg->MemorySize += sizeof(double);
return sizeof(double);
- case RPC_FC_HYPER:
+ case FC_HYPER:
align_pointer(&pStubMsg->Buffer, sizeof(ULONGLONG));
safe_buffer_increment(pStubMsg, sizeof(ULONGLONG));
align_length(&pStubMsg->MemorySize, sizeof(ULONGLONG));
pStubMsg->MemorySize += sizeof(ULONGLONG);
return sizeof(ULONGLONG);
- case RPC_FC_ERROR_STATUS_T:
+ case FC_ERROR_STATUS_T:
align_pointer(&pStubMsg->Buffer, sizeof(error_status_t));
safe_buffer_increment(pStubMsg, sizeof(error_status_t));
align_length(&pStubMsg->MemorySize, sizeof(error_status_t));
pStubMsg->MemorySize += sizeof(error_status_t);
return sizeof(error_status_t);
- case RPC_FC_ENUM16:
+ case FC_ENUM16:
align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
safe_buffer_increment(pStubMsg, sizeof(USHORT));
align_length(&pStubMsg->MemorySize, sizeof(UINT));
pStubMsg->MemorySize += sizeof(UINT);
return sizeof(UINT);
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
+ case FC_INT3264:
+ case FC_UINT3264:
align_pointer(&pStubMsg->Buffer, sizeof(UINT));
safe_buffer_increment(pStubMsg, sizeof(UINT));
align_length(&pStubMsg->MemorySize, sizeof(UINT_PTR));
pStubMsg->MemorySize += sizeof(UINT_PTR);
return sizeof(UINT_PTR);
- case RPC_FC_IGNORE:
+ case FC_IGNORE:
align_length(&pStubMsg->MemorySize, sizeof(void *));
pStubMsg->MemorySize += sizeof(void *);
return sizeof(void *);
@@ -6935,7 +6933,7 @@ static void WINAPI NdrContextHandleBufferSize(
{
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (*pFormat != RPC_FC_BIND_CONTEXT)
+ if (*pFormat != FC_BIND_CONTEXT)
{
ERR("invalid format type %x\n", *pFormat);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6954,7 +6952,7 @@ static unsigned char *WINAPI NdrContextHandleMarshall(
{
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (*pFormat != RPC_FC_BIND_CONTEXT)
+ if (*pFormat != FC_BIND_CONTEXT)
{
ERR("invalid format type %x\n", *pFormat);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -6990,7 +6988,7 @@ static unsigned char *WINAPI NdrContextHandleUnmarshall(
TRACE("pStubMsg %p, ppMemory %p, pFormat %p, fMustAlloc %s\n", pStubMsg,
ppMemory, pFormat, fMustAlloc ? "TRUE": "FALSE");
- if (*pFormat != RPC_FC_BIND_CONTEXT)
+ if (*pFormat != FC_BIND_CONTEXT)
{
ERR("invalid format type %x\n", *pFormat);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
@@ -7126,7 +7124,7 @@ NDR_SCONTEXT WINAPI NdrContextHandleInitialize(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
- if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
+ if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE)
flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
{
@@ -7160,7 +7158,7 @@ void WINAPI NdrServerContextNewMarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
- if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
+ if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE)
flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
{
@@ -7193,7 +7191,7 @@ NDR_SCONTEXT WINAPI NdrServerContextNewUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
- if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
+ if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE)
flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
{
diff --git a/dlls/rpcrt4/ndr_ole.c b/dlls/rpcrt4/ndr_ole.c
index 0f0b7e7..8608691 100644
--- a/dlls/rpcrt4/ndr_ole.c
+++ b/dlls/rpcrt4/ndr_ole.c
@@ -36,8 +36,8 @@
#include "ndr_misc.h"
#include "rpcndr.h"
+#include "ndrtypes.h"
#include "rpcproxy.h"
-#include "wine/rpcfc.h"
#include "cpsf.h"
#include "wine/debug.h"
@@ -288,8 +288,8 @@ static const IID* get_ip_iid(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory
const IID *riid;
if (!pFormat) return &IID_IUnknown;
TRACE("format=%02x %02x\n", pFormat[0], pFormat[1]);
- if (pFormat[0] != RPC_FC_IP) FIXME("format=%d\n", pFormat[0]);
- if (pFormat[1] == RPC_FC_CONSTANT_IID) {
+ if (pFormat[0] != FC_IP) FIXME("format=%d\n", pFormat[0]);
+ if (pFormat[1] == FC_CONSTANT_IID) {
riid = (const IID *)&pFormat[2];
} else {
ComputeConformance(pStubMsg, pMemory, pFormat+2, 0);
diff --git a/dlls/rpcrt4/ndr_stubless.c b/dlls/rpcrt4/ndr_stubless.c
index f84c617..a645a24 100644
--- a/dlls/rpcrt4/ndr_stubless.c
+++ b/dlls/rpcrt4/ndr_stubless.c
@@ -40,7 +40,6 @@
#include "wine/exception.h"
#include "wine/debug.h"
-#include "wine/rpcfc.h"
#include "cpsf.h"
#include "ndr_misc.h"
@@ -154,8 +153,8 @@ static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
DWORD size;
switch(*pFormat)
{
- case RPC_FC_RP:
- if (pFormat[1] & RPC_FC_P_SIMPLEPOINTER)
+ case FC_RP:
+ if (pFormat[1] & FC_SIMPLE_POINTER)
{
FIXME("Simple reference pointer (type %#x).\n", pFormat[2]);
size = sizeof(void *);
@@ -163,52 +162,52 @@ static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
}
size = calc_arg_size(pStubMsg, &pFormat[2] + *(const SHORT*)&pFormat[2]);
break;
- case RPC_FC_STRUCT:
- case RPC_FC_PSTRUCT:
+ case FC_STRUCT:
+ case FC_PSTRUCT:
size = *(const WORD*)(pFormat + 2);
break;
- case RPC_FC_BOGUS_STRUCT:
+ case FC_BOGUS_STRUCT:
size = *(const WORD*)(pFormat + 2);
if(*(const WORD*)(pFormat + 4))
FIXME("Unhandled conformant description\n");
break;
- case RPC_FC_CARRAY:
- case RPC_FC_CVARRAY:
+ case FC_CARRAY:
+ case FC_CVARRAY:
size = *(const WORD*)(pFormat + 2);
ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
size *= pStubMsg->MaxCount;
break;
- case RPC_FC_SMFARRAY:
- case RPC_FC_SMVARRAY:
+ case FC_SMFARRAY:
+ case FC_SMVARRAY:
size = *(const WORD*)(pFormat + 2);
break;
- case RPC_FC_LGFARRAY:
- case RPC_FC_LGVARRAY:
+ case FC_LGFARRAY:
+ case FC_LGVARRAY:
size = *(const DWORD*)(pFormat + 2);
break;
- case RPC_FC_BOGUS_ARRAY:
+ case FC_BOGUS_ARRAY:
pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]);
TRACE("conformance = %ld\n", pStubMsg->MaxCount);
pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount);
size = ComplexStructSize(pStubMsg, pFormat);
size *= pStubMsg->MaxCount;
break;
- case RPC_FC_USER_MARSHAL:
+ case FC_USER_MARSHAL:
size = *(const WORD*)(pFormat + 4);
break;
- case RPC_FC_CSTRING:
+ case FC_CSTRING:
size = *(const WORD*)(pFormat + 2);
break;
- case RPC_FC_WSTRING:
+ case FC_WSTRING:
size = *(const WORD*)(pFormat + 2) * sizeof(WCHAR);
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (*pFormat == RPC_FC_C_CSTRING)
+ case FC_C_CSTRING:
+ case FC_C_WSTRING:
+ if (*pFormat == FC_C_CSTRING)
size = sizeof(CHAR);
else
size = sizeof(WCHAR);
- if (pFormat[1] == RPC_FC_STRING_SIZED)
+ if (pFormat[1] == FC_STRING_SIZED)
ComputeConformance(pStubMsg, NULL, pFormat + 2, 0);
else
pStubMsg->MaxCount = 0;
@@ -217,7 +216,7 @@ static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
default:
FIXME("Unhandled type %02x\n", *pFormat);
/* fallthrough */
- case RPC_FC_IP:
+ case FC_IP:
size = sizeof(void *);
break;
}
@@ -279,10 +278,10 @@ static PFORMAT_STRING client_get_handle(
switch (pProcHeader->handle_type)
{
/* explicit binding: parse additional section */
- case RPC_FC_BIND_EXPLICIT:
+ case 0:
switch (*pFormat) /* handle_type */
{
- case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
+ case FC_BIND_PRIMITIVE: /* explicit primitive */
{
const NDR_EHD_PRIMITIVE *pDesc = (const NDR_EHD_PRIMITIVE *)pFormat;
@@ -294,7 +293,7 @@ static PFORMAT_STRING client_get_handle(
*phBinding = *(handle_t *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
return pFormat + sizeof(NDR_EHD_PRIMITIVE);
}
- case RPC_FC_BIND_GENERIC: /* explicit generic */
+ case FC_BIND_GENERIC: /* explicit generic */
{
const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
void *pObject = NULL;
@@ -312,7 +311,7 @@ static PFORMAT_STRING client_get_handle(
*phBinding = pGenPair->pfnBind(pObject);
return pFormat + sizeof(NDR_EHD_GENERIC);
}
- case RPC_FC_BIND_CONTEXT: /* explicit context */
+ case FC_BIND_CONTEXT: /* explicit context */
{
const NDR_EHD_CONTEXT *pDesc = (const NDR_EHD_CONTEXT *)pFormat;
NDR_CCONTEXT context_handle;
@@ -340,22 +339,22 @@ static PFORMAT_STRING client_get_handle(
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
break;
- case RPC_FC_BIND_GENERIC: /* implicit generic */
- FIXME("RPC_FC_BIND_GENERIC\n");
+ case FC_BIND_GENERIC: /* implicit generic */
+ FIXME("FC_BIND_GENERIC\n");
RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
break;
- case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
+ case FC_BIND_PRIMITIVE: /* implicit primitive */
TRACE("Implicit primitive handle\n");
*phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pPrimitiveHandle;
break;
- case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
- TRACE("RPC_FC_CALLBACK_HANDLE\n");
+ case FC_CALLBACK_HANDLE: /* implicit callback */
+ TRACE("FC_CALLBACK_HANDLE\n");
/* server calls callback procedures only in response to remote call, and most recent
binding handle is used. Calling back to a client can potentially result in another
callback with different current handle. */
*phBinding = I_RpcGetCurrentCallHandle();
break;
- case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
+ case FC_AUTO_HANDLE: /* implicit auto handle */
/* strictly speaking, it isn't necessary to set hBinding here
* since it isn't actually used (hence the automatic in its name),
* but then why does MIDL generate a valid entry in the
@@ -378,10 +377,10 @@ static void client_free_handle(
switch (pProcHeader->handle_type)
{
/* explicit binding: parse additional section */
- case RPC_FC_BIND_EXPLICIT:
+ case 0:
switch (*pFormat) /* handle_type */
{
- case RPC_FC_BIND_GENERIC: /* explicit generic */
+ case FC_BIND_GENERIC: /* explicit generic */
{
const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
void *pObject = NULL;
@@ -399,21 +398,21 @@ static void client_free_handle(
pGenPair->pfnUnbind(pObject, hBinding);
break;
}
- case RPC_FC_BIND_CONTEXT: /* explicit context */
- case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
+ case FC_BIND_CONTEXT: /* explicit context */
+ case FC_BIND_PRIMITIVE: /* explicit primitive */
break;
default:
ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
break;
- case RPC_FC_BIND_GENERIC: /* implicit generic */
- FIXME("RPC_FC_BIND_GENERIC\n");
+ case FC_BIND_GENERIC: /* implicit generic */
+ FIXME("FC_BIND_GENERIC\n");
RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
break;
- case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
- case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
- case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
+ case FC_CALLBACK_HANDLE: /* implicit callback */
+ case FC_BIND_PRIMITIVE: /* implicit primitive */
+ case FC_AUTO_HANDLE: /* implicit auto handle */
break;
default:
ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
@@ -436,7 +435,7 @@ void client_do_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum s
float f;
if (params[i].attr.IsBasetype &&
- params[i].u.type_format_char == RPC_FC_FLOAT &&
+ params[i].u.type_format_char == FC_FLOAT &&
!params[i].attr.IsSimpleRef &&
!fpu_args)
{
@@ -487,26 +486,26 @@ static unsigned int type_stack_size(unsigned char fc)
{
switch (fc)
{
- case RPC_FC_BYTE:
- case RPC_FC_CHAR:
- case RPC_FC_SMALL:
- case RPC_FC_USMALL:
- case RPC_FC_WCHAR:
- case RPC_FC_SHORT:
- case RPC_FC_USHORT:
- case RPC_FC_LONG:
- case RPC_FC_ULONG:
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- case RPC_FC_ENUM16:
- case RPC_FC_ENUM32:
- case RPC_FC_FLOAT:
- case RPC_FC_ERROR_STATUS_T:
- case RPC_FC_IGNORE:
+ case FC_BYTE:
+ case FC_CHAR:
+ case FC_SMALL:
+ case FC_USMALL:
+ case FC_WCHAR:
+ case FC_SHORT:
+ case FC_USHORT:
+ case FC_LONG:
+ case FC_ULONG:
+ case FC_INT3264:
+ case FC_UINT3264:
+ case FC_ENUM16:
+ case FC_ENUM32:
+ case FC_FLOAT:
+ case FC_ERROR_STATUS_T:
+ case FC_IGNORE:
return sizeof(void *);
- case RPC_FC_DOUBLE:
+ case FC_DOUBLE:
return sizeof(double);
- case RPC_FC_HYPER:
+ case FC_HYPER:
return sizeof(ULONGLONG);
default:
ERR("invalid base type 0x%x\n", fc);
@@ -518,13 +517,13 @@ static BOOL is_by_value( PFORMAT_STRING format )
{
switch (*format)
{
- case RPC_FC_USER_MARSHAL:
- case RPC_FC_STRUCT:
- case RPC_FC_PSTRUCT:
- case RPC_FC_CSTRUCT:
- case RPC_FC_CPSTRUCT:
- case RPC_FC_CVSTRUCT:
- case RPC_FC_BOGUS_STRUCT:
+ case FC_USER_MARSHAL:
+ case FC_STRUCT:
+ case FC_PSTRUCT:
+ case FC_CSTRUCT:
+ case FC_CPSTRUCT:
+ case FC_CVSTRUCT:
+ case FC_BOGUS_STRUCT:
return TRUE;
default:
return FALSE;
@@ -554,32 +553,32 @@ PFORMAT_STRING convert_old_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFo
switch (param->param_direction)
{
- case RPC_FC_IN_PARAM_BASETYPE:
+ case FC_IN_PARAM_BASETYPE:
args[i].attr.IsIn = 1;
args[i].attr.IsBasetype = 1;
break;
- case RPC_FC_RETURN_PARAM_BASETYPE:
+ case FC_RETURN_PARAM_BASETYPE:
args[i].attr.IsOut = 1;
args[i].attr.IsReturn = 1;
args[i].attr.IsBasetype = 1;
break;
- case RPC_FC_IN_PARAM:
+ case FC_IN_PARAM:
args[i].attr.IsIn = 1;
args[i].attr.MustFree = 1;
break;
- case RPC_FC_IN_PARAM_NO_FREE_INST:
+ case FC_IN_PARAM_NO_FREE_INST:
args[i].attr.IsIn = 1;
args[i].attr.IsDontCallFreeInst = 1;
break;
- case RPC_FC_IN_OUT_PARAM:
+ case FC_IN_OUT_PARAM:
args[i].attr.IsIn = 1;
args[i].attr.IsOut = 1;
args[i].attr.MustFree = 1;
break;
- case RPC_FC_OUT_PARAM:
+ case FC_OUT_PARAM:
args[i].attr.IsOut = 1;
break;
- case RPC_FC_RETURN_PARAM:
+ case FC_RETURN_PARAM:
args[i].attr.IsOut = 1;
args[i].attr.IsReturn = 1;
break;
@@ -633,7 +632,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
{
const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
stack_size = header_rpc->stack_size;
@@ -650,10 +649,10 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
TRACE("proc num: %d\n", procedure_number);
/* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
/* object is always the first argument */
This = stack_top[0];
@@ -669,7 +668,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
pHandleFormat = pFormat;
/* we only need a handle if this isn't an object method */
- if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
+ if (!(pProcHeader->Oi_flags & Oi_OBJECT_PROC))
{
pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding);
if (!pFormat) goto done;
@@ -710,7 +709,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
else
{
pFormat = convert_old_args( &stubMsg, pFormat, stack_size,
- pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT,
+ pProcHeader->Oi_flags & Oi_OBJECT_PROC,
/* reuse the correlation cache, it's not needed for v1 format */
NdrCorrCache, sizeof(NdrCorrCache), &number_of_params );
}
@@ -718,11 +717,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
stubMsg.BufferLength = 0;
/* store the RPC flags away */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
+ if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED)
NdrRpcSmSetClientToOsf(&stubMsg);
if (Oif_flags.HasPipes)
@@ -749,11 +748,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
* 6. UNMARSHAL - unmarshal [out] params from buffer
* 7. FREE - clear [out] parameters (for proxies, and only on error)
*/
- if ((pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) ||
- (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_HAS_COMM_OR_FAULT))
+ if ((pProcHeader->Oi_flags & Oi_OBJECT_PROC) ||
+ (pProcHeader->Oi_flags & Oi_HAS_COMM_OR_FAULT))
{
/* 1. INITOUT */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
TRACE( "INITOUT\n" );
client_do_args(&stubMsg, pFormat, STUBLESS_INITOUT, fpu_stack,
@@ -769,7 +768,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
/* 3. GETBUFFER */
TRACE( "GETBUFFER\n" );
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
/* allocate the buffer */
NdrProxyGetBuffer(This, &stubMsg);
@@ -782,7 +781,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
#else
@@ -800,7 +799,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
/* 5. SENDRECEIVE */
TRACE( "SENDRECEIVE\n" );
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
/* send the [in] params and receive the [out] and [retval]
* params */
@@ -815,7 +814,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
@@ -838,7 +837,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
}
__EXCEPT_ALL
{
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
/* 7. FREE */
TRACE( "FREE\n" );
@@ -888,7 +887,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
#else
@@ -910,7 +909,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
@@ -943,11 +942,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
}
/* free the full pointer translation tables */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
/* free marshalling buffer */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
NdrProxyFreeBuffer(This, &stubMsg);
else
{
@@ -1180,13 +1179,13 @@ static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg,
else if (param_needs_alloc(params[i].attr) &&
(!params[i].attr.MustFree || params[i].attr.IsSimpleRef))
{
- if (*pTypeFormat != RPC_FC_BIND_CONTEXT) pStubMsg->pfnFree(*(void **)pArg);
+ if (*pTypeFormat != FC_BIND_CONTEXT) pStubMsg->pfnFree(*(void **)pArg);
}
break;
case STUBLESS_INITOUT:
if (param_needs_alloc(params[i].attr) && !params[i].attr.ServerAllocSize)
{
- if (*pTypeFormat == RPC_FC_BIND_CONTEXT)
+ if (*pTypeFormat == FC_BIND_CONTEXT)
{
NDR_SCONTEXT ctxt = NdrContextHandleInitialize(pStubMsg, pTypeFormat);
*(void **)pArg = NDRSContextValue(ctxt);
@@ -1276,7 +1275,7 @@ LONG WINAPI NdrStubCall2(
TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
{
const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
stack_size = header_rpc->stack_size;
@@ -1295,16 +1294,16 @@ LONG WINAPI NdrStubCall2(
switch (pProcHeader->handle_type)
{
/* explicit binding: parse additional section */
- case RPC_FC_BIND_EXPLICIT:
+ case 0:
switch (*pFormat) /* handle_type */
{
- case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
+ case FC_BIND_PRIMITIVE: /* explicit primitive */
pFormat += sizeof(NDR_EHD_PRIMITIVE);
break;
- case RPC_FC_BIND_GENERIC: /* explicit generic */
+ case FC_BIND_GENERIC: /* explicit generic */
pFormat += sizeof(NDR_EHD_GENERIC);
break;
- case RPC_FC_BIND_CONTEXT: /* explicit context */
+ case FC_BIND_CONTEXT: /* explicit context */
pFormat += sizeof(NDR_EHD_CONTEXT);
break;
default:
@@ -1312,31 +1311,31 @@ LONG WINAPI NdrStubCall2(
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
break;
- case RPC_FC_BIND_GENERIC: /* implicit generic */
- case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
- case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
- case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
+ case FC_BIND_GENERIC: /* implicit generic */
+ case FC_BIND_PRIMITIVE: /* implicit primitive */
+ case FC_CALLBACK_HANDLE: /* implicit callback */
+ case FC_AUTO_HANDLE: /* implicit auto handle */
break;
default:
ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
}
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
else
NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
/* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
/* store the RPC flags away */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
+ if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED)
#if 0
NdrRpcSsEnableAllocate(&stubMsg);
#else
@@ -1389,7 +1388,7 @@ LONG WINAPI NdrStubCall2(
else
{
pFormat = convert_old_args( &stubMsg, pFormat, stack_size,
- pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT,
+ pProcHeader->Oi_flags & Oi_OBJECT_PROC,
/* reuse the correlation cache, it's not needed for v1 format */
NdrCorrCache, sizeof(NdrCorrCache), &number_of_params );
}
@@ -1413,7 +1412,7 @@ LONG WINAPI NdrStubCall2(
SERVER_ROUTINE func;
LONG_PTR retval;
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
func = vtbl[pRpcMsg->ProcNum];
@@ -1438,7 +1437,7 @@ LONG WINAPI NdrStubCall2(
break;
case STUBLESS_GETBUFFER:
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
NdrStubGetBuffer(pThis, pChannel, &stubMsg);
else
{
@@ -1480,7 +1479,7 @@ LONG WINAPI NdrStubCall2(
}
/* free the full pointer translation tables */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
/* free server function stack */
@@ -1565,7 +1564,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1);
pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
{
const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
async_call_data->stack_size = header_rpc->stack_size;
@@ -1582,10 +1581,10 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
TRACE("proc num: %d\n", procedure_number);
/* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
+ if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
{
ERR("objects not supported\n");
I_RpcFree(async_call_data);
@@ -1631,7 +1630,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
else
{
pFormat = convert_old_args( pStubMsg, pFormat, async_call_data->stack_size,
- pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT,
+ pProcHeader->Oi_flags & Oi_OBJECT_PROC,
async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache),
&async_call_data->number_of_params );
}
@@ -1641,11 +1640,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
pStubMsg->BufferLength = 0;
/* store the RPC flags away */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
+ if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
+ if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED)
NdrRpcSmSetClientToOsf(pStubMsg);
if (Oif_flags.HasPipes)
@@ -1684,7 +1683,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
#else
@@ -1711,7 +1710,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc,
FIXME("pipes not supported yet\n");
else
{
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsSend(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
@@ -1761,7 +1760,7 @@ RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply)
TRACE( "RECEIVE\n" );
pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
/* receive the [out] params */
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
+ if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
@@ -1798,7 +1797,7 @@ cleanup:
}
/* free the full pointer translation tables */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
/* free marshalling buffer */
diff --git a/dlls/rpcrt4/ndr_stubless.h b/dlls/rpcrt4/ndr_stubless.h
index 2e7beba..ebdb8c8 100644
--- a/dlls/rpcrt4/ndr_stubless.h
+++ b/dlls/rpcrt4/ndr_stubless.h
@@ -26,16 +26,16 @@
typedef struct _NDR_PROC_HEADER
{
/* type of handle to use:
- * RPC_FC_BIND_EXPLICIT = 0 - Explicit handle.
+ * 0 - Explicit handle.
* Handle is passed as a parameter to the function.
* Indicates that explicit handle information follows the header,
* which actually describes the handle.
- * RPC_FC_BIND_GENERIC = 31 - Implicit handle with custom binding routines
+ * FC_BIND_GENERIC = 31 - Implicit handle with custom binding routines
* (MIDL_STUB_DESC::IMPLICIT_HANDLE_INFO::pGenericBindingInfo)
- * RPC_FC_BIND_PRIMITIVE = 32 - Implicit handle using handle_t created by
+ * FC_BIND_PRIMITIVE = 32 - Implicit handle using handle_t created by
* calling application
- * RPC_FC_AUTO_HANDLE = 33 - Automatic handle
- * RPC_FC_CALLBACK_HANDLE = 34 - Implicit handle used for a callback: current handle
+ * FC_AUTO_HANDLE = 33 - Automatic handle
+ * FC_CALLBACK_HANDLE = 34 - Implicit handle used for a callback: current handle
* from last remote call
*/
unsigned char handle_type;
@@ -95,13 +95,11 @@ typedef struct _NDR_PROC_HEADER_RPC
typedef struct _NDR_PROC_PARTIAL_OIF_HEADER
{
/* the pre-computed client buffer size so that interpreter can skip all
- * or some (if the flag RPC_FC_PROC_OI2F_CLTMUSTSIZE is specified) of the
- * sizing pass */
+ * or some (if the flag ClientMustSize is specified) of the sizing pass */
unsigned short constant_client_buffer_size;
/* the pre-computed server buffer size so that interpreter can skip all
- * or some (if the flag RPC_FC_PROC_OI2F_SRVMUSTSIZE is specified) of the
- * sizing pass */
+ * or some (if the flag ServerMustSize is specified) of the sizing pass */
unsigned short constant_server_buffer_size;
INTERPRETER_OPT_FLAGS Oi2Flags;
--
2.7.4
More information about the wine-devel
mailing list