2197 lines
73 KiB
C++
2197 lines
73 KiB
C++
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
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__
|
|
|