windows-server-2003/com/rpc/midl/codegen/proccls.hxx

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

 Module Name:
    
    proccls.hxx

 Abstract:

    Contains definitions for procedure related code gen class definitions.

 Notes:


 History:

    VibhasC        Jul-29-1993        Created.
 ----------------------------------------------------------------------------*/
#ifndef __PROCCLS_HXX__
#define __PROCCLS_HXX__

#include "nulldefs.h"

extern "C"
    {
    #include <stdio.h>
    
    }

#include "ndrcls.hxx"
#include "bindcls.hxx"
#include "sdesc.hxx"

class CG_PARAM;
class CG_RETURN;
class CG_ENCODE_PROC;
class CG_TYPE_ENCODE_PROC;
class CG_INTERFACE;

/////////////////////////////////////////////////////////////////////////////
// the procedure code generation class.
/////////////////////////////////////////////////////////////////////////////


enum PROCKIND {
    PROC_VIRTUAL,
    PROC_PUREVIRTUAL,
    PROC_NONVIRTUAL,
    PROC_STATIC,
    PROC_DISPATCH,
    };

// Platforms for interpreter call flavors

typedef enum 
    {
    PROC_PLATFORM_X86,
    PROC_PLATFORM_V1_INTERPRETER,
    PROC_PLATFORM_IA64
    } PROC_CALL_PLATFORM;

//
// This class corresponds to a procedure specified for remoting. This class
// is responsible for gathering all the information relating to code gen for
// a procedure and generating code for it. There are 2 kinds of procedures
// known to mankind. Call and callback procedures. This class provides the
// basis for both those procedure types. Most of the functionality of the
// call and callback procedures is the same. The main difference is the side
// that the code will be generated in.
//

