/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Copyright (c) 1993-1999 Microsoft Corporation

 Module Name:

    stndr.hxx

 Abstract:

    Contains routines for the generation of the new NDR format strings for
    structure types, and the new NDR marshalling and unmarshalling calls.

 Notes:


 History:

    DKays     Oct-1993     Created.
 ----------------------------------------------------------------------------*/

#include "becls.hxx"
#pragma hdrstop

void
CG_STRUCT::GenNdrFormat( CCB * pCCB )
/*++

Routine Description :

    Generates the format string description for a simple, conformant,
    or conformant varying structure.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    FORMAT_STRING *     pFormatString;
    CG_NDR *            pOldCGNodeContext;
    CG_NDR *            pConformantArray;

    if ( GetFormatStringOffset() != -1 )
        return;

    //
    // Check if this structure is "complex".
    //
    if ( IsComplexStruct() )
        {
        GenNdrFormatComplex( pCCB );
        return;
        }

    //
    // Check if the structure is "hard".
    //
    if ( IsHardStruct() )
        {
        GenNdrFormatHard( pCCB );
        return;
        }

    Unroll();

    //
    // Temporarily set the format string offset to 0 in case this structure
    // has pointers to it's own type.
    //
    SetFormatStringOffset( 0 );
    SetInitialOffset(      0 );

    CG_FIELD *pOldRegionField = NULL;
#if defined(NDR64_ON_DCE_HACK)
    if ( NULL != dynamic_cast<CG_REGION*>( this ) )
        {
        pOldRegionField = pCCB->StartRegion();
        }
    else
#endif
    pOldCGNodeContext = pCCB->SetCGNodeContext( this );

    pFormatString = pCCB->GetFormatString();


    //
    // Search the fields of the structure for embedded structures and generate
    // the format string for these.
    //
    CG_ITERATOR     Iterator;
    CG_FIELD *      pField;
    CG_NDR *        pMember;

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        CG_NDR * pOldPlaceholder;

        pOldPlaceholder = pCCB->SetLastPlaceholderClass( pField );

        pMember = (CG_NDR *) pField->GetChild();

        //
        // If there is a structure or array member then generate
        // it's format string.  We don't have to check for a union, because
        // that will make the struct CG_COMPLEX_STRUCT.
        //
        if ( pMember->IsStruct() || pMember->IsArray() )
            pMember->GenNdrFormat( pCCB );

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        }

    //
    // If this is a conformant (varying) struct then generate the array's
    // description.
    //
    if ( GetCGID() == ID_CG_CONF_STRUCT ||
         GetCGID() == ID_CG_CONF_VAR_STRUCT )
        {
        CG_NDR * pOldPlaceholder;

        pOldPlaceholder =
            pCCB->SetLastPlaceholderClass(
              (CG_NDR *) ((CG_CONFORMANT_STRUCT *)this)->GetConformantField() );

        // Get the conformant array CG class.
        pConformantArray = (CG_NDR *)
                           ((CG_CONFORMANT_STRUCT *)this)->GetConformantArray();

        // Generate the format string for the array.
        pConformantArray->GenNdrFormat( pCCB );

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        }

    //
    // If there are pointers in the structure then before you can start
    // generating the format string for the structure, you must generate
    // the format string for all of the pointees.
    //
    if ( HasPointer() )
        {
        GenNdrStructurePointees( pCCB );
        }

    SetFormatStringOffset( pFormatString->GetCurrentOffset() );
    SetInitialOffset(      pFormatString->GetCurrentOffset() );


    switch ( GetCGID() )
        {
        case ID_CG_STRUCT :
            pFormatString->PushFormatChar( HasPointer() ?
                                           FC_PSTRUCT : FC_STRUCT );
            break;

        case ID_CG_CONF_STRUCT :
            pFormatString->PushFormatChar( HasPointer() ?
                                           FC_CPSTRUCT : FC_CSTRUCT );
            break;

        case ID_CG_CONF_VAR_STRUCT :
            pFormatString->PushFormatChar( FC_CVSTRUCT );
            break;
        }

    // Set the alignment.
    pFormatString->PushByte( GetWireAlignment() - 1 );

    // Set the structure memory size.
    pFormatString->PushShort( (short)GetMemorySize() );

    //
    // If this is a conformant array then push the offset to the conformant
    // array's description.
    //
    if ( GetCGID() == ID_CG_CONF_STRUCT ||
         GetCGID() == ID_CG_CONF_VAR_STRUCT )
        {
        // Set the offset to the array description.
        pFormatString->PushShortOffset( pConformantArray->GetFormatStringOffset() -
                                          pFormatString->GetCurrentOffset() );
        }

    // Generate the pointer layout if needed.
    if ( HasPointer() )
        {
        GenNdrStructurePointerLayout( pCCB, FALSE, FALSE );
        }

    // Now generate the layout.
    GenNdrStructureLayout( pCCB );

    //
    // Now we have to fix up the offset for any recursive pointer to this
    // structure.
    //
    GenNdrPointerFixUp( pCCB, this );

#if defined(NDR64_ON_DCE_HACK)
    if ( NULL != dynamic_cast<CG_REGION*>( this ) )
        {
        pCCB->EndRegion(pOldRegionField);
        }
    else
#endif
    pCCB->SetCGNodeContext( pOldCGNodeContext );

    SetFormatStringEndOffset( pFormatString->GetCurrentOffset() );
    pFormatString->OptimizeFragment( this );
    SetInitialOffset( GetFormatStringOffset() );

    FixupEmbeddedComplex( pCCB );

    if ( GetDuplicatingComplex() )
        GetDuplicatingComplex()->FixupEmbeddedComplex( pCCB );
}

void
CG_STRUCT::GenNdrFormatHard( CCB * pCCB )
/*++

Routine Description :

    Generates the format string description for a packed structure.  The
    description has the same format as for a complex struct.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    FORMAT_STRING * pFormatString;
    CG_NDR *        pOldCGNodeContext;
    CG_NDR *        pUnion;
    CG_FIELD *      pFinalField;
    long            CopySize;
    long            MemoryIncrement;

    if ( GetFormatStringOffset() != -1 )
        return;

    //
    // Temporarily set the format string offset to 0 in case this structure
    // has pointers to it's own type.
    //
    SetFormatStringOffset( 0 );
    SetInitialOffset(      0 );

    pOldCGNodeContext = pCCB->SetCGNodeContext( this );

    pFormatString = pCCB->GetFormatString();

    //
    // Search the fields of the structure for embedded structures and generate
    // the format string for these.
    //
    CG_ITERATOR     Iterator;
    CG_FIELD *      pField;
    CG_NDR *        pMember;
    CG_NDR *        pOldPlaceholder;

    GetMembers( Iterator );

    pOldPlaceholder = pCCB->GetLastPlaceholderClass();

    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        pMember = (CG_NDR *) pField->GetChild();

        //
        // If there is an embedded structure, array, or union then generate
        // it's format string.
        //
        if ( pMember->IsStruct() || pMember->IsArray() || pMember->IsUnion() )
            {
            pCCB->SetLastPlaceholderClass( pField );
            pMember->GenNdrFormat( pCCB );
            }
        }

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );

    SetFormatStringOffset( pFormatString->GetCurrentOffset() );
    SetInitialOffset(      pFormatString->GetCurrentOffset() );

    pFinalField = GetFinalField();

    //
    // See if we have a union.
    //
    if ( pFinalField->GetChild()->IsUnion() )
        pUnion = (CG_NDR *) pFinalField->GetChild();
    else
        pUnion = 0;

    //
    // Determine the copy size and memory increment for the copy.
    //
    if ( pUnion )
        {
        CG_STRUCT * pStruct;

        pStruct = this;
        CopySize = 0;

        for ( ;; )
            {
            pStruct->GetMembers( Iterator );

            while ( ITERATOR_GETNEXT( Iterator, pField ) )
                ;

            CopySize += pField->GetWireOffset();

            pMember = (CG_NDR *) pField->GetChild();

            if ( pMember->IsStruct() )
                {
                pStruct = (CG_STRUCT *) pMember;
                continue;
                }
            else
                break;
            }

        MemoryIncrement = GetMemorySize() - pUnion->GetMemorySize();
        }
    else
        {
        CopySize = GetWireSize();
        MemoryIncrement = GetMemorySize();
        }

    //
    // Format string generation.
    //

    pFormatString->PushFormatChar( FC_HARD_STRUCT );

    // The alignment.
    pFormatString->PushByte( GetWireAlignment() - 1 );

    // The structure's memory size.
    pFormatString->PushShort( (short)GetMemorySize() );

    // Reserved for future use.
    pFormatString->PushLong( 0 );

    //
    // Offset to enum in struct.
    //
    if ( GetNumberOfEnum16s() == 1 )
        pFormatString->PushShort( GetEnum16Offset() );
    else
        pFormatString->PushShort( (short) -1 );

    //
    // Copy size and memory increment.
    //
    pFormatString->PushShort( CopySize );
    pFormatString->PushShort( MemoryIncrement );

    //
    // Offset to union's format string description.
    //
    if ( pUnion )
        {
        pOldPlaceholder = pCCB->GetLastPlaceholderClass();
        pCCB->SetLastPlaceholderClass( pFinalField );

        pFormatString->PushShort( (short)
                                  (pUnion->GetFormatStringOffset() -
                                   pFormatString->GetCurrentOffset()) );

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        }
    else
        pFormatString->PushShort( (short) 0 );

    // Now generate the layout.
    GenNdrStructureLayout( pCCB );

    //
    // Now we have to fix up the offset for any recursive pointer to this
    // structure.
    //
    GenNdrPointerFixUp( pCCB, this );

    pCCB->SetCGNodeContext( pOldCGNodeContext );

    SetFormatStringEndOffset( pFormatString->GetCurrentOffset() );
    pFormatString->OptimizeFragment( this );
    SetInitialOffset( GetFormatStringOffset() );

    FixupEmbeddedComplex( pCCB );
}

void
CG_STRUCT::GenNdrFormatComplex( CCB * pCCB )
/*++

Routine Description :

    Generates the format string description for a packed structure.  The
    description has the same format as for a complex struct.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    CG_CLASS *          pConfField;
    CG_COMPLEX_STRUCT * pComplex;

    if ( (GetCGID() == ID_CG_CONF_STRUCT) ||
         (GetCGID() == ID_CG_CONF_VAR_STRUCT) )
        pConfField = ((CG_CONFORMANT_STRUCT *)this)->GetConformantField();
    else
        pConfField = 0;

    //
    // Do the old duplication trick.
    //
    pComplex = new CG_COMPLEX_STRUCT( this, pConfField );

    SetDuplicatingComplex( pComplex );

    //
    // Now temporarily set our format string offset to 0 to handle recursive
    // definitions.
    //
    SetFormatStringOffset( 0 );
    SetInitialOffset(      0 );
                        
    //
    // This call will set our format string offset correctly.
    //
    pComplex->GenNdrFormat( pCCB );

    // Don't delete since the expression evaluator might need this.
    // delete( pComplex );
}


bool IsEnum16UnionAlignBug( CG_STRUCT *pStruct ) 
{

    // Comment from old hack wacked on stub.
    // The NT 3.50 stubs had a problem with union alignment that affects
    // structs with 16b enum and a union as the only other thing.
    // The old, incorrect alignment was 2 (code 1), the correct alignment is 4 (code 3).
    // All the compilers since NT 3.51, i.e. MIDL 2.0.102 generate correct code,
    // however we needed to introduce the wrong alignment into newly compiled stubs
    // to get interoperability with the released dhcp client and server binaries.
    
    if ( 4 != pStruct->GetWireAlignment())
        return false;

    CG_ITERATOR StructElements;
    pStruct->GetMembers( StructElements );

    ITERATOR_INIT( StructElements );
    size_t Elements = ITERATOR_GETCOUNT( StructElements );

    if ( 2 != Elements )
        return false;

    ITERATOR_INIT( StructElements );
    
    CG_FIELD *pField1 = NULL;
    ITERATOR_GETNEXT( StructElements, pField1 );
    MIDL_ASSERT( NULL != pField1);

    // Is the first field a enum16?
    CG_ENUM *pEnum = dynamic_cast<CG_ENUM*>( pField1->GetChild() );
    if ( ( NULL == pEnum ) || pEnum->IsEnumLong() )
        return false;

    // Is the second field a union
    CG_FIELD *pField2 = NULL;
    ITERATOR_GETNEXT( StructElements, pField2 );
    MIDL_ASSERT( NULL != pField2 );

    if ( ! pField2->GetChild()->IsUnion())
        return false;

    // Ok. We have a 2 field structure were the first field is an enum16 and the second field is
    // and union.
    return true;
}



void
CG_COMPLEX_STRUCT::GenNdrFormat( CCB * pCCB )
/*++

Routine Description :

    Generates the format string description for a complex structure.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    FORMAT_STRING *     pFormatString;
    CG_NDR *            pOldCGNodeContext;
    CG_NDR *            pConformantArray;
    long                PointerLayoutOffset;

    if ( GetFormatStringOffset() != -1 )
        return;

    pFormatString = pCCB->GetFormatString();

    //
    // Temporarily set the format string offset to 0 in case this structure
    // has pointers to it's own type.
    //
    SetFormatStringOffset( 0 );
    SetInitialOffset(      0 );

    pOldCGNodeContext = pCCB->SetCGNodeContext( this );

    //
    // Search the fields of the structure for imbeded structures, arrays, and
    // and unions and generate the format string for these.
    //
    CG_ITERATOR     Iterator;
    CG_FIELD *      pField;
    CG_NDR *        pMember;

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        pMember = (CG_NDR *) pField->GetChild();

        //
        // If the field is anything other than a base type or a
        // non-interface pointer then generate it's description.
        //
        if ( ! pMember->IsSimpleType() &&
             ! ( pMember->IsPointer() &&
                 !pMember->IsInterfacePointer() ) &&
             (pMember->GetCGID() != ID_CG_IGN_PTR) ||
             pMember->GetRangeAttribute() )
            {
            CG_NDR * pOldPlaceholder;

            pOldPlaceholder = pCCB->SetLastPlaceholderClass( pField );

            pMember->GenNdrFormat( pCCB );

            pCCB->SetLastPlaceholderClass( pOldPlaceholder );
            }
        }

    // Generate pointee format strings.
    GenNdrStructurePointees( pCCB );

    // Generate conformant array description.
    if ( ( pConformantArray = (CG_NDR *) GetConformantArray() ) != 0 )
        {
        CG_NDR * pOldPlaceholder;

        pOldPlaceholder = pCCB->SetLastPlaceholderClass(
                                (CG_NDR *) GetConformantField() );

        pConformantArray->GenNdrFormat( pCCB );

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        }

    // Now set the struct's format string offset.
    SetFormatStringOffset( pFormatString->GetCurrentOffset() );
    SetInitialOffset(      pFormatString->GetCurrentOffset() );

    //
    // Set the duplicated struct's format string offset if we were duplicated.
    //
    if ( GetDuplicatedStruct() )
        {
        GetDuplicatedStruct()->SetFormatStringOffset( GetFormatStringOffset() );
        GetDuplicatedStruct()->SetInitialOffset(      GetFormatStringOffset() );
        }

    pFormatString->PushFormatChar( FC_BOGUS_STRUCT );

    WarnAboutEmbeddedComplexStruct();

    //
    // Set the wire alignment.
    //
    if ( pCommand->WireCompat( WIRE_COMPAT_ENUM16UNIONALIGN ) &&
         IsEnum16UnionAlignBug(this) )
        {

        // Comment from old hack wacked on stub.
        // The NT 3.50 stubs had a problem with union alignment that affects
        // structs with 16b enum and a union as the only other thing.
        // The old, incorrect alignment was 2 (code 1), the correct alignment is 4 (code 3).
        // All the compilers since NT 3.51, i.e. MIDL 2.0.102 generate correct code,
        // however we needed to introduce the wrong alignment into newly compiled stubs
        // to get interoperability with the released dhcp client and server binaries.

        pFormatString->AddComment( pFormatString->GetCurrentOffset(), "/* 3 */ /* enum16unionalign Bug Compatibility */" );  
        pFormatString->PushByte( 1 );

        }
    else
        pFormatString->PushByte( GetWireAlignment() - 1 );

    // Set the structure memory size.
    pFormatString->PushShort( (short)GetMemorySize() );

    // Array description.
    if ( pConformantArray )
        pFormatString->PushShortOffset( pConformantArray->GetFormatStringOffset() -
                                          pFormatString->GetCurrentOffset() );
    else
        pFormatString->PushShort( (short) 0 );

    //
    // Remember where the offset_to_pointer_layout<> field will go and push
    // some space for it.
    //
    PointerLayoutOffset = pFormatString->GetCurrentOffset();

    pFormatString->PushShortOffset( 0 );

    // Now generate the structure's layout.
    GenNdrStructureLayout( pCCB );

    //
    // Now see if we have any plain pointer fields and if so generate a
    // pointer layout.  We can't use the HasAtLeastOnePointer() method
    // because this tells us TRUE if we have any embedded arrays, structs,
    // or unions which have pointers.  For complex structs we're only
    // interested in actual pointer fields.
    //
    GetMembers( Iterator );

    //
    // Fill in the offset_to_pointer_layout<2> field and generate a
    // pointer_layout<> if we have any pointer fields.  Interface pointers
    // do not reside in the pointer layout.
    //
    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        if ( pField->GetChild()->IsPointer() &&
             !pField->IsInterfacePointer() )
            {
            // This is an internal offset within the struct descriptor, namely
            // to the pointer layout field, not the offset to a type.

            // Surprisingly, this code may produce an offset to an array etc.
            // Hence, we push an offset to be backward compatible.

            pFormatString->PushShortOffset(
                pFormatString->GetCurrentOffset() - PointerLayoutOffset,
                PointerLayoutOffset );

            GenNdrStructurePointerLayout( pCCB );

            break;
            }

    pFormatString->Align();

    //
    // Now we have to fix up the offset for any recursive pointer to this
    // structure.
    //
    GenNdrPointerFixUp( pCCB, GetDuplicatedStruct() ? GetDuplicatedStruct() : this );

    pCCB->SetCGNodeContext( pOldCGNodeContext );

    SetFormatStringEndOffset( pFormatString->GetCurrentOffset() );
    pFormatString->OptimizeFragment( this );
    SetInitialOffset(      GetFormatStringOffset() );
    if ( GetDuplicatedStruct() )
        GetDuplicatedStruct()->SetFormatStringOffset( GetFormatStringOffset() );

    FixupEmbeddedComplex( pCCB );
    if ( GetDuplicatedStruct() )
        GetDuplicatedStruct()->FixupEmbeddedComplex( pCCB );

    // There is no call to the string optimizer here. If we wanted to put it in,
    // the code should check if the optimization is possible or not by checking the
    // result of GenNdrEmbeddedPointers via GenNdrStructurePointerLayout call.
}

