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

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

 Module Name:

    procgen.cxx

 Abstract:

    code generation for procedures.


 Notes:


 History:

    Aug-15-1993     VibhasC     Created.

 ----------------------------------------------------------------------------*/

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

/****************************************************************************
 *  externs
 ***************************************************************************/
extern  CMD_ARG             *   pCommand;
void GenCorrInit( CCB* );
void GenCorrPassFree( CCB*, char* );

/****************************************************************************/

CG_STATUS
CG_PROC::GenClientStub(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate client stub.

 Arguments:

    pCCB    - pointer to code generation control block.


 Return Value:

    A status of the code generation.

 Notes:

    Set up local variables, parameters etc.
    Perform buffer size and marshalling analysis.
    Generate the stub.


    The strategy for binding is now different than the old stubs. The actual
    binding is performed AFTER the sizing is performed, right at the first
    get buffer call. This allows us to combine the message init and the call
    to get buffer and binding into one single call to an ndr routine.
    Significant code / time savings.
----------------------------------------------------------------------------*/
{
    ANALYSIS_INFO   Analysis;
    BOOL            fHasExceptionHandler = FALSE;
    ISTREAM *   pStream = pCCB->GetStream();

    // [nocode] procs get no client side stub; although they do get a
    // server side stub
    if ( IsNoCode() )
        return CG_OK;

    // call_as procs need additional prototypes
    if ( pCallAsName )
        pCCB->RegisterCallAsRoutine( (node_proc *)GetType() );

    //
    // Set the CCB code generation side.
    //
    pCCB->SetCodeGenSide( CGSIDE_CLIENT );
    pCCB->SetCodeGenPhase( CGPHASE_MARSHALL );

    //
    // Change to -Os if needed because of number of param and/or stack size.
    //
    (void) MustUseSingleEngineCall( pCCB );
    pCCB->SetOptimOption( GetOptimizationFlags() );

    Analysis.SetCurrentSide( C_SIDE );
    Analysis.SetOptimOption( pCCB->GetOptimOption() );
    Analysis.SetMode( pCCB->GetMode() );
    Analysis.SetRpcSSSwitchSet( (unsigned long)pCCB->IsRpcSSSwitchSet() );

    // Declare pre-allocated resources. All params are registered as resources,
    // The standard local variables : an rpc message and the stub message are
    // also set up local variables.

    C_PreAllocateResources( &Analysis );

    // Set current phase. Perform buffer size, binding and marshalling analysis.
    // The binding analysis usually sets up resources needed for binding.

    Analysis.SetCurrentPhase( ANA_PHASE_CLIENT_MARSHALL );

    C_BindingAnalysis( &Analysis );
    MarshallAnalysis( &Analysis );

    // Perform analysis to check if anything needs to be done for ref
    // pointer checks. This is especially needed for arrays of ref pointers
    // where we need to declare indexes for each array dimension.

    RefCheckAnalysis( &Analysis );

    // Perform the unmarshalling analysis. This allows the cg nodes to set
    // up for unmarshall, figure out local variables needed if any.

    Analysis.SetCurrentPhase( ANA_PHASE_CLIENT_UNMARSHALL );
    UnMarshallAnalysis( &Analysis );

    // Perform the Out Local analysis even on the client side, so the engine
    // format string generation will get information if the pointer is
    // allocated on stack. One the client side  this call will NOT actually
    // allocate a resource.

    S_OutLocalAnalysis( &Analysis );

    // Perform this analysis on the client side so the format string is
    // correct for server. It is needed for -Oi RpcSs flag generation.

    RpcSsPackageAnalysis( &Analysis );

    // Find out which alloc and free routines should be put in the stub
    // descriptor.

    PNAME AllocRoutineName, FreeRoutineName;

    GetCorrectAllocFreeRoutines( pCCB,
                                 FALSE,  //client
                                 & AllocRoutineName,
                                 & FreeRoutineName );


    // Init the code gen. controller block for a new procedure. The resource
    // dictionary data base is handed over to the code generation controller
    // for use.

    pCCB->InitForNewProc(
                         GetProcNum(),
                         (RPC_FLAGS) 0,                 // rpc flags
                         AllocRoutineName,
                         FreeRoutineName,
                         Analysis.GetResDictDatabase()  // resource dict.
                        );

    // If the single engine call is to be used, send message to the ndr
    // code generator.

    if ( MustUseSingleEngineCall( pCCB ) )
        {
        if ( IsObject() )
            {
            //
            // Non-call_as object proxies are now stubless.
            //

            if (((CG_OBJECT_PROC *)this)->IsStublessProxy())
                return CG_OK;

            ((CG_OBJECT_PROC *)this)->Out_ProxyFunctionPrototype(pCCB,0);
            pStream->WriteOnNewLine( "{" );
            pStream->NewLine();
            }
        else
            {
            // Generate the function header.
            Out_ClientProcedureProlog( pCCB, GetType() );

            Out_IndentInc( pCCB );
            pStream->NewLine();
            }

        GenNdrSingleClientCall( pCCB );

        Out_IndentDec( pCCB );
        Out_ProcClosingBrace( pCCB );

        // All done.
        return CG_OK;
        }

    pCCB->SetCGNodeContext( this );

    MIDL_ASSERT( pCommand->IsNDRRun() || pCommand->IsNDR64Run() );

    //
    // Always create the format string for the proc.
    //
    if ( pCommand->IsNDRRun() )
        {
        GenNdrFormat( pCCB );        
        }
    else 
        {
        pCCB->GetNdr64Format()->Generate( this );
        }

    // Generate the prolog, the sizing code. Then once the length has been
    // calculated, go ahead and perform the binding using our ndr routines.
    // The call to the ndr routine returns a buffer pointer ready for
    // marshalling.

    C_GenProlog( pCCB );

    if ( ( fHasExceptionHandler = ( HasStatuses() || IsObject() ) ) == TRUE )
        {
        Out_RpcTryExcept( pCCB );
        }

    if ( HasFullPtr() )
        Out_FullPointerInit( pCCB );

    // Generate the null ref check code.
    // For object interfaces we need to generate a call to initialize proxy
    // first as we won't be able to walk parameters later for cleanup.
    // For raw interfaces we don't ned to move initialization call
    // as we don't have the walk problem.

    if ( IsObject() )
        C_GenBind( pCCB );

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

    Out_RpcTryFinally( pCCB);

    if ( !IsObject() )
        C_GenBind( pCCB );

    // generate NdrCorrelationInitialize( _StubMsg, _NdrCorrCache, _NdrCorrCacheSize, _NdrCorrFlags );
    // normally, /deny causes a switch to /Oicf. This code will be executed when a 
    // a switch to from /Os to /Oicf is not posible
    if ( fHasDeny )
        {
        GenCorrInit( pCCB );
        }

    // If the rpc ss package is to be enabled, do so.
    // It would need to be enabled explicitely on the client side when
    // in non-osf mode, with the attribute on the operation AND
    //      - the routine is a callback,
    //      - the routine is not a callback and the interface doesn't
    //        have the attribute (if it does, we optimized via stub descr.)

    if( pCCB->GetMode()  &&  MustInvokeRpcSSAllocate()
        &&
        ( GetCGID() == ID_CG_CALLBACK_PROC  ||
          GetCGID() != ID_CG_CALLBACK_PROC  &&
                                    ! pCCB->GetInterfaceCG()->IsAllRpcSS())
        )
        {
        Out_RpcSSSetClientToOsf( pCCB );
        }

    GenSizing( pCCB );

    GenMarshall( pCCB );

    // Generate the send receive.

    C_GenSendReceive( pCCB );

    // Before Win2000 Ndr<whatetver>SendReceive didn't set the BufferStart
    // and BufferEnd fields.  Do it now.

    pStream->WriteOnNewLine( "_StubMsg.BufferStart = (unsigned char *) _RpcMessage.Buffer; ");
    pStream->WriteOnNewLine( "_StubMsg.BufferEnd   = _StubMsg.BufferStart + _RpcMessage.BufferLength;" );
    pStream->NewLine();
    
    pCCB->SetCodeGenPhase( CGPHASE_UNMARSHALL );
    GenUnMarshall( pCCB );

    // generate NdrCorrelationPass( _StubMsg );
    // normally, /deny causes a switch to /Oicf. This code will be executed when a 
    // a switch to from /Os to /Oicf is not posible
    if ( fHasDeny )
        {
        GenCorrPassFree( pCCB, CSTUB_CORR_PASS_RTN_NAME );
        }

    Out_RpcFinally( pCCB );
    if ( fHasDeny )
        {
        GenCorrPassFree( pCCB, CSTUB_CORR_FREE_RTN_NAME );
        }
    if ( HasFullPtr() )
        Out_FullPointerFree( pCCB );
    C_GenFreeBuffer( pCCB );
    C_GenUnBind( pCCB );
    Out_RpcEndFinally( pCCB );

    if( fHasExceptionHandler )
        {

        if(IsObject())
            {
            ISTREAM * pStream = pCCB->GetStream();

            pStream->NewLine();
            pStream->Write('}');
            pStream->IndentDec();
            pStream->NewLine();
            pStream->Write( "RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)" );
            pStream->IndentInc();
            pStream->NewLine();
            pStream->Write( '{' );
            }
        else
            {
            Out_RpcExcept( pCCB, "1" );
            }

        if(ReturnsHRESULT())
            {
            C_GenClearOutParams( pCCB );
            C_GenMapHRESULT( pCCB );
            }
        else if( HasStatuses() )
            {
            C_GenMapCommAndFaultStatus( pCCB );
            }
        else
            {
            Out_RaiseException( pCCB, "RpcExceptionCode()" );
            }

        Out_RpcEndExcept( pCCB );
        }
    // All done, emit the final closed curly and we're done.
    GenEpilog( pCCB );

    return CG_OK;
}

CG_STATUS
CG_PROC::C_GenMapCommAndFaultStatus(
    CCB     *   pCCB )
    {
    CG_NDR  *   pTemp   = 0;
    CG_NDR  *   pComm   = 0;
    CG_NDR  *   pFault  = 0;
    CG_NDR  *   pRT;
    int         i = 0;
    expr_node   *   pCommExpr;
    expr_node   *   pFaultExpr;
    BOOL        fReturnHasStatus = FALSE;

    ITERATOR    I;

    GetMembers( I );

    if ( (pRT = GetReturnType()) != 0 && (fReturnHasStatus = pRT->HasStatuses() ) == TRUE )
        ITERATOR_INSERT( I, pRT );

    while( ITERATOR_GETNEXT(I, pTemp ) && (i < 2) )
        {
        if( pTemp->HasStatuses() )
            {
            if( pTemp->GetStatuses() == STATUS_COMM )
                pComm = pTemp;
            if( pTemp->GetStatuses() == STATUS_FAULT )
                pFault = pTemp;
            if( pTemp->GetStatuses() == STATUS_BOTH )
                {
                pComm = pFault = pTemp;
                break;
                }
            }
        }

    if( pComm )
        {
        if( pComm == pRT )
            pCommExpr = MakeAddressExpressionNoMatterWhat( pRT->GetResource() );
        else
            pCommExpr = pComm->GetResource();
        }
    else
        pCommExpr = new expr_constant(0L);

    if( pFault )
        {
        if( pFault == pRT )
            pFaultExpr = MakeAddressExpressionNoMatterWhat(pRT->GetResource());
        else
            pFaultExpr = pFault->GetResource();
        }
    else
        pFaultExpr = new expr_constant(0L);

    Out_CallNdrMapCommAndFaultStatus( pCCB,
                                      MakeAddressExpressionNoMatterWhat(
                                             pCCB->GetStandardResource(
                                                 ST_RES_STUB_MESSAGE_VARIABLE)),
                                      GetStatusResource(),
                                      pCommExpr,
                                      pFaultExpr );
    return CG_OK;
    }

CG_STATUS
CG_PROC::C_GenClearOutParams(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate code to clear out params in the case of exceptions.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

    CG_OK
    
 Notes:

    Generate a call to a varargs function which will take a stub message, a
    format string offset and a list of all output parameters.
----------------------------------------------------------------------------*/
{
    ITERATOR    I;
    expr_proc_call *   pProc;
    expr_node       *   pExpr;
    short               Count;
    CG_PARAM        *   pParam;
    ISTREAM         *   pStream = pCCB->GetStream();

    // The first parameter is the stub message.

    Count =  GetOutParamList( I );

    // For each of the output parameters, call the ndr clear out parameters
    // procedure.

    ITERATOR_INIT( I );

    while( ITERATOR_GETNEXT( I, pParam ) )
        {
        pParam->GenNdrTopLevelAttributeSupport( pCCB, TRUE );

        // Create a call to the procedure.

        pProc   = new expr_proc_call( C_NDR_CLEAR_OUT_PARAMS_RTN_NAME );

        // First param is the address of the stub message.

        pExpr   = pCCB->GetStandardResource( ST_RES_STUB_MESSAGE_VARIABLE );
        pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
        pExpr   = MakeExpressionOfCastToTypeName( PSTUB_MESSAGE_TYPE_NAME,
                                                  pExpr );
        pProc->SetParam( pExpr );


        // Second param is the  format string offset of the first out parameter.
        // Emitted as &__MIDL_FormatString[ ?? ]


        pExpr   = Make_1_ArrayExpressionFromVarName(
                                 FORMAT_STRING_STRING_FIELD,
                                 ((CG_NDR *)(pParam->GetChild()))->GetFormatStringOffset() );
        pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
        pExpr   = MakeExpressionOfCastToTypeName(
                                             PFORMAT_STRING_TYPE_NAME,
                                             pExpr);

        pProc->SetParam( pExpr );

        // The last param is the [out] parameter itself.

        pProc->SetParam( MakeCastExprPtrToVoid(pParam->GetResource()) );

        pStream->NewLine();
        pProc->PrintCall( pStream, 0, 0 );
        }

    return CG_OK;

}

CG_STATUS
CG_PROC::C_GenMapHRESULT(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generates code to map exceptions into HRESULT return values.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    ISTREAM *pStream = pCCB->GetStream();

    pStream->NewLine();
    pStream->Write("_RetVal = NdrProxyErrorHandler(RpcExceptionCode());");
    return CG_OK;
}


CG_STATUS
CG_PROC::C_GenProlog(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the procedure prolog for the stub procedure.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise

 Notes:

    Increment the stream indentation at the end of the prolog.
    Although we register params as param resources, we dont generate the
    procedure signature using the PrintType/Decl facility.
----------------------------------------------------------------------------*/
{

    ITERATOR        I;
    ITERATOR        T;

    // Output the bare procedure declaration

    Out_ClientProcedureProlog( pCCB, GetType() );

    // Generate declarations for pre-allocated and analyser-determined locals.

    pCCB->GetListOfLocalResources( I );
    Out_ClientLocalVariables( pCCB, I );

    pCCB->GetListOfTransientResources( T );
    Out_ClientLocalVariables( pCCB, T );

    // Increment the indentation of the output stream. Reset at epilog time.

    Out_IndentInc( pCCB );

    //
    // This is where we output additional variable declarations to handle
    // multidimensional conformant/varying arrays.
    //

    CG_ITERATOR Iterator;
    ISTREAM *   pStream;
    CG_PARAM *  pParam;
    CG_NDR *    pNdr;

    pStream = pCCB->GetStream();

    GetMembers( Iterator );

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

        if ( (pNdr->IsArray() && ((CG_ARRAY *)pNdr)->IsMultiConfOrVar()) ||
             (pNdr->IsPointer() && ((CG_POINTER *)pNdr)->IsMultiSize()) )
            Out_MultiDimVars( pCCB, pParam );
        }
    Iterator.Init();
    while ( ITERATOR_GETNEXT( Iterator, pParam ) )
        {
        pNdr = (CG_NDR *) pParam->GetChild();

        if ( (pNdr->IsArray() && ((CG_ARRAY *)pNdr)->IsMultiConfOrVar()) ||
             (pNdr->IsPointer() && ((CG_POINTER *)pNdr)->IsMultiSize()) )
            Out_MultiDimVarsInit( pCCB, pParam );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::C_GenBind(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate code to bind to server.

 Arguments:

    pCCB    - A pointer to the code generation controller block.
    pAna    - A pointer to the analysis information.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

    The binding process is a part of the stub message initialization. The
    stub initializing routine takes the actual binding as a parameter. The
    binding therefore is done as part of the call to this init routine. This
    routine also calls rpc get buffer. This is a change from the erstwhile
    stub generation when binding was done first before the size pass. With
    this call which takes the length as a parameter which means that now we
    will do the sizing pass before the binding pass.

    In case of auto handles, the call is a slightly different one.

    Also, we need to assign to the local buffer pointer variable only if there
    is at least one param that is shipped.

----------------------------------------------------------------------------*/
{
    ITERATOR            BindingParamList;
    expr_node       *   pExpr;
    expr_node       *   pExprStubMsg;
    BOOL                fCallBack = (GetCGID() == ID_CG_CALLBACK_PROC);

    //
    // collect standard arguments to the init procedure.
    //

    // The rpc message variable.

    pExpr   = pCCB->GetStandardResource( ST_RES_RPC_MESSAGE_VARIABLE );
    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PRPC_MESSAGE_TYPE_NAME, pExpr );

    ITERATOR_INSERT(
                    BindingParamList,
                    pExpr
                   );

    // The stub message variable.

    pExpr   = pCCB->GetStandardResource( ST_RES_STUB_MESSAGE_VARIABLE);
    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PSTUB_MESSAGE_TYPE_NAME, pExpr );
    pExprStubMsg = pExpr;
    ITERATOR_INSERT(
                    BindingParamList,
                    pExpr
                   );

    // The stub descriptor structure variable. This is not allocated as
    // a resource explicitly.

    pExpr   = new RESOURCE( pCCB->GetInterfaceCG()->GetStubDescName(),
                            (node_skl *)0 );

    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PSTUB_DESC_STRUCT_TYPE_NAME,
                                              pExpr );

    ITERATOR_INSERT( BindingParamList, pExpr );

    //
    // Proc num.
    //
    ITERATOR_INSERT( BindingParamList,
                     new expr_constant( (long) GetProcNum() ) );

    // This call doesn't do much nowadays except for generating
    // the initialize call and rpc flags assignment and so could
    // be eliminated.

    Out_HandleInitialize( pCCB,
                          BindingParamList,
                          0,
                          IsAutoHandle(),
                          (unsigned short) GetOperationBits()
                        );

    // Generate an explicit binding call depending upon the handle or callback.
    if( fCallBack )
        {
        pExpr   = new expr_proc_call( CALLBACK_HANDLE_RTN_NAME );
        pExpr   = new expr_assign( GetBindingResource(), pExpr );
        }
    else
        {
        pExpr   = GenBindOrUnBindExpression( pCCB,
                                             TRUE   // call to bind.
                                           );
        }

    // Emit the handle init expression.

    if( IsContextHandle() )
        {

        // Special for context handles:
        // The bind expression will contain only the context handle expression,
        // and not the assignment to the binding handle variable. This is to
        // be done right here. This is because some special code has to be
        // generated for context handles for error checking.

        // if the context handle param is [in] generate code of the form:
        //  if( Context_Handle != 0 )
        //      {
        //      _Handle = NdrContextBinding( Context_Handle );
        //      }
        //  else
        //      {
        //      RpcRaiseException( RPC_X_SS_IN_NULL_CONTEXT );
        //      }
        //
        // if the context handle is [in, out] then generate code of the form:
        //  if( Context_Handle != 0 )
        //      {
        //      Handle = NdrContextBinding( Context_Handle );
        //      }
        //  else
        //      {
        //      _Handle = 0;
        //      }

        // Note: The case of [out] context handle will never come here since
        // this context handle is not a binding handle, and hence will be
        // handled elsewhere.
        //

        ITERATOR    I;
        BOOL        fIn     = (SearchForBindingParam())->IsParamIn();
        BOOL        fInOut  = ((SearchForBindingParam())->IsParamOut()
                                &&
                                fIn );

        // For now assume we always have error checking on. When we get -error
        // none implemented on procs, we can set it based on that.

        BOOL        fErrorCheckReqd = pCCB->MustCheckRef();
        expr_node   *   pAss;
        expr_node   *   pContextParam   =  ((CG_NDR *)SearchForBindingParam())->
                                                GenBindOrUnBindExpression(
                                                                pCCB, TRUE );


        pExpr   =  pContextParam;
        pExpr   = MakeExpressionOfCastToTypeName( CTXT_HDL_C_CONTEXT_TYPE_NAME,
                                                pExpr
                                              );

        ITERATOR_INSERT( I, pExpr );

        pExpr   = MakeProcCallOutOfParamExprList( CTXT_HDL_BIND_RTN_NAME,
                                                  (node_skl *)0,
                                                  I
                                                );
        pAss= new expr_assign(GetBindingResource(), pExpr);

        if( !fErrorCheckReqd )
            {
            pCCB->GetStream()->NewLine();
            pAss->PrintCall( pCCB->GetStream(), 0, 0 );
            pCCB->GetStream()->Write(';');
            pCCB->GetStream()->NewLine();
            }
        else
            {
            Out_If( pCCB, new expr_relational(OP_NOT_EQUAL,
                                               pContextParam,
                                               new expr_constant(0L) ) );
            pCCB->GetStream()->NewLine();
            pAss->PrintCall( pCCB->GetStream(), 0, 0 );
            pCCB->GetStream()->Write(';');
            pCCB->GetStream()->NewLine();
            Out_Endif( pCCB );

            if( !fInOut )
                {
                Out_Else( pCCB );
                Out_RaiseException( pCCB, "RPC_X_SS_IN_NULL_CONTEXT" );
                Out_Endif( pCCB );
                }
            }
        }
    else if( pExpr )
        {
        pCCB->GetStream()->NewLine();
        pExpr->PrintCall( pCCB->GetStream(), 0, 0 );
        pCCB->GetStream()->Write(';');
        pCCB->GetStream()->NewLine();

        if ( IsGenericHandle() )
            {
            // For generic handles generate a check that the handle
            // is not null after calling user's bind routine.

            Out_If( pCCB, new expr_relational( OP_EQUAL,
                                               GetBindingResource(),
                                               new expr_constant(0L) ) );
            Out_RaiseException( pCCB, "RPC_S_INVALID_BINDING" );
            Out_Endif( pCCB );
            }
        }


    return CG_OK;
}

CG_STATUS
CG_PROC::C_GenSendReceive(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate code to call the rpc runtime sendreceive.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

     We will always call an ndr routine for the sendreceive call. This
     is so that we can unify the buffer length updating in that one call.
     The only difference is for Auto handles when we will have to call this
     with an additional parameter.
----------------------------------------------------------------------------*/
{
    PNAME               pProcName;
    expr_proc_call  *   pProc;
    expr_node       *   pExpr;
    expr_node       *   pStubMsgExpr    = pCCB->GetStandardResource(
                                            ST_RES_STUB_MESSAGE_VARIABLE );
    ITERATOR            ParamsList;

    //
    // Check if we're targeting the ndr engine.
    //
    if ( pCCB->GetOptimOption() & OPTIMIZE_SIZE )
        {
        if ( IsAutoHandle() )
            Out_NdrNsSendReceive( pCCB );
        else
            Out_NdrSendReceive( pCCB );

        return CG_OK;
        }

    // update the param list with a pointer to the stub message.

    pStubMsgExpr    = MakeAddressExpressionNoMatterWhat( pStubMsgExpr );

    ITERATOR_INSERT( ParamsList, pStubMsgExpr );

    // In case of auto handles, an additional param is reqd, viz the
    // address of the auto handle variable.

    if( IsAutoHandle() )
        {
        pExpr   = pCCB->GetStandardResource( ST_RES_AUTO_BH_VARIABLE );
        pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
        ITERATOR_INSERT( ParamsList, pExpr );
        pProcName   = AUTO_SR_NDR_RTN_NAME;
        }
    else
        {
        pProcName   = NORMAL_SR_NDR_RTN_NAME;
        }

    ITERATOR_INSERT( ParamsList,
                     new expr_variable(  STUB_MSG_BUFFER_VAR_NAME ) );

    // generate the procedure call expression.

    pProc = MakeProcCallOutOfParamExprList( pProcName,
                                            (node_skl *)0,
                                            ParamsList
                                          );

    pCCB->GetStream()->NewLine();
    pProc->PrintCall( pCCB->GetStream(), 0, 0 );

    return CG_OK;
}

CG_STATUS
CG_PROC::C_GenUnBind(
    CCB         *   pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate code to unbind from server.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

    Dont make unbind calls if not a generic handle.
----------------------------------------------------------------------------*/
{

    if( IsGenericHandle() )
        {
        ISTREAM         *   pStream = pCCB->GetStream();

        expr_proc_call  *   pUnBindCall =
                    (expr_proc_call *)GenBindOrUnBindExpression( pCCB, FALSE );

        pStream->NewLine();
        Out_If( pCCB, GetBindingResource() );
        pStream->NewLine();

        pUnBindCall->PrintCall( pStream, 0, 0 );

        Out_Endif( pCCB );
        }
    return CG_OK;
}

CG_STATUS
CG_PROC::C_GenFreeBuffer(
    CCB             *   pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate code to call runtime to free the rpc buffer.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

    The analyser will supply the binding information.

----------------------------------------------------------------------------*/
{
    if ( pCCB->GetOptimOption() & OPTIMIZE_SIZE )
        {
        Out_NdrFreeBuffer( pCCB );
        return CG_OK;
        }

    Out_NormalFreeBuffer( pCCB );
    return CG_OK;
}

CG_STATUS
CG_PROC::GenServerStub(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the server side unmarshalling stub.

 Arguments:

    pCCB    - A pointer to the code generation block.

 Return Value:

    CG_OK   if all is well
    error   otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    ANALYSIS_INFO           Analysis;
    DISPATCH_TABLE_FLAGS    Dtf;
    BOOL                    fEmitCheckStubData;

    // call_as procs need additional prototypes
    if ( pCallAsName )
        pCCB->RegisterCallAsRoutine( (node_proc *)GetType() );

    BOOL fPicklingProcOrType =  GetCGID() == ID_CG_ENCODE_PROC ||
                                GetCGID() == ID_CG_TYPE_ENCODE_PROC;

    //
    // Set the CCB code generation side.
    //
    pCCB->SetCodeGenSide( CGSIDE_SERVER );
    pCCB->SetCodeGenPhase( CGPHASE_UNMARSHALL );
    pCCB->SetOptimOption( GetOptimizationFlags() );


    Analysis.SetCurrentSide( S_SIDE );
    Analysis.SetOptimOption( pCCB->GetOptimOption() );

    // Set the analysis phase to the correct one.

    Analysis.SetCurrentPhase( ANA_PHASE_SERVER_UNMARSHALL );

    //
    // Change to -Os if needed because of number of param and/or stack size.
    //
    (void) MustUseSingleEngineCall( pCCB );
    Analysis.SetOptimOption( pCCB->GetOptimOption() );

    Analysis.SetMode( pCCB->GetMode() );
    Analysis.SetRpcSSSwitchSet( (unsigned long)pCCB->IsRpcSSSwitchSet() );


    // Preallocate param and local resources if needed. We do need at least
    // one param resource - the rpc message pointer.

    S_PreAllocateResources( &Analysis );

    // The unmarshall analysis figures out the local variables needed,
    // and their allocation type. This helps the code generator select the
    // most optimal instruction. This is performed only for [in] and [in,out]
    // params.

    UnMarshallAnalysis( &Analysis );


    // Perform the initialization analysis for the server side locals if
    // allocated for the [out] ONLY parameters.

    S_OutLocalAnalysis( &Analysis );

    // Perform this analysis so the format string is correct for server.
    // It is needed for -Oi RpcSs flag generation.

    RpcSsPackageAnalysis( &Analysis );

    // Perform InLocalAnalysis to allocate any in params( for now arrays of
    // ref pointers only) on the server side stub stack.

    InLocalAnalysis( &Analysis );

    // Perform the size analysis for the marshalling part of the stub.

    Analysis.SetCurrentPhase( ANA_PHASE_SERVER_MARSHALL );

    MarshallAnalysis( &Analysis );


    // Generate the unmarshalling code. Register this procedure with the
    // dispatch table. Copy the resource dictionary from the analysis phase
    // to be used during the code gen phase.

    char * AllocRoutineName, * FreeRoutineName;

    GetCorrectAllocFreeRoutines( pCCB,
                                 TRUE, //client
                                 &AllocRoutineName,
                                 &FreeRoutineName );


    pCCB->InitForNewProc(
                GetProcNum(),                   // procedure number
                (RPC_FLAGS)0,                   // flags, datagram etc
                (PNAME) AllocRoutineName,
                (PNAME) FreeRoutineName,
                Analysis.GetResDictDatabase()   // copy the resource database
                );

    if( HasNotify() || HasNotifyFlag() )
        GetNotifyTableOffset( pCCB );

    // Register the procedure for the dispatch table.
    // If this proc is interpreted, then the dispatch table has an
    // entry which specifies the NdrServerCall rather than the proc name itself.

    if( GetOptimizationFlags() & OPTIMIZE_INTERPRETER )
        {
        Dtf = DTF_INTERPRETER;
        }
    else
        {
        Dtf = DTF_NONE;
        }

    if ( GetCGID() == ID_CG_ENCODE_PROC )
        Dtf = (DISPATCH_TABLE_FLAGS) (Dtf | DTF_PICKLING_PROC);

    if ( GetCGID() != ID_CG_TYPE_ENCODE_PROC )
        pCCB->GetInterfaceCG()->RegisterProcedure( GetType(), Dtf );

    if ( ! fPicklingProcOrType )
        {
        if ( MustUseSingleEngineCall( pCCB ) )
            {
            if ( UseOldInterpreterMode( pCCB ) )
                {
                GenNdrOldInterpretedServerStub( pCCB );
                }

            if ( NeedsServerThunk( pCCB, CGSIDE_SERVER ) )
                {
                GenNdrThunkInterpretedServerStub( pCCB );
                }

            //
            // This will only do something for a [callback] proc when we're
            // called while generating the client side.
            //       
            MIDL_ASSERT( pCommand->IsNDRRun() || pCommand->IsNDR64Run() );

            if ( pCommand->IsNDRRun() )
               {
               GenNdrFormat( pCCB );        
               }
            else 
               {
               pCCB->GetNdr64Format()->Generate( this );
               }

            return CG_OK;
            }
        }

    pCCB->SetCGNodeContext( this );

    //
    // Always create the format string for the proc.
    //

    if ( pCommand->IsNDRRun() )
        {
        GenNdrFormat( pCCB );        
        }
    else 
        {
        pCCB->GetNdr64Format()->Generate( this );
        }

    // Dont generate the stub itself for pickling.

    if ( fPicklingProcOrType )
        return( CG_OK );

    // Generate the server side procedure prolog. This generates only the
    // server side proc signature, the locals needed and the stub descriptor
    // structure.

    // This also generates the call to server initialize routine.
    // Note, that it is out of RpcTryFinally, but this is ok as
    // we shouldn't attempt to free parameters (they haven't been
    // unmarshaled yet.

    S_GenProlog( pCCB );
    S_GenInitTopLevelStuff( pCCB );

    S_GenInitInLocals( pCCB );

    // Initialize the local variables allocated on the server side if necessary.
    // Also make the initialization call for the server side stub message which
    // updates the buffer pointer.

    // Generate the unmarshalling code.
    Out_RpcTryFinally( pCCB );

    // If the user specifies the -error stub_data to check server unmarshall
    // errors, we need to enclose the unmarshall in a try except, and in the
    // except clause, raise a bad stub data exception.

    fEmitCheckStubData  = pCCB->IsMustCheckStubDataSpecified() && !IsObject();

    if( fEmitCheckStubData )
        {
        Out_RpcTryExcept( pCCB );
        }

    if ( HasFullPtr() )
        Out_FullPointerInit( pCCB );

    // generate NdrCorrelationInitialize( _StubMsg, _NdrCorrCache, _NdrCorrCacheSize, _NdrCorrFlags );
    // normally, /deny causes a switch to /Oicf. This code will be executed when a 
    // a switch to from /Os to /Oicf is not posible
    if ( fHasDeny )
        {
        GenCorrInit( pCCB );
        }

    GenUnMarshall( pCCB );

    // generate NdrCorrelationUninitialize( _StubMsg );
    // normally, /deny causes a switch to /Oicf. This code will be executed when a 
    // a switch to from /Os to /Oicf is not posible
    if ( fHasDeny )
        {
        GenCorrPassFree( pCCB, CSTUB_CORR_PASS_RTN_NAME );
        }

    // If the check for bad stub data must be made, then generate a
    // Rpcexcept() to catch some exceptions here, and re-raise a bad
    // stub data exception for them.
    // Other exceptions would propagate unchanged.

    if( fEmitCheckStubData )
        {
        Out_CheckUnMarshallPastBufferEnd( pCCB );
        Out_RpcExcept( pCCB, "RPC_BAD_STUB_DATA_EXCEPTION_FILTER" );
        Out_RaiseException( pCCB, "RPC_X_BAD_STUB_DATA" );
        Out_RpcEndExcept( pCCB );
        }

    S_GenInitOutLocals( pCCB );

    // Generate the call to the actual manager procedure.

    S_GenCallManager( pCCB );

    S_GenInitMarshall( pCCB );

    pCCB->SetCodeGenPhase( CGPHASE_MARSHALL );

    GenSizing( pCCB );

    // Generate the server side marshall initialization.

    // Marshall the outs and return value.

    GenMarshall( pCCB );

    Out_RpcFinally( pCCB );
    if ( fHasDeny )
        {
        GenCorrPassFree( pCCB, CSTUB_CORR_FREE_RTN_NAME );
        }

    // When notify is used, guard also against an exception in freeing.
    if( HasNotify() || HasNotifyFlag() )
        {
        Out_RpcTryFinally( pCCB );
        }

    // Free anything that needs freeing.

    GenFree( pCCB );

    if( MustInvokeRpcSSAllocate())
        {
        Out_RpcSSDisableAllocate( pCCB );
        }

    if ( HasFullPtr() )
        Out_FullPointerFree( pCCB );

    // If this is a notify procedure, generate the call to the notify procedure.

    if( HasNotify() || HasNotifyFlag() )
        {
        Out_RpcFinally( pCCB );
        GenNotify( pCCB , HasNotifyFlag() );
        Out_RpcEndFinally( pCCB );
        }

    Out_RpcEndFinally( pCCB );

    // For now, just return.

    GenEpilog( pCCB );

    return CG_OK;
}

CG_STATUS
CG_PROC::S_GenInitMarshall(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the server side marshall init.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well,
    error   otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    CG_ITERATOR Iterator;
    ISTREAM *   pStream;
    CG_PARAM *  pParam;
    CG_NDR *    pNdr;

    //
    // We have to fill in the arrays that we use for handling multidimensional
    // arrays.
    //

    pStream = pCCB->GetStream();

    GetMembers( Iterator );

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

        if ( (pNdr->IsArray() && ((CG_ARRAY *)pNdr)->IsMultiConfOrVar()) ||
             (pNdr->IsPointer() && ((CG_POINTER *)pNdr)->IsMultiSize()) )
            Out_MultiDimVarsInit( pCCB, pParam );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::S_GenInitOutLocals(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the initialization of the local variables.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well,
    error   otherwise.

 Notes:

    This method performs initalization of local variables on the server side.
    Local variables may be declared in the server stub for [out] params, and
    for in parameters which cannot reuse the buffer.

    This method will also perform the stub descriptor structure initialization.
    This method will also perform the server side stub message init.
----------------------------------------------------------------------------*/
{
    CG_ITERATOR     Iter;
    CG_PARAM    *   pParam;

    if( GetMembers( Iter ) )
        {
        while( ITERATOR_GETNEXT( Iter, pParam ) )
            {
            pParam->S_GenInitOutLocals( pCCB );
            }
        }

    //
    // We have to catch initialization of returns of pointers to context
    // handles here.
    //
    if ( GetReturnType() )
        {
        GetReturnType()->S_GenInitOutLocals( pCCB );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::S_GenCallManager(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate a call to the manager routine.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   otherwise.

 Notes:

    Make a procedure node with all the parameters that need to be passed to
    the manager code. The actual expression that needs to be passed to the
    actual manager code is set up during earlier passes. This is called the
    result expression.

----------------------------------------------------------------------------*/
{
    CG_ITERATOR         I;
    PNAME               pName;
    expr_proc_call  *   pProc;
    CG_PARAM        *   pParam;
    expr_node       *   pExpr;
    expr_node       *   pReturnExpr = 0;
    CG_RETURN       *   pRT;
    char            *   pSStubPrefix    = NULL;

    pSStubPrefix = pCommand->GetUserPrefix( PREFIX_SERVER_MGR );

    if ( GetCallAsName() )
        pName   = (PNAME ) GenMangledCallAsName( pCCB );
    else if ( pSStubPrefix )
        {
        pName   = new char[ strlen(pSStubPrefix) + strlen(GetType()->GetSymName()) + 1];
        strcpy( pName, pSStubPrefix );
        strcat( pName, GetType()->GetSymName() );
        }
    else
        pName   = (PNAME ) GetType()->GetSymName();

    pProc   = new expr_proc_call( pName );

    GetMembers( I );

    while( ITERATOR_GETNEXT( I, pParam ) )
        {
        if ( pParam->IsOmittedParam() )
            continue;

        if ( ( pExpr = pParam->GetFinalExpression() ) != 0 )
            {
            CG_NDR * pChild = (CG_NDR *)pParam->GetChild();

            //
            // We have to dereference arrays because of how they are defined
            // in the stub.
            //
            if ( pChild->IsArray() )
                {
                pExpr = new expr_u_deref( pExpr );
                }
            else if( (pChild->GetCGID() == ID_CG_GENERIC_HDL ) &&
                     (((CG_NDR *)pChild->GetChild())->IsArray() )
                   )
                {
                pExpr = new expr_u_deref( pExpr );
                }

            //
            // Context handle param is handled differently.
            //
            if ( (pChild->GetCGID() == ID_CG_CONTEXT_HDL) ||
                 ((pChild->GetCGID() == ID_CG_PTR) &&
                  (((CG_NDR *)pChild->GetChild())->GetCGID() ==
                     ID_CG_CONTEXT_HDL)) )
                {
                expr_proc_call *    pCall;

                pCall = new expr_proc_call( "NDRSContextValue" );
                pCall->SetParam(
                    new expr_param(
                    new expr_variable(
                            pParam->GetResource()->GetResourceName() )) );

                expr_node * pFinal;

                if ( pChild->GetCGID() == ID_CG_CONTEXT_HDL )
                    pFinal = new expr_u_deref(pCall);
                else
                    pFinal = pCall;

                //
                // Dereference a plain context handle.
                //
                pExpr = new expr_cast( pParam->GetType()->GetChild(),
                                        pFinal );
                }

            pProc->SetParam( new expr_param( pExpr ) );
            }
        }

    if ( ( pRT = GetReturnType() ) != 0 )
        {
        pReturnExpr = pRT->GetFinalExpression();
        }

    if ( HasNotifyFlag() )
        {
        // Assign TRUE to the notify flag variable.

        expr_node * pNotifyFlag;
        expr_node * pAssignExpr;

        ISTREAM *   pStream = pCCB->GetStream();

        pNotifyFlag = new expr_variable( NOTIFY_FLAG_VAR_NAME );
        pAssignExpr = new expr_assign( pNotifyFlag,
                                       new expr_variable( "TRUE" ) );
        pStream->NewLine();
        pAssignExpr->Print( pStream );
        pStream->Write( ';' );
        pStream->NewLine();
        }

    Out_CallManager( pCCB,
                     pProc,
                     pReturnExpr,
                     (GetCGID() == ID_CG_CALLBACK_PROC)
                   );

    return CG_OK;

}
CG_STATUS
CG_PROC::S_GenInitTopLevelStuff(
    CCB *   pCCB )
    {
    CG_ITERATOR Iter;
    CG_NDR  *   pParam;

    if( GetMembers( Iter ) )
        {
        while( ITERATOR_GETNEXT( Iter, pParam ) )
            {
            pParam->S_GenInitTopLevelStuff( pCCB );
            }
        }

    if ( GetReturnType() )
        GetReturnType()->S_GenInitTopLevelStuff( pCCB );

    return CG_OK;
    }

CG_STATUS
CG_PROC::S_GenProlog(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the server side stub prolog.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

    Print out the signature, locals, the stub descriptor if needed and the
    adjust indent in anticipation of code.
----------------------------------------------------------------------------*/
{

    ITERATOR    LocalsList;
    ITERATOR    ParamsList;
    ITERATOR    TransientList;

    // Collect all the params and locals into lists ready to print.

    pCCB->GetListOfLocalResources( LocalsList );
    pCCB->GetListOfParamResources( ParamsList );
    pCCB->GetListOfTransientResources( TransientList );

    //
    // Print out the procedure signature and the local variables.
    //
    Out_ServerProcedureProlog( pCCB,
                               GetType(),
                               LocalsList,
                               ParamsList,
                               TransientList
                             );

    //
    // Done for interpretation op.  No indent needed either.
    //
    if ( pCCB->GetOptimOption() & OPTIMIZE_INTERPRETER )
        return CG_OK;

    //
    // This is where we output additional variable declarations to handle
    // multidimensional conformant/varying arrays.
    //

    CG_ITERATOR Iterator;
    ISTREAM *   pStream;
    CG_PARAM *  pParam;
    CG_NDR *    pNdr;

    pStream = pCCB->GetStream();

    GetMembers( Iterator );

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

        if ( (pNdr->IsArray() && ((CG_ARRAY *)pNdr)->IsMultiConfOrVar()) ||
             (pNdr->IsPointer() && ((CG_POINTER *)pNdr)->IsMultiSize()) )
            Out_MultiDimVars( pCCB, pParam );
        }

    pStream->NewLine();

    // Removes warning if we don't use the _Status variable.
    pStream->Write( "((void)(" RPC_STATUS_VAR_NAME "));" );
    pStream->NewLine();

    if ( HasNotifyFlag() )
        {
        // Assign FALSE to the notify flag variable.

        expr_node * pNotifyFlag;
        expr_node * pAssignExpr;

        pNotifyFlag = new expr_variable( NOTIFY_FLAG_VAR_NAME );
        pAssignExpr = new expr_assign( pNotifyFlag,
                                       new expr_variable( "FALSE" ) );
        pStream->NewLine();
        pAssignExpr->Print( pStream );
        pStream->Write( ';' );
        pStream->NewLine();
        }

    //
    // Call the NdrServerInitialize routine.
    //

    expr_proc_call  *   pCall;

    pCall = new expr_proc_call( SSTUB_INIT_RTN_NAME );

    pCall->SetParam( new expr_param (
                     new expr_variable( PRPC_MESSAGE_VAR_NAME ) ) );

    pCall->SetParam( new expr_param (
                     new expr_u_address (
                     new expr_variable( STUB_MESSAGE_VAR_NAME ) ) ) );

    pCall->SetParam( new expr_param (
                     new expr_u_address (
                     new expr_variable(
                          pCCB->GetInterfaceCG()->GetStubDescName() ) ) ) );

    pCall->PrintCall( pCCB->GetStream(), 0, 0 );
    pStream->NewLine();

    // if the rpc ss package is to be enabled, do so.

    if( MustInvokeRpcSSAllocate() )
        {
        Out_RpcSSEnableAllocate( pCCB );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::GenUnMarshall(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the unmarshalling code for the server side stub.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well,
    error   Otherwise.

 Notes:


    The new server stubs will contain an ndr transformation phase which will
    convert, in-situ, any incoming buffer that needs ndr transformations like
    big-little endian conversions, char / float transformations etc.

    Therefore the first thing the server stub does is to tranform the data into
    the correct format and then the rest of the stub can proceed as if the
    data came in little endian format.

    Currently we will use the engine to tranform the data.
----------------------------------------------------------------------------*/
{
    CG_ITERATOR         Iterator;
    ITERATOR            ParamList;
    CG_RETURN       *   pRT;
    CGSIDE              Side;
    BOOL                fReturnNeedsUnMarshall  = FALSE;
    long                ParamTotal;

    GetMembers( Iterator );

    ParamTotal = ITERATOR_GETCOUNT( Iterator );

    if ( GetReturnType() )
        ParamTotal++;

    pCCB->SetCodeGenPhase( CGPHASE_UNMARSHALL );

    // Generate a call to tranform the data into the proper endianness.

    S_XFormToProperFormat( pCCB );

    // For all [in] params, generate the unmarshalling code.

    if( (Side = pCCB->GetCodeGenSide()) == CGSIDE_CLIENT )
        GetOutParamList( ParamList );
    else
        GetInParamList( ParamList );

    if ( (Side == CGSIDE_CLIENT) && (pRT = GetReturnType()) != 0 )
        fReturnNeedsUnMarshall = TRUE;

    //
    // Output the call to check for and perform endian or other transformations
    // if needed.
    //
    if ( fReturnNeedsUnMarshall || ParamList.GetCount() )
        Out_NdrConvert( pCCB,
                        GetFormatStringParamStart(),
                        ParamTotal,
                        GetOptimizationFlags() );

    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;
        CG_PARAM    *   pS;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            // The extra fault/comm status param doesn't go on wire.

            pS = (CG_PARAM *)ITERATOR_PEEKTHIS( ParamList );

            pParam->GenUnMarshall( pCCB );
            }
        }

    // For the client side, generate the unmarshall call if there is a return
    // value.

    if( fReturnNeedsUnMarshall )
        {
        pRT->GenUnMarshall( pCCB );
        }

    return CG_OK;
}


CG_STATUS
CG_PROC::GenFree(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generates freeing code.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    CG_ITERATOR         ParamList;
    CGSIDE              Side;
    CG_RETURN       *   pRT;
    BOOL                fReturnNeedsFree    = FALSE;

    if( (Side = pCCB->GetCodeGenSide()) == CGSIDE_CLIENT )
        return CG_OK;

    // Else it's the server side

    GetMembers( ParamList );

    if ( ( pRT = GetReturnType() ) != 0 )
        fReturnNeedsFree = TRUE;

    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            pParam->GenFree( pCCB );
            }
        }

    //
    // Size the return value on the server side if needed.
    //
    if( fReturnNeedsFree )
        {
        pRT->GenFree( pCCB );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::GenNotify(
    CCB *   pCCB,
    BOOL    fHasFlag )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the notify call for the procedure.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

 Notes:

    We need to generate a call to foo_notify with all parameters, exactly
    the same as the original procedure. The return value is a void.
----------------------------------------------------------------------------*/
{
    ISTREAM *   pStream = pCCB->GetStream();

    // Create an expression for the call to the notify procedure. The name
    // of the notify procedure is the procname suffixed by _notify.

    CSzBuffer   ProcName;

    ProcName.Set( GetType()->GetSymName() );
    ProcName.Append( (fHasFlag ? NOTIFY_FLAG_SUFFIX
                               : NOTIFY_SUFFIX) );

    expr_proc_call   ProcExpr( ProcName.GetData(), 0 );
    expr_variable *  pVarNode;
    expr_param    *  pFlagParam;

    if ( fHasFlag )
        {
        pVarNode   = new expr_variable( NOTIFY_FLAG_VAR_NAME );
        pFlagParam = new expr_param( pVarNode );

        ProcExpr.SetParam( pFlagParam );
        }

    // The call expression has been made. Emit it.

    pStream->NewLine();
    ProcExpr.PrintCall( pStream, 0, 0 );
    pStream->NewLine();

    // Clean up.

    if ( fHasFlag )
        {
        delete pVarNode;
        delete pFlagParam;
        }

    return CG_OK;
}


CG_STATUS
CG_PROC::GenEpilog(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the server side epilog for the procedure.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

 Notes:

    Decrement the indent back to the initial, and emit the closing brace.
----------------------------------------------------------------------------*/
{
    if( (pCCB->GetCodeGenSide() == CGSIDE_CLIENT) && GetReturnType() )
        {
        expr_node * pExpr = new expr_variable( RETURN_VALUE_VAR_NAME );
        pCCB->GetStream()->NewLine();
        pCCB->GetStream()->Write( "return " );
        pExpr->Print( pCCB->GetStream() );
        pCCB->GetStream()->Write( ';' );
        }

    if ( (pCCB->GetCodeGenSide() == CGSIDE_SERVER) )
        {
        ISTREAM * pStream = pCCB->GetStream();

        pStream->Write( PRPC_MESSAGE_VAR_NAME "->BufferLength = " );
        pStream->NewLine();
        pStream->Spaces( STANDARD_STUB_TAB );
        pStream->Write( "(unsigned int)(" STUB_MESSAGE_VAR_NAME ".Buffer - ");
        pStream->Write( "(unsigned char *)" PRPC_MESSAGE_VAR_NAME "->Buffer);" );
        pStream->NewLine();
        }

    Out_IndentDec( pCCB );
    Out_ProcClosingBrace( pCCB );
    return CG_OK;
}


CG_STATUS
CG_PROC::GenSizing(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate sizing code.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    ITERATOR            ParamList;
    CGSIDE              Side;
    CG_RETURN       *   pRT;
    BOOL                fReturnNeedsSizing  = FALSE;
    short               ParamCount = 0;

    pCCB->GetStream()->NewLine();


    if( (Side = pCCB->GetCodeGenSide()) == CGSIDE_CLIENT )
        ParamCount = GetInParamList( ParamList );
    else
        ParamCount = GetOutParamList( ParamList );

    if ( (Side == CGSIDE_SERVER) && (pRT = GetReturnType()) != 0 )
        fReturnNeedsSizing = TRUE;

    // On the server side if there are no out params and no returns, dont
    // generate code for sizing and get buffer at all !

    if( (Side == CGSIDE_SERVER) && (ParamCount == 0) && !fReturnNeedsSizing )
        {
        return CG_OK;
        }


    //
    // Analyze all the parameters and compute the constant buffer.
    // 

    long ConstantBufferSize = 0;

    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            long ParamBufferSize = pParam->FixedBufferSize( pCCB );
            pParam->SetFixedBufferSize( ParamBufferSize );

            if (-1 != ParamBufferSize)
                ConstantBufferSize += ParamBufferSize;
            }
        }

    //
    // Size the return value on the server side if needed.
    //
    if( fReturnNeedsSizing )
        {
        long ReturnBufferSize = pRT->FixedBufferSize( pCCB );
        pRT->SetFixedBufferSize( ReturnBufferSize );
        
        if (-1 != ReturnBufferSize)
            ConstantBufferSize += ReturnBufferSize;
        }

    //
    // Init the length variable to 0.
    //

    Out_Assign( pCCB,
                new expr_variable ( STUB_MSG_LENGTH_VAR_NAME, 0 ),
                new expr_constant( ConstantBufferSize )
              );


    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            if (pParam->GetFixedBufferSize() == -1)
                pParam->GenSizing( pCCB );
            }
        }

    //
    // Size the return value on the server side if needed.
    //
    if( fReturnNeedsSizing )
        {
        if (pRT->GetFixedBufferSize() == -1)
            pRT->GenSizing( pCCB );
        }

    GenGetBuffer( pCCB );

    return CG_OK;
}


CG_STATUS
CG_PROC::GenGetBuffer(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Get the message buffer.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    if ( IsAutoHandle() && (pCCB->GetCodeGenSide() == CGSIDE_CLIENT) )
        Out_NdrNsGetBuffer( pCCB );
    else
        Out_NdrGetBuffer( pCCB );

    return CG_OK;
}


CG_STATUS
CG_PROC::GenMarshall(
    CCB             *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Server side procedure to marshall out params.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:


----------------------------------------------------------------------------*/
{
    ITERATOR            ParamList;
    CGSIDE              Side;
    CG_RETURN       *   pRT;
    BOOL                fReturnNeedsMarshall    = FALSE;

    pCCB->SetCodeGenPhase( CGPHASE_MARSHALL );

    // Generate a call to tranform the data into the proper endianness.

    S_XFormToProperFormat( pCCB );

    // For all [in] params, generate the unmarshalling code.

    if( (Side = pCCB->GetCodeGenSide()) == CGSIDE_CLIENT )
        GetInParamList( ParamList );
    else
        GetOutParamList( ParamList );

    if ( (Side == CGSIDE_SERVER) && (pRT = GetReturnType()) != 0 )
        fReturnNeedsMarshall = TRUE;

    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;
        CG_PARAM    *   pS;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            // IsExtraParam

            pS = (CG_PARAM *)ITERATOR_PEEKTHIS( ParamList );
            pParam->GenMarshall( pCCB );
            }
        }

    // For the server side, generate the marshall call if there is a return
    // value.

    if( fReturnNeedsMarshall )
        {
        pRT->GenMarshall( pCCB );
        }

    return CG_OK;
}

CG_STATUS
CG_PROC::GenRefChecks(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate ref checks for a procedure.

 Arguments:

    pCCB    - The code gen block.

 Return Value:

    CG_OK

 Notes:

----------------------------------------------------------------------------*/
{
    CG_ITERATOR         ParamList;
    CGSIDE              Side;

    // On the client side, perform ref checks for every pointer parameter.
    // On the server side, dont perform any checks at all. If it is a top
    // level ref, the stub allocates the pointee on the stack or in memory.
    // if the allocation fails, the engine will always raise an exception.
    // For embedded pointers, the engine checks anyhow.
    //
    // If the parameter is a cs tag (e.g. [cs_stag]), and the proc has 
    // a tag setting routine, the param will be allocated as a local variable
    // so we don't need to check them.

    if( (Side = pCCB->GetCodeGenSide()) == CGSIDE_CLIENT )
        {
        GetMembers( ParamList );

        if( ITERATOR_GETCOUNT( ParamList ) )
            {
            CG_PARAM    *   pParam;
    
            ITERATOR_INIT( ParamList );
    
            while( ITERATOR_GETNEXT( ParamList, pParam ) )
                {
                if( ( pCCB->GetOptimOption() & OPTIMIZE_SIZE )
                    && ( NULL == GetCSTagRoutine() || !pParam->IsSomeCSTag() ) )
                    {
                    pParam->GenRefChecks( pCCB );
                    }
                }
            }
        }
    return CG_OK;
}

CG_STATUS
CG_PROC::S_GenInitInLocals(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate in local initialization for the procedure.

 Arguments:

    pCCB    - The code gen block.

 Return Value:

    CG_OK

 Notes:

----------------------------------------------------------------------------*/
{
    ITERATOR            ParamList;

    GetInParamList( ParamList );

    if( ITERATOR_GETCOUNT( ParamList ) )
        {
        CG_PARAM    *   pParam;

        ITERATOR_INIT( ParamList );

        while( ITERATOR_GETNEXT( ParamList, pParam ) )
            {
            pParam->S_GenInitInLocals( pCCB );
            }
        }

    return CG_OK;
}

/***************************************************************************
 * parameter code generation class implementation.
 ***************************************************************************/
CG_STATUS
CG_PARAM::S_GenInitInLocals(
    CCB *   pCCB )
    {
    pCCB->SetMemoryAllocDone();
    pCCB->ResetRefAllocDone();
    pCCB->SetSourceExpression( GetResource() );
    pCCB->SetLastPlaceholderClass(this);
    ((CG_NDR *)GetChild())->S_GenInitInLocals( pCCB );
    return CG_OK;
    }

CG_STATUS
CG_PARAM::S_GenInitOutLocals(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate local initialization for the parameters.

 Arguments:

    pCCB    - A pointer to the code generation controller block.

 Return Value:

    CG_OK   if all is well
    error   Otherwise.

 Notes:

----------------------------------------------------------------------------*/
{
    
    if ( IsParamPartialIgnore() )
        {

        // Evaluate toplevel size_is.  Ignore first_is and length_is since
        // the entire data needs to be allocated and cleared.

        GenNdrTopLevelAttributeSupport( pCCB, TRUE );

        char *pParamName = GetResource()->GetResourceName();
        long FormatOffset = dynamic_cast<CG_NDR*>(GetChild())->GetFormatStringOffset();

        Out_PartialIgnoreServerInitialize( pCCB,
                                           pParamName,
                                           FormatOffset );
        return CG_OK;
        }

    else if( IsParamOut() && !IsParamIn() )
        {
        pCCB->SetMemoryAllocDone();
        pCCB->ResetRefAllocDone();
        pCCB->SetSourceExpression( GetResource() );
        pCCB->SetLastPlaceholderClass(this);
        ((CG_NDR *)GetChild())->S_GenInitOutLocals( pCCB );
        SetFinalExpression( GetResource() );
        }
    return CG_OK;
}

CG_STATUS
CG_PARAM::S_GenInitTopLevelStuff(
    CCB     *   pCCB )
    {
    ISTREAM *   pStream;
    CG_NDR *    pChild;
    ID_CG       ChildID;

    pStream = pCCB->GetStream();

    pChild = (CG_NDR *)GetChild();
    ChildID = pChild->GetCGID();

    if ( ChildID == ID_CG_GENERIC_HDL )
        {
        pChild = (CG_NDR *)pChild->GetChild();
        ChildID = pChild->GetCGID();
        }

    //
    // Initialize all [in] pointer and array params, and handle by-value
    // structures and unions.
    //
    if ( pChild->IsArray() || pChild->IsSimpleType() )
        {
        expr_node * pParam;
        expr_node *     pExpr;

        pParam = new expr_variable( GetResource()->GetResourceName() );
        pExpr = new expr_assign( pParam,
                                  new expr_constant( (long) 0 ) );

        pStream->NewLine();
        pExpr->Print( pStream );
        pStream->Write( ';' );
        }

    if ( pChild->IsPointer() )
        {
        // const type* ptr or type* const ptr
        // get initialized as (type*) ptr = 0;
        expr_node*  pParam;
        expr_node*  pExpr;
        expr_node*  pLHS;

        pParam = new expr_variable( GetResource()->GetResourceName() );

        node_skl*   pType = GetChild()->GetType();
        if ( pType != 0 && pType->NodeKind() != NODE_INTERFACE_REFERENCE )
            {
            expr_cast*  pCast = new expr_cast( pType, pParam );
            pCast->SetEmitModifiers( false );
            pLHS = pCast;
            }
        else
            {
            pLHS = pParam;
            }

        pExpr = new expr_assign( pLHS, new expr_constant( (long) 0 ) );
        pStream->NewLine();
        pExpr->Print( pStream );
        pStream->Write( ';' );
        }

    //
    // If this is a by-value structure or union then we allocate a
    // local which is a pointer to the same type.
    //
    if ( pChild->IsStruct() || pChild->IsUnion()  ||
         pChild->IsXmitRepOrUserMarshal() )
        {
        expr_node * pParam;
        expr_node * pPointer;
        expr_node *     pExpr;
        char *          pPointerName;
        char *          pPlainName = GetResource()->GetResourceName();

        pPointerName = new char[strlen( pPlainName ) + 10];

        strcpy( pPointerName, LOCAL_NAME_POINTER_MANGLE);
        strcat( pPointerName, pPlainName);

        pParam = new expr_u_address (
                 new expr_variable( pPlainName ) );

        pPointer = new expr_variable( pPointerName );

        pExpr = new expr_assign( pPointer, pParam );

        pStream->NewLine();
        pExpr->Print( pStream );
        pStream->Write( ';' );

        //
        // Memset [in], [in,out] by-value structs & unions in case we catch
        // an exception before we finish unmarshalling them.  If they have
        // embedded pointers they must be zeroed before freeing.
        //
        if ( IsParamIn() &&
             (pChild->IsStruct() || pChild->IsUnion()) )
            {
            Out_MemsetToZero( pCCB,
                              pPointer,
                              new expr_sizeof( pChild->GetType() ) );
            }

        // If there is a transmit_as etc, init the ptr to 0.

        switch( ChildID )
            {
            case ID_CG_TRANSMIT_AS:
                {
                expr_proc_call * pProc = new expr_proc_call( MIDL_MEMSET_RTN_NAME );
                pProc->SetParam( new expr_param( pPointer ) );
                pProc->SetParam( new expr_param( new expr_constant( 0L ) ) );
                pProc->SetParam(
                     new expr_param(
                       new expr_sizeof(
                        ((CG_TRANSMIT_AS *)pChild)->GetPresentedType())));
                pCCB->GetStream()->NewLine();
                pProc->PrintCall( pCCB->GetStream(), 0, 0 );
                break;
                }
            case ID_CG_REPRESENT_AS:
                {
                node_skl    *   pNode = new node_def(
                            ((CG_REPRESENT_AS *)pChild)->GetRepAsTypeName() );
                expr_proc_call * pProc = new expr_proc_call( MIDL_MEMSET_RTN_NAME  );
                pProc->SetParam( new expr_param( pPointer ) );
                pProc->SetParam( new expr_param( new expr_constant( 0L ) ) );
                pProc->SetParam( new expr_param( new expr_sizeof( pNode ) ) );
                pCCB->GetStream()->NewLine();
                pProc->PrintCall( pCCB->GetStream(), 0, 0 );
                break;
                }
            case ID_CG_USER_MARSHAL:
                {
                node_skl    *   pNode = new node_def(
                            ((CG_REPRESENT_AS *)pChild)->GetRepAsTypeName() );
                expr_proc_call * pProc = new expr_proc_call( MIDL_MEMSET_RTN_NAME  );
                pProc->SetParam( new expr_param( pPointer ) );
                pProc->SetParam( new expr_param( new expr_constant( 0L ) ) );
                pProc->SetParam( new expr_param( new expr_sizeof( pNode ) ) );
                pCCB->GetStream()->NewLine();
                pProc->PrintCall( pCCB->GetStream(), 0, 0 );
                break;
                }
            default:
                break;
            }
        }

    if ( ChildID == ID_CG_PRIMITIVE_HDL )
        {
        pStream->NewLine();
        pStream->Write( GetType()->GetSymName() );
        pStream->Write( " = " PRPC_MESSAGE_VAR_NAME "->Handle;" );
        }

    return CG_OK;
    }

CG_STATUS
CG_PARAM::GenMarshall(
    CCB     *   pCCB )
{
    CG_STATUS   Status;
    CG_NDR *    pOldPlaceholder;

    // The fault/comm additional parameter doesn't go on wire.

    if ( IsExtraStatusParam() )
        return CG_OK;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GenNdrMarshallCall( pCCB );
    Status = CG_OK;

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;
}

CG_STATUS
CG_PARAM::GenUnMarshall(
    CCB     *   pCCB )
{
    CG_STATUS       Status;
    CG_NDR      *   pOldPlaceholder;
    CG_NDR      *   pC  = (CG_NDR *)GetChild();
    BOOL            fPtrToContext = FALSE;
    expr_node   *   pFinalExpr  = GetResource();

    // The fault/comm additional parameter doesn't go on wire...
    // However, we need to generate an assignment in its place.

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    if ( pC->GetCGID() == ID_CG_CONTEXT_HDL ||
        ( (fPtrToContext = ( pC->GetChild()) != 0 && pC->GetChild()->GetCGID() == ID_CG_CONTEXT_HDL ) ) == TRUE )
        {
        expr_node      *    pExpr;
        expr_proc_call *    pProc = new expr_proc_call( "NDRSContextValue" );
        CG_CONTEXT_HANDLE * pCtxtHandle;

        pProc->SetParam( new expr_param( GetResource() ) );

        if( fPtrToContext )
            {
            pExpr   = new expr_u_deref( pProc );
            pCtxtHandle = (CG_CONTEXT_HANDLE *)pC->GetChild();
            }
        else
            {
            pExpr   = pProc;
            pCtxtHandle = (CG_CONTEXT_HANDLE *)pC;
            }

        pExpr   = new expr_cast( GetType()->GetChild(), pExpr );
        pFinalExpr = pExpr;

        // Register the context handle for a rundown.

        if( pCtxtHandle->GetHandleType()->NodeKind() == NODE_DEF )
            pCCB->RegisterContextHandleType( pCtxtHandle->GetHandleType() );
        }


    GenNdrUnmarshallCall( pCCB );
    SetFinalExpression( pFinalExpr );
    Status = CG_OK;
	
    pCCB->SetLastPlaceholderClass( pOldPlaceholder );

    return Status;
}


CG_STATUS
CG_PARAM::GenSizing(
    CCB *       pCCB )
{
    CG_STATUS   Status;
    CG_NDR *    pOldPlaceholder;

    // The fault/comm additional parameter doesn't go on wire.

    if ( IsExtraStatusParam() || IsAsyncHandleParam() )
        return CG_OK;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GenNdrBufferSizeCall( pCCB );
		
    Status = CG_OK;
		
    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;
}

CG_STATUS
CG_PARAM::GenFree(
    CCB     *   pCCB )
{
    CG_NDR *    pOldPlaceholder;

    if ( IsExtraStatusParam() )
        return CG_OK;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GenNdrFreeCall( pCCB );

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );

    return CG_OK;
}
CG_STATUS
CG_PARAM::GenRefChecks(
    CCB     *   pCCB )
{
    pCCB->ResetEmbeddingLevel();
    pCCB->ResetIndirectionLevel();
    pCCB->ResetReturnContext();
    pCCB->ResetRefAllocDone();
    pCCB->SetPrefix(0);
    pCCB->SetSourceExpression( GetResource() );
    ((CG_NDR *)GetChild())->GenRefChecks( pCCB );

    return CG_OK;
}

/*****************************************************************************
    CG_RETURN procedures.
 *****************************************************************************/
CG_STATUS
CG_RETURN::GenMarshall(
    CCB     *   pCCB )
{
    CG_NDR *    pOldPlaceholder;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GenNdrMarshallCall( pCCB );
    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;

}

CG_STATUS
CG_RETURN::GenSizing(
    CCB *   pCCB )
    {
    CG_NDR *    pOldPlaceholder;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    pCCB->SetSourceExpression( GetResource() );

  	GenNdrBufferSizeCall( pCCB );
		
    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;
    }

CG_STATUS
CG_RETURN::GenUnMarshall(
    CCB     *   pCCB )
{
    CG_NDR *    pOldPlaceholder;

    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    ISTREAM * pStream;
    
    pStream = pCCB->GetStream();

    //
    // Initialize a pointer return type to 0.
    //
    if ( GetChild()->IsPointer() )
        {
  	pStream->NewLine();
  	pStream->Write( RETURN_VALUE_VAR_NAME );
  	pStream->Write( " = 0;" );
  	}

    //
    // Initialize a struct or union return value.
    //
    if ( GetChild()->IsStruct() || GetChild()->IsUnion() ||
         ((CG_NDR *)GetChild())->IsXmitRepOrUserMarshal() )
  	{
  	pStream->NewLine();
  	pStream->Write( LOCAL_NAME_POINTER_MANGLE RETURN_VALUE_VAR_NAME );
  	pStream->Write( " = " );
  	pStream->Write( "(void *) &" RETURN_VALUE_VAR_NAME );
  	pStream->Write( ';' );
  	}

    GenNdrUnmarshallCall( pCCB );
    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;

}

CG_STATUS
CG_RETURN::S_GenInitOutLocals(
    CCB     *   pCCB )
{
    CG_NDR * pNdr;

    pNdr = (CG_NDR *) GetChild();

    //
    // The only return type we ever have to initialize is a context handle.
    // A pointer to a context handle as a return type is forbidden.
    //
    if ( pNdr->GetCGID() == ID_CG_CONTEXT_HDL )
        {
        pCCB->SetLastPlaceholderClass(this);
        pNdr->S_GenInitOutLocals( pCCB );
        }

    return CG_OK;
}

CG_STATUS
CG_RETURN::S_GenInitTopLevelStuff(
    CCB     *   pCCB )
{
    CG_NDR *    pChild;
    expr_node * pExpr;

    pChild = (CG_NDR *) GetChild();

    pExpr = new expr_u_address (
            new expr_variable( RETURN_VALUE_VAR_NAME ) );

    if ( pChild->IsStruct() || pChild->IsUnion() )
        {
        Out_MemsetToZero( pCCB,
                          pExpr,
                          new expr_sizeof( pChild->GetType() ) );
        }

    return CG_OK;
}

CG_STATUS
CG_RETURN::GenFree(
    CCB *   pCCB )
    {
    CG_NDR *    pOldPlaceholder;
    pOldPlaceholder = pCCB->SetLastPlaceholderClass( this );

    GenNdrFreeCall( pCCB );

    pCCB->SetLastPlaceholderClass( pOldPlaceholder );
    return CG_OK;
    }

expr_node *
CG_RETURN::GetFinalExpression()
    {
    expr_node * pReturnExpr;
    BOOL         fPtrToContext  = FALSE;
    CG_NDR  *    pC = (CG_NDR *)GetChild();

    if( pC->GetCGID() == ID_CG_CONTEXT_HDL ||
        ( (fPtrToContext = ( pC->GetChild()) != 0 &&
                 pC->GetChild()->GetCGID() == ID_CG_CONTEXT_HDL ) ) == TRUE )
        {
        expr_node       *   pExpr;
        expr_proc_call * pProc      = new expr_proc_call( "NDRSContextValue" );

        pProc->SetParam( new expr_param( GetResource() ) );

        // cast the proc call to this type.

        pExpr   = MakeDerefExpressionOfCastPtrToType( GetType(), pProc );

        pReturnExpr = pExpr;
        }
    else
        pReturnExpr = GetResource();

    return pReturnExpr;
    }

CG_STATUS
CG_CALLBACK_PROC::GenClientStub( CCB * pCCB )
    {
    CGSIDE  Side = pCCB->GetCodeGenSide();

    pCCB->GetInterfaceCG()->SetDispatchTBLPtrForCallback();
    pCCB->SetInCallback();
    CG_PROC::GenServerStub( pCCB );
    pCCB->ClearInCallback();
    pCCB->GetInterfaceCG()->RestoreDispatchTBLPtr();

    pCCB->SetCodeGenSide( Side );
    return CG_OK;
    }

CG_STATUS
CG_CALLBACK_PROC::GenServerStub( CCB * pCCB )
    {
    CGSIDE  Side = pCCB->GetCodeGenSide();

    pCCB->GetInterfaceCG()->SetDispatchTBLPtrForCallback();
    pCCB->SetInCallback();
    CG_PROC::GenClientStub( pCCB );
    pCCB->ClearInCallback();
    pCCB->GetInterfaceCG()->RestoreDispatchTBLPtr();
    pCCB->SetCodeGenSide( Side );
    return CG_OK;
    }

void
CG_PROC::GetCorrectAllocFreeRoutines(
    CCB *   pCCB,
    BOOL    fServer,
    char ** ppAllocName,
    char ** ppFreeName )
/*++
    Finds out correct Alloc and Free routine names, depending on the mode
    (osf vs. msft) and need to enable memory management.

    In object mode:
        use NdrOleAllocate, NdrOleFree

    In ms_ext mode and c-ext:
        unless forced to enable allocate, use MIDL_user_*

    In osf mode:
        client always uses NdrRpcSsClient*
        server use a default allocator or RpcSsAllocate.

++*/
{
    *ppAllocName = (char *) DEFAULT_ALLOC_RTN_NAME;      // MIDL_user_allocate
    *ppFreeName  = (char *) DEFAULT_FREE_RTN_NAME;       // MIDL_user_free

    if ( IsObject() )
        {
        *ppAllocName = (char *) OLE_ALLOC_RTN_NAME;      // NdrOleAllocate
        *ppFreeName  = (char *) OLE_FREE_RTN_NAME;       // NdrOleFree
        }
    else if ( MustInvokeRpcSSAllocate() )
        {
        // This means: msft mode - only when forced to enable
        //             osf  mode - when there is a need or forced to.

        if ( fServer )
            {
            *ppAllocName = (char *) RPC_SS_SERVER_ALLOCATE_RTN_NAME;
            *ppFreeName  = (char *) RPC_SS_SERVER_FREE_RTN_NAME;
            }
        else
            {
            *ppAllocName = (char *) RPC_SM_CLIENT_ALLOCATE_RTN_NAME;
            *ppFreeName  = (char *) RPC_SM_CLIENT_FREE_RTN_NAME;
            }
        }
    else
    if ( pCCB->GetMode() == 0 )
        {
        // osf, without having to enable memory manager

        if ( fServer )
            {
            *ppAllocName = (char *) DEFAULT_ALLOC_OSF_RTN_NAME;
            *ppFreeName  = (char *) DEFAULT_FREE_OSF_RTN_NAME;
            }
        else
            {
            *ppAllocName = (char *) RPC_SM_CLIENT_ALLOCATE_RTN_NAME;
            *ppFreeName  = (char *) RPC_SM_CLIENT_FREE_RTN_NAME;
            }
        }
}

void
GenCorrInit (
            CCB*    pCCB
            )
    {
    ISTREAM*    pStream         = pCCB->GetStream();
    ITERATOR    ParamList;

    // _StubMsg
    expr_node*  pExpr = pCCB->GetStandardResource( ST_RES_STUB_MESSAGE_VARIABLE );
    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PSTUB_MESSAGE_TYPE_NAME, pExpr );
    ITERATOR_INSERT( ParamList, pExpr );

    // _Cache
    pExpr  = pCCB->GetLocalResource( NDR_CORR_CACHE_VAR_NAME );
    ITERATOR_INSERT( ParamList, pExpr );
    
    // _CacheSize
    unsigned long ulSize = NDR_CORR_CACHE_SIZE * sizeof( unsigned long );
    pExpr = new expr_constant( ulSize );
    ITERATOR_INSERT( ParamList, pExpr );

    // _Flags
    pExpr = new expr_constant( unsigned long( 0 ) );
    ITERATOR_INSERT( ParamList, pExpr );

    expr_proc_call* pProcCall = MakeProcCallOutOfParamExprList  (
                                                                CSTUB_CORR_INIT_RTN_NAME,
                                                                0,
                                                                ParamList
                                                                );
    pStream->NewLine();
    pProcCall->PrintCall( pStream, 0, 0 );
    pStream->NewLine();
    }

void
GenCorrPassFree (
                CCB*    pCCB,
                char*   szRtn
                )
    {
    ISTREAM*    pStream     = pCCB->GetStream();
    expr_node*  pExpr = pCCB->GetStandardResource( ST_RES_STUB_MESSAGE_VARIABLE );

    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PSTUB_MESSAGE_TYPE_NAME, pExpr );

    ITERATOR    ParamList;
    ITERATOR_INSERT( ParamList, pExpr );

    expr_proc_call* pProcCall = MakeProcCallOutOfParamExprList  (
                                                                szRtn,
                                                                0,
                                                                ParamList
                                                                );
    pStream->NewLine();
    pProcCall->PrintCall( pStream, 0, 0 );
    pStream->NewLine();
    }