windows-nt-4.0/private/rpc/midl20/codegen/pickle.cxx

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

 Module Name:
	
    pickle.cxx

 Abstract:

    Generates stub routines to call the pickle engine.

 Notes:


 History:

    Mar-22-1994 VibhasC     Created

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

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

#include "szbuffer.h"

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

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

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

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

 Routine Description:

    Generate DCE style procedure pickling stub code.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    expr_node		*   pExpr;
    CG_ITERATOR			Iterator;
    ISTREAM         *   pStream = pCCB->GetStream();
    RESOURCE        *   pReturnResource = 0;
    CG_PARAM *			pLastParam;

    // Register this procedure as a proc-encoding procedure.

    pCCB->RegisterEncodeDecodeProc( this );

    // Generate the format strings.

    GenNdrFormatV1( pCCB );

    // Print the prolog of procedure.

    Out_ClientProcedureProlog( pCCB, GetType() );

    // If there exists a return type, declare a local resource of that
    // type.

    if( GetReturnType() )
        {
        pReturnResource = new RESOURCE( RETURN_VALUE_VAR_NAME,
                                        GetReturnType()->GetType() );
        pStream->Write( "    " );
        pReturnResource->GetType()->PrintType(
                                (PRT_PARAM_WITH_TYPE | PRT_CSTUB_PREFIX),
                                pStream,
                                (node_skl *)0 );
        pStream->Write( " " RETURN_VALUE_VAR_NAME ";" );
        pStream->NewLine();
        }

	// For alpha, we may need to emit a va_list and va_start under an #ifdef
    //
    // Emit va_start and declaration only when there are some arguments.
    // If number of args is 0 then we don't have to emit that. The reason is
    // we need to emit this stuff to force the well defined stack layout
    // only for the optimized alpha code But when there is no arguments
    // we don't care about the original stack layout as the engine code
    // won't be accessing the original stack (this happens only for top
    // level parameters that have array attributes: size_is, length_is etc
    // or the switch_is attribute)
    //

	// See if there exists the last the last parameter.

	GetMembers(Iterator);

    pLastParam = 0;
	while ( ITERATOR_GETNEXT( Iterator, pLastParam ) )
        ;

    if ( pLastParam )
        {
    	pStream->IndentDec();
	    pStream->NewLine();
    	pStream->Write( ALPHA_IFDEF );
    	pStream->IndentInc();
    	pStream->NewLine();
	
    	pStream->Write( VA_LIST_TYPE_NAME" "VLIST_VAR_NAME";" );

    	pStream->NewLine( 2 );

        //
    	// Emit "va_start( vlist, last_param_name );

	    expr_node	*	pVaExpr;

        pVaExpr = new expr_proc_call( VA_START_PROC_NAME );
        ((expr_proc_call *)pVaExpr)->SetParam( new expr_param(
							 new expr_variable( VLIST_VAR_NAME,0)));
	    pExpr = new expr_variable( pLastParam->GetType()->GetSymName(), 0 );

	    ((expr_proc_call *)pVaExpr)->SetParam( new expr_param( pExpr ) );

	    pVaExpr->PrintCall( pStream, 0, 0 );
    	pStream->IndentDec();
    	pStream->NewLine();
        pStream->Write( "#endif" );
    	pStream->NewLine();
        }

    GenMesProcEncodeDecodeCall( pCCB, 0 );

    GenEpilog( pCCB );

    return CG_OK;
}