void
CG_COMPLEX_STRUCT::GenNdrStructurePointerLayout( CCB * pCCB )
/*++

Routine Description :

    Generates the format string pointer layout section for a complex
    structure.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    CG_ITERATOR         Iterator;
    CG_FIELD *          pField;
    CG_NDR *            pMember;

    GetMembers( Iterator );

    while( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        CG_NDR *    pOldPlaceholder;
        
        pOldPlaceholder = pCCB->SetLastPlaceholderClass( pField );

        pMember = (CG_NDR *) pField->GetChild();

        if ( pMember->IsPointer() &&
             !pMember->IsInterfacePointer())
            {
            CG_POINTER *        pPointer;

            pPointer = (CG_POINTER *) pMember;

            // The pointer description.
            pPointer->GenNdrFormatEmbedded( pCCB );
            }

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        } // while
}

//---------------------------------------------------------------------------
// Methods shared by all or most structure classes.
//---------------------------------------------------------------------------

void
CG_STRUCT::GenNdrStructurePointerLayout( CCB *  pCCB,
                                         BOOL   fNoPP,
                                         BOOL   fNoType )
/*++

Routine Description :

    Generates the format string pointer layout section for a structure.
    This is the default routine for this used by the structure classes.
    Only CG_COMPLEX_STRUCT redefines this virtual method.

Arguments :

    pCCB        - pointer to the code control block.
    fNoPP       - TRUE if no FC_PP or FC_END should be emitted
    fNoType     - TRUE only the bare offset and description should be emitted
                  for each pointer

 --*/
{
    CG_ITERATOR         Iterator;
    FORMAT_STRING *     pFormatString;
    CG_FIELD *          pField;
    CG_NDR *            pMember;
    long                ImbedingMemSize;
    long                ImbedingBufSize;

    pFormatString = pCCB->GetFormatString();

    // Get/Save the current imbeding sizes.
    ImbedingMemSize = pCCB->GetImbedingMemSize();
    ImbedingBufSize = pCCB->GetImbedingBufSize();

    if ( ! fNoPP )
        {
        pFormatString->PushFormatChar( FC_PP );
        pFormatString->PushFormatChar( FC_PAD );
        }

    GetMembers( Iterator );

    while( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        CG_NDR *    pOldPlaceholder;
        
        pOldPlaceholder = pCCB->SetLastPlaceholderClass( pField );

        pMember = (CG_NDR *) pField->GetChild();

        if ( pMember->IsPointer() &&
             !pMember->IsInterfacePointer() )
            {
            CG_POINTER *        pPointer;

            pPointer = (CG_POINTER *) pMember;

            // Push the instance type.
            if ( ! fNoType )
                {
                pFormatString->PushFormatChar( FC_NO_REPEAT );
                pFormatString->PushFormatChar( FC_PAD );
                }

            pFormatString->PushShort( (short)
                            (ImbedingMemSize + pField->GetMemOffset()));
            pFormatString->PushShort( (short)
                            (ImbedingBufSize + pField->GetWireOffset()));

            // The actual pointer description.
            pPointer->GenNdrFormatEmbedded( pCCB );
            }

        //
        // Generate pointer descriptions for all embedded arrays and structs.
        // We don't have to check for unions because that will make the struct
        // complex.
        //
        if ( pMember->IsArray() )
            {
            CG_NDR * pNdr = (CG_NDR *) pMember->GetChild();

            //
            // For arrays we set the imbeded memory size equal to the
            // size of the whole imbededing structure.
            //
            pCCB->SetImbedingMemSize( ImbedingMemSize + GetMemorySize() );
            pCCB->SetImbedingBufSize( ImbedingBufSize + GetWireSize() );

            if ( (pNdr->IsPointer() && 
                  !pNdr->IsInterfacePointer() )
                 ||
                 ( pNdr->IsStruct() && ((CG_COMP *)pNdr)->HasPointer() )  )
                ((CG_ARRAY *)pMember)->GenNdrFormatArrayPointerLayout( pCCB,
                                                                       TRUE );
            }

        if ( pMember->IsStruct() )
            if ( ((CG_STRUCT *)pMember)->HasPointer() )
                {
                //
                // For embedded structs we add the embedded struct's offset to
                // the value of the current embeddeding size.
                //
                pCCB->SetImbedingMemSize( ImbedingMemSize +
                                          pField->GetMemOffset() );
                pCCB->SetImbedingBufSize( ImbedingBufSize +
                                          pField->GetWireOffset() );

                ((CG_STRUCT *)pMember)->GenNdrStructurePointerLayout( pCCB,
                                                                      TRUE,
                                                                      fNoType );
                }

        pCCB->SetLastPlaceholderClass( pOldPlaceholder );
        } // while

    if ( ! fNoPP )
        pFormatString->PushFormatChar( FC_END );

    // Re-set the old imbeding sizes.
    pCCB->SetImbedingMemSize( ImbedingMemSize );
    pCCB->SetImbedingBufSize( ImbedingBufSize );

    // There is no call to the string optimizer here. If we wanted to put it in,
    // the code should check if the optimization is possible or not by checking the 
    // result of GenNdrEmbeddedPointers via GenNdrStructurePointerLayout call.
}


