diff --git a/dlls/rpcrt4/ndr_contexthandle.c b/dlls/rpcrt4/ndr_contexthandle.c
index 3b262854b7e..a5e1ffc253d 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 59ea8166f0d..158bc7cda2a 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 6356fb9d984..52e27161473 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 0f0b7e7df20..86086912319 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 f84c61751a5..a645a245d07 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 2e7beba2383..ebdb8c825be 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;