1424 lines
39 KiB
C++
1424 lines
39 KiB
C++
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
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();
|
|
}
|
|
|
|
|
|
|