/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Copyright (c) 1989-2000 Microsoft Corporation

 Module Name:
    
    ndrcls.cxx

 Abstract:

    Routines for the ndrcls code generation class.

 Notes:


 History:

    Aug-31-1993     VibhasC     Created.
 ----------------------------------------------------------------------------*/

/****************************************************************************
 *  include files
 ***************************************************************************/
#include "becls.hxx"
#pragma hdrstop

/****************************************************************************
 *  local definitions
 ***************************************************************************/
/****************************************************************************
 *  local data
 ***************************************************************************/

/****************************************************************************
 *  externs
 ***************************************************************************/
/****************************************************************************/

expr_node *
CG_NDR::PresentedLengthExpression( CCB* )
    {
    expr_sizeof *   pExpr   = new expr_sizeof( GetType() );
    return pExpr;
    }

expr_node *
CG_NDR::PresentedSizeExpression( CCB* )
    {
    expr_sizeof *   pExpr   = new expr_sizeof( GetType() );
    return pExpr;
    }
expr_node *
CG_NDR::PresentedFirstExpression( CCB* )
    {
    return new expr_constant(0L);
    }

    
/****************************************************************************
    utility functions
 ****************************************************************************/
CG_STATUS
CG_NDR::SizeAnalysis( ANALYSIS_INFO * pAna )
    {
    pAna;
    return CG_OK;
    }
CG_STATUS
CG_NDR::MarshallAnalysis( ANALYSIS_INFO * pAna )
    {
    pAna;
    return CG_OK;
    }

node_skl    *
CG_NDR::GetBasicType()
    {
    node_skl    *   pT  = GetType();

    switch (pT->NodeKind())
        {
        case NODE_ID:
        case NODE_FIELD:
        case NODE_PARAM:
        case NODE_DEF:
            return pT->GetBasicType();
        }
    return pT;
    }

CG_STATUS
CG_NDR::RefCheckAnalysis(
    ANALYSIS_INFO * pAna )
    {
    CG_NDR * pC = (CG_NDR *)GetChild();

    if( pC )
        pC->RefCheckAnalysis( pAna );

    return CG_OK;
    }

CG_STATUS
CG_NDR::InLocalAnalysis(
    ANALYSIS_INFO * pAna )
    {
    CG_NDR * pC = (CG_NDR *)GetChild();

    if( pC )
        pC->InLocalAnalysis( pAna );

    return CG_OK;
    }

CG_STATUS
CG_NDR::S_GenInitInLocals(
    CCB * pCCB )
    {
    CG_NDR * pC = (CG_NDR *)GetChild();

    if( pC )
        pC->S_GenInitInLocals( pCCB );

    return CG_OK;
    }

CG_STATUS
CG_NDR::GenRefChecks(
    CCB * pCCB )
    {
    CG_NDR * pC = (CG_NDR *)GetChild();

    if( pC )
        pC->GenRefChecks( pCCB );

    return CG_OK;
    }

extern CMD_ARG * pCommand;