CG_FIELD *
CG_STRUCT::GetPreviousField( CG_FIELD * pMarkerField )
/*++

Routine description:

    Finds the field immediately preceding the given field.

Argument:

    pMarkerField  -   the given field

Returns:

    The preceding field or NULL if the given field is the first one.
--*/
{
    CG_ITERATOR         Iterator;
    CG_FIELD            *pField, *pPreviousField = 0;

    GetMembers( Iterator );
    while( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        if ( pField == pMarkerField )
            return( pPreviousField );

        pPreviousField = pField;
        }
    return( 0 );
}


void
CG_STRUCT::GenStructureMemPad( CCB * pCCB, unsigned long MemPad )
/*++

Routine Description :

    Generates the format string for memory padding in a structure layout.

Arguments :

    pCCB        - pointer to the code control block.
    MemPad      - Amount of required padding.
    
 --*/
{
   FORMAT_STRING * pFormatString = pCCB->GetFormatString();
   MIDL_ASSERT( MemPad < 0xFFFF ); // structures must be less then 64k

   switch( MemPad)
       {
       case 0:
           return; // No padding needed
       case 1:
           pFormatString->PushFormatChar( FC_STRUCTPAD1 );
           return;
       case 2:
           pFormatString->PushFormatChar( FC_STRUCTPAD2 );
           return;
       case 3:
           pFormatString->PushFormatChar( FC_STRUCTPAD3 );
           return;
       case 4:
           pFormatString->PushFormatChar( FC_STRUCTPAD4 );
           return;
       case 5:
           pFormatString->PushFormatChar( FC_STRUCTPAD5 );
           return;
       case 6:
           pFormatString->PushFormatChar( FC_STRUCTPAD6 );
           return;
       case 7:
           pFormatString->PushFormatChar( FC_STRUCTPAD7 );
           return;
       default:

           // NDR60 Feature

           // Pad an arbitrary amount
           // FC_STRUCTPADN 0 <unsigned short>
           pFormatString->Align();
           pFormatString->PushFormatChar( FC_STRUCTPADN );
           pFormatString->PushFormatChar( FC_ZERO );
           pFormatString->PushShort( (short)MemPad );

           pCommand->GetNdrVersionControl().SetHasStructPadN();
       }

}

