windows-xp/Source/XPSP1/NT/com/rpc/midl/codegen/frmtstr.cxx

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 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  );
}