able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/midl/codegen/frmtstr.cxx

1664 lines
52 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 1993-2000 Microsoft Corporation
Module Name:
frmtstr.hxx
Abstract:
Notes:
History:
DKays Oct-1993 Created.
----------------------------------------------------------------------------*/
#include "becls.hxx"
#pragma hdrstop
extern CMD_ARG * pCommand;
const char * pExprFormatCharNames[] =
{
""
,"FC_EXPR_CONST32"
,"FC_EXPR_CONST64"
,"FC_EXPR_VAR"
,"FC_EXPR_OPER"
,"FC_EXPR_PAD"
};
const char * pFormatCharNames[] =
{
"", // FC_ZERO
"FC_BYTE",
"FC_CHAR",
"FC_SMALL",
"FC_USMALL",
"FC_WCHAR",
"FC_SHORT",
"FC_USHORT",
"FC_LONG",
"FC_ULONG",
"FC_FLOAT",
"FC_HYPER",
"FC_DOUBLE",
"FC_ENUM16",
"FC_ENUM32",
"FC_IGNORE",
"FC_ERROR_STATUS_T",
"FC_RP", // 11
"FC_UP",
"FC_OP",
"FC_FP",
"FC_STRUCT",
"FC_PSTRUCT",
"FC_CSTRUCT",
"FC_CPSTRUCT",
"FC_CVSTRUCT",
"FC_BOGUS_STRUCT",
"FC_CARRAY",
"FC_CVARRAY",
"FC_SMFARRAY",
"FC_LGFARRAY",
"FC_SMVARRAY",
"FC_LGVARRAY or FC_SPLIT", // 20
"FC_BOGUS_ARRAY",
"FC_C_CSTRING",
"FC_C_BSTRING",
"FC_C_SSTRING",
"FC_C_WSTRING",
"FC_CSTRING",
"FC_BSTRING",
"FC_SSTRING",
"FC_WSTRING",
"FC_ENCAPSULATED_UNION",
"FC_NON_ENCAPSULATED_UNION",
"FC_BYTE_COUNT_POINTER",
"FC_TRANSMIT_AS",
"FC_REPRESENT_AS",
"FC_IP",
"FC_BIND_CONTEXT", // 30
"FC_BIND_GENERIC",
"FC_BIND_PRIMITIVE",
"FC_AUTO_HANDLE",
"FC_CALLBACK_HANDLE",
"FC_UNUSED1",
"FC_POINTER",
"FC_ALIGNM2",
"FC_ALIGNM4",
"FC_ALIGNM8",
"FC_UNUSED2",
"FC_UNUSED3",
"FC_UNUSED4",
"FC_STRUCTPAD1",
"FC_STRUCTPAD2",
"FC_STRUCTPAD3",
"FC_STRUCTPAD4", // 40
"FC_STRUCTPAD5",
"FC_STRUCTPAD6",
"FC_STRUCTPAD7",
"FC_STRING_SIZED",
"FC_UNUSED5",
"FC_NO_REPEAT",
"FC_FIXED_REPEAT",
"FC_VARIABLE_REPEAT",
"FC_FIXED_OFFSET",
"FC_VARIABLE_OFFSET",
"FC_PP",
"FC_EMBEDDED_COMPLEX",
"FC_IN_PARAM",
"FC_IN_PARAM_BASETYPE",
"FC_IN_PARAM_NO_FREE_INST",
"FC_IN_OUT_PARAM", // 50
"FC_OUT_PARAM",
"FC_RETURN_PARAM",
"FC_RETURN_PARAM_BASETYPE",
"FC_DEREFERENCE", // 54
"FC_DIV_2", // 55
"FC_MULT_2", // 56
"FC_ADD_1", // 57
"FC_SUB_1", // 58
"FC_CALLBACK", // 59
"FC_CONSTANT_IID", // 5a
"FC_END", // 5b
"FC_PAD", // 5c
"FC_EXPR", // 5d
"FC_PARTIAL_IGNORE_PARAM", // 5e,
"?", // 5f
"?", "?", "?", "?", "?", "?", "?", "?", // 60-67
"?", "?", "?", "?", "?", "?", "?", "?", // 68-6f
"?", "?", "?", "?", // 70-73
"FC_SPLIT_DEREFERENCE", // 74
"FC_SPLIT_DIV_2", // 75
"FC_SPLIT_MULT_2", // 76
"FC_SPLIT_ADD_1", // 77
"FC_SPLIT_SUB_1", // 78
"FC_SPLIT_CALLBACK", // 79
"?", "?", "?", "?", "?", "?", // 7a-7f
"?", "?", "?", "?", "?", "?", "?", "?", // 80-87
"?", "?", "?", "?", "?", "?", "?", "?", // 88-8f
"?", "?", "?", "?", "?", "?", "?", "?", // 90-97
"?", "?", "?", "?", "?", "?", "?", "?", // 98-9f
"?", "?", "?", "?", "?", "?", "?", "?", // a0-a7
"?", "?", "?", "?", "?", "?", "?", "?", // a8-af
"?", // b0
"FC_HARD_STRUCT",
"FC_TRANSMIT_AS_PTR",
"FC_REPRESENT_AS_PTR",
"FC_USER_MARSHAL",
"FC_PIPE",
"?", // FC_BLKHOLE. obselete
"FC_RANGE", // b7
"FC_INT3264", // b8
"FC_UINT3264", // b9
// Post NT5.0
"FC_CSARRAY", // ba
"FC_CS_TAG", // bb
"FC_STRUCTPADN", // bc
"FC_INT128", // 0xbd
"FC_UINT128", // 0xbe
"FC_FLOAT80", // 0xbf
"FC_FLOAT128", // 0xc0
"FC_BUFFER_ALIGN", // 0xc1
"FC_ENCAP_UNION", // 0xc2
// new 64bit array types
"FC_FIX_ARRAY", // 0xc3
"FC_CONF_ARRAY", // 0xc4
"FC_VAR_ARRAY", // 0xc5
"FC_CONFVAR_ARRAY", // 0xc6
"FC_FIX_FORCED_BOGUS_ARRAY",// 0xc7
"FC_FIX_BOGUS_ARRAY", // 0xc8
"FC_FORCED_BOGUS_ARRAY", // 0xc9
"FC_CHAR_STRING", // 0xca
"FC_WCHAR_STRING", // 0xcb
"FC_STRUCT_STRING", // 0xcc
"FC_CONF_CHAR_STRING", // 0xcd
"FC_CONF_WCHAR_STRING", // 0xce
"FC_CONF_STRUCT_STRING", // 0xcf
// new structure types
"FC_CONF_STRUCT", // 0xd0
"FC_CONF_PSTRUCT", // 0xd1
"FC_CONFVAR_STRUCT", // 0xd2
"FC_CONFVAR_PSTRUCT", // 0xd3
"FC_FORCED_BOGUS_STRUCT", // 0xd4
"FC_CONF_BOGUS_STRUCT", // 0xd5
"FC_FORCED_CONF_BOGUS_STRUCT",// 0xd7
"FC_END_OF_UNIVERSE" // 0xd8
};
const char * pExprOpFormatCharNames[] =
{
"",
"OP_UNARY_PLUS",
"OP_UNARY_MINUS",
"OP_UNARY_NOT",
"OP_UNARY_COMPLEMENT",
"OP_UNARY_INDIRECTION",
"OP_UNARY_CAST",
"OP_UNARY_AND",
"OP_UNARY_SIZEOF",
"OP_UNARY_ALIGNOF",
"OP_PRE_INCR",
"OP_PRE_DECR",
"OP_POST_INCR",
"OP_POST_DECR",
"OP_PLUS",
"OP_MINUS",
"OP_STAR",
"OP_SLASH",
"OP_MOD",
"OP_LEFT_SHIFT",
"OP_RIGHT_SHIFT",
"OP_LESS",
"OP_LESS_EQUAL",
"OP_GREATER_EQUAL",
"OP_GREATER",
"OP_EQUAL",
"OP_NOT_EQUAL",
"OP_AND",
"OP_OR",
"OP_XOR",
"OP_LOGICAL_AND",
"OP_LOGICAL_OR",
"OP_EXPRESSION",
"",
"",
"", // function
"", // param
"", // pointsto
"", // dot
"", // index
"", // comma
"", // stmt
"", // assign
"OP_ASYNCSPLIT", // asyncsplit
"OP_CORR_POINTER", // corr_pointer
"OP_CORR_TOP_LEVEL", // corr_toplevel
};
//
// This table is indexed by FORMAT_CHARACTER (see ndrtypes.h).
// To construct the correct name concatenate the name in this table with
// "Marshall", "Unmarshall", "BufferSize" etc.
//
char * pNdrRoutineNames[] =
{
"", // FC_ZERO
"NdrSimpleType", // FC_BYTE
"NdrSimpleType", // FC_CHAR
"NdrSimpleType", // FC_SMALL
"NdrSimpleType", // FC_USMALL
"NdrSimpleType", // FC_WCHAR
"NdrSimpleType", // FC_SHORT
"NdrSimpleType", // FC_USHORT
"NdrSimpleType", // FC_LONG
"NdrSimpleType", // FC_ULONG
"NdrSimpleType", // FC_FLOAT
"NdrSimpleType", // FC_HYPER
"NdrSimpleType", // FC_DOUBLE
"NdrSimpleType", // FC_ENUM16
"NdrSimpleType", // FC_ENUM32
"NdrSimpleType", // FC_IGNORE
"NdrSimpleType", // FC_ERROR_STATUS_T
"NdrPointer", // FC_RP
"NdrPointer", // FC_UP
"NdrPointer", // FC_OP
"NdrPointer", // FC_FP
"NdrSimpleStruct", // FC_STRUCT
"NdrSimpleStruct", // FC_PSTRUCT
"NdrConformantStruct", // FC_CSTRUCT
"NdrConformantStruct", // FC_CPSTRUCT
"NdrConformantVaryingStruct", // FC_CVSTRUCT
"NdrComplexStruct", // FC_BOGUS_STRUCT
"NdrConformantArray", // FC_CARRAY
"NdrConformantVaryingArray", // FC_CVARRAY
"NdrFixedArray", // FC_SMFARRAY
"NdrFixedArray", // FC_LGFARRAY
"NdrVaryingArray", // FC_SMVARRAY
"NdrVaryingArray", // FC_LGVARRAY
"NdrComplexArray", // FC_BOGUS_ARRAY
"NdrConformantString", // FC_C_CSTRING
"NdrConformantString", // FC_C_BSTRING
"NdrConformantString", // FC_C_SSTRING
"NdrConformantString", // FC_C_WSTRING
"NdrNonConformantString", // FC_CSTRING
"NdrNonConformantString", // FC_BSTRING
"NdrNonConformantString", // FC_SSTRING
"NdrNonConformantString", // FC_WSTRING
"NdrEncapsulatedUnion", // FC_ENCAPSULATED_UNION
"NdrNonEncapsulatedUnion", // FC_NON_ENCAPSULATED_UNION
"NdrByteCountPointer", // FC_BYTE_COUNT_POINTER
"NdrXmitOrRepAs", // FC_TRANSMIT_AS
"NdrXmitOrRepAs", // FC_REPRESENT_AS
"NdrInterfacePointer", // FC_INTERFACE_POINTER
"NdrContextHandle", // FC_BIND_CONTEXT
"?", "?", "?", "?", "?", "?", "?", // 31-37
"?", "?", "?", "?", "?", "?", "?", "?", // 38-3f
"?", "?", "?", "?", "?", "?", "?", "?", // 40-47
"?", "?", "?", "?", "?", "?", "?", "?", // 48-4f
"?", "?", "?", "?", "?", "?", "?", "?", // 50-57
"?", "?", "?", // 58-5a
"?", "?", // FC_END & FC_PAD
"?", "?", "?", // 5d-5f
"?", "?", "?", "?", "?", "?", "?", "?", // 60-67
"?", "?", "?", "?", "?", "?", "?", "?", // 68-6f
"?", "?", "?", "?", "?", "?", "?", "?", // 70-77
"?", "?", "?", "?", "?", "?", "?", "?", // 78-7f
"?", "?", "?", "?", "?", "?", "?", "?", // 80-87
"?", "?", "?", "?", "?", "?", "?", "?", // 88-8f
"?", "?", "?", "?", "?", "?", "?", "?", // 90-97
"?", "?", "?", "?", "?", "?", "?", "?", // 98-9f
"?", "?", "?", "?", "?", "?", "?", "?", // a0-a7
"?", "?", "?", "?", "?", "?", "?", "?", // a8-af
"?", // 0xb0
"NdrHardStruct", // FC_HARD_STRUCT
"NdrXmitOrRepAs", // FC_TRANSMIT_AS_PTR
"NdrXmitOrRepAs", // FC_REPRESENT_AS_PTR
"NdrUserMarshal", // FC_USER_MARSHAL
"NdrPipe", // FC_PIPE
0, // FC_BLKHOLE
0, // FC_RANGE
"NdrSimpleType", // FC_INT3264
"NdrSimpleType", // FC_UINT3264
"NdrCsArray", // FC_CSARRAY
"NdrCsTag", // FC_CS_TAG
0
};
// ============================================================================
//
// FORMAT_STRING class, general comments on fragment optimization.
//
// There are 3 type of offsets that matter a lot when format string fragments
// are optimized. These are absolute type offsets, relative type offsets and
// stack (or field) offsets.
//
// - Absolute type offsets are offsets from the proc format string to type
// format string. For 32b implementation they are limited to ushort32 range.
// An absolute type offset indicates a type of a parameter.
// Note that there is only one absolute type offset for a parameter regardless
// of the platform.
//
// - Relative type offsets are offsets within the type format string.
// For 32b implementation they are limited to short32 range.
// A relative type offset indicates a type of a component for a compund type.
// Note that there is only one relative type offset for a field or element
// regardless of the platform.
//
// - Stack offset is a stack offset to a parameter within a proc stack or
// a field offset to a field within a struct.
// For a 32b implementation stack offsets are limited to a short32 range. This
// is because some of these offsets are relative to a current position within
// a struct or union. They have been clampd together because of correlation
// descriptors may have stack or field offsets.
// Proper stack offsets actually come in a ushort and usmall range variaty.
// Proper field offsets come in as shorts.
// For a given position in the format string, there is a set of stack offsets
// as in general a x86 stack offset is different from other platform offsets
// and a field offset may be different as well.
//
// Proc format string uses only absolute type offsets and stack offsets.
//
// the constructor
FORMAT_STRING::FORMAT_STRING()
{
// Allocate the buffer and align it on a short boundary.
pBuffer = (unsigned char *) new short[ DEFAULT_FORMAT_STRING_SIZE / 2 ];
// Allocate the cousin buffer type array. This does not need to
// be aligned.
pBufferType = new unsigned char[ DEFAULT_FORMAT_STRING_SIZE ];
memset( pBuffer, 0, DEFAULT_FORMAT_STRING_SIZE );
memset( pBufferType, FS_FORMAT_CHARACTER, DEFAULT_FORMAT_STRING_SIZE );
BufferSize = DEFAULT_FORMAT_STRING_SIZE;
CurrentOffset = 0;
LastOffset = 0;
pReuseDict = new FRMTREG_DICT( this );
}
void
FORMAT_STRING::CheckSize()
/*++
Routine Description :
Reallocates a new format string buffer if the current buffer is within
4 bytes of overflowing.
Arguments :
None.
--*/
{
//
// Allocate a new buffer if we're within 4 bytes of
// overflowing the current buffer.
//
if ( CurrentOffset + 3 > BufferSize )
{
unsigned char * pBufferNew;
// double the Buffer size
pBufferNew = (unsigned char *) new short[ BufferSize ];
memcpy( pBufferNew,
pBuffer,
(unsigned int) BufferSize );
memset( pBufferNew + BufferSize, 0, BufferSize );
delete pBuffer;
pBuffer = pBufferNew;
// double the BufferType size
pBufferNew = (unsigned char *) new short[ BufferSize ];
memcpy( pBufferNew,
pBufferType,
(unsigned int) BufferSize );
memset( pBufferNew + BufferSize, FS_FORMAT_CHARACTER, BufferSize );
delete pBufferType;
pBufferType = pBufferNew;
BufferSize *= 2;
}
}
//
// Push a short type-fmt-string offset at the current offset.
// This is used as the offset from a parameter into type format string.
// For 32b code, this needs to be a value within an unsigned short.
// We use a long value internally for better fragment optimization.
//
void
FORMAT_STRING::PushShortTypeOffset( long s )
{
CheckSize();
if ( s < 0 || s > _UI16_MAX )
{
// CG_NDR * pNdr = pCCB->GetLastPlaceholderClass();
CG_NDR * pNdr = 0;
char * pName = pNdr ? pNdr->GetSymName()
: "";
RpcError(NULL, 0, FORMAT_STRING_LIMITS, pName );
exit( FORMAT_STRING_LIMITS );
}
pBufferType[CurrentOffset] = FS_SHORT_TYPE_OFFSET;
pBufferType[CurrentOffset+1] = FS_SMALL;
*((unsigned short UNALIGNED *)(pBuffer + CurrentOffset)) = (unsigned short)s;
TypeOffsetDict.Insert( (long) CurrentOffset, s );
IncrementOffset(2);
}
//
// Push a short offset at the current offset.
// This is the relative type offset within the type string.
// For 32b code, this needs to be a value within a signed short, eventually.
// We use a long value internally for better fragment optimization.
//
void
FORMAT_STRING::PushShortOffset( long TypeOffset )
{
CheckSize();
// We don't check the range for the offset here for better optimization.
pBufferType[ CurrentOffset ] = FS_SHORT_OFFSET;
pBufferType[ CurrentOffset + 1 ] = FS_SMALL;
*((short UNALIGNED *)(pBuffer + CurrentOffset)) = (short)TypeOffset;
TypeOffsetDict.Insert( (long) CurrentOffset, TypeOffset );
IncrementOffset(2);
}
// This an auxilary method to handle relative offsets.
// It is used when we need to write out an offset temporarily and then fix it
// later, for example in pointers, structs etc.
//
void
FORMAT_STRING::PushShortOffset( long TypeOffset, long Position )
{
// We don't check the range for the offset here for better optimization.
pBufferType[ Position ] = FS_SHORT_OFFSET;
pBufferType[ Position + 1 ] = FS_SMALL;
*((short UNALIGNED *)(pBuffer + Position)) = (short)TypeOffset;
TypeOffsetDict.Insert( Position, TypeOffset );
}
//
// Push a stack size or an absolute offset.
//
void
FORMAT_STRING::PushUShortStackOffsetOrSize(
long X86Offset )
{
CheckSize();
if ( X86Offset < 0 || X86Offset > _UI16_MAX )
{
// Make it a warning with a name.
// CG_NDR * pNdr = pCCB->GetLastPlaceholderClass();
CG_NDR * pNdr = 0;
char * pName = pNdr ? pNdr->GetSymName()
: "";
RpcError(NULL, 0, STACK_SIZE_TOO_BIG, pName );
exit( FORMAT_STRING_LIMITS );
}
pBufferType[CurrentOffset] = FS_SHORT_STACK_OFFSET;
pBufferType[CurrentOffset+1] = FS_SMALL;
*((short UNALIGNED *)(pBuffer + CurrentOffset)) = (short) X86Offset;
#if defined(RKK_FRAG_OPT)
{
printf("PushShortStackOffset CurrentOffset %d\n", CurrentOffset );
int offLow = CurrentOffset - 10; if (offLow < 0) offLow = 0;
int offHig = CurrentOffset + 10;
printf(" off=%d ", offLow );
for (int off = offLow; off < offHig; off++)
printf("%02x ", pBuffer[ off ]);
printf( "\n" );
printf(" off=%d ", offLow );
for ( off = offLow; off < offHig; off++)
printf("%02x ", pBufferType[ off ]);
printf( "\n" );
}
#endif
OffsetDict.Insert( (long) CurrentOffset,
X86Offset );
IncrementOffset(2);
}
//
// Push a stack offset.
// Needs to be relative because of offsets in structs etc.
//
void
FORMAT_STRING::PushShortStackOffset(
long X86Offset )
{
CheckSize();
if ( X86Offset < _I16_MIN || X86Offset > _I16_MAX )
{
// Make it a warning with a name.
// CG_NDR * pNdr = pCCB->GetLastPlaceholderClass();
CG_NDR * pNdr = 0;
char * pName = pNdr ? pNdr->GetSymName()
: "";
RpcError(NULL, 0, FORMAT_STRING_LIMITS, pName );
exit( FORMAT_STRING_LIMITS );
}
pBufferType[CurrentOffset] = FS_SHORT_STACK_OFFSET;
pBufferType[CurrentOffset+1] = FS_SMALL;
*((short UNALIGNED *)(pBuffer + CurrentOffset)) = (short) X86Offset;
#if defined(RKK_FRAG_OPT)
{
printf("PushShortStackOffset CurrentOffset %d\n", CurrentOffset );
int offLow = CurrentOffset - 10; if (offLow < 0) offLow = 0;
int offHig = CurrentOffset + 10;
printf(" off=%d ", offLow );
for (int off = offLow; off < offHig; off++)
printf("%02x ", pBuffer[ off ]);
printf( "\n" );
printf(" off=%d ", offLow );
for ( off = offLow; off < offHig; off++)
printf("%02x ", pBufferType[ off ]);
printf( "\n" );
}
#endif
OffsetDict.Insert( (long) CurrentOffset,
X86Offset );
IncrementOffset(2);
}
// =============================================================================
//
// Helper routines writing comments about some tokens.
//
__inline void
Out_PointerFlags(
ISTREAM * pStream,
unsigned char * pFlags
)
{
if ( *pFlags & FC_ALLOCATE_ALL_NODES )
pStream->Write( " [all_nodes]");
if ( *pFlags & FC_DONT_FREE )
pStream->Write( " [dont_free]");
if ( *pFlags & FC_ALLOCED_ON_STACK )
pStream->Write( " [alloced_on_stack]");
if ( *pFlags & FC_SIMPLE_POINTER )
pStream->Write( " [simple_pointer]");
if ( *pFlags & FC_POINTER_DEREF )
pStream->Write( " [pointer_deref]");
}
__inline void
Out_OldProcFlags(
ISTREAM * pStream,
unsigned char * pFlags
)
{
INTERPRETER_FLAGS * pOiFlags = (INTERPRETER_FLAGS *)pFlags;
if ( pOiFlags->FullPtrUsed )
pStream->Write( " full ptr,");
if ( pOiFlags->RpcSsAllocUsed )
pStream->Write( " DCE mem package,");
if ( pOiFlags->ObjectProc )
{
pStream->Write( " object,");
if ( pOiFlags->IgnoreObjectException )
pStream->Write( " ignore obj exc,");
if ( pOiFlags->HasCommOrFault )
pStream->Write( " Oi2");
}
else
{
if ( pOiFlags->IgnoreObjectException )
pStream->Write( " encode,");
if ( pOiFlags->HasCommOrFault )
pStream->Write( " comm or fault/decode");
}
}
__inline void
Out_Oi2ProcFlags(
ISTREAM * pStream,
unsigned char * pFlags
)
{
INTERPRETER_OPT_FLAGS * pOi2Flags = (INTERPRETER_OPT_FLAGS *)pFlags;
if ( pOi2Flags->ServerMustSize )
pStream->Write( " srv must size,");
if ( pOi2Flags->ClientMustSize )
pStream->Write( " clt must size,");
if ( pOi2Flags->HasReturn )
pStream->Write( " has return,");
if ( pOi2Flags->HasPipes )
pStream->Write( " has pipes,");
if ( pOi2Flags->HasAsyncUuid )
pStream->Write( " has async uuid,");
if ( pOi2Flags->HasExtensions )
pStream->Write( " has ext,");
if ( pOi2Flags->HasAsyncHandle )
pStream->Write( " has async handle");
}
__inline void
Out_ExtProcFlags(
ISTREAM * pStream,
unsigned char * pFlags
)
{
INTERPRETER_OPT_FLAGS2 * pExtFlags = (INTERPRETER_OPT_FLAGS2 *)pFlags;
if ( pExtFlags->HasNewCorrDesc )
pStream->Write( " new corr desc,");
if ( pExtFlags->ClientCorrCheck )
pStream->Write( " clt corr check,");
if ( pExtFlags->ServerCorrCheck )
pStream->Write( " srv corr check,");
if ( pExtFlags->HasNotify )
pStream->Write( " has notify");
if ( pExtFlags->HasNotify2 )
pStream->Write( " has notify_flag");
if ( pExtFlags->HasComplexReturn )
pStream->Write( " has complex return");
}
__inline void
Out_ParameterFlags(
ISTREAM * pStream,
PARAM_ATTRIBUTES * pParamAttr
)
{
char Buf[8];
if ( pParamAttr->MustSize )
pStream->Write( " must size,");
if ( pParamAttr->MustFree )
pStream->Write( " must free,");
if ( pParamAttr->IsPipe )
pStream->Write( " pipe,");
if ( pParamAttr->IsIn )
pStream->Write( " in,");
if ( pParamAttr->IsOut )
pStream->Write( " out,");
if ( pParamAttr->IsReturn )
pStream->Write( " return,");
if ( pParamAttr->IsBasetype )
pStream->Write( " base type,");
if ( pParamAttr->IsByValue )
pStream->Write( " by val,");
if ( pParamAttr->IsSimpleRef )
pStream->Write( " simple ref,");
if ( pParamAttr->IsDontCallFreeInst )
pStream->Write( " dont call free inst,");
if ( pParamAttr->IsForceAllocate )
pStream->Write( " force allocate," );
if ( pParamAttr->SaveForAsyncFinish )
pStream->Write( " split async,");
if ( pParamAttr->ServerAllocSize )
{
pStream->Write( " srv alloc size=");
pStream->Write( MIDL_ITOA( 8 * pParamAttr->ServerAllocSize, Buf, 10) );
}
}
__inline void
Out_CorrelationType(
ISTREAM * pStream,
unsigned char * pCorrType
)
{
unsigned char CorrType = *pCorrType;
if ( CorrType & FC_NORMAL_CONFORMANCE )
pStream->Write( " field, ");
if ( CorrType & FC_POINTER_CONFORMANCE )
pStream->Write( " field pointer, ");
if ( CorrType & FC_TOP_LEVEL_CONFORMANCE )
pStream->Write( " parameter, ");
if ( CorrType & FC_TOP_LEVEL_MULTID_CONFORMANCE )
pStream->Write( " multidim parameter, ");
if ( CorrType & FC_CONSTANT_CONFORMANCE )
{
unsigned long ConstVal;
char Buf[12];
pStream->Write( " constant, val=");
// next three bytes: just a weird way of generating it
ConstVal = (ulong) pCorrType[1] << 16;
ConstVal |= *(unsigned short UNALIGNED *)( pCorrType + 2);
pStream->Write( MIDL_ITOA( ConstVal, Buf, 10) );
}
else
{
pStream->Write( pFormatCharNames[ CorrType & 0xf ] );
}
}
__inline void
Out_CorrelationFlags(
ISTREAM * pStream,
unsigned char * pNewCorrFlags
)
{
NDR_CORRELATION_FLAGS * pCorrFlags = (NDR_CORRELATION_FLAGS *)pNewCorrFlags;
if ( pCorrFlags->Early )
pStream->Write( " early," );
if ( pCorrFlags->Split )
pStream->Write( " split," );
if ( pCorrFlags->IsIidIs )
pStream->Write( " iid_is," );
if ( pCorrFlags->DontCheck )
pStream->Write( " dont check" );
}
__inline void
Out_ContextHandleFlags(
ISTREAM * pStream,
unsigned char * pContextFlags
)
{
PNDR_CONTEXT_HANDLE_FLAGS pFlags = (PNDR_CONTEXT_HANDLE_FLAGS)pContextFlags;
if ( pFlags->IsViaPtr )
pStream->Write( " via ptr," );
if ( pFlags->IsIn )
pStream->Write( " in," );
if ( pFlags->IsOut )
pStream->Write( " out," );
if ( pFlags->IsReturn )
pStream->Write( " ret," );
if ( pFlags->IsStrict )
pStream->Write( " strict," );
if ( pFlags->NoSerialize )
pStream->Write( " no serialize," );
if ( pFlags->Serialize )
pStream->Write( " serialize," );
if ( pFlags->CannotBeNull)
pStream->Write( " can't be null" );
}
__inline void
Out_SmallStackSize(
ISTREAM * pStream,
long StackSize,
char * pEnvComment
)
{
char Buf[102];
//
// Non-Alpha stack size.
//
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA(StackSize, Buf, 16) );
pStream->Write( ",\t\t/* ");
pStream->Write( pEnvComment );
pStream->Write( " stack size = ");
pStream->Write( MIDL_ITOA(StackSize, Buf, 10) );
pStream->Write( " */");
}
// The comment table is initialized in FORMAT_STRING::Output as appropriate
// for a given environment { 64b, 32b, others }.
// The comments correspond to the ifdef situation described below.
static char * Env64Comment = "ia64";
static char * Env32Comment = "x86";
static char * OtherEnvComment = "";
__inline void
Out_ShortStackOffset(
ISTREAM * pStream,
OffsetDictElem * pStackOffsets,
char * EnvComment
)
{
char Buf[102];
//
// Emit the main (x86 or ia64) offset.
//
unsigned long OffsetValue = pStackOffsets->X86Offset;
pStream->Write( "NdrFcShort( 0x" );
pStream->Write( MIDL_ITOA( OffsetValue, Buf, 16) );
pStream->Write( " ),\t/* " );
pStream->Write( EnvComment );
pStream->Write( " Stack size/offset = " );
pStream->Write( MIDL_ITOA( OffsetValue, Buf, 10) );
pStream->Write( " */");
}
void
FORMAT_STRING::Output(
ISTREAM * pStream,
char * pTypeName,
char * pName,
RepAsPadExprDict * pPadDict,
RepAsSizeDict * pSizeDict )
/*++
Routine Description :
Outputs the format string structure.
Arguments :
pStream - Stream to output the format string to.
--*/
{
long Offset;
long LastPrinted = 0;
char Buf[102];
BOOL InPP = FALSE;
REP_AS_PAD_EXPR_DESC * pPadExprDesc;
REP_AS_SIZE_DESC * pSizeDesc;
char * pComment;
BOOL fLimitErr = FALSE;
pStream->NewLine();
pStream->Write( "static const " );
pStream->Write( pTypeName );
pStream->Write( ' ' );
pStream->Write( pName );
pStream->Write( " =");
pStream->IndentInc();
pStream->NewLine();
pStream->Write( '{' );
pStream->IndentInc();
pStream->NewLine();
pStream->Write( "0," );
pStream->NewLine();
pStream->Write( '{' );
pStream->IndentInc();
// Reset the pad and size macro dictionaries
pPadExprDesc = pPadDict->GetFirst();
pSizeDesc = pSizeDict->GetFirst();
pStream->IndentDec();
pStream->IndentDec();
pStream->IndentDec();
BOOL f32 = pCommand->GetEnv() == ENV_WIN32;
BOOL f64 = pCommand->GetEnv() == ENV_WIN64;
char * EnvComment;
if ( f32 )
{
EnvComment = Env32Comment;
}
else if ( f64 )
{
EnvComment = Env64Comment;
}
else
{
EnvComment = OtherEnvComment;
}
for ( Offset = 0; Offset < (long)LastOffset; )
{
pStream->NewLine();
pComment = CommentDict.GetComments( Offset );
if ( pComment )
pStream->Write( pComment );
if ( ! (Offset % 2) && ( Offset != LastPrinted ) )
{
sprintf(Buf,"/* %2d */\t",Offset);
LastPrinted = Offset;
pStream->Write(Buf);
}
else
{
pStream->Write("\t\t\t");
}
switch ( pBufferType[Offset] )
{
case FS_FORMAT_CHARACTER :
// Make the format string readable.
switch ( pBuffer[Offset] )
{
case FC_IN_PARAM :
case FC_IN_OUT_PARAM :
case FC_PARTIAL_IGNORE_PARAM :
case FC_OUT_PARAM :
case FC_RETURN_PARAM :
case FC_STRUCT :
case FC_PSTRUCT :
case FC_CSTRUCT :
case FC_CPSTRUCT :
case FC_CVSTRUCT :
case FC_BOGUS_STRUCT :
case FC_NO_REPEAT :
case FC_FIXED_REPEAT :
case FC_VARIABLE_REPEAT :
case FC_CARRAY :
case FC_CVARRAY :
case FC_SMFARRAY :
case FC_LGFARRAY :
case FC_SMVARRAY :
case FC_LGVARRAY :
case FC_BOGUS_ARRAY :
case FC_C_CSTRING :
case FC_C_SSTRING :
case FC_C_WSTRING :
case FC_CSTRING :
case FC_SSTRING :
case FC_WSTRING :
case FC_ENCAPSULATED_UNION :
case FC_NON_ENCAPSULATED_UNION :
case FC_IP :
pStream->NewLine();
pStream->Write("\t\t\t");
break;
case FC_RP :
case FC_UP :
case FC_OP :
case FC_FP :
//
// If we're not in a pointer layout, and the previous
// format char was not a param/result char then print
// a new line.
//
if ( ! InPP &&
( Offset &&
pBuffer[Offset - 1] != FC_IN_PARAM &&
pBuffer[Offset - 1] != FC_IN_OUT_PARAM &&
pBuffer[Offset - 1] != FC_PARTIAL_IGNORE_PARAM &&
pBuffer[Offset - 1] != FC_OUT_PARAM &&
pBuffer[Offset - 1] != FC_IN_PARAM_NO_FREE_INST &&
pBuffer[Offset - 1] != FC_RETURN_PARAM )
)
{
pStream->NewLine();
pStream->Write("\t\t\t");
}
break;
case FC_PP :
InPP = TRUE;
pStream->NewLine();
pStream->Write("\t\t\t");
break;
case FC_END :
if ( InPP )
{
pStream->NewLine();
pStream->Write("\t\t\t");
}
break;
default:
break;
}
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset], Buf, 16 ) );
pStream->Write( ",\t\t/* ");
pStream->Write( pFormatCharNames[pBuffer[Offset]] );
pStream->Write( " */");
if ( (pBuffer[Offset] == FC_END) && InPP )
{
pStream->NewLine();
InPP = FALSE;
}
Offset++;
break;
case FS_POINTER_FORMAT_CHARACTER :
//
// If we're not in a pointer layout, and the previous
// format char was not a param/result char then print
// a new line.
//
if ( ! InPP &&
( Offset &&
pBuffer[Offset - 1] != FC_IN_PARAM &&
pBuffer[Offset - 1] != FC_IN_OUT_PARAM &&
pBuffer[Offset - 1] != FC_PARTIAL_IGNORE_PARAM &&
pBuffer[Offset - 1] != FC_OUT_PARAM &&
pBuffer[Offset - 1] != FC_RETURN_PARAM )
)
{
pStream->NewLine();
pStream->Write("\t\t\t");
}
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset], Buf, 16 ) );
pStream->Write( ", 0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset + 1] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t/* ");
pStream->Write( pFormatCharNames[pBuffer[Offset]] );
Out_PointerFlags( pStream, pBuffer + Offset + 1 );
pStream->Write( " */");
Offset += 2;
break;
case FS_SMALL :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* ");
pStream->Write( MIDL_ITOA( pBuffer[Offset], Buf, 10 ) );
pStream->Write( " */");
Offset++;
break;
case FS_OLD_PROC_FLAG_BYTE :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* Old Flags: ");
Out_OldProcFlags( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset++;
break;
case FS_Oi2_PROC_FLAG_BYTE :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* Oi2 Flags: ");
Out_Oi2ProcFlags( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset++;
break;
case FS_EXT_PROC_FLAG_BYTE :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* Ext Flags: ");
Out_ExtProcFlags( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset++;
break;
case FS_CORR_TYPE_BYTE :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* Corr desc: ");
Out_CorrelationType( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset++;
break;
case FS_CONTEXT_HANDLE_FLAG_BYTE :
pStream->Write( "0x" );
pStream->Write( MIDL_ITOA( pBuffer[Offset] & 0x00ff, Buf, 16 ) );
pStream->Write( ",\t\t/* Ctxt flags: ");
Out_ContextHandleFlags( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset++;
break;
case FS_SHORT :
pStream->Write( "NdrFcShort( 0x" );
pStream->Write(
MIDL_ITOA( *((unsigned short UNALIGNED *)(pBuffer+Offset)), Buf, 16));
pStream->Write( " ),\t/* ");
pStream->Write(
MIDL_ITOA(*((short UNALIGNED *)(pBuffer+Offset)), Buf, 10));
pStream->Write( " */");
Offset += 2;
break;
case FS_MAGIC_UNION_SHORT :
pStream->Write( "NdrFcShort( 0x" );
pStream->Write(
MIDL_ITOA( *((unsigned short UNALIGNED *)(pBuffer+Offset)), Buf, 16));
pStream->Write( " ),\t/* Simple arm type: ");
pStream->Write( pFormatCharNames[ pBuffer[Offset] ]
? pFormatCharNames[ pBuffer[Offset] ]
: "" );
pStream->Write( " */");
Offset += 2;
break;
case FS_PARAM_FLAG_SHORT :
pStream->Write( "NdrFcShort( 0x" );
pStream->Write(
MIDL_ITOA( *((unsigned short UNALIGNED *)(pBuffer + Offset)), Buf, 16));
pStream->Write( " ),\t/* Flags: ");
Out_ParameterFlags( pStream, (PARAM_ATTRIBUTES *)(pBuffer + Offset) );
pStream->Write( " */");
Offset += 2;
break;
case FS_CORR_FLAG_SHORT :
pStream->Write( "NdrFcShort( 0x" );
pStream->Write(
MIDL_ITOA( *((unsigned short UNALIGNED *)(pBuffer + Offset)), Buf, 16));
pStream->Write( " ),\t/* Corr flags: ");
Out_CorrelationFlags( pStream, pBuffer + Offset );
pStream->Write( " */");
Offset += 2;
break;
case FS_SHORT_OFFSET :
{
// The relative type offset.
TypeOffsetDictElem * pTO;
long ItsOffset;
ItsOffset = *((short UNALIGNED *)(pBuffer + Offset));
pTO = TypeOffsetDict.LookupOffset( Offset );
if ( pTO->TypeOffset != ItsOffset ||
pTO->TypeOffset < UNION_OFFSET16_MIN )
{
pStream->Write( "Relative type offset out of range" );
pStream->NewLine();
RpcError(NULL, 0, FORMAT_STRING_LIMITS, "" );
fLimitErr = TRUE;
}
if ( 0 == ( pTO->TypeOffset + Offset ) ||
-1 == ( pTO->TypeOffset + Offset ) )
{
fprintf( stdout, " MIDL_fixup: Invalid offset at %d\n", Offset );
RpcError( NULL, 0, FORMAT_STRING_OFFSET_IS_ZERO, "" );
}
pStream->Write( "NdrFcShort( 0x" );
pStream->Write( MIDL_ITOA( ItsOffset, Buf, 16 ) );
pStream->Write( " ),\t/* Offset= ");
pStream->Write( MIDL_ITOA( pTO->TypeOffset, Buf, 10 ) );
pStream->Write( " (");
pStream->Write( MIDL_ITOA( pTO->TypeOffset + Offset, Buf, 10 ) );
pStream->Write( ") */");
Offset += 2;
}
break;
case FS_SHORT_TYPE_OFFSET :
{
// The absolute type offset.
TypeOffsetDictElem * pTO;
long ItsOffset;
ItsOffset = *((unsigned short UNALIGNED *)(pBuffer + Offset));
pTO = TypeOffsetDict.LookupOffset( Offset );
if ( pTO->TypeOffset != ItsOffset )
{
pStream->Write( "Type offset out of range" );
pStream->NewLine();
RpcError(NULL, 0, FORMAT_STRING_LIMITS, "" );
fLimitErr = TRUE;
}
if ( 0 == pTO->TypeOffset || -1 == pTO->TypeOffset )
{
fprintf( stdout, " MIDL_fixup: Invalid type offset at %d\n", Offset );
RpcError( NULL, 0, TYPE_OFFSET_IS_ZERO, "" );
}
pStream->Write( "NdrFcShort( 0x" );
pStream->Write( MIDL_ITOA( ItsOffset, Buf, 16 ) );
pStream->Write( " ),\t/* Type Offset=");
pStream->Write( MIDL_ITOA( pTO->TypeOffset, Buf, 10 ) );
pStream->Write( " */");
Offset += 2;
}
break;
case FS_SHORT_STACK_OFFSET :
{
Out_ShortStackOffset( pStream,
OffsetDict.LookupOffset( Offset ),
EnvComment );
Offset += 2;
break;
}
case FS_SMALL_STACK_SIZE :
{
Out_SmallStackSize( pStream,
pBuffer[Offset],
EnvComment );
Offset++;
break;
}
case FS_LONG :
pStream->Write( "NdrFcLong( 0x" );
pStream->Write(
MIDL_LTOA( *((long UNALIGNED *)(pBuffer+Offset)), Buf, 16));
pStream->Write( " ),\t/* ");
pStream->Write(
MIDL_LTOA(*((long UNALIGNED *)(pBuffer+Offset)), Buf, 10));
pStream->Write( " */");
Offset += 4;
break;
case FS_PAD_MACRO :
if ( pPadExprDesc )
{
MIDL_ASSERT( Offset == (long)pPadExprDesc->KeyOffset );
pPadDict->WriteCurrentPadDesc( pStream );
pPadExprDesc = pPadDict->GetNext();
}
else
{
pStream->Write( "0x0,\t\t/* macro */" );
MIDL_ASSERT( 0 && "Pad macro missing" );
}
Offset++;
break;
case FS_SIZE_MACRO :
if ( pSizeDesc )
{
MIDL_ASSERT( Offset == (long)pSizeDesc->KeyOffset );
pSizeDict->WriteCurrentSizeDesc( pStream );
pSizeDesc = pSizeDict->GetNext();
}
else
{
pStream->Write( "0x0, 0x0,\t\t// macro" );
MIDL_ASSERT( 0 && "Size macro missing" );
}
Offset += 2;
break;
case FS_UNKNOWN_STACK_SIZE :
{
char * LongBuf = Buf;
long NameLen = (long) strlen(
UnknownStackSizeDict.LookupTypeName( (long) Offset ));
if ( NameLen > 25 )
LongBuf = new char[ 75 + NameLen ];
sprintf(
LongBuf,
"%s ( (sizeof(%s) + %s) & ~ (%s) ),",
"(unsigned char)",
UnknownStackSizeDict.LookupTypeName( (long) Offset ),
"sizeof(int) - 1",
"sizeof(int) - 1" );
pStream->Write( LongBuf );
}
Offset++;
break;
}
}
pStream->NewLine( 2 );
//
// Spit out a terminating 0 so we don't ever fall off the end
// of the world.
//
pStream->Write( "\t\t\t0x0" );
pStream->IndentInc();
pStream->IndentInc();
pStream->IndentInc();
pStream->IndentDec();
pStream->NewLine();
pStream->Write( '}' );
pStream->IndentDec();
pStream->NewLine();
pStream->Write( "};" );
pStream->IndentDec();
pStream->NewLine();
if ( LastOffset > _UI16_MAX )
{
pStream->Write( "Total Format String size is too big." );
pStream->NewLine();
fprintf(stdout, "Total Format String size = %d\n", LastOffset );
RpcError(NULL, 0, FORMAT_STRING_LIMITS, "" );
fLimitErr = TRUE;
}
if ( fLimitErr )
exit( FORMAT_STRING_LIMITS );
}
long
FORMAT_STRING::OptimizeFragment(
CG_NDR * pNode )
/*++
Routine Description :
Optimize a format string fragment away.
Arguments :
pNode - CG_NDR node, with format string start
and end offsets already set.
--*/
{
long StartOffset = pNode->GetFormatStringOffset();
long EndOffset = pNode->GetFormatStringEndOffset();
FRMTREG_ENTRY NewFragment( StartOffset, EndOffset );
FRMTREG_ENTRY * pOldFragment;
// perform format string optimization
#if defined(RKK_FRAG_OPT)
{
printf("Optimizing: start=%d, end=%d\n", StartOffset, EndOffset);
printf(" off str=%d ", StartOffset );
for (int off = StartOffset; off <= EndOffset; off++)
printf("%02x ", pBuffer[ off ]);
printf( "\n" );
printf(" off typ=%d ", StartOffset );
for ( off = StartOffset; off <= EndOffset; off++)
printf("%02x ", pBufferType[ off ]);
printf( "\n" );
}
#endif
if ( pCommand->IsSwitchDefined( SWITCH_NO_FMT_OPT ) )
return StartOffset;
// We attempt to optimize fragments even if they are apart by more than 32k.
MIDL_ASSERT ( EndOffset <= (long)LastOffset );
// add to dictionary
// if match found, reset format string offset back to our start
if ( GetReuseDict()->GetReUseEntry( pOldFragment, &NewFragment ) )
{
long OldStartOffset = pOldFragment->GetStartOffset();
// if we are not the end, we can't do anything about ourselves
// similarly, if we match ourselves, don't do anything
if ( ( GetCurrentOffset() == EndOffset ) &&
( OldStartOffset != StartOffset ) )
{
// move format string offset back
SetCurrentOffset( StartOffset );
pNode->SetFormatStringOffset( OldStartOffset );
pNode->SetFormatStringEndOffset( pOldFragment->GetEndOffset() );
return OldStartOffset;
}
#if defined(RKK_FRAG_OPT)
else if ( GetCurrentOffset() != EndOffset )
{
printf( "OptimizeFragment fragment not at the end End=%d, frag End=%d\n",
GetCurrentOffset(), EndOffset );
}
#endif
} // duplicate found
return StartOffset;
}
unsigned short
FORMAT_STRING::RegisterFragment(
CG_NDR * pNode )
/*++
Routine Description :
Register, but do not remove, a format string fragment.
Arguments :
pNode - CG_NDR node, with format string start offset already set.
EndOffset - end offset of format string fragment
--*/
{
unsigned short StartOffset = (unsigned short)
pNode->GetFormatStringOffset();
unsigned short EndOffset = (unsigned short)
pNode->GetFormatStringEndOffset();
FRMTREG_ENTRY NewFragment( StartOffset, EndOffset );
FRMTREG_ENTRY * pOldFragment;
// perform format string optimization
if ( pCommand->IsSwitchDefined( SWITCH_NO_FMT_OPT ) )
return StartOffset;
MIDL_ASSERT( ( ((short) StartOffset) != -1 ) &&
( ((short) EndOffset) != -1 ) );
MIDL_ASSERT ( EndOffset <= LastOffset );
// add to dictionary, or return pointer to old entry
GetReuseDict()->GetReUseEntry( pOldFragment, &NewFragment );
return StartOffset;
}
char *
CommentDictionary::GetComments(
long Offset
)
{
CommentDictElem Elem;
CommentDictElem * pHead;
CommentDictElem * pElem;
Dict_Status DictStatus;
char * Comments;
long Length;
Elem.FormatStringOffset = Offset;
DictStatus = Dict_Find( &Elem );
if ( DictStatus != SUCCESS )
return 0;
pHead = (CommentDictElem *) Dict_Item();
Length = 0;
for ( pElem = pHead; pElem; pElem = pElem->Next )
Length += (long) strlen( pElem->Comment );
Comments = new char[Length+1];
Comments[0] = 0;
for ( pElem = pHead; pElem; pElem = pElem->Next )
strcat( Comments, pElem->Comment );
return Comments;
}
void
CommentDictionary::Insert(
long FormatStringOffset,
char * Comment
)
{
CommentDictElem Elem;
CommentDictElem * pHead;
CommentDictElem * pElem;
Dict_Status DictStatus;
Elem.FormatStringOffset = FormatStringOffset;
DictStatus = Dict_Find( &Elem );
if ( DictStatus == SUCCESS )
pHead = (CommentDictElem *) Dict_Item();
else
pHead = 0;
pElem = new CommentDictElem;
pElem->Next = pHead;
pElem->FormatStringOffset = FormatStringOffset;
pElem->Comment = Comment;
//
// We delete any current entry and add a new entry so that comments
// are always prepended to the list.
//
if ( pHead )
Dict_Delete( (pUserType *) &pHead );
Dict_Insert( pElem );
}
Reference in a new issue Copy permalink