CG_STATUS
CG_ENCODE_PROC::GenMesProcEncodeDecodeCall(
    CCB *       pCCB,
    BOOL        fAlpha )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate DCE style procedure pickling stub code.

 Arguments:

    pCCB    - The code gen controller block.
    pAlpha  - The alpha version flag (with va-list argument).

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    expr_proc_call	*   pProc;
    node_skl        *   pType;
    expr_node		*   pExpr;
    CG_ITERATOR         I;
    CG_PARAM        *   pCG;
    ISTREAM         *   pStream = pCCB->GetStream();
    PNAME               pHandleName;
    RESOURCE        *   pReturnResource = 0;


	//
    // Generate a call to the single encode proc engine call.

    pProc   = new expr_proc_call( PROC_ENCODE_DECODE_RTN_NAME );

    // Handle. If the handle is explicit, then it must be a MIDL_ES_HANDLE

    if( GetHandleUsage() == HU_EXPLICIT )
        {
        pHandleName = SearchForBindingParam()->GetName();
        pType   = MakeIDNodeFromTypeName( pHandleName,
                                          MIDL_ES_HANDLE_TYPE_NAME );
        }
    else
        {
        assert( pCCB->GetInterfaceCG()->GetImplicitHandle() != 0 );

        pType = (node_id *)pCCB->GetInterfaceCG()->GetImplicitHandle()->
                                                        GetHandleIDOrParam();
        pHandleName = pType->GetSymName();
        }

    pProc->SetParam( new expr_variable( pHandleName, pType ) );

    // Stub descriptor.

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

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

    pProc->SetParam( pExpr );

    // Offset into the format string.

    pExpr   =  Make_1_ArrayExpressionFromVarName(
                                                 PROC_FORMAT_STRING_STRING_FIELD,
                                                 GetFormatStringOffset()
                                                );
    pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
    pExpr   = MakeExpressionOfCastToTypeName( PFORMAT_STRING_TYPE_NAME, pExpr );
    pProc->SetParam( pExpr );

    // Parameters to the engine are the address of each of the parameters to
    // this procedure. If there is no parameter AND no return type, push a
    // null (0).

    if( GetMembers( I ) )
        {
        while( ITERATOR_GETNEXT( I, pCG ) )
            {
            pExpr   = new expr_variable( pCG->GetType()->GetSymName(),
                                          pCG->GetType());
            pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
            pExpr   = MakeCastExprPtrToUChar( pExpr );
            pProc->SetParam( pExpr );
            }
        }
    else if( !GetReturnType() )
        {
        pProc->SetParam( new expr_constant( 0L ) );
        }

    // If there is a return value, then set another parameter to the generated
    // procedure expression.

    if( GetReturnType() )
        {
        pReturnResource = new RESOURCE( RETURN_VALUE_VAR_NAME,
                                        GetReturnType()->GetType() );
        pExpr   = MakeAddressExpressionNoMatterWhat( pReturnResource );
        pExpr   = MakeCastExprPtrToUChar( pExpr );
        pProc->SetParam( pExpr );
        }

    if ( fAlpha )
        {
        // We wait for Bruce's comments to see if this is really necessary.
        // Right now it seems to work without this or something similar.

		pExpr = new expr_variable( VLIST_A0, 0 );
		pProc->SetParam( new expr_param( pExpr ));
		}

    // Now print the call out.

    pStream->IndentInc();
    pStream->NewLine();

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

    pStream->NewLine();

    return CG_OK;
}


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

 Routine Description:

    Generate the client side type encoding stub for this proc.

 Arguments:

    pCCB    - The code gen controller block.


 Return Value:

	CG_OK
	
 Notes:

    This proc node hanging under the encode interface node is really a dummy
    proc, put in so that the format string generator can have a placeholder
    node to look at.
----------------------------------------------------------------------------*/
{
    return ((CG_PARAM *)GetChild())->GenTypeEncodingStub( pCCB );
}

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

 Routine Description:

    Generate the client side type encoding stub for this param.

 Arguments:

    pCCB    - The code gen controller block.


 Return Value:

	CG_OK
	
 Notes:

    This param is really a dummy param, put in so that the format string
    generator can have a placeholder node to look at.
----------------------------------------------------------------------------*/
{
    CG_STATUS   Status;
    CG_NDR  *   pLast = pCCB->SetLastPlaceholderClass( this );

    Status =  ((CG_TYPE_ENCODE *)GetChild())->GenTypeEncodingStub( pCCB );

    pCCB->SetLastPlaceholderClass( pLast );

    return Status;
}


