mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1161 lines
25 KiB
1161 lines
25 KiB
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
misccls.hxx
|
|
|
|
Abstract:
|
|
|
|
cg classes for miscellaneous nodes.
|
|
|
|
Notes:
|
|
|
|
|
|
History:
|
|
|
|
----------------------------------------------------------------------------*/
|
|
#ifndef __MISCCLS_HXX__
|
|
#define __MISCCLS_HXX__
|
|
|
|
#include "ndrcls.hxx"
|
|
#include "auxcls.hxx"
|
|
#include "bindcls.hxx"
|
|
|
|
|
|
class node_file;
|
|
class node_interface;
|
|
class node_source;
|
|
|
|
|
|
class CG_INTERFACE : public CG_NDR
|
|
{
|
|
private:
|
|
|
|
//
|
|
// CG nodes for the implicit handle, if any...
|
|
//
|
|
|
|
CG_HANDLE * pImpHdlCG;
|
|
|
|
//
|
|
// Store the Protseq endpoint count. This count is 0 if the
|
|
// endpoint attribute was not specified.
|
|
//
|
|
|
|
short ProtSeqEPCount;
|
|
|
|
//
|
|
// flags.
|
|
//
|
|
|
|
BOOL fMopsPresent : 1;
|
|
BOOL fCallbacksPresent : 1;
|
|
BOOL fAllRpcSS : 1;
|
|
BOOL fUsesRpcSS : 1;
|
|
BOOL fHasPipes : 1;
|
|
|
|
NdrVersionControl VersionControl; // compiler evaluation
|
|
//
|
|
// This set of fields gathers info about dispatch tables. There is a
|
|
// normal dispatch table and a callback dispatch table. We keep separate
|
|
// dictionaries for these dispatch tables.
|
|
//
|
|
|
|
DISPATCH_TABLE * pNormalDispatchTable;
|
|
|
|
DISPATCH_TABLE * pCallbackDispatchTable;
|
|
|
|
DISPATCH_TABLE ** ppDispatchTable;
|
|
|
|
DISPATCH_TABLE ** ppDispatchTableSaved;
|
|
|
|
void * _pCTI;
|
|
|
|
protected:
|
|
//
|
|
// Interface's stub descriptor name.
|
|
//
|
|
|
|
char * pStubDescName;
|
|
|
|
//
|
|
// Store the 5 are components of the guid.
|
|
//
|
|
|
|
GUID_STRS GuidStrs;
|
|
|
|
// handy place to cache the interface name
|
|
char * pIntfName;
|
|
|
|
// used when enumerating all base classes
|
|
BOOL fVisited;
|
|
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_INTERFACE(
|
|
node_interface * pI,
|
|
GUID_STRS GStrs,
|
|
BOOL CallbacksYes,
|
|
BOOL fMopsYes,
|
|
CG_HANDLE * pIH
|
|
);
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_INTERFACE;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsObject()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsIUnknown()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsDispatchable(BOOL fInTypeLib)
|
|
{
|
|
CG_CLASS * pCG;
|
|
named_node * pBaseIntf;
|
|
|
|
if (0 == _stricmp("IDispatch", pIntfName ) )
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
if (pBaseIntf = ((node_interface *)(GetType()))->GetMyBaseInterfaceReference())
|
|
{
|
|
node_interface_reference * pRef = (node_interface_reference *)pBaseIntf;
|
|
// skip forward reference if necessary
|
|
if (pRef->NodeKind() == NODE_FORWARD)
|
|
{
|
|
pRef = (node_interface_reference *)pRef->GetChild();
|
|
}
|
|
pCG = ((node_interface *)(pRef->GetChild()))->GetCG( fInTypeLib );
|
|
|
|
return ((CG_INTERFACE *)pCG)->IsDispatchable(fInTypeLib);
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
char * GetInterfaceName()
|
|
{
|
|
return pIntfName;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenClientStub( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenServerStub( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB );
|
|
|
|
//
|
|
// Generate typeinfo
|
|
//
|
|
virtual
|
|
CG_STATUS GenTypeInfo( CCB * pCCB);
|
|
|
|
//
|
|
// Get And set methods.
|
|
//
|
|
|
|
CG_HANDLE * GetImplicitHandle()
|
|
{
|
|
return pImpHdlCG;
|
|
}
|
|
|
|
char * GetStubDescName()
|
|
{
|
|
return pStubDescName;
|
|
}
|
|
|
|
BOOL SetAllRpcSS( BOOL f )
|
|
{
|
|
return (fAllRpcSS = f);
|
|
}
|
|
|
|
BOOL IsAllRpcSS()
|
|
{
|
|
return fAllRpcSS;
|
|
}
|
|
|
|
void SetUsesRpcSS( BOOL f )
|
|
{
|
|
fUsesRpcSS = f;
|
|
}
|
|
|
|
BOOL GetUsesRpcSS()
|
|
{
|
|
return fUsesRpcSS;
|
|
}
|
|
|
|
BOOL SetHasPipes( BOOL f )
|
|
{
|
|
return (fHasPipes = f);
|
|
}
|
|
|
|
BOOL HasPipes()
|
|
{
|
|
return fHasPipes;
|
|
}
|
|
|
|
NdrVersionControl & GetNdrVersionControl()
|
|
{
|
|
return( VersionControl );
|
|
}
|
|
virtual
|
|
void EvaluateVersionControl();
|
|
|
|
virtual
|
|
BOOL HasStublessProxies()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL HasItsOwnOi2();
|
|
|
|
virtual
|
|
BOOL HasOi2()
|
|
{
|
|
return VersionControl.HasOi2();
|
|
}
|
|
|
|
|
|
//
|
|
// Dispatch table management functions.
|
|
//
|
|
|
|
void CreateDispatchTables();
|
|
|
|
void SetDispatchTBLPtrForCallback()
|
|
{
|
|
ppDispatchTable = &pCallbackDispatchTable;
|
|
}
|
|
|
|
void RestoreDispatchTBLPtr()
|
|
{
|
|
ppDispatchTable = &pNormalDispatchTable;
|
|
}
|
|
|
|
void RegisterProcedure( node_skl * pProc,
|
|
DISPATCH_TABLE_FLAGS Flags )
|
|
{
|
|
(*ppDispatchTable)->RegisterProcedure(pProc, Flags);
|
|
}
|
|
|
|
unsigned short GetNormalProcedureCount()
|
|
{
|
|
return pNormalDispatchTable->GetCount();
|
|
}
|
|
|
|
unsigned short GetCallbackProcedureCount()
|
|
{
|
|
return pCallbackDispatchTable->GetCount();
|
|
}
|
|
|
|
unsigned short GetNormalProcedureList(
|
|
ITERATOR& NormalProcList,
|
|
DISPATCH_TABLE_FLAGS Flags
|
|
)
|
|
{
|
|
return pNormalDispatchTable->GetProcList(
|
|
NormalProcList,
|
|
Flags
|
|
);
|
|
}
|
|
|
|
unsigned short GetCallbackProcedureList(
|
|
ITERATOR& CallbackProcList,
|
|
DISPATCH_TABLE_FLAGS Flags )
|
|
{
|
|
return pCallbackDispatchTable->GetProcList(
|
|
CallbackProcList,
|
|
Flags
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
// miscellaneous methods.
|
|
//
|
|
|
|
ITERATOR * GetProtSeqEps();
|
|
|
|
char * GetCBDispatchTableName()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
char * GetMopIInfoName()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
BOOL HasInterpretedProc();
|
|
BOOL HasOnlyInterpretedProcs();
|
|
BOOL HasInterpretedCallbackProc();
|
|
BOOL HasClientInterpretedCommOrFaultProc(
|
|
CCB * pCCB );
|
|
|
|
BOOL IsLastInterface()
|
|
{
|
|
return !( ( BOOL ) GetSibling() );
|
|
}
|
|
|
|
CG_STATUS InitializeCCB( CCB * pCCB );
|
|
|
|
void OutputProcOffsets( CCB * pCCB, BOOL fLast, BOOL fLocal );
|
|
|
|
void OutputThunkTableEntries( CCB * pCCB, BOOL fLast );
|
|
|
|
virtual
|
|
node_skl * GetThisDeclarator()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void GetMyMemberFunctions( ITERATOR & I )
|
|
{
|
|
GetMembers( I );
|
|
}
|
|
|
|
void GetMyMemberFunctions( CG_ITERATOR & I )
|
|
{
|
|
GetMembers( I );
|
|
}
|
|
|
|
virtual
|
|
void GetAllMemberFunctions( ITERATOR & I )
|
|
{
|
|
GetMyMemberFunctions( I );
|
|
}
|
|
|
|
BOOL HasPicklingStuff()
|
|
{
|
|
CG_ITERATOR I;
|
|
CG_NDR * pCG;
|
|
|
|
if( GetMembers( I ) )
|
|
{
|
|
while( ITERATOR_GETNEXT( I, pCG ) )
|
|
{
|
|
if (pCG->GetCGID() == ID_CG_ENCODE_PROC ||
|
|
pCG->GetCGID() == ID_CG_TYPE_ENCODE_PROC
|
|
)
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL HasPicklingStuffOnly()
|
|
{
|
|
CG_ITERATOR I;
|
|
CG_NDR * pCG;
|
|
|
|
if( GetMembers( I ) )
|
|
{
|
|
while( ITERATOR_GETNEXT( I, pCG ) )
|
|
{
|
|
if (pCG->GetCGID() != ID_CG_ENCODE_PROC &&
|
|
pCG->GetCGID() != ID_CG_TYPE_ENCODE_PROC
|
|
)
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
virtual
|
|
void GetListOfUniqueBaseInterfaces( ITERATOR & )
|
|
{
|
|
}
|
|
|
|
void MarkVisited( BOOL fMark )
|
|
{
|
|
fVisited = fMark;
|
|
}
|
|
|
|
|
|
BOOL IsVisited()
|
|
{
|
|
return fVisited;
|
|
}
|
|
|
|
void GetGuidStrs( char * &p1,
|
|
char * &p2,
|
|
char * &p3,
|
|
char * &p4,
|
|
char * &p5 )
|
|
{
|
|
GuidStrs.GetStrs( p1, p2, p3, p4, p5 );
|
|
}
|
|
|
|
GUID_STRS & GetGuidStrs()
|
|
{
|
|
return GuidStrs;
|
|
}
|
|
|
|
void OutputInterfaceIdComment( CCB * pCCB );
|
|
|
|
};
|
|
|
|
|
|
class CG_OBJECT_INTERFACE : public CG_INTERFACE
|
|
{
|
|
|
|
// the CG node for the base interface; It may be a normal object interface
|
|
// or it may be an inherited object interface
|
|
CG_OBJECT_INTERFACE * pBaseCG;
|
|
|
|
// a node_id declaration for the this pointer for this interface
|
|
node_skl * pThisDeclarator;
|
|
|
|
BOOL fLocal; // whether intf is local
|
|
BOOL fForcedDelegation; // some weird cases
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_OBJECT_INTERFACE(
|
|
node_interface * pI,
|
|
GUID_STRS GStrs,
|
|
BOOL fCallbacksYes,
|
|
BOOL fMopsYes,
|
|
CG_OBJECT_INTERFACE * pBCG
|
|
);
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_OBJECT_INTERFACE;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsObject()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// interfaces in the current file that are [local] are delegated
|
|
virtual
|
|
BOOL IsDelegated()
|
|
{
|
|
return fLocal;
|
|
}
|
|
|
|
BOOL HasForcedDelegation()
|
|
{
|
|
return fForcedDelegation;
|
|
}
|
|
|
|
void SetHasForcedDelegation()
|
|
{
|
|
fForcedDelegation = 1;
|
|
}
|
|
|
|
CG_OBJECT_INTERFACE * GetDelegatedInterface()
|
|
{
|
|
CG_OBJECT_INTERFACE * pBaseCG = this;
|
|
|
|
while ( pBaseCG = pBaseCG->GetBaseInterfaceCG() )
|
|
{
|
|
if ( pBaseCG->IsDelegated() )
|
|
return pBaseCG;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CG_OBJECT_INTERFACE * SetBaseInterfaceCG( CG_OBJECT_INTERFACE * pCG )
|
|
{
|
|
return ( pBaseCG = pCG );
|
|
}
|
|
|
|
CG_OBJECT_INTERFACE * GetBaseInterfaceCG()
|
|
{
|
|
return pBaseCG;
|
|
}
|
|
|
|
BOOL IsLastObjectInterface();
|
|
BOOL HasOnlyInterpretedMethods();
|
|
|
|
BOOL IsLocal()
|
|
{
|
|
return fLocal;
|
|
}
|
|
|
|
BOOL HasItsOwnStublessProxies();
|
|
|
|
virtual
|
|
void EvaluateVersionControl();
|
|
|
|
virtual
|
|
BOOL HasStublessProxies()
|
|
{
|
|
return GetNdrVersionControl()
|
|
.HasStublessProxies();
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenComClassServerMembers( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS ReGenComClassServerMembers( CCB * pCCB );
|
|
|
|
//
|
|
// miscellaneous methods.
|
|
//
|
|
|
|
CG_STATUS CPlusPlusLanguageBinding(CCB *pCCB);
|
|
|
|
CG_STATUS CLanguageBinding(CCB *pCCB);
|
|
|
|
CG_STATUS ProxyPrototypes(CCB *pCCB);
|
|
|
|
CG_STATUS GenInterfaceProxy( CCB *pCCB, unsigned long index);
|
|
|
|
CG_STATUS GenInterfaceStub( CCB *pCCB, unsigned long index);
|
|
|
|
unsigned long CountMemberFunctions();
|
|
|
|
unsigned long PrintProxyMemberFunctions( ISTREAM * pStream,
|
|
BOOL fForcesDelegation );
|
|
|
|
unsigned long PrintStubMemberFunctions( ISTREAM * pStream );
|
|
|
|
STATUS_T PrintVtableEntries( CCB * pCCB );
|
|
|
|
STATUS_T PrintMemberFunctions( ISTREAM * pStream,
|
|
BOOL fAbstract = TRUE );
|
|
|
|
virtual
|
|
node_skl * GetThisDeclarator()
|
|
{
|
|
return pThisDeclarator;
|
|
}
|
|
|
|
virtual
|
|
void GetAllMemberFunctions( ITERATOR & I )
|
|
{
|
|
if ( pBaseCG )
|
|
pBaseCG->GetAllMemberFunctions( I );
|
|
|
|
GetMyMemberFunctions( I );
|
|
}
|
|
|
|
CG_STATUS CLanguageMacros(CCB *pCCB);
|
|
|
|
CG_STATUS PrintCMacros(CCB *pCCB);
|
|
|
|
virtual
|
|
void GetListOfUniqueBaseInterfaces( ITERATOR & );
|
|
|
|
|
|
};
|
|
|
|
class CG_INHERITED_OBJECT_INTERFACE : public CG_OBJECT_INTERFACE
|
|
{
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_INHERITED_OBJECT_INTERFACE(
|
|
node_interface * pI,
|
|
GUID_STRS GStrs,
|
|
BOOL fCallbacksYes,
|
|
BOOL fMopsYes,
|
|
CG_OBJECT_INTERFACE * pBCG
|
|
) : CG_OBJECT_INTERFACE(
|
|
pI,
|
|
GStrs,
|
|
fCallbacksYes,
|
|
fMopsYes,
|
|
pBCG )
|
|
{
|
|
};
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_INHERITED_OBJECT_INTERFACE;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB )
|
|
{
|
|
return CG_OK;
|
|
}
|
|
|
|
CG_STATUS GenInterfaceProxy( CCB *pCCB,
|
|
unsigned long index)
|
|
{
|
|
return CG_OK;
|
|
}
|
|
|
|
CG_STATUS GenInterfaceStub( CCB *pCCB,
|
|
unsigned long index)
|
|
{
|
|
return CG_OK;
|
|
}
|
|
|
|
//
|
|
// miscellaneous methods.
|
|
//
|
|
|
|
// interfaces inherited from another file are delegated
|
|
virtual
|
|
BOOL IsDelegated()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
};
|
|
|
|
class CG_IUNKNOWN_OBJECT_INTERFACE : public CG_INHERITED_OBJECT_INTERFACE
|
|
{
|
|
|
|
BOOL fInherited;
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_IUNKNOWN_OBJECT_INTERFACE(
|
|
node_interface * pI,
|
|
GUID_STRS GStrs,
|
|
BOOL fCallbacksYes,
|
|
BOOL fMopsYes,
|
|
CG_OBJECT_INTERFACE * pBCG,
|
|
BOOL fInh
|
|
) : CG_INHERITED_OBJECT_INTERFACE(
|
|
pI,
|
|
GStrs,
|
|
fCallbacksYes,
|
|
fMopsYes,
|
|
pBCG )
|
|
{
|
|
fInherited = fInh;
|
|
};
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
if ( fInherited )
|
|
return CG_INHERITED_OBJECT_INTERFACE::GetCGID();
|
|
else
|
|
return CG_OBJECT_INTERFACE::GetCGID();
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB )
|
|
{
|
|
if ( fInherited )
|
|
return CG_INHERITED_OBJECT_INTERFACE::GenCode( pCCB );
|
|
else
|
|
return CG_OBJECT_INTERFACE::GenCode( pCCB );
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB )
|
|
{
|
|
if ( fInherited )
|
|
return CG_INHERITED_OBJECT_INTERFACE::GenHeader( pCCB );
|
|
else
|
|
return CG_OBJECT_INTERFACE::GenHeader( pCCB );
|
|
}
|
|
|
|
CG_STATUS GenInterfaceProxy( CCB *pCCB,
|
|
unsigned long index)
|
|
{
|
|
if ( fInherited )
|
|
return CG_INHERITED_OBJECT_INTERFACE::GenInterfaceProxy( pCCB, index );
|
|
else
|
|
return CG_OBJECT_INTERFACE::GenInterfaceProxy( pCCB, index );
|
|
}
|
|
|
|
CG_STATUS GenInterfaceStub( CCB *pCCB,
|
|
unsigned long index)
|
|
{
|
|
if ( fInherited )
|
|
return CG_INHERITED_OBJECT_INTERFACE::GenInterfaceStub( pCCB, index );
|
|
else
|
|
return CG_OBJECT_INTERFACE::GenInterfaceStub( pCCB, index );
|
|
}
|
|
|
|
//
|
|
// miscellaneous methods.
|
|
//
|
|
|
|
// IUnknown is never delegated
|
|
virtual
|
|
BOOL IsDelegated()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsIUnknown()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
};
|
|
|
|
class CG_COM_CLASS : public CG_OBJECT_INTERFACE
|
|
{
|
|
|
|
// the CG nodes for the base interfaces; They may be normal object interfaces
|
|
// or inherited object interfaces
|
|
ITERATOR * pBaseCGList;
|
|
|
|
// a node_id declaration for the this pointer for this interface
|
|
node_skl * pThisDeclarator;
|
|
|
|
// indicate whether this is an all-local interface
|
|
BOOL fLocal;
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_COM_CLASS(
|
|
node_interface * pI,
|
|
GUID_STRS GStrs,
|
|
BOOL fCallbacksYes,
|
|
BOOL fMopsYes,
|
|
ITERATOR * pBCG
|
|
);
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_COM_CLASS;
|
|
}
|
|
|
|
ITERATOR * SetBaseInterfaceCGList( ITERATOR * pList )
|
|
{
|
|
return ( pBaseCGList = pList );
|
|
}
|
|
|
|
ITERATOR * GetBaseInterfaceCGList()
|
|
{
|
|
return pBaseCGList;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenComClassServer( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS ReGenComClassServer( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenComClassFactory( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenComClassIUnknown( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenComClassConstructor( CCB * pCCB,
|
|
char * pDesignatedClassName );
|
|
|
|
CG_STATUS DumpAllMethodsToHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenAllocatorHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenEmbeddedIUnknownHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenComClassFactoryHeader(CCB *pCCB);
|
|
|
|
virtual
|
|
void GetListOfUniqueBaseInterfaces( ITERATOR & );
|
|
|
|
CG_STATUS GenComOuterUnknown( CCB * pCCB,
|
|
char * pDesignatedClassName );
|
|
|
|
CG_STATUS GenComInnerUnknown( CCB * pCCB,
|
|
char * pDesignatedClassName );
|
|
|
|
CG_STATUS GenComClassFactoryCreateInstance( CCB * pCCB );
|
|
|
|
CG_STATUS GenComClassFactoryTables( CCB * pCCB );
|
|
|
|
};
|
|
|
|
class CG_COM_SERVER : public CG_NDR
|
|
{
|
|
|
|
// the CG nodes for the COM classes
|
|
ITERATOR * pBaseCGList;
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_COM_SERVER(
|
|
node_com_server * pI,
|
|
ITERATOR * pBCG
|
|
);
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_COM_CLASS;
|
|
}
|
|
|
|
ITERATOR * GetClassList()
|
|
{
|
|
return pBaseCGList;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsObject()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenHeader( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenDataStructures( CCB * pCCB )
|
|
{
|
|
return CG_OK;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenClassFactoryArray( CCB * pCCB );
|
|
|
|
|
|
};
|
|
|
|
class CG_COM_SERVER_DLL : public CG_COM_SERVER
|
|
{
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_COM_SERVER_DLL(
|
|
node_com_server * pI,
|
|
ITERATOR * pBCG
|
|
)
|
|
: CG_COM_SERVER( pI, pBCG )
|
|
{
|
|
}
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_COM_SERVER_DLL;
|
|
}
|
|
|
|
|
|
virtual
|
|
CG_STATUS GenDataStructures( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenEntryPts( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenRegistryEntryPts( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenDllDefFile( CCB * pCCB );
|
|
|
|
};
|
|
|
|
class CG_COM_SERVER_EXE : public CG_COM_SERVER
|
|
{
|
|
|
|
public:
|
|
|
|
//
|
|
// The constructor.
|
|
//
|
|
|
|
CG_COM_SERVER_EXE(
|
|
node_com_server * pI,
|
|
ITERATOR * pBCG
|
|
)
|
|
: CG_COM_SERVER( pI, pBCG )
|
|
{
|
|
}
|
|
|
|
//
|
|
// code generation methods.
|
|
//
|
|
virtual
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_COM_SERVER_EXE;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenCode( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenMain( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenDataStructures( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenCleanupRoutines( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenIteratorClass( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenClassRegisterRevoke( CCB * pCCB );
|
|
|
|
virtual
|
|
CG_STATUS GenRegistryCode( CCB * pCCB );
|
|
|
|
};
|
|
|
|
class CG_LIBRARY : public CG_NDR
|
|
{
|
|
public:
|
|
CG_LIBRARY ( node_library * pLib, XLAT_SIZE_INFO & szInfo )
|
|
: CG_NDR ( pLib, szInfo )
|
|
{
|
|
}
|
|
|
|
CG_STATUS GenTypeInfo(CCB * pCCB);
|
|
|
|
virtual
|
|
CG_STATUS GenHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenCode(CCB * pCCB)
|
|
{
|
|
UNUSED(pCCB);
|
|
return CG_OK;
|
|
}
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_LIBRARY;
|
|
}
|
|
};
|
|
|
|
class CG_INTERFACE_REFERENCE : public CG_NDR
|
|
{
|
|
private:
|
|
public:
|
|
CG_INTERFACE_REFERENCE ( node_interface_reference * pRef, XLAT_SIZE_INFO & szInfo )
|
|
: CG_NDR ( pRef, szInfo )
|
|
{
|
|
}
|
|
|
|
CG_STATUS GenTypeInfo(CCB * pCCB);
|
|
|
|
virtual
|
|
CG_STATUS GenHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenCode(CCB * pCCB)
|
|
{
|
|
UNUSED(pCCB);
|
|
return CG_OK;
|
|
}
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_INTERFACE_REFERENCE;
|
|
}
|
|
};
|
|
|
|
class CG_DISPINTERFACE : public CG_OBJECT_INTERFACE
|
|
{
|
|
private:
|
|
GUID_STRS GuidStrs;
|
|
void * _pCTI;
|
|
CG_CLASS * _pcgDispatch;
|
|
public:
|
|
CG_DISPINTERFACE (
|
|
node_dispinterface * pI,
|
|
GUID_STRS GStrs,
|
|
CG_OBJECT_INTERFACE * pBCG
|
|
) : CG_OBJECT_INTERFACE(pI, GStrs, FALSE, FALSE, pBCG)
|
|
{
|
|
GuidStrs = GStrs;
|
|
GuidStrs.SetValue();
|
|
_pCTI = NULL;
|
|
_pcgDispatch = pBCG;
|
|
}
|
|
|
|
CG_STATUS GenTypeInfo(CCB * pCCB);
|
|
|
|
virtual
|
|
CG_STATUS GenHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenCode(CCB * pCCB)
|
|
{
|
|
UNUSED(pCCB);
|
|
return CG_OK;
|
|
}
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_DISPINTERFACE;
|
|
}
|
|
|
|
CG_CLASS * GetCGDispatch(void)
|
|
{
|
|
return _pcgDispatch;
|
|
}
|
|
};
|
|
|
|
class CG_MODULE : public CG_NDR
|
|
{
|
|
private:
|
|
void * _pCTI;
|
|
public:
|
|
CG_MODULE ( node_module * pMod, XLAT_SIZE_INFO & szInfo )
|
|
: CG_NDR ( pMod, szInfo )
|
|
{
|
|
_pCTI = NULL;
|
|
}
|
|
|
|
CG_STATUS GenTypeInfo(CCB * pCCB);
|
|
|
|
virtual
|
|
CG_STATUS GenHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenCode(CCB * pCCB)
|
|
{
|
|
UNUSED(pCCB);
|
|
return CG_OK;
|
|
}
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_MODULE;
|
|
}
|
|
};
|
|
|
|
class CG_COCLASS : public CG_NDR
|
|
{
|
|
private:
|
|
void * _pCTI;
|
|
public:
|
|
CG_COCLASS ( node_coclass * pCoclass, XLAT_SIZE_INFO & szInfo )
|
|
: CG_NDR ( pCoclass, szInfo )
|
|
{
|
|
_pCTI = NULL;
|
|
}
|
|
|
|
virtual
|
|
CG_STATUS GenTypeInfo(CCB * pCCB);
|
|
|
|
virtual
|
|
CG_STATUS GenHeader(CCB *pCCB);
|
|
|
|
CG_STATUS GenCode(CCB * pCCB)
|
|
{
|
|
UNUSED(pCCB);
|
|
return CG_OK;
|
|
}
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_COCLASS;
|
|
}
|
|
};
|
|
|
|
class CG_SAFEARRAY : public CG_NDR
|
|
{
|
|
private:
|
|
public:
|
|
CG_SAFEARRAY ( node_safearray * pSA, XLAT_SIZE_INFO & szInfo )
|
|
: CG_NDR ( pSA, szInfo )
|
|
{
|
|
}
|
|
|
|
//
|
|
// TYPEDESC generation routine
|
|
//
|
|
virtual
|
|
CG_STATUS GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB);
|
|
|
|
ID_CG GetCGID()
|
|
{
|
|
return ID_CG_SAFEARRAY;
|
|
}
|
|
};
|
|
|
|
#endif // __MISCCLS_HXX__
|
|
|
|
|
|
|