void
CG_STRUCT::GenNdrStructureLayout( CCB * pCCB )
/*++

Routine Description :

    Generates the format string layout section for a structure.

Arguments :

    pCCB        - pointer to the code control block.

 --*/
{
    FORMAT_STRING * pFormatString = pCCB->GetFormatString();

    CG_NDR * pOldPlaceholder = pCCB->GetLastPlaceholderClass();

    CG_ITERATOR         Iterator;
    GetMembers( Iterator );

    CG_FIELD *    pField;
    CG_FIELD *    pPrevField = NULL;
    unsigned long BufferOffset = 0;
    bool          fSawUnknownRepAs = false;

    while( ITERATOR_GETNEXT( Iterator, pField ) ) 
        {
        if ( fSawUnknownRepAs && !pField->HasEmbeddedUnknownRepAs() )
            {
            switch ( pField->GetMemoryAlignment() )
                {
                case 2: pFormatString->PushFormatChar( FC_ALIGNM2 ); break;
                case 4: pFormatString->PushFormatChar( FC_ALIGNM4 ); break;
                case 8: pFormatString->PushFormatChar( FC_ALIGNM8 ); break;
                }        
            }
        else if ( !fSawUnknownRepAs && !pField->HasEmbeddedUnknownRepAs() )
            {
            unsigned long MemPad = pField->GetMemOffset() - BufferOffset;

            GenStructureMemPad( pCCB, MemPad );

            BufferOffset += MemPad;
            }

        pCCB->SetLastPlaceholderClass( pField );
        
        CG_NDR *pMember = (CG_NDR *) pField->GetChild();
        
        while ( pMember->GetCGID() == ID_CG_TYPEDEF )
            {
            pMember = ( CG_NDR* )pMember->GetChild();
            }
        
        // The ending conformat array is not included in the
        // size of the structure.
        // Note that this must be the last field.
        if ( pMember->GetCGID() == ID_CG_CONF_ARRAY ||
             pMember->GetCGID() == ID_CG_CONF_VAR_ARRAY ||
             pMember->GetCGID() == ID_CG_CONF_STRING_ARRAY )
            {
            break;
            }

        // Generate an embedded complex for embedded things.
        if ( pMember->IsStruct() ||
             pMember->IsUnion() ||
             pMember->IsArray() ||
             pMember->IsXmitRepOrUserMarshal() ||
             pMember->GetRangeAttribute() ||
             pMember->IsInterfacePointer() )
            {
            pFormatString->PushFormatChar( FC_EMBEDDED_COMPLEX );

            if ( pField->HasEmbeddedUnknownRepAs() )
                {
                pCCB->GetRepAsPadExprDict()->Register(
                            pFormatString->GetCurrentOffset(),
                            GetType(),
                            pField->GetType()->GetSymName(),
                            pPrevField ? pPrevField->GetType() : 0 );

                pFormatString->PushByteWithPadMacro();
                fSawUnknownRepAs = true;
                }
            else
                {
                pFormatString->PushByte( 0 ); //Padding is generated independently
                }

            if ( pMember->GetFormatStringOffset() == -1 ||
                 pMember->GetFormatStringOffset() == 0 )
                {
                RegisterComplexEmbeddedForFixup(
                    pMember,
                    pFormatString->GetCurrentOffset() - GetInitialOffset() );
                }

            pFormatString->PushShortOffset( pMember->GetFormatStringOffset() -
                                              pFormatString->GetCurrentOffset() );
            }

        else if (pMember->IsPointer() ||
                 ( pMember->GetCGID() == ID_CG_IGN_PTR ) )
            {
            if ( pMember->IsPointer() )
                {
                if ( GetCGID() == ID_CG_COMPLEX_STRUCT )
                    pFormatString->PushFormatChar( FC_POINTER );
                else
                    {
                    pFormatString->PushFormatChar( FC_LONG );
#if !defined(NDR64_ON_DCE_HACK )
                    MIDL_ASSERT( ! pCommand->Is64BitEnv() );
#endif
                    }
                }
            else
                pFormatString->PushFormatChar( FC_IGNORE );

            }
#if defined( NDR64_ON_DCE_HACK )
        else if ( NULL != dynamic_cast<CG_PAD*>( pMember ) )
            {
            pFormatString->PushFormatChar( FC_BUFFER_ALIGN );
            pFormatString->PushByte( pMember->GetWireAlignment() - 1);
            }
#endif
        else 
            {
            //
            // Must be a CG_BASETYPE if we get here.
            //
            FORMAT_CHARACTER FormatChar = ((CG_BASETYPE *)pMember)->GetFormatChar();
            pFormatString->PushFormatChar( FormatChar );
            }

        BufferOffset += pField->GetMemorySize();
        pPrevField = pField;
        }

    // Account for padding at the end of the structure.

    MIDL_ASSERT( GetMemorySize() >= BufferOffset );

    unsigned long EndingPad = GetMemorySize() - BufferOffset;

    // End padding is only allow on complex struct.
    MIDL_ASSERT( EndingPad  ? ( (GetCGID() == ID_CG_COMPLEX_STRUCT) ||
                                IsComplexStruct() || IsHardStruct() )
                            : true ); 

    GenStructureMemPad( pCCB, EndingPad );          

    //
    // If the format string is on a short boundary right now then push
    // a format character so that the format string will be properly aligned
    // following the FC_END.
    //
    if ( ! (pFormatString->GetCurrentOffset() % 2) )
        pFormatString->PushFormatChar( FC_PAD );

    pFormatString->PushFormatChar( FC_END );

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );

}

