windows-nt/Source/XPSP1/NT/com/inc/ndrshared/ndrmisc.h
2020-09-26 16:20:57 +08:00

337 lines
8.1 KiB
C

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 2000 Microsoft Corporation
Module Name :
ndrmisc.h
Abtract :
Contains misc. function prototypes, flags, and macros, mainly from
rpc\ndr20\ndrp.h.
Revision History :
John Doty johndoty May 2000 (Assembled from other ndr headers)
--------------------------------------------------------------------*/
#ifndef __NDRMISC_H__
#define __NDRMISC_H__
//
// Type marshalling and buffer manipulation
//
EXTERN_C uchar *
NdrpMemoryIncrement(
PMIDL_STUB_MESSAGE pStubMsg,
uchar * pMemory,
PFORMAT_STRING pFormat
);
EXTERN_C void
NdrUnmarshallBasetypeInline(
PMIDL_STUB_MESSAGE pStubMsg,
uchar * pArg,
uchar Format
);
EXTERN_C
unsigned char
RPC_ENTRY
NdrGetSimpleTypeBufferAlignment(
unsigned char FormatChar
);
EXTERN_C
unsigned char
RPC_ENTRY
NdrGetSimpleTypeBufferSize(
unsigned char FormatChar
);
EXTERN_C
unsigned char
RPC_ENTRY
NdrGetSimpleTypeMemorySize(
unsigned char FormatChar
);
EXTERN_C
unsigned long
RPC_ENTRY
NdrGetTypeFlags(
unsigned char FormatChar
);
EXTERN_C
void
RPC_ENTRY
NdrTypeSize(
PMIDL_STUB_MESSAGE pStubMsg,
unsigned char __RPC_FAR * pMemory,
PFORMAT_STRING pFormat
);
EXTERN_C
unsigned char *
RPC_ENTRY
NdrTypeMarshall(
PMIDL_STUB_MESSAGE pStubMsg,
unsigned char __RPC_FAR * pMemory,
PFORMAT_STRING pFormat
);
EXTERN_C
unsigned char *
RPC_ENTRY
NdrTypeUnmarshall(
PMIDL_STUB_MESSAGE pStubMsg,
unsigned char __RPC_FAR ** ppMemory,
PFORMAT_STRING pFormat,
unsigned char fSkipRefCheck
);
EXTERN_C
void
RPC_ENTRY
NdrTypeFree(
PMIDL_STUB_MESSAGE pStubMsg,
unsigned char __RPC_FAR * pMemory,
PFORMAT_STRING pFormat
);
// used by callframe guys
EXTERN_C void
NdrOutInit(
PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat,
uchar ** ppArg
);
// This definition is adjusted for a native platform.
// The wire size is fixed for DCE NDR regardless of platform.
#define PTR_MEM_SIZE sizeof(void *)
#define PTR_MEM_ALIGN (sizeof(void *)-1)
#define PTR_WIRE_SIZE (4)
#define NDR_MAX_BUFFER_ALIGNMENT (16)
#define CONTEXT_HANDLE_WIRE_SIZE 20
#define IGNORED(Param)
//
// Alignment macros.
//
#define ALIGN( pStuff, cAlign ) \
pStuff = (uchar *)((LONG_PTR)((pStuff) + (cAlign)) \
& ~ ((LONG_PTR)(cAlign)))
#define LENGTH_ALIGN( Length, cAlign ) \
Length = (((Length) + (cAlign)) & ~ (cAlign))
//
// Simple type alignment and size lookup macros.
//
#ifdef _RPCRT4_
#define SIMPLE_TYPE_ALIGNMENT(FormatChar) SimpleTypeAlignment[FormatChar]
#define SIMPLE_TYPE_BUFSIZE(FormatChar) SimpleTypeBufferSize[FormatChar]
#define SIMPLE_TYPE_MEMSIZE(FormatChar) SimpleTypeMemorySize[FormatChar]
#else
#define SIMPLE_TYPE_ALIGNMENT(FormatChar) NdrGetSimpleTypeBufferAlignment(FormatChar)
#define SIMPLE_TYPE_BUFSIZE(FormatChar) NdrGetSimpleTypeBufferSize(FormatChar)
#define SIMPLE_TYPE_MEMSIZE(FormatChar) NdrGetSimpleTypeMemorySize(FormatChar)
#endif
//
// Format character attribute bits used in global NdrTypesFlags defined in
// global.c.
//
#define _SIMPLE_TYPE_ 0x0001L
#define _POINTER_ 0x0002L
#define _STRUCT_ 0x0004L
#define _ARRAY_ 0x0008L
#define _STRING_ 0x0010L
#define _UNION_ 0x0020L
#define _XMIT_AS_ 0x0040L
#define _BY_VALUE_ 0x0080L
#define _HANDLE_ 0x0100L
#define _BASIC_POINTER_ 0x0200L
//
// Format character query macros.
//
#ifdef __RPCRT4__
#define _FC_FLAGS(FC) NdrTypeFlags[(FC)]
#else
#define _FC_FLAGS(FC) NdrGetTypeFlags(FC)
#endif
#define IS_SIMPLE_TYPE(FC) (_FC_FLAGS(FC) & _SIMPLE_TYPE_)
#define IS_POINTER_TYPE(FC) (_FC_FLAGS(FC) & _POINTER_)
#define IS_BASIC_POINTER(FC) (_FC_FLAGS(FC) & _BASIC_POINTER_)
#define IS_ARRAY(FC) (_FC_FLAGS(FC) & _ARRAY_)
#define IS_STRUCT(FC) (_FC_FLAGS(FC) & _STRUCT_)
#define IS_UNION(FC) (_FC_FLAGS(FC) & _UNION_)
#define IS_STRING(FC) (_FC_FLAGS(FC) & _STRING_)
#define IS_ARRAY_OR_STRING(FC) (_FC_FLAGS(FC) & (_STRING_ | _ARRAY_))
#define IS_XMIT_AS(FC) (_FC_FLAGS(FC) & _XMIT_AS_)
#define IS_BY_VALUE(FC) (_FC_FLAGS(FC) & _BY_VALUE_)
#define IS_HANDLE(FC) (NdrTypeFlags[(FC)] & _HANDLE_)
//
// Pointer attribute extraction and querying macros.
//
#define ALLOCATE_ALL_NODES( FC ) ((FC) & FC_ALLOCATE_ALL_NODES)
#define DONT_FREE( FC ) ((FC) & FC_DONT_FREE)
#define ALLOCED_ON_STACK( FC ) ((FC) & FC_ALLOCED_ON_STACK)
#define SIMPLE_POINTER( FC ) ((FC) & FC_SIMPLE_POINTER)
#define POINTER_DEREF( FC ) ((FC) & FC_POINTER_DEREF)
//
// Handle query macros.
//
#define IS_HANDLE_PTR( FC ) ((FC) & HANDLE_PARAM_IS_VIA_PTR)
#define IS_HANDLE_IN( FC ) ((FC) & HANDLE_PARAM_IS_IN)
#define IS_HANDLE_OUT( FC ) ((FC) & HANDLE_PARAM_IS_OUT)
#define IS_HANDLE_RETURN( FC ) ((FC) & HANDLE_PARAM_IS_RETURN)
//
// Stack and argument defines.
//
#if defined(_AMD64_) || defined(_IA64_)
#define REGISTER_TYPE _int64
#else
#define REGISTER_TYPE int
#endif
#define RETURN_SIZE 8
//
// Argument retrieval macros.
//
#define INIT_ARG(argptr,arg0) va_start(argptr, arg0)
#ifndef _ALPHA_
//
// Both MIPS and x86 are 4 byte aligned stacks, with MIPS supporting 8byte
// alignment on the stack as well. Their va_list is essentially an
// unsigned char *.
//
#if defined(_IA64_)
#define GET_FIRST_IN_ARG(argptr)
#define GET_FIRST_OUT_ARG(argptr)
#elif defined(_AMD64_)
#define GET_FIRST_IN_ARG(argptr)
#define GET_FIRST_OUT_ARG(argptr)
#else
#define GET_FIRST_IN_ARG(argptr) argptr = *(va_list *)argptr
#define GET_FIRST_OUT_ARG(argptr) argptr = *(va_list *)argptr
#endif
#define GET_NEXT_C_ARG(argptr,type) va_arg(argptr,type)
#define SKIP_STRUCT_ON_STACK(ArgPtr, Size) ArgPtr += Size
#define GET_STACK_START(ArgPtr) ArgPtr
#define GET_STACK_POINTER(ArgPtr, mode) ArgPtr
#else // _ALPHA_
//
// The Alpha has an 8byte aligned stack, with its va_list being a structure
// consisting of an unsigned char *, a0 and an int offset. See stdarg.h for
// the gory details.
//
#define GET_FIRST_IN_ARG(argptr) \
argptr.a0 = va_arg(argptr, char *); \
argptr.offset = 0
#define GET_FIRST_OUT_ARG(argptr) \
argptr.a0 = va_arg(argptr, char *); \
argptr.offset = 0
//
// Note that this macro does nothing for the Alpha. The stack incrementing is
// folded into the GET_STACK_POINTER below.
//
#define GET_NEXT_C_ARG(argptr,type)
#define SKIP_STRUCT_ON_STACK(ArgPtr, Size) \
Size += 7; Size &= ~7; \
for(Size /= sizeof(_int64);Size;--Size){va_arg(ArgPtr, _int64);}
#define GET_STACK_START(ArgPtr) ArgPtr.a0
//
// Ok, this ugly mess is just a trimmed dowm version of the va_arg macro for
// the alpha. What is missing is the dereference operator (*) and the test for
// a float (__builtin_isfloat()).
//
#define GET_STACK_POINTER(ArgPtr, mode) \
( \
((ArgPtr).offset += ((int)sizeof(mode) + 7) & -8) , \
(mode *)((ArgPtr).a0 + \
(ArgPtr).offset - \
(((int)sizeof(mode) + 7) & -8)) \
)
#endif // _ALPHA_
//
// Use the following macro _after_ argptr has been saved or processed
//
#define SKIP_PROCESSED_ARG(argptr, type) \
GET_NEXT_C_ARG(argptr, type); \
GET_STACK_POINTER(argptr,type)
#define GET_NEXT_S_ARG(argptr,type) argptr += sizeof(type)
#endif