void 
CG_NDR::GetNdrParamAttributes( CCB *pCCB, PARAM_ATTRIBUTES *attributes)
{
    CG_PARAM *          pParam;
    CG_NDR *            pChild;
    CG_PROC *           pProc;

    pChild = (CG_NDR *) GetChild();

    if ( pChild && (pChild->GetCGID() == ID_CG_GENERIC_HDL) )
        pChild = (CG_NDR *) pChild->GetChild();

    pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();

    pProc = (CG_PROC *) pCCB->GetCGNodeContext();

    if ( IsPipeOrPipeReference() )
        {
        // Pipe parameters are never sized.

        attributes->MustSize = 0;
        }
    else
        attributes->MustSize = (unsigned short) pParam->GetInterpreterMustSize();

    attributes->IsIn = (unsigned short) pParam->IsParamIn();
    attributes->IsOut = (unsigned short) pParam->IsParamOut();
    attributes->IsReturn = ( pParam->GetCGID() == ID_CG_RETURN )
                           || ( pProc->HasComplexReturnType() 
                                && NULL == pParam->GetSibling() );
    attributes->IsPartialIgnore = pParam->IsParamPartialIgnore();
    attributes->IsForceAllocate = pParam->IsForceAllocate();
    attributes->IsBasetype = 0;
    // SAFEARRAY(FOO) is being generated as ID_CG_SAFEARRAY. It's in fact user 
    // marshal on the wire.
    attributes->IsByValue = 
            IsStruct() || 
            IsUnion() ||
            ( GetCGID() == ID_CG_TRANSMIT_AS )  ||
            ( GetCGID() == ID_CG_REPRESENT_AS ) ||
            ( GetCGID() == ID_CG_USER_MARSHAL ) ||
            ( GetCGID() == ID_CG_SAFEARRAY )    ||
            ( GetCGID() == ID_CG_CS_TAG ) ;
    attributes->IsSimpleRef = 
            (pParam->GetCGID() != ID_CG_RETURN) &&
            IsPointer() && 
            ((CG_POINTER *)this)->IsBasicRefPointer();
    attributes->IsDontCallFreeInst = (unsigned short) pParam->GetDontCallFreeInst();
    attributes->IsPipe = (unsigned short) IsPipeOrPipeReference();
    attributes->SaveForAsyncFinish = (unsigned short) pParam->IsSaveForAsyncFinish();

    if ( (attributes->IsPipe) || (GetCGID() == ID_CG_CONTEXT_HDL) ||
         (IsPointer() && pChild && (pChild->GetCGID() == ID_CG_CONTEXT_HDL)))
        attributes->MustFree = 0;
    else
        attributes->MustFree = 1;

    attributes->ServerAllocSize = 0;

    if ( GetCGID() == ID_CG_PTR ) 
        {
        long Size = 0;

        (void) 
        ((CG_POINTER *)this)->InterpreterAllocatesOnStack( pCCB, 
                                                           pParam, 
                                                           &Size );

        attributes->ServerAllocSize = unsigned short(Size / 8);
        }

    //
    // Now make a final check for a simple ref pointer to a basetype and for 
    // a ref pointer to pointer.
    //
    // We mark pointers to basetypes as being both a basetype and a simple 
    // ref pointer.  Kind of an anomoly, but it works out well in the 
    // interpreter.  
    //
    // For both of these cases the pointer must have no allocate attributes
    // and can not be a return value.
    //
    if ( 
         IsPointer() && 
         (((CG_POINTER *)this)->GetPtrType() == PTR_REF) &&

         ! IS_ALLOCATE( ((CG_POINTER *)this)->GetAllocateDetails(), 
                        ALLOCATE_ALL_NODES ) &&
         ! IS_ALLOCATE( ((CG_POINTER *)this)->GetAllocateDetails(), 
                        ALLOCATE_DONT_FREE ) &&

         (pParam->GetCGID() != ID_CG_RETURN) 
       )
        {
        //
        // Now make sure it's a pointer to basetype and that it is either 
        // [in] or [in,out] (in which case we use the buffer to hold it) or 
        // that it is [out] and there is room for it on the interpreter's 
        // stack.  We don't mark enum16s as SimpleRef-Basetype because of
        // their special handling (i.e. wire size != memory size).
        //
        if ( ((CG_POINTER *)this)->IsPointerToBaseType() && 
             ( pParam->IsParamIn() ||
               (((CG_POINTER *)this)->GetFormatAttr() & FC_ALLOCED_ON_STACK) ) )
            {
            if ( ((CG_BASETYPE *)pChild)->GetFormatChar() != FC_ENUM16 )
                {
                attributes->IsBasetype = 1;
                attributes->IsSimpleRef = 1;
                }
            attributes->MustFree = 0;
            }

        // we give a warning here because pointer to range doesn't work on 
        // w2k sp2 and xp 2600 and before. There is a NDR bug that doesn't
        // allocate memory for poitner to range case.
        if (pChild && 
             pChild->IsSimpleType() && 
             ((CG_BASETYPE *)pChild)->GetRangeAttribute() != NULL  &&
             !pCommand->IsNDR64Run()  )
                    {
                    RpcError( NULL, 0,  TOP_LEVEL_POINTER_RANGE, pParam->GetSymName() );
                    }

        }
}