void
CG_STRUCT::GenNdrStructurePointees( CCB * pCCB )
{
    CG_ITERATOR         Iterator;
    FORMAT_STRING *     pFormatString;
    CG_FIELD *          pField;
    CG_NDR *            pMember;

    pFormatString = pCCB->GetFormatString();

    GetMembers( Iterator );

    //
    // We only have to check for pointer fields here, because if the structure
    // has a struct or array field which has pointers, this will be handled
    // when we generate their format strings.
    //
    while( ITERATOR_GETNEXT( Iterator, pField ) )
        {   
        pMember = (CG_NDR *) pField->GetChild();

        if ( pMember->IsPointer() &&
             !pMember->IsInterfacePointer() )
            {
            CG_NDR * pOldPlaceholder;

            pOldPlaceholder = pCCB->SetLastPlaceholderClass( pField );

            //
            // Skip over an unattributed pointer to a simple type or string.
            //
            if ( ( pMember->GetCGID() == ID_CG_PTR &&
                   ((CG_NDR *)pMember->GetChild())->IsSimpleType() ) ||
                 ( pMember->GetCGID() == ID_CG_STRING_PTR ) )
                {
                pCCB->SetLastPlaceholderClass( pOldPlaceholder );
                continue;
                }

            ((CG_POINTER *)pMember)->GenNdrFormatPointee( pCCB );

            pCCB->SetLastPlaceholderClass( pOldPlaceholder );
            }
        }
}

