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

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

 Module Name:
    
    bindcls.hxx

 Abstract:

    Contains definitions for binding related code generation class definitions.

 Notes:


 History:

    VibhasC     Sep-18-1993     Created.
 ----------------------------------------------------------------------------*/
#ifndef __BINDCLS_HXX__
#define __BINDCLS_HXX__

#include "nulldefs.h"

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

#include "ndrcls.hxx"
#include "ilxlat.hxx"

#if 0

    Although not apparent, a large occurence of binding handle parameters need
    the parameter be shipped on the wire. Generic handles get shipped as
    ordinary data and context handles as a special representation. The only
    class that does not ship anything is primitive handles. Their usage is
    rare. Since most binding handle usage WILL result in shipped data, it
    warrants a special code generation class of its own.

    The usage of the handles is either explicit or implicit. Therefore, the 
    binding handle class will appear as an explicit child of a param
    cg class if there is an explicit handle. The proc cg class always keeps
    a ptr to a binding handle class on its own anyway. So in case of explicit
    handles, the binding handle class pointer points to another cg class which
    is in the param list. In case of implicit handles, there is a new binding
    class instance created which is local only to the proc cg class. Therefore,
    in both cases, after the IL translation is done, an explicit or implicit
    handle looks the same to the analyser and code generation.

    If any handle is part of the parameter list, then the handle will get
    the GenCode and other related messages. An implicit handle will not be in
    the normal parameter list and therefore will never get the code generation
    messages. Therefore we dont really need to define implicit or explicit
    classes deriving out of the basic handle classes. Handle classes will
    implement the code generation methods appropriately and therefore the 
    differentiation between explicit and implicit will be based purely on 
    whether an instance of a class gets the code generation message or not.
    Only the proc node needs to know if the handle is explicit or implicit,
    and that it can do with a flag.

#endif // 0
/////////////////////////////////////////////////////////////////////////////
// The general binding handle class.
/////////////////////////////////////////////////////////////////////////////

class CG_HANDLE : public CG_NDR
    {
private:

    //
    // The type represented in this field is the type of the actual handle.
    // Therefore, in case of a generic handle, this field will get the typedef
    // node on which the [handle] attribute was applied. In case of a 
    // context_handle, this is either the typedef node on which [context_handle]
    // was applied or the basic type of the parameter node on which the
    // [context_handle] was applied. Therefore this field keeps the actual
    // handle type.

    // Remember this class derives from an ndr code gen class, so that has a 
    // type node pointer of its own. That is actually the pointer to the param
    // node which is the binding handle. In case of implicit handles, that 
    // field is not relevant and can be 0.
    //
     
    node_skl            *   pHandleType;

    //
    // The actual param param or id node.
    //

    node_skl            *   pHandleIDOrParam;

    //
    // Offset to binding format string description.
    //
    long                    NdrBindDescriptionOffset;

public:

    
    //
    // The constructor. Note again that 2 params are required in most cases,
    // the first representing the actual type of the handle, and the seconf
    // param which is the node_skl of the actual parameter node which is the
    // handle. In case of implicit handles, this can be 0.
    //

                            CG_HANDLE( node_skl * pHT, // handle type.
                                       node_skl * pHP,  // handle param or 0.
                                       XLAT_SIZE_INFO & Info    // memory size
                                     ) : CG_NDR(pHP, Info )
                                {
                                pHandleType         = pHT;
                                pHandleIDOrParam    = pHP;
                                NdrBindDescriptionOffset = -1;
                                }

    virtual
    void                    Visit( CG_VISITOR *pVisitor ) = 0;

    //
    // Get and set methods.
    //

    node_skl            *   SetHandleType( node_skl * pHT )
                                {
                                return (pHandleType = pHT);
                                }

    node_skl            *   GetHandleType()
                                {
                                return pHandleType;
                                }

    node_skl            *   GetHandleIDOrParam()
                                {
                                return pHandleIDOrParam;
                                }

    void                    SetNdrBindDescriptionOffset( long Offset )
                                {
                                NdrBindDescriptionOffset = Offset;
                                }

    long                    GetNdrBindDescriptionOffset()
                                {
                                return NdrBindDescriptionOffset;
                                }

    //
    // Queries.
    //

    //
    // Queries here should generally return a false, since the derived classes
    // should implement the methods and return the correct result.
    //

    virtual
    BOOL                    IsPrimitiveHandle()
                                {
                                return FALSE;
                                }

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

    virtual
    BOOL                    IsAHandle()
                                {
                                return TRUE;
                                }

    //
    // Format string generation for the bind handle description in a 
    // procedure's description.
    //

    virtual
    unsigned char           MakeExplicitHandleFlag(
                                    CG_PARAM *      pHandleParam );

    virtual 
    void                    GetNdrHandleInfo( CCB *, NDR64_BINDINGS * )
                                {
                                // Should be redefined by inheriting classes.
                                MIDL_ASSERT(0);
                                }

    virtual
    void                    GenNdrHandleFormat( CCB * )
                                {
                                // Should be redefined by inheriting classes.
                                MIDL_ASSERT(0);
                                }

    virtual
    void                    GenNdrParamDescription( CCB * pCCB );

    virtual
    void                    GenNdrParamDescriptionOld( CCB * pCCB );

    virtual
    long                    FixedBufferSize( CCB * )
                                {
                                return - 1;
                                }
    };