CG_STATUS
CG_TYPE_ENCODE::GenTypeEncodingStub(
    CCB     *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the pickling stubs for a given type.

 Arguments:

    pCCB    - A pointer to the code generator control block.

 Return Value:

	CG_OK
	
 Notes:

    Emit the Type_Encode(), Type_Size() and Type_Decode() routines.
    If the encode is needed, then sizing is needed too !.
----------------------------------------------------------------------------*/
{
    CG_NDR  *   pChild  = (CG_NDR *)GetChild();

    // Generate the ndr format for the types.

    if( ! pChild->IsSimpleType() )
        pChild->GenNdrFormat( pCCB );

    // Check if implicit binding exists.

    if( pCCB->GetInterfaceCG()->GetImplicitHandle() )
        {
        SetHasImplicitHandle();
        }

    // Create a resource dictionary database.

    pCCB->SetResDictDatabase( new RESOURCE_DICT_DATABASE );
    pCCB->ClearParamResourceDict();

    // If the type has [encode] on it, generate the sizing and encode routines.

    if( IsEncode() )
        {
        // Allocate standard resources for type encoding.

        AllocateEncodeResources( pCCB );

        // Generate the sizing and encode routines.

        GenTypeSize( pCCB );
        GenTypeEncode( pCCB );

        }

    pCCB->ClearParamResourceDict();

    // If the type has [decode] on it, generate the decode routine.

    if( IsDecode() )
        {
        // Allocate standard resources for type decoding.

        AllocateEncodeResources( pCCB );

        GenTypeDecode( pCCB );
        GenTypeFree( pCCB );
        }

    return CG_OK;
}


CG_STATUS
CG_TYPE_ENCODE::GenTypeSize(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the type sizing routine for the type.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    ISTREAM *   pStream = pCCB->GetStream();
    PNAME       pName;
    TYPE_ENCODE_INFO    *   pTEInfo = new TYPE_ENCODE_INFO;

    // Generate the standard prototype. This really means emit the proto of
    // the proc in the stub file. Remember, a real proc node does not exist
    // for this pickling type. So we emit a prototype by hand (so to speak).
    // The body of the function is output later,

    GenStdMesPrototype( pCCB,
                        (pName = GetType()->GetSymName()),
                        TYPE_ALIGN_SIZE_CODE,
                        HasImplicitHandle()
                      );

    pStream->NewLine();
    pStream->Write( '{' );
    pStream->IndentInc();
    pStream->NewLine();

    // The procedure body consists of a single procedure call.

    expr_proc_call *   pProc = CreateStdMesEngineProc( pCCB, TYPE_ALIGN_SIZE_CODE);

    pStream->Write( "return " );
    pProc->PrintCall( pStream, 0, 0 );

    // Terminate the procedure body.

    pStream->IndentDec();
    pStream->NewLine();
    pStream->Write( '}' );
    pStream->NewLine();

    // Register the routine with the ccb to enable emitting of prototypes.

    pTEInfo->pName = pName;
    pTEInfo->Flags = HasImplicitHandle() ? TYPE_ENCODE_WITH_IMPL_HANDLE : 0;
    pCCB->RegisterTypeAlignSize( pTEInfo );

    return CG_OK;

}


CG_STATUS
CG_TYPE_ENCODE::GenTypeEncode(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the type encoding routine for the type.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    ISTREAM *   pStream = pCCB->GetStream();
    PNAME       pName;
    TYPE_ENCODE_INFO    *   pTEInfo = new TYPE_ENCODE_INFO;

    // Generate the standard prototype. This really means emit the proto of
    // the proc in the stub file. The body of the function output later,

    GenStdMesPrototype( pCCB,
                        (pName = GetType()->GetSymName()),
                        TYPE_ENCODE_CODE,
                        HasImplicitHandle()
                      );

    pStream->NewLine();
    pStream->Write( '{' );
    pStream->IndentInc();pStream->NewLine();

    // The procedure body consists of a single procedure call.

    expr_proc_call *   pProc = CreateStdMesEngineProc( pCCB, TYPE_ENCODE_CODE);

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

    // Terminate the procedure body.

    pStream->IndentDec();
    pStream->NewLine();
    pStream->Write( '}' );
    pStream->NewLine();

    // Register the routine with the ccb to enable emitting of prototypes.

    pTEInfo->pName = pName;
    pTEInfo->Flags = HasImplicitHandle() ? TYPE_ENCODE_WITH_IMPL_HANDLE : 0;
    pCCB->RegisterTypeEncode( pTEInfo );

    return CG_OK;

}


CG_STATUS
CG_TYPE_ENCODE::GenTypeDecode(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the type sizing routine for the type.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    ISTREAM *   pStream = pCCB->GetStream();
    PNAME       pName;
    TYPE_ENCODE_INFO    *   pTEInfo = new TYPE_ENCODE_INFO;

    // Generate the standard prototype. This really means emit the proto of
    // the proc in the stub file. The body of the function output later,

    GenStdMesPrototype( pCCB,
                        ( pName = GetType()->GetSymName()),
                        TYPE_DECODE_CODE,
                        HasImplicitHandle()
                       );

    pStream->NewLine();
    pStream->Write( '{' );
    pStream->IndentInc();pStream->NewLine();

    // The procedure body consists of a single procedure call.

    expr_proc_call *   pProc = CreateStdMesEngineProc( pCCB, TYPE_DECODE_CODE);

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

    // Terminate the procedure body.

    pStream->IndentDec();
    pStream->NewLine();
    pStream->Write( '}' );
    pStream->NewLine();

    // Register the routine with the ccb to enable emitting of prototypes.

    pTEInfo->pName = pName;
    pTEInfo->Flags = HasImplicitHandle() ? TYPE_ENCODE_WITH_IMPL_HANDLE : 0;
    pCCB->RegisterTypeDecode( pTEInfo );

    return CG_OK;

}


CG_STATUS
CG_TYPE_ENCODE::GenTypeFree(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate the type freeing routine for the type.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

----------------------------------------------------------------------------*/
{
    // Currently disabled. This was a code written for Dave Straube.
    // Still under evaluation.

    if ( NO_FREEING_FOR_PICKLING )
        return CG_OK;

    ISTREAM *   pStream = pCCB->GetStream();
    PNAME       pName;
    TYPE_ENCODE_INFO    *   pTEInfo = new TYPE_ENCODE_INFO;

    // Generate the standard prototype. This really means emit the proto of
    // the proc in the stub file. The body of the function output later,

    if ( ((CG_NDR *)GetChild())->IsSimpleType() )
        return CG_OK;

    GenStdMesPrototype( pCCB,
                        ( pName = GetType()->GetSymName()),
                        TYPE_FREE_CODE,
                        HasImplicitHandle()
                       );

    pStream->NewLine();
    pStream->Write( '{' );
    pStream->IndentInc();pStream->NewLine();

    // The procedure body consists of a single procedure call.

    expr_proc_call *   pProc = CreateStdMesEngineProc( pCCB, TYPE_FREE_CODE);

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

    // Terminate the procedure body.

    pStream->IndentDec();
    pStream->NewLine();
    pStream->Write( '}' );
    pStream->NewLine();

    // Register the routine with the ccb to enable emitting of prototypes.

    pTEInfo->pName = pName;
    pTEInfo->Flags = HasImplicitHandle() ? TYPE_ENCODE_WITH_IMPL_HANDLE : 0;
    pCCB->RegisterTypeFree( pTEInfo );

    return CG_OK;
}


void
CG_TYPE_ENCODE::AllocateEncodeResources(
    CCB *   pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Allocate predefined resources for type pickling.

 Arguments:

    pCCB    - The code gen controller block.

 Return Value:

	CG_OK
	
 Notes:

    Resources are:

    1. The MIDL_ES_HANDLE if explicit binding.
    2. A pointer to the type.

    If there is no explicit binding set the implicit binding resource.
----------------------------------------------------------------------------*/
{
    node_id         *   pMidlESHandle;
    RESOURCE        *   pBindingResource;
    node_id         *   pType           = MakeIDNode( PTYPE_VAR_NAME,GetType());
    CG_INTERFACE    *   pInterfaceCG    = pCCB->GetInterfaceCG();

    // If explicit binding, then a parameter of the type MIDL_ES_HANDLE will
    // be specified by the user. This must be added to the dictionary of
    // parameter resources.

    if( !HasImplicitHandle() )
        {
        pMidlESHandle   = MakeIDNodeFromTypeName( MIDL_ES_HANDLE_VAR_NAME,
                                                  MIDL_ES_HANDLE_TYPE_NAME
                                                );
        pBindingResource = pCCB->AddParamResource(
                                                  MIDL_ES_HANDLE_VAR_NAME,
                                                  pMidlESHandle
                                                 );
        }
    else
        {

        PNAME   pName;

        // If an implicit binding has been specified, a global variable of the
        // type MIDL_ES_HANDLE will have been specified by the user. Pick that
        // up and use as the binding resource.

        assert( pCCB->GetInterfaceCG()->GetImplicitHandle() != 0 );

        pMidlESHandle =
           (node_id *)pCCB->GetInterfaceCG()->
                                GetImplicitHandle()->
                                    GetHandleIDOrParam();
        pName   = pMidlESHandle->GetSymName();

        pBindingResource = new RESOURCE( pName,
                                         MakeIDNodeFromTypeName(
                                                    pName,
                                                    MIDL_ES_HANDLE_TYPE_NAME));

        }

    SetBindingResource( pBindingResource );

    // Add a param for the type being pickled.

    pCCB->AddParamResource( PTYPE_VAR_NAME, pType );
}


expr_proc_call *
CG_TYPE_ENCODE::CreateStdMesEngineProc(
    CCB *   pCCB,
    int     Code )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Create a standard proc expression for calls to the engine for encode/decode
    or size.

 Arguments:

    pCCB        -   The code gen controller block.
    Code        -   Which can be any standard encoding services code.

 Return Value:

	CG_OK
	
 Notes:

    If the child is a base type that is being pickled, make direct calls
    to the internal apis.

----------------------------------------------------------------------------*/
{
    expr_node      *   pExpr;
    expr_proc_call *   pProc;
    PNAME               pProcName;
    CG_NDR          *   pChild  = (CG_NDR *)GetChild();
    CSzBuffer           ProcNameBuf;
    BOOL                fIsBaseType;

    fIsBaseType = pChild->IsSimpleType();

    if( fIsBaseType )
        {
        assert( Code != TYPE_FREE_CODE );

        pProcName = "SimpleType";

        ProcNameBuf.Set("NdrMes");
        ProcNameBuf.Append(pProcName);
        ProcNameBuf.Append((Code == TYPE_ALIGN_SIZE_CODE) ? "AlignSize" :
                    (Code == TYPE_ENCODE_CODE) ? "Encode" : "Decode");
//        sprintf( ProcNameBuf,
//                 "NdrMes%s%s",
//                 pProcName,
//                 (Code == TYPE_ALIGN_SIZE_CODE) ? "AlignSize" :
//                    (Code == TYPE_ENCODE_CODE) ? "Encode" : "Decode"
//               );
        pProcName = new char [strlen( ProcNameBuf) + 1];
        strcpy( pProcName, ProcNameBuf );
        }
    else
        {
        switch( Code )
            {
            case TYPE_ALIGN_SIZE_CODE   : pProcName = NDR_MES_TYPE_ALIGN_SIZE;
                break;
            case TYPE_ENCODE_CODE       : pProcName = NDR_MES_TYPE_ENCODE;
                break;
            case TYPE_DECODE_CODE       : pProcName = NDR_MES_TYPE_DECODE;
                break;
            case TYPE_FREE_CODE         : pProcName = NDR_MES_TYPE_FREE;
                break;

            default:
                assert( FALSE );
            }
        }

    pProc = new expr_proc_call( pProcName );

    // Set parameters. First the encoding handle.
    // The handle may be implicit or explicit as usual.

    pProc->SetParam( GetBindingResource() );

	if( !fIsBaseType  ||  Code == TYPE_ENCODE_CODE )
	    {
	    // Create an expression of address to the stub descriptor. Set a param
	    // of that name.
        // For base types, only encode needs that, as it may allocate memory.

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

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

        pProc->SetParam( pExpr );
        }

	if( !fIsBaseType )
	    {
        // Next parameter is the address of the format string indexed by the
        // correct offset i.e &__MIDLFormatString[ ? ].

        pExpr   =  Make_1_ArrayExpressionFromVarName(FORMAT_STRING_STRING_FIELD,
                                                     pChild->GetFormatStringOffset());
        pExpr   = MakeAddressExpressionNoMatterWhat( pExpr );
        pExpr   = MakeExpressionOfCastToTypeName( PFORMAT_STRING_TYPE_NAME, pExpr );
        pProc->SetParam( pExpr );

        }

    // The type pointer variable.

    if ( ! (fIsBaseType  &&  Code == TYPE_ALIGN_SIZE_CODE) )
        {
        pExpr = pCCB->GetParamResource( PTYPE_VAR_NAME );
        pProc->SetParam( pExpr );
        }

    // Data size for simple type encoding and decoding

    if ( fIsBaseType )
        {
        switch ( Code )
            {
            case TYPE_ALIGN_SIZE_CODE:
                break;

            case TYPE_ENCODE_CODE:
                {
                pExpr = new expr_constant( (short) pChild->GetMemorySize() );
                pProc->SetParam( pExpr );

                }
                break;

            case TYPE_DECODE_CODE:
                // We need format char because of conversion.

                pExpr = new expr_constant( (short)
                                 ((CG_BASETYPE *)pChild)->GetFormatChar() );
                pProc->SetParam( pExpr );
                break;

            default:
                assert( FALSE );
                break;
            }
        }

    return pProc;
}


void
GenStdMesPrototype(
    CCB *   pCCB,
    PNAME   TypeName,
    int     Code,
    BOOL    fImplicitHandle )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Generate a standard prototype for the type pickle routines.

 Arguments:

    pCCB            - The code gen controller block.
    PNAME           - Name of the type.
    Code            - Size / Encode / Decode code.
    fImplicitImplicitHandle - TRUE if implicit binding handle used.

 Return Value:
	
 Notes:

----------------------------------------------------------------------------*/
    {
    CSzBuffer   Buffer;
    char    *   p;

    switch( Code )
        {
        case TYPE_ALIGN_SIZE_CODE: p = "AlignSize"; break;
        case TYPE_ENCODE_CODE: p = "Encode"; break;
        case TYPE_DECODE_CODE: p = "Decode"; break;
        case TYPE_FREE_CODE:   p = "Free"; break;
        default:
            assert( FALSE );
        }

    if( fImplicitHandle )
        {
        Buffer.Set("\n");
        Buffer.Append((Code == TYPE_ALIGN_SIZE_CODE) ? "size_t" : "void");
        Buffer.Append("\n");
        Buffer.Append(TypeName);
        Buffer.Append("_");
        Buffer.Append(p);
        Buffer.Append("(\n    ");
        Buffer.Append(TypeName);
        Buffer.Append(" __RPC_FAR * ");
        Buffer.Append(PTYPE_VAR_NAME);
        Buffer.Append(")");
//        sprintf( Buffer,
//                "\n%s\n%s_%s(\n    %s __RPC_FAR * %s)",
//                (Code == TYPE_ALIGN_SIZE_CODE) ? "size_t" : "void",
//                TypeName,
//                p,
//                TypeName,
//                PTYPE_VAR_NAME );
        }
    else
        {
        Buffer.Set("\n");
        Buffer.Append((Code == TYPE_ALIGN_SIZE_CODE) ? "size_t" : "void");
        Buffer.Append("\n");
        Buffer.Append(TypeName);
        Buffer.Append("_");
        Buffer.Append(p);
        Buffer.Append("(\n    ");
        Buffer.Append(MIDL_ES_HANDLE_TYPE_NAME);
        Buffer.Append(" ");
        Buffer.Append(MIDL_ES_HANDLE_VAR_NAME);
        Buffer.Append(",\n    ");
        Buffer.Append(TypeName);
        Buffer.Append(" __RPC_FAR * ");
        Buffer.Append(PTYPE_VAR_NAME);
        Buffer.Append(")");
//        sprintf( Buffer,
//                "\n%s\n%s_%s(\n    %s %s,\n    %s __RPC_FAR * %s)",
//                (Code == TYPE_ALIGN_SIZE_CODE) ? "size_t" : "void",
//                TypeName,
//                p,
//                MIDL_ES_HANDLE_TYPE_NAME,
//                MIDL_ES_HANDLE_VAR_NAME,
//                TypeName,
//                PTYPE_VAR_NAME );
        }

    pCCB->GetStream()->Write( Buffer );
    }