void
CG_NDR::GenNdrParamDescription( CCB * pCCB )
{
    FORMAT_STRING *     pProcFormatString;
    PARAM_ATTRIBUTES    Attributes;
    long                FormatStringOffset;
    CG_PARAM *          pParam;
    CG_NDR *            pChild;

    pChild = (CG_NDR *) GetChild();

    if ( pChild && (pChild->GetCGID() == ID_CG_GENERIC_HDL) )
        pChild = (CG_NDR *) pChild->GetChild();

    pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();
    
    pProcFormatString = pCCB->GetProcFormatString();
    
    // Attributes.

    GetNdrParamAttributes( pCCB, &Attributes );

    pProcFormatString->PushParamFlagsShort( *((short *)&Attributes) );

    // Stack offset as number of ints.
    pProcFormatString->PushUShortStackOffsetOrSize(
            pParam->GetStackOffset( pCCB, I386_STACK_SIZING ) );

    //
    // If we found a pointer to a basetype, make sure and emit the basetype's
    // param format.
    //
    if ( Attributes.IsSimpleRef && Attributes.IsBasetype )
        {
        pProcFormatString->PushFormatChar( 
                ((CG_BASETYPE *)pChild)->GetFormatChar() );
        pProcFormatString->PushByte( 0 );
        return;
        }

    if ( Attributes.IsSimpleRef ) 
        {
        CG_POINTER *    pPointer;

        pPointer = (CG_POINTER *) this;

        switch ( pPointer->GetCGID() )
            {
            case ID_CG_STRING_PTR :
                if ( ((CG_STRING_POINTER *)pPointer)->IsStringableStruct() )
                    FormatStringOffset = GetFormatStringOffset();
                else
                    FormatStringOffset = pPointer->GetFormatStringOffset() + 2;
                break;

            case ID_CG_SIZE_STRING_PTR :
                if ( ((CG_STRING_POINTER *)pPointer)->IsStringableStruct() )
                    FormatStringOffset = GetFormatStringOffset();
                else
                    FormatStringOffset = pPointer->GetPointeeFormatStringOffset();
                break;

            case ID_CG_STRUCT_STRING_PTR :
                FormatStringOffset = GetFormatStringOffset();
                break;

            default :
                FormatStringOffset = pPointer->GetPointeeFormatStringOffset();
                break;
            }
        }
    else
        {
        FormatStringOffset = GetFormatStringOffset();
        }

    //
    // Push the offset in the type format string to the param's description.
    //
    pProcFormatString->PushShortTypeOffset( FormatStringOffset );
}

void
CG_NDR::GenNdrParamDescriptionOld( CCB * pCCB )
{
    FORMAT_STRING * pProcFormatString;
    CG_PARAM *      pParam;
    long            StackSize;
    long            StackElem;

    pProcFormatString = pCCB->GetProcFormatString();

    pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();

    if ( pCommand->Is64BitEnv() )
        StackElem = 8;
    else
        StackElem = 4;
    
    StackSize = pParam->GetStackSize();

    StackSize = (StackSize + StackElem - 1) & ~ (StackElem - 1);

    pProcFormatString->PushSmallStackSize( (char) (StackSize / StackElem) );

    //
    // Push the offset in the type format string to the param's description.
    //
    pProcFormatString->PushShortTypeOffset( GetFormatStringOffset() );
}