//////////////////////////////////////////////////////////////////////////////
// The auto handle class.
//////////////////////////////////////////////////////////////////////////////

class CG_PRIMITIVE_HANDLE   : public CG_HANDLE
    {
private:
public:

    //
    // The constructors.
    //

                            CG_PRIMITIVE_HANDLE( node_skl * pHT,
                                                 node_skl * pHP,
                                                 XLAT_SIZE_INFO & Info  // memory size
                                                  ):
                                                    CG_HANDLE( pHT, pHP, Info )
                                {
                                }

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

    //
    // Queries. An auto handle is treated as an implicit primitive handle.
    //

    virtual
    BOOL                    IsPrimitiveHandle()
                                {
                                return TRUE;
                                }

    //
    // Generate the format string for a handle. 
    //
    virtual
    void                    GenNdrFormat( CCB * pCCB );

    //
    // This method is called to generate offline portions of a type's
    // format string.  
    //
    virtual
    void                    GenNdrParamOffline( CCB * pCCB );

    virtual
    void                    GenNdrParamDescription( CCB * pCCB );

    virtual
    void                    GenNdrParamDescriptionOld( CCB * pCCB );

    virtual
    void                    GetNdrHandleInfo( CCB *, NDR64_BINDINGS * );

    virtual
    void                    GenNdrHandleFormat( CCB * pCCB );

    virtual
    long                    FixedBufferSize( CCB * )
                                {
                                return 0;
                                }
    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * )
                                {
                                return CG_OK;
                                }
    };

////////////////////////////////////////////////////////////////////////////
// The generic handle class.
////////////////////////////////////////////////////////////////////////////

//
// The generic handle drives off the name of the type which was defined as
// a handle. The typedef node, which is the handle type serves as the
// placeholder for the name of the handle.
//

class CG_GENERIC_HANDLE : public CG_HANDLE
    {
private:
public:
    //
    // The constructor. The generic handle class needs info about the type
    // of the handle. The typedef node on which the [handle] was applied,
    // can serve as a placeholder for the name too. The second need is the
    // parameter node which is the handle param in case the handle was an
    // explicit parameter, or the id node of the implicit handle.
    //
                            CG_GENERIC_HANDLE( node_skl * pHT,
                                               node_skl * pHP,
                                               XLAT_SIZE_INFO & Info    // memory size
                                                ) : 
                                                    CG_HANDLE( pHT, pHP, Info )
                                {
                                }


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

    //
    // Get and set methods.
    //

    PNAME                   GetHandleTypeName()
                                {
                                return GetHandleType()->GetSymName();
                                }

    long                    GetImplicitSize()
                                {
                                return 4;
                                }

    //
    // Queries.
    //

    virtual
    BOOL                    IsGenericHandle()
                                {
                                return TRUE;
                                }
    virtual
    BOOL                    HasAFixedBufferSize()
                                {
                                return GetChild()->HasAFixedBufferSize();
                                }
    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * pAna )
                                {
                                return ((CG_NDR *)GetChild())->MarshallAnalysis( pAna );
                                }
    virtual
    CG_STATUS               UnMarshallAnalysis( ANALYSIS_INFO * pAna )
                                {
                                return ((CG_NDR *)GetChild())->UnMarshallAnalysis( pAna );
                                }
    virtual
    CG_STATUS               S_OutLocalAnalysis( ANALYSIS_INFO * pAna )
                                {
                                return ((CG_NDR *)GetChild())->S_OutLocalAnalysis( pAna );
                                }
    virtual
    CG_STATUS               S_GenInitOutLocals( CCB * pCCB )
                                {
                                return ((CG_NDR *)GetChild())->S_GenInitOutLocals( pCCB );
                                }

    //
    // Generate the format string for a handle. 
    //
    virtual
    void                    GenNdrFormat( CCB * pCCB );

    //
    // This method is called to generate offline portions of a type's
    // format string.  
    //
    virtual
    void                    GenNdrParamOffline( CCB * pCCB );

    virtual
    void                    GenNdrParamDescription( CCB * pCCB );

    virtual
    void                    GetNdrParamAttributes(
                                    CCB * pCCB,
                                    PARAM_ATTRIBUTES *attributes );

    virtual
    void                    GenNdrParamDescriptionOld( CCB * pCCB );

    virtual
    void                    GetNdrHandleInfo( CCB *, NDR64_BINDINGS * );

    virtual
    void                    GenNdrHandleFormat( CCB * pCCB );

    virtual
    BOOL                    ShouldFreeOffline()
                                {
                                return ((CG_NDR *)GetChild())->
                                            ShouldFreeOffline();
                                }

    virtual
    void                    GenFreeInline( CCB * pCCB )
                                {
                                ((CG_NDR *)GetChild())->GenFreeInline( pCCB );
                                }

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