class CG_PROC    : public CG_NDR
    {
private:

    //
    // Flags storing information about in and out params. The fHasShippedParam
    // field specifies that at least one param exists that is shipped. This
    // is different from fHasIn, because the proc may have an [in] handle_t
    // param which does not get shipped, so no buffer allocation for that is
    // necessary, yet such a param must be generated and initialized in the
    // server stub.
    //

    unsigned long               fHasIn                : 1;
    unsigned long               fHasOut               : 1;
    unsigned long               fHasShippedParam      : 1;
    unsigned long               fHasStatuses          : 1;
    unsigned long               fHasExtraStatusParam  : 1;  // the invisible one
    unsigned long               fNoCode               : 1;
    unsigned long               fOutLocalAnalysisDone : 1;
    unsigned long               fHasFullPtr           : 1;
    unsigned long               fHasNotify            : 1;
    unsigned long               fHasNotifyFlag        : 1;
    unsigned long               fRpcSSSpecified       : 1;
    unsigned long               fMustRpcSSAllocate    : 1;
    unsigned long               fReturnsHRESULT       : 1;
    unsigned long               fHasPipes             : 1;
    unsigned long               fSupressHeader        : 1;
    unsigned long               fHasAsyncHandle       : 1;
    unsigned long               fHasDeny              : 1;
    unsigned long               fHasAsyncUUID         : 1;
    unsigned long               fHasServerCorr        : 1;
    unsigned long               fHasClientCorr        : 1;
    unsigned long               fIsBeginProc          : 1;
    unsigned long               fIsFinishProc         : 1;
    unsigned long               fHasComplexReturn     : 1;

    //
    // This is used by type info generation to determine what the FUNKIND should be
    //
    unsigned                    uProckind;

    //
    // This field specifies the usage of the handle. This information really
    // needs to be kept only with the cg_proc since the proc is entity
    // responsible for the binding.
    //

    HANDLE_USAGE                HandleUsage           : 1;

    //
    // This field keeps track of the binding handle. Refer to the binding
    // handle class definition for more info on how it is used.
    // If the handle is explicit, then this is a pointer to a cg class which
    // will be part of the param list anyhow. If the handle is implicit, then
    // this is a pointer to a separately allocated binding handle class.
    // Also, this field is used in conjunction with the HandleUsage field,
    // which specifies the usage of the binding: explicit or implicit.

    CG_HANDLE        *          pHDLClass;

    //
    // This field specifies the usage of the handle. This information really
    // needs to be kept only with the cg_proc since the proc is entity
    // responsible for the binding.
    //

    CG_PARAM        *           pHandleUsage;


    //
    // This field specifies the procedure number. The proc num is the lexical
    // sequence number of the proc specified in the idl file, not counting the
    // callback procedures which have their own lexical sequence. This field
    // is an unsigned int to match the declaration in the rpc message.
    //

    unsigned int                ProcNum;

    //
    // This field specifies the return type.
    // This is NULL if there is no return type.  Otherwise, it points to a
    // CG_RETURN node which in turn points to the CG nodes for the return
    // type.
    //

    CG_RETURN    *              pReturn;

    // the optimization flags to use for this procedure

    OPTIM_OPTION                OptimizationFlags;

    // The generated size expression generated out of the sizing pass of the
    // code generator.

    expr_node            *      pSizeExpr;

    RESOURCE             *      pBindingResource;

    RESOURCE             *      pStatusResource;

    // The stub descriptor for the procedure.

    SDESC                *      pSStubDescriptor;
    SDESC                *      pCStubDescriptor;

    long                        FormatStringParamStart;

    // the operation flags such as BROADCAST, IDEMPOTENT, etc in internal format
    unsigned int                OperationBits;

    // the call_as name, if any
    char                 *      pCallAsName;

    // pointer to MY interface node
    CG_INTERFACE         *      pMyInterfaceCG;

    short                       ContextHandleCount;

    FORMAT_STRING        *      pSavedFormatString;

    FORMAT_STRING        *      pSavedProcFormatString;

    short                       cRefSaved;

    unsigned short              uNotifyTableOffset;

    CG_PROC              *      pCallAsType;

    CG_PROC              *      pAsyncRelative;

    //
    // Specifies the international character tag-setting routine to be used 
    // for this proc.  If the proc doesn't use international characters
    // it will be NULL.
    //

    node_proc            *      pCSTagRoutine;

public:
    
    //
    // The constructor.
    //
                            CG_PROC(
                                     unsigned int   ProcNum,
                                     node_skl     * pProc,
                                     CG_HANDLE    * pBH,
                                     CG_PARAM     * pHU,
                                     BOOL           fAtLeastOneIn,
                                     BOOL           fAtLeastOneOut,
                                     BOOL           fAtLeastOneShipped,
                                     BOOL           fHasStatuses,
                                     BOOL           fHasFullPtr,
                                     CG_RETURN    * pReturn,
                                     OPTIM_OPTION   OptimFlags,
                                     unsigned short OpBits,
                                     BOOL           fDeny );

    virtual
    unsigned                GetProckind()
                                {
                                return uProckind;
                                }

    virtual
    unsigned                SetProckind(unsigned uKind)
                                {
                                return (uProckind = uKind);
                                }

    CG_PROC *               SetCallAsCG(CG_PROC * p)
                                {
                                return (pCallAsType = p);
                                }

    CG_PROC *               GetCallAsCG()
                                {
                                return (pCallAsType);
                                }
    //
    // Generate typeinfo
    //
    virtual
    CG_STATUS               GenTypeInfo( CCB * pCCB);

    void                    SetRpcSSSpecified( unsigned long f )
                                {
                                fRpcSSSpecified = f;
                                }

    BOOL                    IsRpcSSSpecified()
                                {
                                return (BOOL)( fRpcSSSpecified == 1 );
                                }

    void                    SetMustInvokeRpcSSAllocate( unsigned long f )
                                {
                                fMustRpcSSAllocate = f;
                                }

    BOOL                    MustInvokeRpcSSAllocate()
                                {
                                return (BOOL)fMustRpcSSAllocate;
                                }

    void                    SetOutLocalAnalysisDone()
                                {
                                fOutLocalAnalysisDone = 1;
                                }
    BOOL                    IsOutLocalAnalysisDone()
                                {
                                return (BOOL)( fOutLocalAnalysisDone == 1);
                                }

    RESOURCE           *    SetStatusResource( RESOURCE * pR )
                                {
                                return (pStatusResource = pR);
                                }

    RESOURCE           *    GetStatusResource()
                                {
                                return pStatusResource;
                                }
    RESOURCE           *    SetBindingResource( RESOURCE * pR )
                                {
                                return (pBindingResource = pR);
                                }

    RESOURCE           *    GetBindingResource()
                                {
                                return pBindingResource;
                                }

    SDESC              *    SetSStubDescriptor( SDESC * pSD )
                                {
                                return (pSStubDescriptor = pSD );
                                }

    SDESC              *    GetSStubDescriptor()
                                {
                                return pSStubDescriptor;
                                }

    SDESC              *    SetCStubDescriptor( SDESC * pSD )
                                {
                                return (pCStubDescriptor = pSD );
                                }

    SDESC              *    GetCStubDescriptor()
                                {
                                return pCStubDescriptor;
                                }

    OPTIM_OPTION            SetOptimizationFlags( OPTIM_OPTION  Opt )
                                {
                                return (OptimizationFlags = Opt );
                                }

    OPTIM_OPTION            GetOptimizationFlags()
                                {
                                return OptimizationFlags;
                                }

    unsigned int            SetOperationBits( unsigned int OpBits )
                                {
                                return (OperationBits = OpBits );
                                }

    unsigned int            GetOperationBits()
                                {
                                return OperationBits;
                                }

    void                    GetCommAndFaultOffset( CCB * pCCB,
                                                   long & CommOffset,
                                                   long & FaultOffset );

    void                    SetNoCode()
                                {
                                fNoCode = TRUE;
                                }

    BOOL                    IsNoCode()
                                {
                                return fNoCode;
                                }

    void                    SetHasNotify()
                                {
                                fHasNotify = TRUE;
                                }

    void                    SetHasNotifyFlag()
                                {
                                fHasNotifyFlag = TRUE;
                                }

    BOOL                    HasNotify()
                                {
                                return fHasNotify;
                                }

    BOOL                    HasNotifyFlag()
                                {
                                return fHasNotifyFlag;
                                }

    void                    SetReturnsHRESULT()
                                {
                                fReturnsHRESULT = TRUE;
                                }

    BOOL                    ReturnsHRESULT()
                                {
                                return fReturnsHRESULT;
                                }

    void                    SetHasAsyncHandle()
                                {
                                fHasAsyncHandle = TRUE;
                                }

    BOOL                    HasAsyncHandle()
                                {
                                return fHasAsyncHandle;
                                }

    void                    SetHasAsyncUUID()
                                {
                                fHasAsyncUUID = TRUE;
                                }

    BOOL                    HasAsyncUUID()
                                {
                                return fHasAsyncUUID;
                                }

    void                    SetHasServerCorr()
                                {
                                fHasServerCorr = TRUE;
                                }

    BOOL                    HasServerCorr()
                                {
                                return fHasServerCorr;
                                }

    void                    SetHasClientCorr()
                                {
                                fHasClientCorr = TRUE;
                                }

    BOOL                    HasClientCorr()
                                {
                                return fHasClientCorr;
                                }

    void                    SetHasDeny()
                                {
                                fHasDeny = TRUE;
                                }

    BOOL                    HasDeny()
                                {
                                return fHasDeny;
                                }

    virtual
    CG_STATUS               Pass1( ANALYSIS_INFO * )
                                {
                                return CG_OK;
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_PROC;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                                {
                                pVisitor->Visit( this );
                                }

    virtual
    BOOL                    IsProc()
                                {
                                return TRUE;
                                }

    virtual
    BOOL                    IsInherited()
                                {
                                return FALSE;
                                }

    virtual
    BOOL                    IsDelegated()
                                {
                                return FALSE;
                                }

    //
    // Get and set methods.
    //
    
    void                    SetFormatStringParamStart( long Offset )
                                {
                                FormatStringParamStart = Offset;
                                }

    long                    GetFormatStringParamStart()
                                {
                                return FormatStringParamStart;
                                }

    expr_node          *    SetSizeExpression( expr_node * pE )
                                {
                                return ( pSizeExpr = pE );
                                }

    expr_node          *    GetSizeExpression()
                                {
                                return pSizeExpr;
                                }

    unsigned int            SetProcNum( unsigned int ProcNumber )
                                {
                                return (ProcNum = ProcNumber);
                                }

    virtual
    unsigned int            GetProcNum()
                                {
                                return ProcNum;
                                }

    short                   GetFloatArgMask( CCB * pCCB );

    void                    SetContextHandleCount( short c )
                                {
                                ContextHandleCount = c;
                                }

    short                   GetContextHandleCount()
                                {
                                return ContextHandleCount;
                                }

    CG_HANDLE          *    SetHandleClassPtr( CG_HANDLE * pHC )
                                {
                                return (pHDLClass = pHC);
                                }

    CG_HANDLE          *    GetHandleClassPtr()
                                {
                                return pHDLClass;
                                }

    CG_PARAM           *    SetHandleUsagePtr( CG_PARAM * pHU )
                                {
                                return (pHandleUsage = pHU);
                                }

    CG_PARAM           *    GetHandleUsagePtr()
                                {
                                return pHandleUsage;
                                }

    HANDLE_USAGE            GetHandleUsage()
                                {
                                return (pHandleUsage)
                                            ? HU_EXPLICIT
                                            : HU_IMPLICIT;
                                }

    CG_RETURN          *    SetReturnType( CG_RETURN * pRT )
                                {
                                return (pReturn = pRT);
                                }

    CG_RETURN          *    GetReturnType()
                                {
                                return pReturn;
                                }

    void                    SetHasComplexReturnType()
                                {
                                fHasComplexReturn = 1;
                                }

    BOOL                    HasComplexReturnType()
                                {
                                return fHasComplexReturn;
                                }

    CG_INTERFACE       *    SetInterfaceNode( CG_INTERFACE * pIntf )
                                {
                                return (pMyInterfaceCG = pIntf);
                                }

    CG_INTERFACE       *    GetInterfaceNode()
                                {
                                return pMyInterfaceCG;
                                }

    char               *    GetInterfaceName();

    char               *    SetCallAsName( char * pName );

    char               *    GetCallAsName()
                                {
                                return pCallAsName;
                                }

    char               *    GenMangledCallAsName( CCB * pCCB )
                                {
                                char * pName = new char[62];

                                strcpy( pName, pCCB->GetInterfaceName() );
                                strcat( pName, pCCB->GenMangledName() );
                                strcat( pName, "_" );
                                strcat( pName, pCallAsName );
                                return pName;
                                }

    void                    SetHasAtLeastOneShipped()
                                {
                                fHasShippedParam = 1;
                                }

    void                    ResetHasAtLeastOneShipped()
                                {
                                fHasShippedParam = 0;
                                }

    void                    SetHasAtLeastOneIn()
                                {
                                fHasIn = 1;
                                }

    void                    SetHasAtLeastOneOut()
                                {
                                fHasOut = 1;
                                }

    void                    ResetHasAtLeastOneIn()
                                {
                                fHasIn = 0;
                                }

    void                    ResetHasAtLeastOneOut()
                                {
                                fHasOut = 0;
                                }

    BOOL                    HasAtLeastOneShipped()
                                {
                                return (BOOL)(fHasShippedParam == 1);
                                }

    BOOL                    HasAtLeastOneIn()
                                {
                                return (BOOL)(fHasIn == 1);
                                }

    BOOL                    HasAtLeastOneOut()
                                {
                                return (BOOL)(fHasOut == 1);
                                }

    BOOL                    HasPipes()
                                {
                                return (BOOL)(fHasPipes == 1);
                                }

    BOOL                    SetHasPipes(BOOL f);

    BOOL                    SupressHeader()
                                {
                                return (BOOL)(1 == fSupressHeader);
                                }
    
    void                    SetSupressHeader()
                                {
                                fSupressHeader = TRUE;
                                }

    virtual
    BOOL                    HasStatuses()
                                {
                                return (BOOL)(fHasStatuses);
                                }

    BOOL                    HasExtraStatusParam()
                                {
                                return ( fHasExtraStatusParam );
                                }

    void                    SetHasExtraStatusParam()
                                {
                                fHasExtraStatusParam = TRUE;
                                }

    BOOL                    HasFullPtr()
                                {
                                return ( fHasFullPtr );
                                }

    BOOL                    SetHasFullPtr( BOOL f )
                                {
                                return ( fHasFullPtr = f );
                                }

    BOOL                    HasReturn()
                                {
                                return (BOOL)(pReturn != NULL);
                                }

    BOOL                    HasOuts()
                                {
                                return (HasAtLeastOneOut() || HasReturn());
                                }

    BOOL                    HasInterpreterDeferredFree();

    BOOL                    IsNullCall()    
                                {
                                return (!HasAtLeastOneIn() &&
                                        !HasAtLeastOneOut()&&
                                        !HasReturn()
               );
                                }

    virtual
    BOOL                    HasEncode()
                                {
                                return FALSE;
                                }
    virtual
    BOOL                    HasDecode()
                                {
                                return FALSE;
                                }
    virtual
    BOOL                    HasAPicklingAttribute()
                                {
                                return FALSE;
                                }

    void                    SetAsyncRelative( CG_PROC *pAsync )
                                {
                                pAsyncRelative = pAsync;
                                }
    CG_PROC *               GetAsyncRelative() 
                                {
                                return pAsyncRelative;
                                }
    void                    SetIsBeginProc()
                                {
                                fIsBeginProc = TRUE;
                                }
    BOOL                    IsBeginProc()
                                {
                                return fIsBeginProc;
                                }

    void                    SetIsFinishProc()
                                {
                                fIsFinishProc = TRUE;
                                }
    BOOL                    IsFinishProc()
                                {
                                return fIsFinishProc;
                                }

    void                    SetCSTagRoutine( node_proc *p )
                                {
                                pCSTagRoutine = p;
                                }

    node_proc *             GetCSTagRoutine()
                                {
                                return pCSTagRoutine;
                                }

    unsigned short          GetNotifyTableOffset( CCB *pCCB )
                                {
                                uNotifyTableOffset = pCCB->RegisterNotify(this);
                                return uNotifyTableOffset;
                                }
    //
    // Queries.
    //

    virtual
    BOOL                    IsAutoHandle()
                                {
                                return (GetHandleClassPtr() == 0);
                                }

    virtual
    BOOL                    IsPrimitiveHandle()
                                {
                                return (!IsAutoHandle()) && GetHandleClassPtr()->IsPrimitiveHandle();
                                }

    virtual
    BOOL                    IsGenericHandle()
                                {
                                return (!IsAutoHandle()) && GetHandleClassPtr()->IsGenericHandle();
                                }

    virtual
    BOOL                    IsContextHandle()
                                {
                                return (!IsAutoHandle()) && GetHandleClassPtr()->IsContextHandle();
                                }

    //
    // Generate the client and server stubs.
    //

    virtual
    CG_STATUS               GenClientStub( CCB * pCCB );
    
    //
    // This method does size calculation analysis for the client side
    // marshalling.
    //

    //
    // This method performs binding related analysis on the client side.
    //

    virtual
    CG_STATUS               C_BindingAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               RefCheckAnalysis( ANALYSIS_INFO * pAna );

    //
    // Unmarshalling analysis for the server side.
    //

    // This pair of methods generates the prolog and epilog for the client
    // side marshall.
    //

    virtual
    CG_STATUS               C_GenProlog( CCB * pCCB );

    virtual
    CG_STATUS               C_GenBind( CCB * pCCB );

    virtual
    CG_STATUS               GenSizing( CCB * pCCB );

    virtual
    CG_STATUS               GenGetBuffer( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitMarshall( CCB * pCCB );

    virtual
    CG_STATUS               GenMarshall( CCB * pCCB );

    virtual
    CG_STATUS               C_GenSendReceive( CCB * pCCB );

    virtual
    CG_STATUS               GenUnMarshall( CCB * pCCB );

    virtual
    CG_STATUS               C_GenUnBind( CCB * pCCB );

    virtual
    CG_STATUS               GenFree( CCB * pCCB );

    virtual
    CG_STATUS               C_GenFreeBuffer( CCB * pCCB );

    virtual
    CG_STATUS               GenEpilog( CCB * pCCB );

    virtual
    CG_STATUS               GenServerStub( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitOutLocals( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitTopLevelStuff( CCB * pCCB );

    virtual
    CG_STATUS               S_GenProlog( CCB * pCCB );

    //
    // Format string routines for generating the format string and
    // the NDR calls.
    //

    virtual
    void                    GenNdrFormat( CCB * pCCB );

    void                    GenNdrFormatV1( CCB * pCCB );

    void                    SetupFormatStrings( CCB * pCCB );

    void                    UnsetupFormatStrings( CCB * pCCB );

    void                    GenNdrFormatProcInfo( CCB * pCCB );

    //
    // This routine generates the code for the "one call" Ndr case on the
    // client side.
    //
    virtual
    void                    GenNdrSingleClientCall( CCB * pCCB );

    expr_node        *      GenCoreNdrSingleClientCall( CCB * pCCB,
                                                        PROC_CALL_PLATFORM Platform );

    //
    // This routine generates the code for the "one call" Ndr case on the
    // server side.  It's actually 3 calls, but who's counting.
    //
    virtual
    void                    GenNdrSingleServerCall( CCB * pCCB );

    //
    // Outputs an old style "three call" server stub.
    //
    void                    GenNdrOldInterpretedServerStub( CCB * pCCB );

    //
    // Outputs a thunk stub to call the server routine.  Thunk stub is called
    // from the interpreter, not the rpc runtime.
    //
    void                    GenNdrThunkInterpretedServerStub( CCB * pCCB );

    //
    // Outputs the locals for interpreted server stubs.
    //
    void                    GenNdrInterpretedServerLocals( CCB * pCCB );

    //
    // Outputs the param struct for interpreted server stubs.
    //
    void                    GenNdrInterpreterParamStruct(
                                    CCB * pCCB);

    void                    GenNdrInterpreterParamStruct32(
                                    CCB * pCCB );

    void                    GenNdrInterpreterParamStruct64(
                                    CCB * pCCB);

    //
    // Outputs the call to the manager routine for interpreted server stubs.
    //
    virtual
    void                    GenNdrInterpretedManagerCall( CCB * pCCB );

    virtual
    CG_STATUS               C_XFormToProperFormat( CCB *  )
                                {
                                return CG_OK;
                                }
    virtual
    CG_STATUS               S_XFormToProperFormat( CCB *  )
                                {
                                return CG_OK;
                                }

    virtual
    CG_STATUS               S_GenCallManager( CCB * pCCB );


    //
    // Queries.
    //

    BOOL                    MustUseSingleEngineCall( CCB * pCCB );

    BOOL                    UseOldInterpreterMode( CCB * pCCB );

    BOOL                    NeedsServerThunk( CCB *     pCCB,
                                              CGSIDE    Side );

    //
    // miscellaneous methods.
    //

    // Oi stack size, includes the return type.

    long                    GetTotalStackSize( CCB  * pCCB );

    //
    // This method registers pre-allocated stub resources like the params,
    // standard local variables etc, with the corresponding resource dictionary
    // in the analysis block.
    //

    void                    C_PreAllocateResources( ANALYSIS_INFO * );

    virtual
    void                    S_PreAllocateResources( ANALYSIS_INFO * );

    virtual
    expr_node          *    GenBindOrUnBindExpression( CCB * pCCB, BOOL fBind );


    short                   GetInParamList( ITERATOR& );


    short                   GetOutParamList( ITERATOR& );


    CG_PARAM           *    SearchForBindingParam()
                                {
                                return (CG_PARAM *)GetHandleUsagePtr();
                                }

    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               SizeAnalysis( ANALYSIS_INFO *  )
                                {
                                return CG_OK;
                                }

    virtual
    CG_STATUS               UnMarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               S_OutLocalAnalysis( ANALYSIS_INFO * pAna );

    void                    RpcSsPackageAnalysis( ANALYSIS_INFO * pAna );

    CG_STATUS               C_GenMapCommAndFaultStatus( CCB * pCCB );

    CG_STATUS               C_GenMapHRESULT( CCB * pCCB );

    CG_STATUS               C_GenClearOutParams( CCB * pCCB );

    virtual
    CG_STATUS               GenRefChecks( CCB * pCCB );

    virtual
    CG_STATUS               InLocalAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               S_GenInitInLocals( CCB * pCCB );

    unsigned int            TranslateOpBitsIntoUnsignedInt();

    void                    GetCorrectAllocFreeRoutines(
                                CCB *    pCCB,
                                BOOL     fServer,
                                char **  pAllocRtnName,
                                char **  pFreeRtnName );

    CG_STATUS               GenNotify( CCB * pCCB, BOOL fHasFlag );

    };

/////////////////////////////////////////////////////////////////////////////
// the callback proc code generation class.
/////////////////////////////////////////////////////////////////////////////
//
// this is derived from the regular proc class

class CG_CALLBACK_PROC: public CG_PROC
    {

public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_CALLBACK_PROC(
                                         unsigned int ProcNum,
                                         node_skl     * pProc,
                                         CG_HANDLE    * pBH,
                                         CG_PARAM     * pHU,
                                         BOOL           fAtLeastOneIn,
                                         BOOL           fAtLeastOneOut,
                                         BOOL           fAtLeastOneShipped,
                                         BOOL           fHasStatuses,
                                         BOOL           fHasFullPtr,
                                         CG_RETURN    * pRT,
                                         OPTIM_OPTION   OptimFlags,
                                         unsigned short OpBits,
                                         BOOL           fDeny )
                                : CG_PROC( ProcNum,
                                           pProc,
                                           pBH,
                                           pHU,
                                           fAtLeastOneIn,
                                           fAtLeastOneOut,
                                           fAtLeastOneShipped,
                                           fHasStatuses,
                                           fHasFullPtr,
                                           pRT,
                                           OptimFlags,
                                           OpBits,
                                           fDeny )
                                {
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_CALLBACK_PROC;
                                }
    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                               {
                               pVisitor->Visit( this );
                               }

    CG_STATUS               GenClientStub( CCB * pCCB );

    CG_STATUS               GenServerStub( CCB * pCCB );

    
    virtual
    BOOL                    IsAutoHandle()
                                {
                                return FALSE;
                                }
    virtual
    BOOL                    IsPrimitiveHandle()
                                {
                                return FALSE;
                                }
    virtual
    BOOL                    IsGenericHandle()
                                {
                                return FALSE;
                                }
    virtual
    BOOL                    IsContextHandle()
                                {
                                return FALSE;
                                }
    };

/////////////////////////////////////////////////////////////////////////////
// the object proc code generation classes.
/////////////////////////////////////////////////////////////////////////////
//
// this is derived from the regular proc class

class CG_OBJECT_PROC: public CG_PROC
    {

public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_OBJECT_PROC(
                                         unsigned int   ProcNum,
                                         node_skl     * pProc,
                                         CG_HANDLE    * pBH,
                                         CG_PARAM     * pHU,
                                         BOOL           fAtLeastOneIn,
                                         BOOL           fAtLeastOneOut,
                                         BOOL           fAtLeastOneShipped,
                                         BOOL           fHasStatuses,
                                         BOOL           fHasFullPtr,
                                         CG_RETURN    * pRT,
                                         OPTIM_OPTION   OptimFlags,
                                         unsigned short OpBits,
                                         BOOL           fDeny)
                                : CG_PROC( ProcNum,
                                           pProc,
                                           pBH,
                                           pHU,
                                           fAtLeastOneIn,
                                           fAtLeastOneOut,
                                           fAtLeastOneShipped,
                                           fHasStatuses,
                                           fHasFullPtr,
                                           pRT,
                                           OptimFlags,
                                           OpBits,
                                           fDeny )
                                {
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_OBJECT_PROC;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                                {
                                pVisitor->Visit( this );
                                }
    virtual
    BOOL                    IsObject()
                                {
                                return TRUE;
                                }

    virtual
    BOOL                    IsLocal()
                                {
                                return FALSE;
                                }

    //
    // miscellaneous methods.
    //

    //
    // This method registers pre-allocated stub resources like the params,
    // standard local variables etc, with the corresponding resource dictionary
    // in the analysis block.
    //


    virtual
    CG_STATUS               C_GenProlog( CCB * pCCB );

    virtual
    CG_STATUS               C_GenBind( CCB * pCCB );

    virtual
    CG_STATUS               GenGetBuffer( CCB * pCCB );

    virtual
    CG_STATUS               C_GenSendReceive( CCB * pCCB );

    virtual
    CG_STATUS               C_GenFreeBuffer( CCB * pCCB );

    virtual
    CG_STATUS               C_GenUnBind( CCB * pCCB );

    virtual
    void                    S_PreAllocateResources( ANALYSIS_INFO * );

    virtual
    CG_STATUS               S_GenProlog( CCB * pCCB );

    virtual
    CG_STATUS               S_GenCallManager( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitMarshall( CCB * pCCB );

    //
    // Outputs the call to the manager routine for interpreted server stubs.
    //
    virtual
    void                    GenNdrInterpretedManagerCall( CCB * pCCB );

    CG_STATUS               PrintVtableEntry( CCB * pCCB);

    void                    Out_ServerStubProlog( CCB *     pCCB,
                                                  ITERATOR& LocalsList,
                                                  ITERATOR& TransientList );

    void                    Out_ProxyFunctionPrototype(CCB *pCCB, PRTFLAGS F );

    void                    Out_StubFunctionPrototype(CCB *pCCB);

    CG_STATUS               GenCMacro(CCB * pCCB );

    CG_STATUS               GenComClassMemberFunction( CCB * pCCB );

    CG_STATUS               ReGenComClassMemberFunction( CCB * pCCB );

    virtual
    BOOL                    IsDelegated()
                                {
                                return FALSE;
                                }

    void                    OutProxyRoutineName( ISTREAM * pStream,
                                                 BOOL      fForcesDelegation );

    void                    OutStubRoutineName( ISTREAM * pStream );

    BOOL                    IsStublessProxy();

    };

// the class for inherited object procs

class CG_INHERITED_OBJECT_PROC: public CG_OBJECT_PROC
    {


public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_INHERITED_OBJECT_PROC(
                                         unsigned int   ProcNum,
                                         node_skl     * pProc,
                                         CG_HANDLE    * pBH,
                                         CG_PARAM     * pHU,
                                         BOOL           fAtLeastOneIn,
                                         BOOL           fAtLeastOneOut,
                                         BOOL           fAtLeastOneShipped,
                                         BOOL           fHasStatuses,
                                         BOOL           fHasFullPtr,
                                         CG_RETURN    * pRT,
                                         OPTIM_OPTION   OptimFlags,
                                         unsigned short OpBits,
                                         BOOL           fDeny )
                                : CG_OBJECT_PROC( ProcNum,
                                                  pProc,
                                                  pBH,
                                                  pHU,
                                                  fAtLeastOneIn,
                                                  fAtLeastOneOut,
                                                  fAtLeastOneShipped,
                                                  fHasStatuses,
                                                  fHasFullPtr,
                                                  pRT,
                                                  OptimFlags,
                                                  OpBits,
                                                  fDeny )
                                {
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_INHERITED_OBJECT_PROC;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                                {
                                pVisitor->Visit( this );
                                }

    //
    // miscellaneous methods.
    //

    virtual
    BOOL                    IsInherited()
                                {
                                return TRUE;
                                }


    virtual
    BOOL                    IsDelegated()
                                {
                                return TRUE;
                                }


    //
    // This method registers pre-allocated stub resources like the params,
    // standard local variables etc, with the corresponding resource dictionary
    // in the analysis block.
    //

    };

// the class for local object procs, whether inherited or not

class CG_LOCAL_OBJECT_PROC: public CG_OBJECT_PROC
    {

    BOOL                fInherited;

public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_LOCAL_OBJECT_PROC(
                                         unsigned int   ProcNum,
                                         node_skl   *   pProc,
                                         BOOL           fInh,
                                         OPTIM_OPTION   OptimFlags,
                                         BOOL           fDeny )
                                : CG_OBJECT_PROC( ProcNum,
                                                  pProc,
                                                  NULL,
                                                  NULL,
                                                  0,
                                                  0,
                                                  0,
                                                  0,
                                                  0,
                                                  NULL,
                                                  OptimFlags,
                                                  0,
                                                  fDeny )
                                {
                                fInherited = fInh;
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_LOCAL_OBJECT_PROC;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                                {
                                pVisitor->Visit( this );
                                }
    //
    // miscellaneous methods.
    //
    virtual
    BOOL                    IsInherited()
                                {
                                return fInherited;
                                }

    virtual
    CG_STATUS               GenClientStub( CCB * )
                                {
                                return CG_OK;
                                }

    virtual
    CG_STATUS               GenServerStub( CCB * )
                                {
                                return CG_OK;
                                }

    virtual
    BOOL                    IsDelegated()
                                {
                                return TRUE;
                                }

      virtual
    BOOL                    IsLocal()
                                {
                                return TRUE;
                                }


    };

class CG_IUNKNOWN_OBJECT_PROC : public CG_LOCAL_OBJECT_PROC
    {

public:
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_IUNKNOWN_OBJECT_PROC(
                                                     unsigned int   ProcNum,
                                                     node_skl*      pProc,
                                                     BOOL           fInh,
                                                     OPTIM_OPTION   OptimFlags,
                                                     BOOL           fDeny )
                                : CG_LOCAL_OBJECT_PROC( ProcNum,
                                                        pProc,
                                                        fInh,
                                                        OptimFlags,
                                                        fDeny )
                                {
                                }

    virtual
    void                        Visit( CG_VISITOR *pVisitor )
                                    {
                                    pVisitor->Visit( this );
                                    }
    virtual
    BOOL                    IsDelegated()
                                {
                                return FALSE;
                                }

    };

/////////////////////////////////////////////////////////////////////////////
// the encode proc code generation class.
/////////////////////////////////////////////////////////////////////////////
//
// this is derived from the regular proc class

class CG_ENCODE_PROC: public CG_PROC
    {

    BOOL            fHasEncode;
    BOOL            fHasDecode;

public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_ENCODE_PROC(
                                            unsigned int    ProcNum,
                                            node_skl     *  pProc,
                                            CG_HANDLE    *  pBH,
                                            CG_PARAM     *  pHU,
                                            BOOL            fAtLeastOneIn,
                                            BOOL            fAtLeastOneOut,
                                            BOOL            fAtLeastOneShipped,
                                            BOOL            fHasStatuses,
                                            BOOL            fHasFullPtr,
                                            CG_RETURN    *  pRT,
                                            OPTIM_OPTION    OptimFlags,
                                            unsigned short  OpBits,
                                            BOOL            fEncode,
                                            BOOL            fDecode,
                                            BOOL            fDeny )
                                : CG_PROC( ProcNum,
                                           pProc,
                                           pBH,
                                           pHU,
                                           fAtLeastOneIn,
                                           fAtLeastOneOut,
                                           fAtLeastOneShipped,
                                           fHasStatuses,
                                           fHasFullPtr,
                                           pRT,
                                           OptimFlags,
                                           OpBits,
                                           fDeny ),
                                  fHasEncode( fEncode ),
                                  fHasDecode( fDecode )
                                {
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_ENCODE_PROC;
                                }
    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                               {
                               pVisitor->Visit( this );
                               }

    virtual
    BOOL                    HasEncode()
                                {
                                return fHasEncode;
                                }
    virtual
    BOOL                    HasDecode()
                                {
                                return fHasDecode;
                                }
    virtual
    BOOL                    HasAPicklingAttribute()
                                {
                                return TRUE;
                                }

    // Generate the client side (the only side) of the encoding stub.

    virtual
    CG_STATUS               GenClientStub( CCB * pCCB );

    CG_STATUS               GenClientStubV1( CCB * pCCB );

    CG_STATUS               GenMesProcEncodeDecodeCall( 
                                                CCB *               pCCB,
                                                PROC_CALL_PLATFORM  Platform );

    virtual
    CG_STATUS               GenServerStub( CCB *  )
                                {
                                return CG_OK;
                                }

    };

/////////////////////////////////////////////////////////////////////////////
// the type encode code generation class.
/////////////////////////////////////////////////////////////////////////////
//
// this is derived from the regular proc class

class CG_TYPE_ENCODE_PROC:  public CG_PROC
    {
public:
    
    //
    // The constructor.    Just call the proc constructor
    //
                            CG_TYPE_ENCODE_PROC(
                                            unsigned int   ProcNum,
                                            node_skl     * pProc,
                                            CG_HANDLE    * pBH,
                                            CG_PARAM     * pHU,
                                            BOOL           fAtLeastOneIn,
                                            BOOL           fAtLeastOneOut,
                                            BOOL           fAtLeastOneShipped,
                                            BOOL           fHasStatuses,
                                            BOOL           fHasFullPtr,
                                            CG_RETURN    * pRT,
                                            OPTIM_OPTION   OptimFlags,
                                            unsigned short OpBits,
                                            BOOL           fDeny )
                                : CG_PROC( ProcNum,
                                           pProc,
                                           pBH,
                                           pHU,
                                           fAtLeastOneIn,
                                           fAtLeastOneOut,
                                           fAtLeastOneShipped,
                                           fHasStatuses,
                                           fHasFullPtr,
                                           pRT,
                                           OptimFlags,
                                           OpBits,
                                           fDeny )
                                {
                                }

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_TYPE_ENCODE_PROC;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                               {
                               pVisitor->Visit( this );
                               }

    // Generate the client side (the only side) of the encoding stub.

    virtual
    CG_STATUS               GenClientStub( CCB * pCCB );

    virtual
    CG_STATUS               GenServerStub( CCB *  )
                                {
                                return CG_OK;
                                }
    };

/////////////////////////////////////////////////////////////////////////////
// the parameter code generation class.
/////////////////////////////////////////////////////////////////////////////

typedef unsigned long    PARAM_DIR_FLAGS;

#define IN_PARAM             0x1
#define OUT_PARAM            0x2
#define IN_OUT_PARAM         (IN_PARAM | OUT_PARAM)
#define PARTIAL_IGNORE_PARAM (IN_PARAM | OUT_PARAM | 0x4 )

#define I386_STACK_SIZING   0x1

struct StackOffsets
{
    union 
    {                   // Historically x86 was overloaded to mean ia64
        long    x86;    // in 64bit.
        long    ia64;
    };
};

//
// The following defines the code generation class for the parameter.
//

class CG_PARAM    : public CG_NDR
    {
private:

    PARAM_DIR_FLAGS         fDirAttrs           : 3; // directional info

    unsigned long           fDontCallFreeInst   : 1; // as the name says
    unsigned long           fInterpreterMustSize: 1; // interpreter has to size
    unsigned long           fIsExtraStatusParam : 1; // invisible fault/comm
    unsigned long           fIsAsyncHandle      : 1;
    unsigned long           fIsCSSTag           : 1; // is cs sending tag
    unsigned long           fIsCSDRTag          : 1; // is cs desired recv tag
    unsigned long           fIsCSRTag           : 1; // is cs receiving tag
    unsigned long           fIsOmitted          : 1; // is not in param list
    unsigned long           fIsForceAllocate    : 1; // is forced to allocate flag set 

    unsigned short          Statuses;                // comm/fault statuses

    short                   ParamNumber;

    expr_node            *  pFinalExpression;       // for the server stub
    expr_node            *  pSizeExpression;        // sizing expression

    // For unions only.

    expr_node            *  pSwitchExpr;            // the switch_is expression 
                                                    // (if a non-encap union below)
    long                    UnionFormatStringOffset;

    // Resource for size / length if necessary.

    RESOURCE            *   pSizeResource;
    RESOURCE            *   pLengthResource;
    RESOURCE            *   pFirstResource;
    RESOURCE            *   pSubstitutePtrResource;

    unsigned long           MarshallWeight;         // the marshaling weight
    bool                    fSaveForAsyncFinish;

    long                    SavedFixedBufferSize;

public:
    
    //
    // The constructor.
    //
                                
                            CG_PARAM( node_skl        * pParam,
                                      PARAM_DIR_FLAGS   Dir,
                                      XLAT_SIZE_INFO  & Info ,
                                      expr_node       * pSw,
                                      unsigned short    Stat );

    virtual void            SaveForAsyncFinish() { fSaveForAsyncFinish = true; };
    virtual bool            IsSaveForAsyncFinish() { return fSaveForAsyncFinish; };
    //
    // TYPEDESC generation routine
    //
    virtual
    CG_STATUS               GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB);

    //
    // get and set methods.
    //

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_PARAM;
                                }
    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                                {
                                pVisitor->Visit( this );
                                }

    void                    SetParamNumber( short pn )
                                {
                                ParamNumber = pn;
                                }

    short                   GetParamNumber()
                                {
                                MIDL_ASSERT( ParamNumber != -1 );
                                return ParamNumber;
                                }

    long                    GetStackOffset( CCB * pCCB,
                                            long  Platform );

    void                    GetStackOffsets( CCB * pCCB, StackOffsets *p )
                                {
                                // x86 is a synonym for ia64 in 64bit
                                p->x86 = GetStackOffset( 
                                                pCCB, I386_STACK_SIZING );
                                }

    long                    GetStackSize();

    expr_node *                SetSwitchExpr( expr_node * pE )
                                {
                                return (pSwitchExpr = pE);
                                }

    expr_node *             GetSwitchExpr()
                                {
                                return pSwitchExpr;
                                }

    void                    SetUnionFormatStringOffset( long offset )
                                {
                                UnionFormatStringOffset = offset;
                                }


    long                    GetUnionFormatStringOffset()
                                {
                                return UnionFormatStringOffset;
                                }

    virtual
    unsigned short          GetStatuses()
                                {
                                return Statuses;
                                }

    virtual
    BOOL                    HasStatuses()
                                {
                                return (BOOL)( Statuses != STATUS_NONE );
                                }

    BOOL                    IsExtraStatusParam()
                                {
                                return fIsExtraStatusParam;
                                }
    void                    SetIsExtraStatusParam()
                                {
                                fIsExtraStatusParam = TRUE;
                                }
    virtual
    RESOURCE            *   SetSubstitutePtrResource( RESOURCE * pSR )
                                {
                                return pSubstitutePtrResource = pSR;
                                }
    BOOL                    IsAsyncHandleParam()
                                {
                                return fIsAsyncHandle;
                                }
    void                    SetIsAsyncHandleParam()
                                {
                                fIsAsyncHandle = TRUE;
                                }

    virtual
    RESOURCE            *   GetSubstitutePtrResource()
                                {
                                return pSubstitutePtrResource;
                                }


    virtual
    RESOURCE            *   SetSizeResource( RESOURCE * pSR )
                                {
                                return pSizeResource = pSR;
                                }

    virtual
    RESOURCE            *   SetLengthResource( RESOURCE * pLR )
                                {
                                return pLengthResource = pLR;
                                }

    virtual
    RESOURCE            *   GetSizeResource()
                                {
                                return pSizeResource;
                                }

    virtual
    RESOURCE            *   GetLengthResource()
                                {
                                return pLengthResource;
                                }

    virtual
    RESOURCE            *   SetFirstResource( RESOURCE * pR)
                                {
                                return (pFirstResource = pR);
                                }

    virtual
    RESOURCE            *   GetFirstResource()
                                {
                                return pFirstResource;
                                }

    unsigned long           SetMarshallWeight( unsigned long W )
                                {
                                return (MarshallWeight = W);
                                }

    unsigned long           GetMarshallWeight()
                                {
                                return MarshallWeight;
                                }

    BOOL                    GetDontCallFreeInst()
                                {
                                return (BOOL) fDontCallFreeInst;
                                }

    void                    SetDontCallFreeInst( BOOL fDontCall )
                                {
                                fDontCallFreeInst = fDontCall ? 1 : 0;
                                }

    void                    SetForceAllocate( )
                                {
                                fIsForceAllocate = TRUE;
                                }

    BOOL                    IsForceAllocate()
                                {
                                return fIsForceAllocate;
                                }
								
    BOOL                    IsOptional()
                                {
                                return(((node_param *)GetType())->IsOptional());
                                }
                                
    BOOL                    IsRetval()
                                {
                                return(((node_param *)GetType())->IsRetval());
                                }

    expr_node            *  SetFinalExpression( expr_node * pR )
                                {
                                return (pFinalExpression = pR );
                                }

    expr_node            *  GetFinalExpression()
                                {
                                return pFinalExpression;
                                }

    expr_node            *  SetSizeExpression( expr_node * pR )
                                {
                                return (pSizeExpression = pR );
                                }

    expr_node            *  GetSizeExpression()
                                {
                                return pSizeExpression;
                                }

    void                    SetIsCSSTag(BOOL f)
                                {
                                fIsCSSTag = f;
                                }

    BOOL                    IsCSSTag()
                                {
                                return fIsCSSTag;
                                }

    void                    SetIsCSDRTag(BOOL f)
                                {
                                fIsCSDRTag = f;
                                }

    BOOL                    IsCSDRTag()
                                {
                                return fIsCSDRTag;
                                }

    void                    SetIsCSRTag(BOOL f)
                                {
                                fIsCSRTag = f;
                                }

    BOOL                    IsCSRTag()
                                {
                                return fIsCSRTag;
                                }

    BOOL                    IsSomeCSTag()
                                {
                                return IsCSSTag() || IsCSDRTag() || IsCSRTag();
                                }

    BOOL                    IsOmittedParam()
                                {
                                return fIsOmitted;
                                }

    void                    SetIsOmittedParam( BOOL f = TRUE )
                                {
                                fIsOmitted = f;
                                }

    long                    GetFixedBufferSize()
                                {
                                return SavedFixedBufferSize;
                                }

    void                    SetFixedBufferSize(long NewBufferSize)
                                {
                                SavedFixedBufferSize = NewBufferSize;
                                }

    long                    FixedBufferSize( CCB * pCCB )
                                {
                                return ((CG_NDR *)GetChild())->FixedBufferSize( pCCB );
                                }

    //
    // This method performs binding related analysis on the client side.
    //

    virtual
    CG_STATUS               C_BindingAnalysis( ANALYSIS_INFO *  )
                                {
                                return CG_OK;
                                }

    //
    // Generate the client side marshalling code.
    //

    virtual
    CG_STATUS               GenMarshall( CCB * pCCB );


    virtual
    CG_STATUS               GenUnMarshall( CCB * pCCB );

    virtual
    CG_STATUS               GenSizing( CCB * pCCB );

    virtual
    CG_STATUS               GenFree( CCB * pCCB );

    CG_STATUS               GenTypeEncodingStub( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitOutLocals( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitTopLevelStuff( CCB * pCCB );

    //
    // Format string routines for generating the format string and
    // the NDR calls for a parameter.
    //

    virtual
    void                    GenNdrFormat( CCB * pCCB );

    void                    GenNdrFormatOld( CCB * pCCB );

    void                    GenNdrMarshallCall( CCB * pCCB );

    void                    GenNdrUnmarshallCall( CCB * pCCB );

    void                    GenNdrBufferSizeCall( CCB * pCCB );

    void                    GenNdrFreeCall( CCB * pCCB );

    void                    GenNdrTopLevelAttributeSupport(
                                CCB *   pCCB,
                                BOOL    fForClearOut = FALSE );

    //
    // Queries.
    //

    BOOL                    IsParamIn()
                                {
                                return (BOOL)
                                    ((fDirAttrs & IN_PARAM) == IN_PARAM);
                                }

    BOOL                    IsParamOut()
                                {
                                return (BOOL)
                                    ((fDirAttrs & OUT_PARAM) == OUT_PARAM);
                                }
                                
    BOOL                    IsParamPartialIgnore()
                                {
                                return (BOOL)
                                   ((fDirAttrs  & PARTIAL_IGNORE_PARAM ) == PARTIAL_IGNORE_PARAM );
                                }

    //
    // Should we use the new NDR engine to marshall/unmarshall a parameter.
    // For now we pass the CCB since it contains optimization information.
    // Later the analyzer will put optimization information in the CG_PARAM
    // class.
    //
    
    BOOL                    UseNdrEngine( CCB * pCCB )
                                {
                                return (pCCB->GetOptimOption() & OPTIMIZE_SIZE);
                                }

    //
    // miscellaneous methods.
    //

    virtual
    expr_node            *  GenBindOrUnBindExpression( CCB * pCCB, BOOL fBind );

////////////////////////////////////////////////////////////////////////////

    virtual
    CG_STATUS               BufferAnalysis( ANALYSIS_INFO * )
                                {
                                return CG_OK;
                                }

    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               SizeAnalysis( ANALYSIS_INFO *  )
                                {
                                return CG_OK;
                                }

    virtual
    CG_STATUS               UnMarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               S_OutLocalAnalysis( ANALYSIS_INFO * pAna );

    void                    RpcSsPackageAnalysis( ANALYSIS_INFO * pAna );

    void                    InitParamMarshallAnalysis( ANALYSIS_INFO * pAna );

    void                    InitParamUnMarshallAnalysis( ANALYSIS_INFO * pAna );

    void                    ConsolidateParamMarshallAnalysis( ANALYSIS_INFO * pAna );

    void                    ConsolidateParamUnMarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               GenRefChecks( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitInLocals( CCB * pCCB );

    void                    SetInterpreterMustSize( BOOL f )
                                {
                                fInterpreterMustSize = f ? 1 : 0;
                                }

    BOOL                    GetInterpreterMustSize()
                                {
                                return fInterpreterMustSize;
                                }
    };


//
// The return-type code generation class
//
// This is a place-holder node for the return type, much like the param
// and field nodes.  This way, info about marshalling/unmarshalling the
// return type doesn't need to clutter up the proc node.
//
// If the function has no return (or returns "void") then no CG_RETURN
// is generated for the function.
//

class CG_RETURN : public CG_PARAM
    {
private:

public:
    
    //
    // The constructor.
    //
                            CG_RETURN( node_skl       * pRetType,
                                       XLAT_SIZE_INFO & Info,
                                       unsigned short   Stat )
                                : CG_PARAM( pRetType,
                                            OUT_PARAM,
                                            Info,
                                            NULL,
                                            Stat )
                                {
                                }

    //
    // get and set methods.
    //

    virtual
    ID_CG                   GetCGID()
                                {
                                return ID_CG_RETURN;
                                }


    virtual
    void                    Visit( CG_VISITOR *pVisitor )
                               {
                               pVisitor->Visit( this );
                               }
                               
    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               UnMarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               GenMarshall( CCB * pCCB );

    virtual
    CG_STATUS               GenUnMarshall( CCB * pCCB );

    virtual
    CG_STATUS               GenSizing( CCB * pCCB );

    virtual
    CG_STATUS               GenFree( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitOutLocals( CCB * pCCB );

    virtual
    CG_STATUS               S_GenInitTopLevelStuff( CCB * pCCB );

    expr_node        *      GetFinalExpression();
    };

#endif // __PROCCLS_HXX__