BOOL
CG_STRUCT::ShouldFreeOffline()
{
    return ( (GetCGID() == ID_CG_COMPLEX_STRUCT) ||
             (GetCGID() == ID_CG_CONF_VAR_STRUCT) ||
             HasPointer() ||
             IsComplexStruct() ||
             IsHardStruct() );
}

void
CG_STRUCT::GenFreeInline( CCB* )
{
}

void
CG_NDR::GenNdrPointerFixUp( CCB * pCCB, CG_STRUCT * pStruct )
{
    CG_ITERATOR     Iterator;
    CG_NDR *        pMember;
    CG_NDR *        pNdr;
    long            Offset;

    if ( ! IsStruct() && ! IsArray()  &&  ! IsUnion() )
        return;

    if ( IsInFixUp() )
        return;

    SetFixUpLock( TRUE );

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pMember ) )
        {
        if ( IsStruct() )
            {
            pNdr = (CG_NDR *) pMember->GetChild();
            }
        else if ( IsUnion() )
            {
            // member of union is a case, then case->field->ndr

            if ( pMember->GetChild() &&  pMember->GetChild()->GetChild() )
                pNdr = (CG_NDR *) pMember->GetChild()->GetChild();
            else
                continue;
            }
        else // IsArray()
            {
            pNdr = pMember;

            //
            // See if the array's element is the structure we're looking for.
            //
            if ( pNdr == pStruct )
                {
                Offset = ((CG_ARRAY *)this)->GetElementDescriptionOffset() + 2;
                pCCB->GetFormatString()->PushShortOffset(
                        pStruct->GetFormatStringOffset() - Offset,
                        Offset );
                }
            }

        if (pNdr->GetCGID() == ID_CG_TYPEDEF )
            pNdr = (CG_NDR *)pNdr->GetChild();

        if ( (pNdr->GetCGID() == ID_CG_PTR) ||
             (pNdr->GetCGID() == ID_CG_SIZE_PTR) ||
             (pNdr->GetCGID() == ID_CG_SIZE_LENGTH_PTR) )
            {
            CG_POINTER * pPointer = (CG_POINTER *) pNdr;

            //
            // Check if we're ready for this guy yet.
            //
            if ( pPointer->GetFormatStringOffset() == -1 )
                continue;

            // Get the pointee.
            switch ( pPointer->GetCGID() )
                {
                case ID_CG_PTR :
                    pNdr = (CG_NDR *) pPointer->GetChild();
                    break;
                case ID_CG_SIZE_PTR :
                    pNdr = ((CG_SIZE_POINTER *)pPointer)->GetPointee();
                    break;
                case ID_CG_SIZE_LENGTH_PTR :
                    pNdr = ((CG_SIZE_LENGTH_POINTER *)pPointer)->GetPointee();
                    break;
                }
        
            //
            // If the pointer's pointee is the struct we're checking for,
            // then patch up the pointer's offset_to_description<2> field.
            //
            if ( pNdr == pStruct )
                {
                long    PointerOffset;

                //
                // Get the offset in the format string where the
                // offset_to_description<2> field of the pointer is.
                //
                PointerOffset = pPointer->GetFormatStringOffset() + 2;
/*
                printf( "    **MIDL_fixup: Non-Reg Actually fixing %s at %d with %d (%d)\n", 
                        pNdr->GetSymName(),
                        PointerOffset, 
                        pNdr->GetFormatStringOffset() - PointerOffset,                      
                        pNdr->GetFormatStringOffset() );
*/
                pCCB->GetFormatString()->PushShortOffset(
                        pStruct->GetFormatStringOffset() - PointerOffset,
                        PointerOffset );
                
                continue;
                }
            }

        //
        // This can happen sometimes because of structs which are promoted
        // to complex because of padding.
        //
        if ( pNdr == this )
            continue;

        //
        // Continue the chase if necessary.
        //
        if ( pNdr->IsStruct() || pNdr->IsUnion() || pNdr->IsArray() )
            pNdr->GenNdrPointerFixUp( pCCB, pStruct );
        }

    SetFixUpLock( FALSE );
}