////////////////////////////////////////////////////////////////////////////
// The context handle class.
////////////////////////////////////////////////////////////////////////////


class CG_CONTEXT_HANDLE : public CG_HANDLE
    {
private:
    bool    fStrictContext;
    bool    fNoSerialize;
    bool    fSerialize;
    bool    fCannotBeNull;
    char*   pRundownRoutineName;

public:
                            CG_CONTEXT_HANDLE   (
                                                node_skl * pHT,
                                                node_skl * pHP,
                                                XLAT_CTXT& Info
                                                ) :
                                                CG_HANDLE( pHT, pHP, ( XLAT_SIZE_INFO& ) Info),
                                                pRundownRoutineName( 0 )

                                {
                                fStrictContext = Info.GetInterfaceContext()
                                                        ->GetAttribute( ATTR_STRICT_CONTEXT_HANDLE ) != 0;
                                fNoSerialize   = Info.ExtractAttribute( ATTR_NOSERIALIZE ) != 0;
                                fSerialize     = Info.ExtractAttribute( ATTR_SERIALIZE ) != 0;
                                fCannotBeNull  = false;
                                }

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

    virtual
    BOOL                    IsContextHandle()
                                {
                                return TRUE;
                                }

    bool                    GetCannotBeNull()
                                {
                                return fCannotBeNull;
                                }

    void                    SetCannotBeNull()
                                {
                                fCannotBeNull = true;
                                }

    BOOL                    HasNewContextFlavor()
                                {
                                return fStrictContext || fNoSerialize || fSerialize;
                                }

    BOOL                    HasSerialize()
                                {
                                return fSerialize;
                                }

    BOOL                    HasNoSerialize()
                                {
                                return fNoSerialize;
                                }

    BOOL                    HasStrict()
                                {
                                return fStrictContext;
                                }

    PNAME                   GetRundownRtnName();

    virtual
    CG_STATUS               MarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               UnMarshallAnalysis( ANALYSIS_INFO * pAna );

    virtual
    CG_STATUS               S_GenInitOutLocals( CCB * pCCB );

    //
    // Generate the format string for a handle. 
    //
    virtual
    void                    GenNdrFormat( CCB * pCCB );

    //
    // This method is called to generate offline portions of a type's
    // format string.  
    //
    virtual
    void                    GenNdrParamOffline( CCB * pCCB );

    virtual
    void                    GenNdrParamDescription( CCB * pCCB );

    virtual
    void                    GetNdrParamAttributes(
                                    CCB * pCCB,
                                    PARAM_ATTRIBUTES *attributes );

    virtual
    void                    GenNdrParamDescriptionOld( CCB * pCCB );

    virtual 
    unsigned char           MakeExplicitHandleFlag(
                                    CG_PARAM *      pHandleParam );    
    
    virtual
    void                    GetNdrHandleInfo( CCB *, NDR64_BINDINGS * );

    virtual
    void                    GenNdrHandleFormat( CCB * pCCB );

    virtual
    long                    FixedBufferSize( CCB * )
                                {
                                return MAX_WIRE_ALIGNMENT + 20;
                                }
    };

class CG_ASYNC_HANDLE   : public CG_NDR
    {
    private:

    public:
        CG_ASYNC_HANDLE(node_skl*       pType,
                        XLAT_SIZE_INFO& Info) : CG_NDR( pType, Info )
            {
            SetSStubAllocLocation( S_STUB_ALLOC_LOCATION_UNKNOWN );
            SetSStubAllocType( S_STUB_ALLOC_TYPE_NONE );
            SetSStubInitNeed( S_STUB_INIT_NOT_NEEDED );
            }

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

        ID_CG   GetCGID()
            {
            return ID_CG_ASYNC_HANDLE;
            }
    };

#endif // __BINDCLS_HXX__