able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/midl/codegen/misccls.cxx

1424 lines
39 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 1989-1999 Microsoft Corporation
Module Name:
misccls.hxx
Abstract:
Code generation methods for miscellaneous cg classes.
Notes:
History:
Sep-01-1993 VibhasC Created.
----------------------------------------------------------------------------*/
/****************************************************************************
* include files
***************************************************************************/
#include "becls.hxx"
#pragma hdrstop
#include "malloc.h"
/****************************************************************************
* local definitions
***************************************************************************/
/****************************************************************************
* local data
***************************************************************************/
GUID_STRS TransferSyntaxGuidStrs( TRANSFER_SYNTAX_GUID_STR_1,
TRANSFER_SYNTAX_GUID_STR_2,
TRANSFER_SYNTAX_GUID_STR_3,
TRANSFER_SYNTAX_GUID_STR_4,
TRANSFER_SYNTAX_GUID_STR_5);
GUID_STRS NDR64TransferSyntaxGuidStrs( NDR64_TRANSFER_SYNTAX_GUID_STR_1,
NDR64_TRANSFER_SYNTAX_GUID_STR_2,
NDR64_TRANSFER_SYNTAX_GUID_STR_3,
NDR64_TRANSFER_SYNTAX_GUID_STR_4,
NDR64_TRANSFER_SYNTAX_GUID_STR_5);
GUID_STRS FakeNDR64TransferSyntaxGuidStrs(
FAKE_NDR64_TRANSFER_SYNTAX_GUID_STR_1,
FAKE_NDR64_TRANSFER_SYNTAX_GUID_STR_2,
FAKE_NDR64_TRANSFER_SYNTAX_GUID_STR_3,
FAKE_NDR64_TRANSFER_SYNTAX_GUID_STR_4,
FAKE_NDR64_TRANSFER_SYNTAX_GUID_STR_5);
/****************************************************************************
* externs
***************************************************************************/
extern CMD_ARG * pCommand;
extern BOOL IsTempName( char * );
/****************************************************************************/
CG_INTERFACE::CG_INTERFACE(
node_interface * pI,
GUID_STRS GStrs,
BOOL fCallbacks,
BOOL fMopInfo,
CG_HANDLE * pIH,
CG_INTERFACE* pBaseIF
) :CG_NDR(pI, XLAT_SIZE_INFO() ),
fTypeInfoInitialized( FALSE )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
The constructor for the code generation file node.
Arguments:
pI - A pointer to the interface node in type graph.
GStrs - guid strings
fCallbacks - Does the interface have any callbacks ?
fMopInfo - Does the interface have any mops ?
pIH - A pointer to the CG nodes for any implicit handle
Return Value:
Notes:
----------------------------------------------------------------------------*/
{
pCGBase = pBaseIF;
_pCTI = NULL;
char * pName = GetType()->GetSymName();
GuidStrs = GStrs;
GuidStrs.SetValue();
fMopsPresent = fMopInfo;
fCallbacksPresent = fCallbacks;
pImpHdlCG = (CG_HANDLE *) pIH;
CreateDispatchTables();
fAllRpcSS = FALSE;
fUsesRpcSS = FALSE;
pIntfName = pName;
fHasPipes = FALSE;
fVisited = FALSE;
fLocal = GetType()->FInSummary( ATTR_LOCAL );
fHasMSConfStructAttr = FALSE;
//
// For now.
//
ProtSeqEPCount = 0;
pStubDescName = new char[ strlen(STUB_DESC_STRUCT_VAR_NAME) +
strlen(pName) + 1 ];
strcpy( pStubDescName, pName );
strcat( pStubDescName, STUB_DESC_STRUCT_VAR_NAME );
pSyntaxInfoName = new char [strlen(MIDL_SYNTAX_INFO_VAR_NAME) +
strlen(pName) + 1];
strcpy( pSyntaxInfoName, pName );
strcat( pSyntaxInfoName, MIDL_SYNTAX_INFO_VAR_NAME );
pProxyInfoName = new char [strlen(MIDL_PROXY_INFO_VAR_NAME) +
strlen(pName) + 1];
strcpy( pProxyInfoName, pName );
strcat( pProxyInfoName, MIDL_PROXY_INFO_VAR_NAME );
}
CG_STATUS
CG_INTERFACE::GenClientInfo(
CCB * pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate code for the file node.
Arguments:
pCCB - a pointer to the code generation control block.
Return Value:
CG_OK if all is well, error otherwise.
Notes:
----------------------------------------------------------------------------*/
{
unsigned short M,m; // for MAJOR and minor versions :-)
CG_ITERATOR I;
CG_PROC * pCG;
CG_HANDLE * pCGHandle = GetImplicitHandle();
node_skl * pID;
char Buffer[_MAX_DRIVE+_MAX_DIR+_MAX_FNAME+_MAX_EXT+1];
short CallbackCount;
ISTREAM * pStream = pCCB->GetStream();
int ProtSeqEPCount = 0;
ITERATOR * pProtSeqIterator;
char * pCStubPrefix;
//Initialize the CCB for this interface.
InitializeCCB(pCCB);
pCCB->SetImplicitHandleIDNode( 0 );
if( !GetMembers( I ) )
{
return CG_OK;
}
//
// Emit the external variables needed.
//
if ( HasInterpretedCallbackProc() )
Out_InterpreterServerInfoExtern( pCCB );
if ( pCommand->NeedsNDR64Run() )
Out_ProxyInfoExtern( pCCB );
pStream->NewLine();
if( pCGHandle )
{
pID = pCGHandle->GetHandleIDOrParam();
pID->PrintType( PRT_ID_DECLARATION, pStream, 0 );
}
//
// Emit the protseq endpoint structure if necessary. It is not
// necessary if the endpoint attribute was not specified in which
// case the ep count is 0.
//
if ( ( pProtSeqIterator = GetProtSeqEps() ) != 0 )
{
ProtSeqEPCount = ITERATOR_GETCOUNT( *pProtSeqIterator );
Out_EP_Info( pCCB, pProtSeqIterator );
}
//
// Emit the interface information structure.
//
pCCB->GetVersion( &M,&m );
CallbackCount = ((node_interface *)GetType())->GetCallBackProcCount();
if( CallbackCount )
{
sprintf( Buffer,
"extern %s %s%s%s%_DispatchTable;",
RPC_DISPATCH_TABLE_TYPE_NAME,
pCCB->GetInterfaceName(),
pCommand->IsNDR64Run()?"_NDR64_":"",
pCCB->GenMangledName() );
pStream->NewLine( 2 );
pStream->Write( Buffer );
/// NOTE:: This buffer is printed in the Out_IfInfo call !!!!
sprintf( Buffer,
"&%s%s%s_DispatchTable",
pCCB->GetInterfaceName(),
pCommand->IsNDR64Run()?"_NDR64_":"",
pCCB->GenMangledName() );
}
//
// Must set this before outputing the interface info.
//
pCCB->SetCodeGenSide( CGSIDE_CLIENT );
Out_IFInfo( pCCB, // controller block.
RPC_C_INT_INFO_TYPE_NAME, // interface info type name.
RPC_C_INT_INFO_STRUCT_NAME, // variable name.
SIZEOF_RPC_CLIENT_INTERFACE, // string speicifying size.
GuidStrs, // Guid specified in idl
M, // user specified major version
m, // user specified minor version
// TransferSyntaxGuidStrs, // ndr identifying guid.
// NDR_UUID_MAJOR_VERSION, // ndr's version
// NDR_UUID_MINOR_VERSION,
CallbackCount ? Buffer : 0, // call back dispatch table name
ProtSeqEPCount, // if this is 0, then the next
// 2 fields are ignored by
// the call.
PROTSEQ_EP_TYPE_NAME, // RPC_PROTSEQ_ENDPOINT
PROTSEQ_EP_VAR_NAME, // ___RpcProtSeqEndpoint
pCCB->IsNoDefaultEpv(),
0, // client side
HasPipes()
);
if ( (pCStubPrefix = pCommand->GetUserPrefix( PREFIX_CLIENT_STUB ) ) == 0 )
{
pCStubPrefix = "";
}
pStream->NewLine();
sprintf( Buffer,
"RPC_IF_HANDLE %s%s%s_%s = (RPC_IF_HANDLE)& %s" RPC_C_INT_INFO_STRUCT_NAME";",
pCStubPrefix,
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
((pCCB->IsOldNames()) ? "ClientIfHandle" : "c_ifspec"),
pCCB->GetInterfaceName()
);
pStream->Write( Buffer );
//
// Emit the stub descriptor extern declaration.
//
Out_StubDescriptorExtern( pCCB );
//
// Check for use of [enable_allocate]
// Use in ms_ext when explicit, in osf always, to cover some weird cases.
//
if ( GetUsesRpcSS() || pCCB->InOSFMode() )
pCCB->SetMallocAndFreeStructExternEmitted();
// Emit the auto handle extern
pStream->NewLine();
sprintf( Buffer,
"static %s %s%s;",
AUTO_BH_TYPE_NAME,
pCCB->GetInterfaceName(),
AUTO_BH_VAR_NAME
);
pStream->Write( Buffer );
pStream->NewLine();
//
// Send the message to the children to emit code.
//
//
// for all procedure in this interface, generate code.
//
while( ITERATOR_GETNEXT( I, pCG ) )
{
pCG->GenClientStub( pCCB );
}
return CG_OK;
}
void
CG_INTERFACE::Out_ProcOffsetTable( CCB *pCCB, BOOL IsForCallback )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Output a table of offsets to procedure information in the format
string/structure.
Arguments:
pCCB - a pointer to the code generation control block.
IsForCallback - Is this is a table of callback offsets?
Notes:
----------------------------------------------------------------------------*/
{
ISTREAM *pStream = pCCB->GetStream();
if ( pCommand->IsNDR64Run() )
pStream->WriteOnNewLine( "static const FormatInfoRef " );
else
pStream->WriteOnNewLine( "static const unsigned short " );
if ( IsForCallback )
pStream->Write( MIDL_CALLBACK_VAR_NAME );
pStream->Write( GetSymName() );
if ( pCommand->IsNDR64Run() )
pStream->Write( "_Ndr64ProcTable[] =" );
else
pStream->Write( "_FormatStringOffsetTable[] =" );
pStream->IndentInc();
pStream->WriteOnNewLine( '{' );
pStream->NewLine();
OutputProcOffsets( pCCB, TRUE, IsForCallback );
pStream->Write( "};" );
pStream->IndentDec();
pStream->NewLine( 2 );
// If we need a table of callbacks also, recursively call ourselves
if ( !IsForCallback && HasInterpretedCallbackProc() )
Out_ProcOffsetTable( pCCB, TRUE );
}
CG_STATUS
CG_INTERFACE::OutputClientStub(
CCB * pCCB )
{
CG_ITERATOR I;
if( !GetMembers( I ) )
{
return CG_OK;
}
//Initialize the CCB for this interface.
InitializeCCB(pCCB);
// Output a table containing the offsets of each proc description for this
// interface in the format info string/struct. Output another table for
// callbacks if needed.
Out_ProcOffsetTable( pCCB );
//
// Emit the stub descriptor and all that is specific to the interface,
// Generate externs to tables that may be common to several interfaces.
//
Out_StubDescriptor( GetImplicitHandle(), pCCB );
if ( pCommand->NeedsNDR64Run() )
Out_ProxyInfo( pCCB, FALSE );
//
// Generate the dispatch table.
//
short CallbackCount = ( (node_interface *) GetType() )
->GetCallBackProcCount();
if( CallbackCount )
{
ITERATOR ProcList;
GetCallbackProcedureList( ProcList, DTF_NONE );
Out_DispatchTableStuff( pCCB,
ProcList,
CallbackCount
);
}
if ( HasInterpretedCallbackProc() )
{
GenSyntaxInfo( pCCB, TRUE );
Out_InterpreterServerInfo( pCCB, CGSIDE_CLIENT );
}
return CG_OK;
}
CG_STATUS
CG_INTERFACE::GenServerInfo(
CCB * pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate code for the interface node.
Arguments:
pCCB - a pointer to the code generation control block.
Return Value:
CG_OK if all is well, error otherwise.
Notes:
----------------------------------------------------------------------------*/
{
unsigned short M,m; // for MAJOR and minor versions :-)
CG_PROC * pCG;
CG_ITERATOR I;
char Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
ISTREAM * pStream = pCCB->GetStream();
ITERATOR * pProtSeqIterator;
node_interface * pInterface = (node_interface *)GetType();
char * pSStubPrefix;
InitializeCCB(pCCB);
if( !GetMembers( I ) )
{
return CG_OK;
}
//
// Emit the external variables needed.
//
if ( HasInterpretedProc() )
Out_InterpreterServerInfoExtern( pCCB );
//
// Emit the protseq endpoint structure if necessary. It is not
// necessary if the endpoint attribute was not specified in which
// case the ep count is 0.
//
if ( ( pProtSeqIterator = GetProtSeqEps() ) != 0 )
{
ProtSeqEPCount = ITERATOR_GETCOUNT( *pProtSeqIterator );
Out_EP_Info( pCCB, pProtSeqIterator );
}
//
// Emit the interface information structure.
//
pCCB->GetVersion( &M,&m );
//
// Emit the extern decl for the server's dispatch table, which goes
// in the server interface structure which follows.
//
sprintf( Buffer,
"extern %s %s%s%s_DispatchTable;",
RPC_DISPATCH_TABLE_TYPE_NAME,
pCCB->GetInterfaceName(),
pCommand->IsNDR64Run()?"_NDR64_":"",
pCCB->GenMangledName() );
pStream->NewLine( 2 );
pStream->Write( Buffer );
//
// Emit the extern decl for the server side manager epv table, which goes
// in the server interface structure which follows.
//
if( pCCB->IsMEpV() &&
!pCCB->IsNoDefaultEpv() &&
(pInterface->GetProcCount() != 0) )
{
sprintf( Buffer,
"extern %s%s_%s DEFAULT_EPV;",
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
pCCB->IsOldNames() ? "SERVER_EPV" : "epv_t" );
pStream->NewLine( 2 );
pStream->Write( Buffer );
}
// Prepare address string for the address of the dispatch table in the
// interface information structure.
sprintf( Buffer,
"&%s%s%s_DispatchTable",
pCCB->GetInterfaceName(),
pCommand->IsNDR64Run()?"_NDR64_":"",
pCCB->GenMangledName()
);
//
// Must set this before outputing the interface info.
//
pCCB->SetCodeGenSide( CGSIDE_SERVER );
Out_IFInfo( pCCB, // controller block.
RPC_S_INT_INFO_TYPE_NAME, // interface info type name.
RPC_S_INT_INFO_STRUCT_NAME, // variable name.
SIZEOF_RPC_SERVER_INTERFACE, // string speicifying size.
GuidStrs, // Guid specified in idl
M, // user specified major version
m, // user specified minor version
// TransferSyntaxGuidStrs, // ndr identifying guid.
// NDR_UUID_MAJOR_VERSION, // ndr's version
// NDR_UUID_MINOR_VERSION,
Buffer,
ProtSeqEPCount, // if this is 0, then the next
// 2 fields are ignored by
// the call.
PROTSEQ_EP_TYPE_NAME, // RPC_PROTSEQ_ENDPOINT
PROTSEQ_EP_VAR_NAME, // ___RpcProtSeqEndpoint
pCCB->IsNoDefaultEpv(),
1,
HasPipes()
);
if ( (pSStubPrefix = pCommand->GetUserPrefix( PREFIX_SERVER_MGR ) ) == 0 )
{
pSStubPrefix = "";
}
pStream->NewLine();
sprintf( Buffer,
"RPC_IF_HANDLE %s%s%s_%s = (RPC_IF_HANDLE)& %s"
RPC_S_INT_INFO_STRUCT_NAME";",
pSStubPrefix,
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
((pCCB->IsOldNames()) ? "ServerIfHandle" : "s_ifspec"),
pCCB->GetInterfaceName()
);
pStream->Write( Buffer );
//
// Emit the stub descriptor extern declaration.
//
Out_StubDescriptorExtern( pCCB );
//
// Check for use of [enable_allocate]
//
if ( GetUsesRpcSS() && !pCCB->InOSFMode() )
pCCB->SetMallocAndFreeStructExternEmitted();
// has callback and Needsndr64: we need to generate proxy info for callback's
// client stub.
if ( HasInterpretedCallbackProc() )
Out_ProxyInfoExtern( pCCB );
//
// Send the message to the children to emit code.
//
//
// For all procedures in this interface, generate code.
//
while( ITERATOR_GETNEXT( I, pCG ) )
{
pCG->GenServerStub( pCCB );
}
return CG_OK;
}
CG_STATUS
CG_INTERFACE::OutputServerStub(
CCB * pCCB )
{
CG_ITERATOR I;
if( !GetMembers( I ) )
{
return CG_OK;
}
short NormalProcCount;
ITERATOR NormalProcList;
InitializeCCB( pCCB );
// For procs that return complex types (structures, floating point, etc)
// we need to have a thunk that takes a pointer to where to store this
// type.
OutputComplexReturnThunks( pCCB );
// Output a table containing the offsets of each proc description for this
// interface in the format info string/struct. Output another table for
// callbacks if needed.
Out_ProcOffsetTable( pCCB );
//
// Emit the stub descriptor.
//
if ( HasInterpretedProc() )
pCCB->SetOptimOption( unsigned short( pCCB->GetOptimOption() | OPTIMIZE_INTERPRETER ) );
Out_StubDescriptor( GetImplicitHandle(), pCCB );
//
// Generate the dispatch table.
//
NormalProcCount = GetNormalProcedureList( NormalProcList,
DTF_NONE
);
if( NormalProcCount )
Out_DispatchTableStuff( pCCB,
NormalProcList,
NormalProcCount
);
// Generate the manager epv if the -use epv switch has been specified.
if( pCCB->IsMEpV() && !pCCB->IsNoDefaultEpv() )
{
ITERATOR ProcList;
short Count;
Count = GetNormalProcedureList( ProcList,
DTF_NONE
);
if( Count )
{
Out_ManagerEpv( pCCB, pCCB->GetInterfaceName(), ProcList, Count );
}
}
if ( pCommand->NeedsNDR64Run() )
{
GenSyntaxInfo( pCCB, FALSE );
if ( pCCB->GetInterfaceCG()->HasInterpretedCallbackProc() )
Out_ProxyInfo( pCCB, TRUE );
}
if ( HasInterpretedProc() )
Out_InterpreterServerInfo( pCCB, CGSIDE_SERVER );
return CG_OK;
}
void
CG_INTERFACE::OutputComplexReturnThunks(
CCB * pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
For procs that return complex types (structures, floating point, etc
we need to have a thunk that takes a pointer to where to store this
type.
Arguments:
pCCB - a pointer to the code generation control block.
Notes:
The thunk looks like:
void Proc_ComplexThunk(..., ReturnType *_RetVal)
{
*_RetVal = Proc(...);
}
REVIEW:
Integrate this with NeedsServerThunk stuff
----------------------------------------------------------------------------*/
{
if ( CGSIDE_SERVER != pCCB->GetCodeGenSide() )
return;
if ( !pCommand->IsFinalProtocolRun() )
return;
ISTREAM *pStream = pCCB->GetStream();
ITERATOR procs;
CG_PROC *procCG;
GetMembers( procs );
while ( ITERATOR_GETNEXT( procs, procCG ) )
{
if ( ! procCG->HasComplexReturnType() || procCG->HasAsyncHandle() )
continue;
ITERATOR params;
short nParams;
expr_proc_call *pCall = new expr_proc_call( procCG->GetSymName() );
expr_node *pExpr;
CG_PARAM *param;
procCG->GetMembers( params );
nParams = ITERATOR_GETCOUNT( params );
for ( int i = 0; i < nParams - 1; i++ )
{
ITERATOR_GETNEXT( params, param );
pCall->SetParam( new expr_variable( param->GetResource()->GetResourceName() ) );
}
node_proc *proc = new node_proc( (node_proc *) procCG->GetType() );
node_param *pParam;
node_skl *pVoid;
node_skl *pOldChild;
char *pProcName = (char *) alloca(
strlen( proc->GetSymName() )
+ sizeof( "_ComplexThunk" ) );
strcpy( pProcName, proc->GetSymName() );
strcat( pProcName, "_ComplexThunk" );
proc->SetSymName( pProcName );
// REVIEW: A lot of this is cruft, clean it up!
GetBaseTypeNode( &pVoid, SIGN_UNDEF, SIZE_UNDEF, TYPE_VOID, ATTR_NONE );
pParam = new node_param;
pParam->SetSymName( RETURN_VALUE_VAR_NAME );
pParam->SetChild( new node_pointer( proc->GetChild() ) );
pParam->GetChild()->GetModifiers().SetModifier( ATTR_TAGREF );
pOldChild = proc->GetChild();
proc->SetChild( pVoid );
// proc->SetHasComplexReturnType( FALSE );
proc->RemoveAttribute( ATTR_PTR_KIND );
proc->AddLastMember( pParam );
pExpr = new expr_assign(new expr_variable( "*" RETURN_VALUE_VAR_NAME ), pCall );
pStream->NewLine( 2 );
proc->PrintType( PRT_DECL, pStream );
pStream->WriteOnNewLine( "{" );
pStream->IndentInc();
pStream->NewLine();
pExpr->PrintCall( pStream, 0, 0 );
pStream->IndentDec();
pStream->WriteOnNewLine( "}" );
proc->RemoveLastMember();
proc->SetChild( pOldChild );
}
}
CG_STATUS
CG_INTERFACE::GenHeader(
CCB * pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate interface header file.
Arguments:
pCCB - a pointer to the code generation control block.
Return Value:
CG_OK if all is well, error other wise.
Notes:
----------------------------------------------------------------------------*/
{
node_interface * pInterface = (node_interface *) GetType();
ITERATOR I;
ITERATOR J;
char Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
CG_HANDLE * pCGHandle = GetImplicitHandle();
node_skl * pID;
ISTREAM * pStream = pCCB->GetStream();
unsigned short M, m;
char * pCStubPrefix;
char * pSStubPrefix;
char * pName = pInterface->GetSymName();
BOOL fAnonymous = IsTempName( pName );
//Initialize the CCB for this interface.
InitializeCCB(pCCB);
// put out the interface guards
if ( !fAnonymous )
{
pStream->Write("\n#ifndef __");
pStream->Write( pName );
pStream->Write( "_INTERFACE_DEFINED__\n" );
pStream->Write( "#define __");
pStream->Write( pName );
pStream->Write( "_INTERFACE_DEFINED__\n" );
}
// Print out the declarations of the types and the procedures.
// If the user defined a prefix for the cstub or sstub,
// then emit prototypes with the prefix in them.
pStream->NewLine();
pInterface->PrintType(
PRT_INTERFACE | PRT_BOTH_PREFIX | PRT_OMIT_CS_TAG_PARAMS,
pStream,
0 );
if( pCGHandle )
{
pID = pCGHandle->GetHandleIDOrParam();
pStream->NewLine();
pStream->Write( "extern " );
pID->PrintType( PRT_ID_DECLARATION, pStream, 0 );
}
// Emit the declarations for user supplied routines.
// Print out the dispatch table.
pStream->NewLine();
GetNormalProcedureList( I, DTF_NONE );
if( pCCB->IsMEpV() )
{
if( ITERATOR_GETCOUNT(I) )
Out_DispatchTableTypedef(
pCCB,
pCCB->GetInterfaceName(),
I,
0
);
}
GetCallbackProcedureList( J, DTF_NONE );
if( ITERATOR_GETCOUNT(J ) )
Out_DispatchTableTypedef(
pCCB,
pCCB->GetInterfaceName(),
J,
1
);
pCCB->GetVersion( &M, &m );
if ( (pCStubPrefix = pCommand->GetUserPrefix( PREFIX_CLIENT_STUB ) ) == 0 )
{
pCStubPrefix = 0;
}
if ( (pSStubPrefix = pCommand->GetUserPrefix( PREFIX_SERVER_MGR ) ) == 0 )
{
pSStubPrefix = 0;
}
// Generate the extern for the client if handle.
pStream->NewLine();
sprintf( Buffer, "extern RPC_IF_HANDLE %s%s%s_%s;",
(pCStubPrefix == 0) ? "" : pCStubPrefix,
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
(pCCB->IsOldNames()) ? "ClientIfHandle" : "c_ifspec" );
pStream->Write( Buffer );
// If a prefix is defined for cstub, generate another extern for the
// non - prefixed client if handle. Remember, in the header file we need
// both the externs, since the header file generated out of the -prefix
// cstub invocation contains prototypes for both prefixed and non-prefix
// stuff.
if( pCStubPrefix )
{
pStream->NewLine();
sprintf( Buffer, "extern RPC_IF_HANDLE %s%s%s_%s;",
"",
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
(pCCB->IsOldNames()) ? "ClientIfHandle" : "c_ifspec" );
pStream->Write( Buffer );
}
pStream->NewLine();
sprintf( Buffer, "extern RPC_IF_HANDLE %s%s%s_%s;",
(pSStubPrefix == 0) ? "" : pSStubPrefix,
pCCB->GetInterfaceName(),
pCCB->GenMangledName(),
(pCCB->IsOldNames()) ? "ServerIfHandle" : "s_ifspec" );
pStream->Write( Buffer );
pStream->NewLine();
// put out the trailing interface guard
if ( !fAnonymous )
{
pStream->Write( "#endif /* __");
pStream->Write( pName );
pStream->Write( "_INTERFACE_DEFINED__ */\n" );
}
return CG_OK;
}
ITERATOR *
CG_INTERFACE::GetProtSeqEps()
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Get the protocol sequences pairs iterator.
Arguments:
Iterator reference.
Return Value:
FALSE if there are no endpoints
Notes:
The iterator is invalid if there are no endpoints.
----------------------------------------------------------------------------*/
{
node_interface * pIntf = (node_interface *) GetType();
node_endpoint * pEps = (node_endpoint *)
pIntf->GetAttribute( ATTR_ENDPOINT );
return ( pEps ) ? &(pEps->GetEndPointPairs()) : NULL;
}
void
CG_INTERFACE::CreateDispatchTables()
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Set up the stub dispatch tables.
Arguments:
None.
Return Value:
None.
Notes:
----------------------------------------------------------------------------*/
{
pNormalDispatchTable = new DISPATCH_TABLE();
pCallbackDispatchTable = new DISPATCH_TABLE();
ppDispatchTableSaved = ppDispatchTable = &pNormalDispatchTable;
}
BOOL
CG_INTERFACE::HasInterpretedProc()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER )
return TRUE;
return FALSE;
}
BOOL
CG_INTERFACE::HasOnlyInterpretedProcs()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( (pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER ) == 0 )
return FALSE;
return TRUE;
}
BOOL
CG_OBJECT_INTERFACE::HasOnlyInterpretedMethods()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
CG_OBJECT_INTERFACE* pBaseCG = (CG_OBJECT_INTERFACE*) GetBaseInterfaceCG();
if ( pBaseCG && !pBaseCG->HasOnlyInterpretedMethods() )
return FALSE;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( (pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER ) == 0 )
return FALSE;
return TRUE;
}
BOOL
CG_INTERFACE::HasItsOwnOi2()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( (pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2) )
return TRUE;
return FALSE;
}
void
CG_INTERFACE::EvaluateVersionControl()
{
if ( HasItsOwnOi2() )
{
GetNdrVersionControl().SetHasOi2();
}
}
BOOL
CG_OBJECT_INTERFACE::HasItsOwnStublessProxies()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if (pProc->GetOptimizationFlags() & OPTIMIZE_STUBLESS_CLIENT )
return TRUE;
return FALSE;
}
void
CG_OBJECT_INTERFACE::EvaluateVersionControl()
{
CG_OBJECT_INTERFACE* pBaseCG = (CG_OBJECT_INTERFACE*) GetBaseInterfaceCG();
if ( pBaseCG )
{
pBaseCG->EvaluateVersionControl();
}
if ( HasItsOwnStublessProxies() ||
pBaseCG && pBaseCG->HasStublessProxies() )
{
GetNdrVersionControl().SetHasStublessProxies();
}
if ( HasItsOwnOi2() ||
pBaseCG && pBaseCG->HasOi2() )
{
GetNdrVersionControl().SetHasOi2();
}
}
BOOL
CG_INTERFACE::HasInterpretedCallbackProc()
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( pProc->GetCGID() == ID_CG_CALLBACK_PROC &&
pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER )
return TRUE;
return FALSE;
}
BOOL
CG_INTERFACE::HasClientInterpretedCommOrFaultProc( CCB * pCCB )
{
CG_ITERATOR Iterator;
CG_PROC * pProc;
CGSIDE Side;
Side = pCCB->GetCodeGenSide();
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
if ( (pProc->GetOptimizationFlags() & OPTIMIZE_INTERPRETER) &&
pProc->HasStatuses() &&
( ((pProc->GetCGID() == ID_CG_PROC) && (Side == CGSIDE_CLIENT)) ||
((pProc->GetCGID() == ID_CG_CALLBACK_PROC) && (Side == CGSIDE_SERVER)) ) )
return TRUE;
return FALSE;
}
CG_STATUS
CG_INTERFACE::InitializeCCB( CCB * pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Initialize the CCB for this interface.
Arguments:
pCCB - a pointer to the code generation control block.
Return Value:
CG_OK if all is well, error otherwise.
Notes:
----------------------------------------------------------------------------*/
{
unsigned short Major,minor;
node_interface *pInterface = (node_interface *) GetType();
pInterface->GetVersionDetails(&Major, &minor);
pCCB->SetVersion(Major, minor);
pCCB->SetInterfaceName(pInterface->GetSymName());
pCCB->SetInterfaceCG(this);
return CG_OK;
}
void
CG_INTERFACE::OutputProcOffsets( CCB * pCCB, BOOL fLast, BOOL IsForCallback )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Output a list of offsets (from the beginning of the proc format info)
to each proc in the interface
Arguments:
pCCB - a pointer to the code generation control block.
fLast -
IsForCallback -
Notes:
For Ndr32 the list is a table of shorts that offset from the beginning
of the proc format string.
For Ndr64 it is a table of longs that is the offset from the format info
structure.
----------------------------------------------------------------------------*/
{
CG_PROC * pProc;
CG_ITERATOR Iterator;
ISTREAM * pStream = pCCB->GetStream();
CGSIDE Side;
long Offset;
// IUnknown doesn't get entries in the proc offsets table
if ( IsIUnknown() )
{
if ( fLast )
{
pStream->Write( '0' );
pStream->NewLine();
}
return;
}
Side = pCCB->GetCodeGenSide();
if ( IsObject() )
{
CG_OBJECT_INTERFACE * pObjInterface;
pObjInterface = (CG_OBJECT_INTERFACE *) this;
if ( pObjInterface->GetBaseInterfaceCG() )
{
pObjInterface->GetBaseInterfaceCG()->OutputProcOffsets( pCCB, FALSE, IsForCallback );
}
}
GetMembers( Iterator );
BOOL fNoOffsetsEmitted = TRUE;
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
{
if ( (Side == CGSIDE_CLIENT) &&
( IsForCallback ? ( pProc->GetCGID() != ID_CG_CALLBACK_PROC ) :
(pProc->GetCGID() == ID_CG_CALLBACK_PROC) ) )
continue;
if ( (Side == CGSIDE_SERVER) &&
( ( IsForCallback ? ( pProc->GetCGID() != ID_CG_CALLBACK_PROC ) :
( pProc->GetCGID() == ID_CG_CALLBACK_PROC ) )
|| (pProc->GetCGID() == ID_CG_TYPE_ENCODE_PROC ) ) )
continue;
CG_PROC *pTargetProc = pProc;
if ( fLocal )
pTargetProc = pProc->GetCallAsCG();
// type encode procs are not real procs
if ( dynamic_cast<CG_TYPE_ENCODE_PROC *>(pTargetProc) )
continue;
fNoOffsetsEmitted = FALSE;
// REVIEW: If Offset is -1 (dce) or 0 (ndr64) then we haven't generated
// format info for the proc. This can only happen in certain
// conditions ([nocode], methods in parent interface). There
// should be an assert.
if ( pCommand->IsNDR64Run() )
{
Offset = 0;
if ( pTargetProc )
Offset = (long) (size_t) pCCB->GetNdr64Format()->GetRoot()
->LookupFragmentID( pTargetProc );
if ( 0 == Offset )
pStream->Write( "(FormatInfoRef) -1" );
else
pStream->WriteNumber( "&__midl_frag%d", Offset );
}
else
{
Offset = -1;
if ( pTargetProc )
Offset = pTargetProc->GetFormatStringOffset();
if ( -1 == Offset )
pStream->Write( "(unsigned short) -1" );
else
pStream->WriteNumber( "%d", Offset );
}
if ( pProc->GetSibling() || !fLast )
pStream->Write( ',' );
pStream->NewLine();
}
if ( fNoOffsetsEmitted && fLast )
{
pStream->Write( '0' );
pStream->NewLine();
}
}
void
CG_INTERFACE::OutputThunkTableEntries( CCB * pCCB, BOOL fLast )
{
CG_PROC * pProc;
CG_ITERATOR Iterator;
ISTREAM * pStream = pCCB->GetStream();
CGSIDE Side = pCCB->GetCodeGenSide();
char * pIntfName = GetType()->GetSymName();
// IUnknown doesn't get entries in the thunk table
if ( IsIUnknown() )
{
if ( fLast )
{
pStream->Write( '0' );
pStream->NewLine();
}
return;
}
if ( IsObject() )
{
CG_OBJECT_INTERFACE * pObjInterface;
pObjInterface = (CG_OBJECT_INTERFACE *) this;
if ( pObjInterface->GetBaseInterfaceCG() )
{
pObjInterface->GetBaseInterfaceCG()->OutputThunkTableEntries( pCCB, FALSE );
}
}
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pProc ) )
{
if ( (Side == CGSIDE_CLIENT) &&
(pProc->GetCGID() != ID_CG_CALLBACK_PROC) )
continue;
if ( (Side == CGSIDE_SERVER) &&
(pProc->GetCGID() == ID_CG_CALLBACK_PROC) )
continue;
if ( pProc->NeedsServerThunk( pCCB, Side ) && !pProc->IsDelegated() )
{
pStream->Write( pIntfName );
pStream->Write( '_' );
pStream->Write( pProc->GetType()->GetSymName() );
// if( IsObject() )
pStream->Write( "_Thunk" );
}
else
pStream->Write( '0' );
if ( pProc->GetSibling() || !fLast )
pStream->Write( ',' );
pStream->NewLine();
}
}
void
CG_INTERFACE::OutputInterfaceIdComment( CCB * pCCB )
{
char TmpBuf[40];
unsigned short Major, Minor;
ISTREAM * pStream = pCCB->GetStream();
char * pIfKind = IsObject() ? "Object"
: HasPicklingStuffOnly() ? "Pickling"
: "Standard";
pStream->NewLine(2);
sprintf( TmpBuf, "/* %s interface: ", pIfKind );
pStream->Write( TmpBuf );
pStream->Write( GetInterfaceName() );
((node_interface *) GetType())->GetVersionDetails( &Major, &Minor );
sprintf( TmpBuf, ", ver. %d.%d,\n GUID=", Major, Minor );
pStream->Write( TmpBuf );
Out_Guid( pCCB, GetGuidStrs() );
pStream->Write( " */" );
pStream->NewLine();
}
Reference in a new issue Copy permalink