void
CG_NDR::RegisterComplexEmbeddedForFixup(
    CG_NDR *    pEmbeddedComplex,
    long        RelativeOffset )
{
    if ( GetInitialOffset() == -1 )
        printf( "  Internal compiler problem with recursive embeddings\n" );

    MIDL_ASSERT( GetInitialOffset() != -1 );

    if ( pEmbeddedComplexFixupRegistry == NULL )
        {
        pEmbeddedComplexFixupRegistry = new TREGISTRY;
        }

//    printf( "MIDL_fixup: RegisterComplex %s\n", pEmbeddedComplex->GetSymName());

    EMB_COMPLEX_FIXUP * pFixup = new EMB_COMPLEX_FIXUP;

    pFixup->pEmbeddedNdr   = pEmbeddedComplex;
    pFixup->RelativeOffset = RelativeOffset;

    pEmbeddedComplexFixupRegistry->Register( (node_skl *)pFixup );
}


void
CG_NDR::FixupEmbeddedComplex(
    CCB * pCCB )
{
    if ( IsInComplexFixup() )
        return;

    SetComplexFixupLock( TRUE );

    // Go down first
    CG_ITERATOR     Iterator;
    CG_NDR *        pField;

    GetMembers( Iterator );

    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        pField->FixupEmbeddedComplex( pCCB );

    // Now fix up this level description.

    if ( GetEmbeddedComplexFixupRegistry() )
        {
        ITERATOR            FixupList;
        EMB_COMPLEX_FIXUP * pFixup;
        long                FixAtOffset;
        FORMAT_STRING *     pFormatString =  pCCB->GetFormatString();
    
        GetListOfEmbeddedComplex( FixupList );
    
        while ( ITERATOR_GETNEXT( FixupList, pFixup ) )
            {
            FixAtOffset = GetFormatStringOffset() + pFixup->RelativeOffset;
    
            pFormatString->PushShortOffset(
                pFixup->pEmbeddedNdr->GetFormatStringOffset() - FixAtOffset,
                FixAtOffset );
/*
            printf( "    MIDL_fixup: Reg-Cmplx Actually fixing at %d with %d\n", 
                    FixAtOffset, 
                    pFixup->pEmbeddedNdr->GetFormatStringOffset() - FixAtOffset );
*/
            }
        }

    // Due to duplication, the list may be at the duplicating node.
        
    if ( IsStruct() )
        {
        CG_COMPLEX_STRUCT * pDuping = ((CG_STRUCT *)this)->GetDuplicatingComplex();
        if ( pDuping )
            pDuping->FixupEmbeddedComplex( pCCB );
        }

    SetComplexFixupLock( FALSE );
}

// All these different ways of fixing recursive pointers need to be cleaned up.
// The RecPointer registry seems to be the best solution in that it fixes 
// the pointers once per compilation while complex embed fixup calls walk the 
// tree several times recursively.
// Also, the reason the below registry is different from previously introduced 
// EmbeddedComplex fixup registry is that the emb cplx fixup registry uses 
// a relative pointer when fixing up while the bug we are trying to address now
// affects standalone pointers where absolute offset is appropriate.
// The basic scheme with "struct _S**" field shows up in VARIANT and LPSAFEARRAY.
// Rkk, May, 1999.

void
CCB::RegisterRecPointerForFixup(
    CG_NDR *    pNdr,
    long        AbsoluteOffset )
{
    if ( pRecPointerFixupRegistry == NULL )
        {
        pRecPointerFixupRegistry = new TREGISTRY;
        }

    POINTER_FIXUP * pFixup = new POINTER_FIXUP;

//    printf( "MIDL_fixup: Registering for %s at %d\n", pNdr->GetSymName(), AbsoluteOffset);

    pFixup->pNdr           = pNdr;
    pFixup->AbsoluteOffset = AbsoluteOffset;
    pFixup->fFixed         = false; 
    pRecPointerFixupRegistry->Register( (node_skl *)pFixup );
}


void
CCB::FixupRecPointers()
{
    if ( GetRecPointerFixupRegistry() )
        {
        ITERATOR            FixupList;
        POINTER_FIXUP *     pFixup;
        long                FixAtOffset;
        FORMAT_STRING *     pFormatString = GetFormatString();
    
        GetListOfRecPointerFixups( FixupList );
    
        while ( ITERATOR_GETNEXT( FixupList, pFixup ) )
            {
            FixAtOffset = pFixup->AbsoluteOffset;
    
            if ( ! pFixup->fFixed )
                {
                long Recorded = pFormatString->GetFormatShort(FixAtOffset) + FixAtOffset;
                long NdrOffset = pFixup->pNdr->GetFormatStringOffset();

                if (  0 == Recorded  &&   0 != NdrOffset  ||
                     -1 == Recorded  &&  -1 != NdrOffset  )
                    {
/*                    
                    printf( "    MIDL_fixup: Actually fixing %s at %d with %d (%d)\n", 
                            pFixup->pNdr->GetSymName(),
                            FixAtOffset, 
                            NdrOffset - FixAtOffset,
                            NdrOffset );
*/
                    pFormatString->PushShortOffset( NdrOffset - FixAtOffset,
                                                    FixAtOffset );

                    pFixup->fFixed = true;
                    }
/*
                else if ( 0 != Recorded  &&  -1 != Recorded )
                    {
                    printf( "     MIDL_fixup: %s at %d was already fixed to %d (%d)\n",
                            pFixup->pNdr->GetSymName(),
                            FixAtOffset, 
                            NdrOffset - FixAtOffset,
                            NdrOffset );

                    pFixup->fFixed = true;
                    }
                else
                    {
                    printf( "     MIDL_fixup: %s at %d has not been fixed to %d (%d)\n",
                            pFixup->pNdr->GetSymName(),
                            FixAtOffset, 
                            NdrOffset - FixAtOffset,
                            NdrOffset );
                    }
*/
                } // if ! fixed
            } // while
        }
}

long
CG_STRUCT::FixedBufferSize( CCB * pCCB )
{
    CG_ITERATOR Iterator;
    CG_FIELD *  pField;
    CG_NDR *    pNdr;
    CG_NDR *    pOldPlaceholder;
    long        TotalBufferSize;
    long        BufSize;

    //
    // Check for recursion.
    //
    if ( IsInFixedBufferSize() )
        return -1;

    if ( (GetCGID() == ID_CG_CONF_STRUCT) ||
         (GetCGID() == ID_CG_CONF_VAR_STRUCT) ||
         (GetCGID() == ID_CG_COMPLEX_STRUCT) ||
         IsComplexStruct() )
        return -1;

    if ( IsHardStruct() )
        {
        if ( GetNumberOfUnions() == 0 )
            return MAX_WIRE_ALIGNMENT + GetWireSize();
        else
            return -1;
        }

    SetInFixedBufferSize( TRUE );

    MIDL_ASSERT( GetCGID() == ID_CG_STRUCT );

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GetMembers( Iterator );

    TotalBufferSize = MAX_WIRE_ALIGNMENT + GetWireSize();

    while ( ITERATOR_GETNEXT( Iterator, pField ) )
        {
        pNdr = (CG_NDR *) pField->GetChild();

        // skip these nodes to get to the transmitted element type.
    
        if ( pNdr->IsXmitRepOrUserMarshal() )
            pNdr = (CG_NDR *)pNdr->GetChild();

        if ( pNdr->IsStruct() || pNdr->IsArray() || pNdr->IsPointer() )
            {
            BufSize = pNdr->FixedBufferSize( pCCB );

            if ( BufSize == -1 )
                {
                SetInFixedBufferSize( FALSE );
                return -1;
                }

            //
            // First subtract the basic size of this thing from the struct's
            // size and then add back the value it returned.
            //
            TotalBufferSize -= pNdr->GetWireSize();
            TotalBufferSize += BufSize;
            }
        }

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );

    SetInFixedBufferSize( FALSE );

    // Success!
    return TotalBufferSize;
}