/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 1989-1999 Microsoft Corporation
Module Name:
ilxlat.cxx
Abstract:
Intermediate Language translator
Notes:
Author:
GregJen Jun-11-1993 Created.
Notes:
----------------------------------------------------------------------------*/
/****************************************************************************
* include files
***************************************************************************/
#include "becls.hxx"
#pragma hdrstop
#include "ilxlat.hxx"
#include "ilreg.hxx"
#include "control.hxx"
#include "tlgen.hxx"
/****************************************************************************
* local data
***************************************************************************/
// #define trace_cg 1
/****************************************************************************
* externs
***************************************************************************/
extern CMD_ARG * pCommand;
extern BOOL IsTempName( char *);
extern ccontrol * pCompiler;
extern REUSE_DICT * pReUseDict;
extern SymTable * pBaseSymTbl;
/****************************************************************************
* definitions
***************************************************************************/
void
AddToCGFileList( CG_FILE *& pCGList, CG_FILE * pFile )
{
if (pFile)
{
pFile->SetSibling( pCGList );
pCGList = pFile;
}
}
void XLAT_CTXT::InitializeMustAlign( node_skl * pPar )
{
if (pPar)
{
if (pPar->GetModifiers().IsModifierSet(ATTR_DECLSPEC_ALIGN))
{
GetMustAlign() = true;
GetMemAlign() = __max(GetMemAlign(),
pPar->GetModifiers().GetDeclspecAlign());
}
}
}
//--------------------------------------------------------------------
//
// XLAT_CTXT::~XLAT_CTXT
//
// Notes: If the node that created this context didn't remove all
// the attributes it added, force the issue. This is done
// mostly because tlb generation short-circuits code
// generation and tends to leave attributes hanging around.
// This causes asserts and possibly other problems in random
// places later on. Also note that a lot of the top-level
// stuff (interfaces, etc) don't strip much so you get lots
// of hits with those.
//
//--------------------------------------------------------------------
XLAT_CTXT::~XLAT_CTXT()
{
if ( !GetParent() || !GetParent()->HasAttributes() )
return;
named_node *pNode = dynamic_cast<named_node *>(GetParent());
type_node_list attrs;
node_base_attr *pAttr;
MIDL_ASSERT( NULL != pNode);
pNode->GetAttributeList(&attrs);
while (ITERATOR_GETNEXT(attrs, pAttr))
{
#ifdef DUMP_UNEXTRACTED_ATTRIBUTES
extern void GetSemContextString(char *, node_skl *, WALK_CTXT *);
char szContext[1024];
GetSemContextString(szContext, pNode, this);
fprintf(
stderr,
"Unextracted attribute: %s: %s\n",
pAttr->GetNodeNameString(),
szContext );
#endif
ExtractAttribute( pAttr->GetAttrID() );
}
}
//--------------------------------------------------------------------
//
// IsComplexReturn
//
// Notes: A complex return value is one that isn't be returned in an
// ordinary register. structs, unions, and floating point
// values are complex
//
//--------------------------------------------------------------------
bool IsComplexReturn(node_skl *node)
{
// straight dce doesn't support complex returns in intrepreted mode yet
if ( !pCommand->NeedsNDR64Run() )
return false;
node = node->GetNonDefSelf();
NODE_T kind = node->NodeKind();
if ( NODE_STRUCT == kind
|| NODE_UNION == kind
|| NODE_ARRAY == kind
|| NODE_FLOAT == kind
|| NODE_DOUBLE == kind
|| ( NODE_HYPER == kind && pCommand->Is32BitEnv() ) )
{
return true;
}
// REVIEW: NODE_INT64, NODE_LONGLONG
return false;
}
//--------------------------------------------------------------------
//
// node_file::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_file::ILxlate( XLAT_CTXT * pContext )
{
node_interface * pI = 0;
CG_CLASS * pcgInterfaceList = NULL;
CG_CLASS * pPrevChildCG = NULL;
CG_PROXY_FILE * pProxyCG = NULL;
CG_IID_FILE * pIidCG = NULL;
CG_TYPELIBRARY_FILE * pLibCG = NULL;
CG_NETMONSTUB_FILE * pNetmonCG = NULL;
CG_NETMONSTUB_FILE * pNetmonObjCG = NULL;
CG_CSTUB_FILE * pCCG = NULL;
CG_SSTUB_FILE * pSCG = NULL;
CG_HDR_FILE * pHCG = NULL;
CG_CLASS * pChildCG = NULL;
CG_FILE * pCGList = NULL;
char * pHdrName = pCommand->GetHeader();
XLAT_CTXT MyContext(this);
BOOL HasObjectInterface = FALSE;
BOOL HasRemoteProc = FALSE;
BOOL HasRemoteObjectProc = FALSE;
BOOL HasDefs = FALSE;
BOOL HasLibrary = FALSE;
#ifdef trace_cg
printf("..node_file,\t%s\n", GetSymName());
#endif
// don't process for imported stuff
if ( ImportLevel > 0 )
{
return NULL;
}
// at this point, there should be no more attributes...
MIDL_ASSERT( !MyContext.HasAttributes() );
//////////////////////////////////////////////////////////////////////
// compute all the child nodes
for(pI = (node_interface *)GetFirstMember();
pI;
pI = (node_interface *)pI->GetSibling())
{
// build a linked list of CG_INTERFACE and CG_OBJECT_INTERFACE nodes.
// Notes: pChildCG points to first node. pPrevChildCG points to last node.
MyContext.SetInterfaceContext( &MyContext );
pcgInterfaceList = pI->ILxlate( &MyContext );
if(pcgInterfaceList)
{
if (pPrevChildCG)
{
pPrevChildCG->SetSibling( pcgInterfaceList );
}
else
{
pChildCG = pcgInterfaceList;
}
pPrevChildCG = pcgInterfaceList;
// advance to the end of the list (skipping inherited interfaces)
while ( pPrevChildCG->GetSibling() )
pPrevChildCG = pPrevChildCG->GetSibling();
switch(pPrevChildCG->GetCGID())
{
case ID_CG_INTERFACE:
//Check for a remote procedure.
if(pPrevChildCG->GetChild())
HasRemoteProc = TRUE;
HasDefs = TRUE;
break;
case ID_CG_OBJECT_INTERFACE:
case ID_CG_INHERITED_OBJECT_INTERFACE:
HasDefs = TRUE;
HasObjectInterface = TRUE;
//Check for a remote object procedure or base interface
if( pPrevChildCG->GetChild() ||
((CG_OBJECT_INTERFACE *)pPrevChildCG)->GetBaseInterfaceCG() )
HasRemoteObjectProc = TRUE;
break;
case ID_CG_LIBRARY:
HasLibrary = TRUE;
if( pCommand->IsSwitchDefined( SWITCH_HEADER ) )
HasDefs = TRUE;
break;
default:
break;
}
}
}
// process the server and client stubs
// make the list of imported files
ITERATOR * pFileList = new ITERATOR;
named_node * pCur;
// make a list of the file nodes included directly by the main file
// start with the first child of our parent
pCur = (named_node *)
((node_source *) pContext->GetParent())
->GetFirstMember();
while ( pCur )
{
if ( ( pCur->NodeKind() == NODE_FILE ) &&
( ( (node_file *) pCur )->GetImportLevel() == 1 ) )
{
// add all the files imported at lex level 1
ITERATOR_INSERT( (*pFileList), ((void *) pCur) );
}
pCur = pCur->GetSibling();
}
ITERATOR_INIT( (*pFileList) );
//////////////////////////////////////////////////////////////////////
// manufacture the header file node
if ( HasDefs )
{
pHCG = new CG_HDR_FILE( this,
pHdrName,
pFileList);
pHCG->SetChild( pChildCG );
}
//////////////////////////////////////////////////////////////////////
// manufacture the CG_SSTUB_FILE
// if the IDL file contains at least one remotable function in a
// non-object interface, then generate a server stub file.
//
if ( HasRemoteProc &&
(pChildCG != NULL) ) // if server stub desired
{
pSCG = new CG_SSTUB_FILE(
this,
( pCommand->GenerateSStub() ) ?
pCommand->GetSstubFName():
NULL,
pHdrName
);
// plug in the child subtree and add the sstub to the head of the list
pSCG->SetChild( pChildCG );
}
//////////////////////////////////////////////////////////////////////
// manufacture the CG_CSTUB_FILE
// if the IDL file contains at least one remotable function in a
// non-object interface, then generate a client stub file.
if ( HasRemoteProc &&
(pChildCG != NULL) ) // if client stub desired
{
pCCG = new CG_CSTUB_FILE(
this,
( pCommand->GenerateCStub() ) ?
pCommand->GetCstubFName():
NULL,
pHdrName
);
pCCG->SetChild( pChildCG );
}
// If the IDL file contains at least one remotable function in an
// object interface, then generate a proxy file.
if ( HasRemoteObjectProc &&
(pChildCG != NULL) ) // if proxy file desired
{
pProxyCG = new CG_PROXY_FILE(
this,
( pCommand->GenerateProxy() ) ?
pCommand->GetProxyFName():
NULL,
pHdrName
);
pProxyCG->SetChild( pChildCG );
}
// If the IDL file contains at least one object interface,
// then generate an IID file.
if ( (HasObjectInterface || (HasLibrary && HasDefs) )&&
(pChildCG != NULL) ) // if IID file desired
{
pIidCG = new CG_IID_FILE(
this,
( pCommand->GenerateIID() ) ?
pCommand->GetIIDFName():
NULL);
pIidCG->SetChild( pChildCG );
}
// If the IDL file contains a library then gnerate a TYPELIBRARY_FILE
if (HasLibrary && (NULL != pChildCG) )
{
#ifdef _WIN64
bool fGenTypeLib = pCommand->Is64BitEnv() || ( pCommand->Is32BitEnv() && pCommand->IsSwitchDefined( SWITCH_ENV ) );
#else
bool fGenTypeLib = pCommand->Is32BitEnv() || ( pCommand->Is64BitEnv() && pCommand->IsSwitchDefined( SWITCH_ENV ) );
#endif
if ( fGenTypeLib && pCommand->GenerateTypeLibrary() )
{
pLibCG = new CG_TYPELIBRARY_FILE(
this,
pCommand->GetTypeLibraryFName() ) ;
pLibCG->SetChild( pChildCG );
}
}
// If the -netmon switch was used, generate the two NETMONSTUB_FILE's
if ( pCommand->IsNetmonStubGenerationEnabled() )
{
if (HasRemoteProc)
{
pNetmonCG = new CG_NETMONSTUB_FILE(
FALSE,
this,
pCommand->GetNetmonStubFName());
pNetmonCG->SetChild( pChildCG );
}
if (HasRemoteObjectProc)
{
pNetmonObjCG = new CG_NETMONSTUB_FILE(
TRUE,
this,
pCommand->GetNetmonStubObjFName());
pNetmonObjCG->SetChild( pChildCG );
}
}
/////////////////////////////////////////////////////////////////////
// glue all the parts together by tacking onto the head of the list.
// the final order is:
// CStub - SStub - Proxy - IID - Hdr
// doesn't need to create Hdr & tlb in ndr64 run.
pCGList = NULL;
AddToCGFileList( pCGList, pNetmonObjCG );
AddToCGFileList( pCGList, pNetmonCG );
if ( !pCommand->Is2ndCodegenRun() )
AddToCGFileList( pCGList, pHCG );
if ( !pCommand->Is2ndCodegenRun() )
AddToCGFileList( pCGList, pIidCG );
AddToCGFileList( pCGList, pProxyCG );
AddToCGFileList( pCGList, pSCG );
AddToCGFileList( pCGList, pCCG );
if ( !pCommand->Is2ndCodegenRun() )
AddToCGFileList( pCGList, pLibCG );
return pCGList;
};
//--------------------------------------------------------------------
//
// node_implicit::ILxlate
//
// Notes:
//
// This is a little bit different, since it is not a node_skl...
// therefore, it will not set up its own context
//
//--------------------------------------------------------------------
CG_CLASS *
node_implicit::ILxlate( XLAT_CTXT * pContext )
{
CG_NDR * pCG;
if ( pHandleType->NodeKind() == NODE_HANDLE_T )
{
pCG = new CG_PRIMITIVE_HANDLE( pHandleType,
pHandleID,
*pContext );
}
else // assume generic handle
{
pCG = new CG_GENERIC_HANDLE( pHandleType,
pHandleID,
*pContext );
}
#ifdef trace_cg
printf("..node_implicit,\t\n");
#endif
return pCG;
}
//--------------------------------------------------------------------
//
// node_proc::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_proc::ILxlate( XLAT_CTXT * pContext )
{
MEM_ITER MemIter( this );
node_param * pN;
CG_PROC * pCG;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
CG_CLASS * pFirstChildCG = NULL;
CG_RETURN * pReturnCG = NULL;
CG_CLASS * pBinding = NULL;
CG_CLASS * pBindingParam = NULL;
BOOL fHasCallback = FALSE;
BOOL fNoCode = FALSE;
BOOL fObject;
BOOL fRetHresult = FALSE;
BOOL fEnableAllocate;
XLAT_CTXT MyContext( this, pContext );
unsigned short OpBits = MyContext.GetOperationBits();
XLAT_CTXT * pIntfCtxt = (XLAT_CTXT *)
MyContext.GetInterfaceContext();
node_interface * pIntf = (node_interface *)
pIntfCtxt->GetParent();
node_base_attr * pNotify,
* pNotifyFlag;
BOOL HasEncode = (NULL !=
MyContext.ExtractAttribute( ATTR_ENCODE ) );
BOOL HasDecode = (NULL !=
MyContext.ExtractAttribute( ATTR_DECODE ) );
node_call_as * pCallAs = (node_call_as *)
MyContext.ExtractAttribute( ATTR_CALL_AS );
bool fLocalProc = MyContext.ExtractAttribute( ATTR_LOCAL ) != 0;
BOOL fLocal = (BOOL ) fLocalProc ||
pIntfCtxt->FInSummary( ATTR_LOCAL );
BOOL fLocalCall = IsCallAsTarget();
unsigned short SavedProcCount = 0;
unsigned short SavedCallbackProcCount = 0;
node_param * pComplexReturn = NULL;
MyContext.ExtractAttribute( ATTR_ENTRY );
MyContext.ExtractAttribute( ATTR_ID );
MyContext.ExtractAttribute( ATTR_HELPCONTEXT );
MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT );
MyContext.ExtractAttribute( ATTR_HELPSTRING );
MyContext.ExtractAttribute( ATTR_IDLDESCATTR );
MyContext.ExtractAttribute( ATTR_FUNCDESCATTR );
MyContext.ExtractAttribute( ATTR_HIDDEN );
MyContext.ExtractAttribute( ATTR_ASYNC );
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
#ifdef trace_cg
printf("..node_proc,\t%s\n", GetSymName());
#endif
BOOL fSupressHeader = FALSE;
unsigned long ulOptFlags;
unsigned long ulStackSize = 0;
node_member_attr * pMA;
while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 );
// do my attribute parsing...
fHasCallback = (NULL != MyContext.ExtractAttribute( ATTR_CALLBACK ) );
fObject = (NULL != MyContext.ExtractAttribute( ATTR_OBJECT )) ||
pIntfCtxt->FInSummary( ATTR_OBJECT );
// do my attribute parsing... attributes to ignore here
MyContext.ExtractAttribute( ATTR_OPTIMIZE );
MyContext.ExtractAttribute( ATTR_EXPLICIT );
HasEncode = HasEncode || pIntfCtxt->FInSummary( ATTR_ENCODE );
HasDecode = HasDecode || pIntfCtxt->FInSummary( ATTR_DECODE );
pNotify = MyContext.ExtractAttribute( ATTR_NOTIFY );
pNotifyFlag = MyContext.ExtractAttribute( ATTR_NOTIFY_FLAG );
fEnableAllocate = (NULL != MyContext.ExtractAttribute( ATTR_ENABLE_ALLOCATE ));
fEnableAllocate = fEnableAllocate ||
pIntfCtxt->FInSummary( ATTR_ENABLE_ALLOCATE ) ||
pCommand->IsRpcSSAllocateEnabled();
// do my attribute parsing...
// locally applied [code] attribute overrides global [nocode] attribute
fNoCode = MyContext.ExtractAttribute( ATTR_NOCODE ) ||
pIntfCtxt->FInSummary( ATTR_NOCODE );
fNoCode = !MyContext.ExtractAttribute( ATTR_CODE ) && fNoCode;
if ( NULL != MyContext.ExtractAttribute( ATTR_CSTAGRTN ) )
MyContext.SetAncestorBits( IL_CS_HAS_TAG_RTN );
BOOL fImported = FALSE;
if ( GetDefiningFile() )
{
fImported = GetDefiningFile()->GetImportLevel() != 0;
}
if ( fLocalProc && !IsCallAsTarget() && fObject )
{
SemError( this, MyContext, LOCAL_NO_CALL_AS, 0 );
}
// determine if the proc is local and
// determine the proc number (local procs don't bump the number)
if (fLocalCall || (fLocal && !fObject))
{
// return without making anything
return NULL;
}
else
{
if ( fHasCallback )
{
ProcNum = ( pIntf ->GetCallBackProcCount() )++;
}
else
{
ProcNum = ( pIntf ->GetProcCount() )++;
}
}
if ( fLocal && fObject && !MyContext.AnyAncestorBits(IL_IN_LIBRARY) )
{
if ( pIntf->IsValidRootInterface() )
{
pCG = new CG_IUNKNOWN_OBJECT_PROC( ProcNum,
this,
GetDefiningFile()->GetImportLevel() > 0,
GetOptimizationFlags(),
fHasDeny );
}
else
{
pCG = new CG_LOCAL_OBJECT_PROC( ProcNum,
this,
GetDefiningFile()->GetImportLevel() > 0,
GetOptimizationFlags(),
fHasDeny );
}
goto done;
}
SavedProcCount = pIntf->GetProcCount();
SavedCallbackProcCount = pIntf->GetCallBackProcCount();
// add the return type
if ( HasReturn() )
{
node_skl * pReturnType = GetReturnType();
CG_CLASS * pRetCG;
// If the return value is complex it is treated in ndr as if a ref
// pointer to the complex type was in the parameter list instead of
// a true return value. Temporarily add a parameter to the type
// to get the back-end parameter created.
if ( IsComplexReturn( pReturnType ) )
{
pComplexReturn = new node_param;
pComplexReturn->SetSymName( RETURN_VALUE_VAR_NAME );
pComplexReturn->SetChild( new node_pointer( pReturnType) );
pComplexReturn->GetChild()->GetModifiers().SetModifier( ATTR_TAGREF );
pComplexReturn->SetAttribute( new node_base_attr( ATTR_OUT ) );
MemIter.AddLastMember( pComplexReturn );
ITERATOR_INIT( MemIter );
}
else
{
pRetCG = pReturnType->ILxlate( &MyContext );
fRetHresult = (BOOL) ( pRetCG->GetCGID() == ID_CG_HRESULT );
pReturnCG = new CG_RETURN( pReturnType,
MyContext,
(unsigned short) RTStatuses );
pReturnCG->SetChild( pRetCG );
}
}
// at this point, there should be no more attributes...
MIDL_ASSERT( !MyContext.HasAttributes() );
pContext->ReturnSize( MyContext );
if ( MemIter.GetNumberOfArguments() > 0 )
{
//
// for each of the parameters, call the core transformer.
//
while ( ( pN = (node_param *) MemIter.GetNext() ) != 0 )
{
// REVIEW: One could argue that hidden status params
// aren't on the wire so there shouldn't be a CG node
// for them. The main problem with this is that we
// need to be able to calculate a stack offset for the
// hidden param and that can only be done in the
// back end.
// Hidden status params are not really [out] params but the way
// the -Os generator builds up local resources requires them to
// be.
if ( pN->IsExtraStatusParam()
&& ! ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) )
{
pN->SetAttribute( ATTR_OUT );
}
pChildCG = pN->ILxlate( &MyContext );
#ifdef trace_cg
printf("back from..node_param %s\n",pN->GetSymName());
printf("binding is now %08x\n",pBindingParam );
printf("child is now %08x\n",pChildCG );
#endif
// pChildCG could be NULL if it's imported from .tlb somewhere else already
if ( pChildCG )
{
// the first binding param gets picked up for binding
if ( !pBindingParam
&& pN->IsBindingParam() )
{
#ifdef trace_cg
printf("value for IsBindingParam is %08x\n",pN->IsBindingParam() );
printf("binding found on node_param %s\n",pN->GetSymName());
printf("binding is now %08x\n",pBindingParam );
#endif
pBindingParam = pChildCG;
}
// build up the parameter list
if( pPrevChildCG )
{
pPrevChildCG->SetSibling( pChildCG );
}
else
{
pFirstChildCG = pChildCG;
};
// this is only a calculated guess. We need more information to make an accurate
// estimate.
unsigned long ulSize = ( ( CG_PARAM* ) pChildCG )->GetStackSize();
ulSize += (8 - (ulSize % 8));
ulStackSize += ulSize;
pPrevChildCG = pChildCG;
}
else
SemError( this, MyContext, FAILED_TO_GENERATE_PARAM, pN->GetSymName() );
}
}
ulOptFlags = GetOptimizationFlags();
if ( ( ulOptFlags & OPTIMIZE_INTERPRETER ) &&
!( ulOptFlags & OPTIMIZE_INTERPRETER_V2 ) &&
( ulStackSize > INTERPRETER_THUNK_PARAM_SIZE_THRESHOLD ) )
{
if ( ForceNonInterpret() )
{
SemError( this, *pContext, OI_STACK_SIZE_EXCEEDED, 0 );
}
}
if ( ulOptFlags & OPTIMIZE_INTERPRETER && ulStackSize > INTERPRETER_PROC_STACK_FRAME_SIZE_THRESHOLD )
{
if ( ForceNonInterpret() )
{
SemError( this, *pContext, STACK_FRAME_SIZE_EXCEEDED, GetSymName() );
exit ( STACK_FRAME_SIZE_EXCEEDED );
}
}
if (fForcedI2 && fForcedS)
{
// ERROR - Can't force it both ways.
SemError( this, *pContext, CONFLICTING_OPTIMIZATION_REQUIREMENTS, 0 );
exit ( CONFLICTING_OPTIMIZATION_REQUIREMENTS );
}
#ifdef trace_cg
printf("done with param list for %s\n",GetSymName());
printf("binding is now %08x\n",pBindingParam );
#endif
// get the binding information
if ( pBindingParam )
{
pBinding = pBindingParam;
while (! ((CG_NDR *) pBinding)->IsAHandle() )
pBinding = pBinding->GetChild();
// pBinding now points to the node for the binding handle
}
else // implicit handle or auto handle
{
// note: if no implicit handle,
// then leave pBinding NULL for auto_handle
if (pIntfCtxt->FInSummary( ATTR_IMPLICIT ) )
{
node_implicit * pImplAttr;
pImplAttr = (node_implicit *) pIntf->GetAttribute( ATTR_IMPLICIT );
pBinding = pImplAttr->ILxlate( &MyContext );
}
}
#ifdef trace_cg
printf("done with binding for %s",GetSymName());
printf("binding is now %08x\n",pBinding );
#endif
// see if thunked interpreter needed for server side
if ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER )
{ // check for non-stdcall
ATTR_T CallingConv;
GetCallingConvention( CallingConv );
if ( ( CallingConv != ATTR_STDCALL ) &&
( CallingConv != ATTR_NONE ) )
{
SetOptimizationFlags( unsigned short( GetOptimizationFlags() | OPTIMIZE_THUNKED_INTERPRET ) );
}
else if ( pCallAs )
{
SetOptimizationFlags( unsigned short( GetOptimizationFlags() | OPTIMIZE_THUNKED_INTERPRET ) );
}
else if ( pReturnCG ) // check the return type
{
CG_NDR * pRetTypeCG = (CG_NDR *) pReturnCG->GetChild();
if ( !pCommand->NeedsNDR64Run()
&& pRetTypeCG->GetCGID() != ID_CG_CONTEXT_HDL )
{
// This check is bogus. First off, it should be checking the
// memory size, not the wire size. Secondly, for straight dce
// mode large (i.e. complex) return types are prohibited in
// semantic analysis. Finally, it should be checking the size
// against the pointer size, not 4.
if ( ( pRetTypeCG->GetWireSize() > 4 ) ||
( !pRetTypeCG->IsSimpleType() &&
!pRetTypeCG->IsPointer() ) )
SetOptimizationFlags( unsigned short( GetOptimizationFlags() | OPTIMIZE_THUNKED_INTERPRET ) );
}
}
}
if ( fHasCallback )
{
pCG = new CG_CALLBACK_PROC(
ProcNum,
this,
(CG_HANDLE *) pBinding,
(CG_PARAM *) pBindingParam,
HasAtLeastOneIn(),
HasAtLeastOneOut(),
HasAtLeastOneShipped(),
fHasStatuses,
fHasFullPointer,
pReturnCG,
GetOptimizationFlags(),
OpBits,
fHasDeny
);
}
else if ( fObject )
{
BOOL fInherited = 0;
if ( GetDefiningFile() )
{
fInherited = GetDefiningFile()->GetImportLevel() > 0;
}
if ( fInherited )
{
pCG = new CG_INHERITED_OBJECT_PROC(
ProcNum,
this,
(CG_HANDLE *) pBinding,
(CG_PARAM *) pBindingParam,
HasAtLeastOneIn(),
HasAtLeastOneOut(),
HasAtLeastOneShipped(),
fHasStatuses,
fHasFullPointer,
pReturnCG,
GetOptimizationFlags(),
OpBits,
fHasDeny
);
}
else
{
pCG = new CG_OBJECT_PROC(
ProcNum,
this,
(CG_HANDLE *) pBinding,
(CG_PARAM *) pBindingParam,
HasAtLeastOneIn(),
HasAtLeastOneOut(),
HasAtLeastOneShipped(),
fHasStatuses,
fHasFullPointer,
pReturnCG,
GetOptimizationFlags(),
OpBits,
fHasDeny
);
}
}
else if ( HasEncode || HasDecode )
{
pCG = new CG_ENCODE_PROC(
ProcNum,
this,
(CG_HANDLE *) pBinding,
(CG_PARAM *) pBindingParam,
HasAtLeastOneIn(),
HasAtLeastOneOut(),
HasAtLeastOneShipped(),
fHasStatuses,
fHasFullPointer,
pReturnCG,
GetOptimizationFlags(),
OpBits,
HasEncode,
HasDecode,
fHasDeny
);
}
else
{
pCG = new CG_PROC(
ProcNum,
this,
(CG_HANDLE *) pBinding,
(CG_PARAM *) pBindingParam,
HasAtLeastOneIn(),
HasAtLeastOneOut(),
HasAtLeastOneShipped(),
fHasStatuses,
fHasFullPointer,
pReturnCG,
GetOptimizationFlags(),
OpBits,
fHasDeny
);
}
pCG->SetChild( pFirstChildCG );
#ifdef trace_cg
printf("....returning from %s\n",GetSymName());
#endif
pIntf->GetProcCount() = SavedProcCount;
pIntf->GetCallBackProcCount() = SavedCallbackProcCount;
done:
// save a pointer to the interface CG node
pCG->SetInterfaceNode( (CG_INTERFACE*) pIntf->GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) ) );
if (fSupressHeader)
pCG->SetSupressHeader();
// mark nocode procs
if ( fNoCode )
pCG->SetNoCode();
if ( pNotify )
pCG->SetHasNotify();
if ( pNotifyFlag )
pCG->SetHasNotifyFlag();
if ( fEnableAllocate )
pCG->SetRpcSSSpecified( 1 );
if ( fRetHresult )
pCG->SetReturnsHRESULT();
if (HasPipes())
pCG->SetHasPipes(1);
if ( pCallAs )
pCG->SetCallAsName( pCallAs->GetCallAsName() );
if ( HasExtraStatusParam() )
pCG->SetHasExtraStatusParam();
if ( HasAsyncHandle() )
pCG->SetHasAsyncHandle();
if ( HasAsyncUUID() )
pCG->SetHasAsyncUUID();
if ( HasServerCorr() )
pCG->SetHasServerCorr();
if ( HasClientCorr() )
pCG->SetHasClientCorr();
// A fake parameter was added to the type for complex return values.
// Remove it.
if ( pComplexReturn )
{
pCG->SetHasComplexReturnType();
MemIter.RemoveLastMember();
}
pCG->SetCSTagRoutine( GetCSTagRoutine() );
// Typelib generation does not remove ATTR_V1_ENUM.
MyContext.ExtractAttribute( ATTR_V1_ENUM );
// at this point, there should be no more attributes...
MIDL_ASSERT( !MyContext.HasAttributes() );
if ( ( pCG->GetOptimizationFlags() & OPTIMIZE_INTERPRETER ) &&
!( pCG->GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) &&
pCommand->Is64BitEnv() )
{
SemError( this, *pContext, NO_OLD_INTERPRETER_64B, GetSymName() );
exit ( NO_OLD_INTERPRETER_64B );
}
return pCG;
}
//--------------------------------------------------------------------
//
// node_param::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_param::ILxlate( XLAT_CTXT * pContext )
{
CG_PARAM * pCG;
CG_CLASS * pChildCG = NULL;
expr_node * pSwitchExpr = NULL;
#ifdef trace_cg
printf("..node_param,\t%s\n",GetSymName());
#endif
PARAM_DIR_FLAGS F = 0;
XLAT_CTXT MyContext( this, pContext );
// make sure all member attributes get processed
node_member_attr * pMA;
MyContext.ExtractAttribute(ATTR_IDLDESCATTR);
MyContext.ExtractAttribute(ATTR_DEFAULTVALUE);
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
if ( MyContext.ExtractAttribute(ATTR_FLCID) )
{
LCID();
}
while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 )
{
switch (pMA->GetAttr())
{
case MATTR_RETVAL:
Retval();
break;
case MATTR_OPTIONAL:
{
Optional();
}
break;
default:
char * pAttrName = pMA->GetNodeNameString();
SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName);
break;
}
}
if( MyContext.ExtractAttribute( ATTR_IN ) )
{
F |= IN_PARAM;
}
if( MyContext.ExtractAttribute( ATTR_OUT ) )
{
F |= OUT_PARAM;
}
if ( MyContext.ExtractAttribute( ATTR_PARTIAL_IGNORE ) )
{
F |= PARTIAL_IGNORE_PARAM;
}
// default to in
if ( F == 0 && !IsExtraStatusParam() )
F |= IN_PARAM;
if ( MyContext.FInSummary( ATTR_SWITCH_IS ) )
{
node_switch_is * pAttr;
if ( pCommand->IsNDR64Run() )
{
pAttr = (node_switch_is *) MyContext.GetAttribute( ATTR_SWITCH_IS );
}
else
{
pAttr = (node_switch_is *) MyContext.ExtractAttribute( ATTR_SWITCH_IS );
}
pSwitchExpr = pAttr->GetExpr();
}
BOOL fHasCSSTag = ( NULL != MyContext.ExtractAttribute( ATTR_STAG ) );
BOOL fHasCSDRTag = ( NULL != MyContext.ExtractAttribute( ATTR_DRTAG ) );
BOOL fHasCSRTag = ( NULL != MyContext.ExtractAttribute( ATTR_RTAG ) );
MyContext.SetAncestorBits(
( fHasCSSTag ? IL_CS_STAG : 0 )
| ( fHasCSDRTag ? IL_CS_DRTAG : 0 )
| ( fHasCSRTag ? IL_CS_RTAG : 0 ) );
BOOL HasForceAllocate = ( NULL != MyContext.ExtractAttribute( ATTR_FORCEALLOCATE ) );
pChildCG = GetChild()->ILxlate( &MyContext );
pContext->ReturnSize( MyContext );
#ifdef trace_cg
printf("..node_param back.. %s\n",GetSymName());
#endif
// make sure void parameters get skipped
if ( !pChildCG )
return NULL;
pCG = new CG_PARAM( this,
F,
MyContext,
pSwitchExpr,
(unsigned short) Statuses );
#ifdef trace_cg
printf("..node_param ..... %08x child=%08x\n", pCG, pChildCG );
fflush(stdout);
#endif
if ( IsExtraStatusParam() )
pCG->SetIsExtraStatusParam();
// only set the bit if there was non-toplevel only
if ( fDontCallFreeInst == 1 )
pCG->SetDontCallFreeInst( TRUE );
#ifdef trace_cg
printf("..node_param ........ %08x child=%08x\n", pCG, pChildCG );
fflush(stdout);
#endif
pCG->SetChild( pChildCG );
if (IsAsyncHandleParam())
{
pCG->SetIsAsyncHandleParam();
}
if ( IsSaveForAsyncFinish() )
{
pCG->SaveForAsyncFinish();
}
pCG->SetIsCSSTag( fHasCSSTag );
pCG->SetIsCSDRTag( fHasCSDRTag );
pCG->SetIsCSRTag( fHasCSRTag );
if ( MyContext.AnyAncestorBits( IL_CS_HAS_TAG_RTN ) && pCG->IsSomeCSTag() )
pCG->SetIsOmittedParam();
#ifdef trace_cg
printf("..node_param return %s\n",GetSymName());
fflush(stdout);
#endif
if ( HasForceAllocate )
{
pCG->SetForceAllocate( );
}
if ( !MyContext.AnyAncestorBits(IL_IN_LIBRARY) )
{
SetCG( pCG );
}
// REVIEW: There is no concept of switch_type in a library block.
// Perhaps issue an error in semantic analysis.
if ( MyContext.AnyAncestorBits( IL_IN_LIBRARY )
&& MyContext.ExtractAttribute( ATTR_SWITCH_TYPE ) )
{
SemError(
this,
MyContext,
IGNORE_UNIMPLEMENTED_ATTRIBUTE,
"[switch_type] in a library block");
}
return pCG;
}
const GUID_STRS DummyGuidStrs( "00000000", "0000", "0000", "0000", "000000000000" );
// helper function for adding a new list to the end of the list of children
inline
void AddToCGList(
const CG_CLASS * pCNew,
CG_CLASS * * ppChild,
CG_CLASS * * ppLastSibling )
{
CG_CLASS * pCurrent;
CG_CLASS * pNew = (CG_CLASS *) pCNew;
// hook the head on
if ( !*ppChild )
*ppChild = pNew;
else
(*ppLastSibling)->SetSibling( pNew );
// advance the last sibling pointer
*ppLastSibling = pNew;
while ( ( pCurrent = (*ppLastSibling)->GetSibling() ) != 0 )
*ppLastSibling = pCurrent;
}
//--------------------------------------------------------------------
//
// node_interface::ILxlate
//
// Notes: This function returns either a CG_INTERFACE or a
// CG_OBJECT_INTERFACE node.
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_interface::ILxlate( XLAT_CTXT * pContext )
{
CG_NDR * pcgInterface = NULL;
CG_NDR * pResultCG = NULL;
CG_CLASS * pCG = NULL;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
MEM_ITER MemIter( this );
node_skl * pN;
XLAT_CTXT MyContext( this, pContext );
XLAT_CTXT ChildContext( MyContext );
node_guid * pGuid = (node_guid *)
MyContext.ExtractAttribute( ATTR_GUID );
GUID_STRS GuidStrs;
node_implicit * pImpHdl = NULL;
CG_HANDLE * pImpHdlCG = NULL;
NODE_T ChildKind;
BOOL IsPickle = MyContext.FInSummary( ATTR_ENCODE ) ||
MyContext.FInSummary( ATTR_DECODE );
BOOL fAllRpcSS = MyContext.FInSummary( ATTR_ENABLE_ALLOCATE ) ||
pCommand->IsRpcSSAllocateEnabled();
BOOL fObject = MyContext.FInSummary( ATTR_OBJECT );
node_interface * pBaseIntf = GetMyBaseInterface();
CG_OBJECT_INTERFACE * pBaseCG = NULL;
CG_OBJECT_INTERFACE * pCurrentCG = NULL;
CG_OBJECT_INTERFACE * pLastItfCG = 0;
BOOL fInheritedIntf = NULL;
MyContext.ExtractAttribute( ATTR_TYPEDESCATTR );
MyContext.ExtractAttribute( ATTR_HIDDEN );
MyContext.ExtractAttribute( ATTR_ASYNC );
MyContext.ExtractAttribute( ATTR_CSTAGRTN );
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
#ifdef trace_cg
printf("..node_interface,\t%s\n", GetSymName());
#endif
if( FInSummary( ATTR_IMPLICIT ) )
{
pImpHdl = (node_implicit *) GetAttribute( ATTR_IMPLICIT );
if (pImpHdl)
pImpHdlCG = (CG_HANDLE *) pImpHdl->ILxlate( &MyContext );
}
if (pGuid)
GuidStrs = pGuid->GetStrs();
else
GuidStrs = DummyGuidStrs;
// don't pass the interface attributes down...
// save them off elsewhere
ChildContext.SetInterfaceContext( &MyContext );
// if we already got spit out, don't do it again...
if ( GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) ) )
return NULL;
// start the procnum counting over
GetProcCount() = 0;
GetCallBackProcCount() = 0;
// Generate the interface's CG node first
if( fObject || MyContext.AnyAncestorBits(IL_IN_LIBRARY))
{
// object interfaces need to have their base classes generated, too
if ( pBaseIntf )
{
pBaseCG = (CG_OBJECT_INTERFACE *) pBaseIntf->GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) );
if ( !pBaseCG )
{
XLAT_CTXT BaseCtxt( &ChildContext );
BaseCtxt.SetInterfaceContext( &BaseCtxt );
pCurrentCG = (CG_OBJECT_INTERFACE *)
pBaseIntf->ILxlate( &BaseCtxt );
AddToCGList( pCurrentCG, (CG_CLASS**) &pResultCG, (CG_CLASS**) &pLastItfCG );
// our base interface made the last one on the list
pBaseCG = pLastItfCG;
}
// start the procnum from our base interface
GetProcCount() = pBaseIntf->GetProcCount();
GetCallBackProcCount() = pBaseIntf->GetCallBackProcCount();
}
if ( GetFileNode() )
{
fInheritedIntf = GetFileNode()->GetImportLevel() > 0;
}
if ( IsValidRootInterface() )
{
pcgInterface = new CG_IUNKNOWN_OBJECT_INTERFACE(this,
GuidStrs,
FALSE,
FALSE,
pBaseCG,
fInheritedIntf);
}
else if ( fInheritedIntf )
{
pcgInterface = new CG_INHERITED_OBJECT_INTERFACE(this,
GuidStrs,
FALSE,
FALSE,
pBaseCG);
}
else
{
pcgInterface = new CG_OBJECT_INTERFACE(this,
GuidStrs,
FALSE,
FALSE,
pBaseCG);
}
}
else
{
pcgInterface = new CG_INTERFACE(this,
GuidStrs,
FALSE,
FALSE,
pImpHdlCG,
pBaseCG);
}
if ( fHasMSConfStructAttr )
{
( (CG_INTERFACE*) pcgInterface)->SetHasMSConfStructAttr();
}
// store a pointer to our CG node
SetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY), pcgInterface );
// if we generated a bunch of new inherited interfaces, link us to the end
// of the list, and return the list
AddToCGList( pcgInterface, (CG_CLASS**) &pResultCG, (CG_CLASS**) &pLastItfCG );
BOOL fImported = FALSE;
if ( GetDefiningFile() )
{
fImported = GetDefiningFile()->GetImportLevel() != 0;
}
// if they specified LOCAL, don't generate any CG nodes (except for object)
if ( MyContext.FInSummary(ATTR_LOCAL) && !fObject )
{
return pResultCG;
}
//
// for each of the procedures.
//
CG_PROC * pBeginProc = NULL;
while ( ( pN = MemIter.GetNext() ) != 0 )
{
ChildKind = pN->NodeKind();
// proc nodes may hang under node_id's
if( ( ChildKind == NODE_PROC ) ||
( ( ChildKind == NODE_ID )
&& ( pN->GetChild()->NodeKind() == NODE_PROC ) ) ||
( ( ChildKind == NODE_DEF )
&& ( IsPickle ||
pN->FInSummary( ATTR_ENCODE ) ||
pN->FInSummary( ATTR_DECODE ) ) ) )
{
// skip call_as targets
if (ChildKind == NODE_PROC && ((node_proc *)pN)->IsCallAsTarget())
continue;
// translate target of call_as proc
CG_PROC * pTarget = NULL;
if (ChildKind == NODE_PROC)
{
node_proc * p = ((node_proc *)pN)->GetCallAsType();
if (p)
{
pTarget = (CG_PROC *) p->ILxlate( &ChildContext);
}
}
// translate CG_NODE
pChildCG = pN->ILxlate( &ChildContext );
// attach target of call_as proc
if ( pChildCG )
{
if (pTarget)
((CG_PROC *)pChildCG)->SetCallAsCG(pTarget);
AddToCGList( pChildCG, &pCG, &pPrevChildCG );
}
// Connect Begin and Finish async DCOM procs together.
// CloneIFAndSplitMethods always places the procedures
// immediatly under the interface with the Finish proc
// immediatly following the begin proc. This code
// will need to be changed if CloneIFAndSplitMethods
// changes.
if ( NODE_PROC == ChildKind )
{
node_proc *pProc = ( node_proc * ) pN;
if ( pProc->IsBeginProc() )
{
MIDL_ASSERT( ( ( CG_NDR * ) pChildCG )->IsProc() );
pBeginProc = ( CG_PROC * )pChildCG;
#ifndef NDEBUG
// assert that the next proc is the finish proc
MEM_ITER NewMemIter = MemIter;
named_node *pNextNode = NewMemIter.GetNext();
MIDL_ASSERT( pNextNode );
MIDL_ASSERT( NODE_PROC == pNextNode->NodeKind() );
MIDL_ASSERT( ( (node_proc *)pNextNode )->IsFinishProc() );
#endif // NDEBUG
}
else if ( pProc->IsFinishProc() )
{
MIDL_ASSERT( ( ( CG_NDR * ) pChildCG )->IsProc() );
CG_PROC *pFinishProc = ( CG_PROC * )pChildCG;
// Link the begin and finsh procs together
pBeginProc->SetIsBeginProc();
pBeginProc->SetAsyncRelative( pFinishProc );
pFinishProc->SetIsFinishProc();
pFinishProc->SetAsyncRelative( pBeginProc );
pBeginProc = NULL;
}
}
}
}
// make sure we don't have too many procs
if ( fObject && fInheritedIntf )
{
if ( ( GetProcCount() > 256 ) )
{
// complain about too many delegated routines
SemError(this, MyContext, TOO_MANY_DELEGATED_PROCS, NULL);
}
else if ( GetProcCount() > 64 )
{
pCommand->GetNdrVersionControl().SetHasMoreThan64DelegatedProcs();
}
}
// mark ourselves if we are an all RPC SS interface
// or if enable is used anywhere within.
if ( fAllRpcSS )
{
((CG_INTERFACE *)pcgInterface)->SetAllRpcSS( TRUE );
}
if ( fAllRpcSS || GetHasProcsWithRpcSs() )
{
((CG_INTERFACE *)pcgInterface)->SetUsesRpcSS( TRUE );
}
// consume all the interface attributes
MyContext.ClearAttributes();
pContext->ReturnSize( MyContext );
pcgInterface->SetChild(pCG);
return pResultCG;
}
//--------------------------------------------------------------------
//
// node_interface_reference::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_interface_reference::ILxlate( XLAT_CTXT * pContext )
{
XLAT_CTXT MyContext( this, pContext );
CG_CLASS * pCG = NULL;
#ifdef trace_cg
printf("..node_interface_reference,\t%s\n", GetSymName());
#endif
pCG = new CG_INTERFACE_POINTER( this,
(node_interface *) GetChild() );
pContext->ReturnSize( MyContext );
return pCG;
};
//--------------------------------------------------------------------
//
// node_source::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_source::ILxlate( XLAT_CTXT * pContext )
{
MEM_ITER MemIter( this );
CG_CLASS * pCG;
CG_CLASS * pNew;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
node_skl * pN;
XLAT_CTXT MyContext( this, pContext );
#ifdef trace_cg
printf("..node_source,\t%s\n", GetSymName());
#endif
pCG = (CG_CLASS *) new CG_SOURCE( this );
//
// for each of the children.
//
while ( ( pN = MemIter.GetNext() ) != 0 )
{
pChildCG = pN->ILxlate( &MyContext );
if ( pChildCG )
{
if (pPrevChildCG)
{
pPrevChildCG->SetSibling( pChildCG );
}
else
{
pCG->SetChild(pChildCG);
};
pPrevChildCG = pChildCG;
while ( ( pNew = pPrevChildCG->GetSibling() ) != 0 )
pPrevChildCG = pNew;
}
}
pContext->ReturnSize( MyContext );
return pCG;
};
//--------------------------------------------------------------------
//
// node_echo_string::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_echo_string::ILxlate( XLAT_CTXT* )
{
#ifdef trace_cg
printf("..node_echo_string,\t%s\n", GetSymName());
#endif
return 0;
};
//--------------------------------------------------------------------
//
// node_error::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_error::ILxlate( XLAT_CTXT* )
{
#ifdef trace_cg
printf("..node_error,\t%s\n", GetSymName());
#endif
return 0;
};
CG_CLASS *
Transform(
IN node_skl * pIL )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
This routine performs the translation from the type graph into the
code generation classes.
Arguments:
pIL - a pointer to the il tranformer controlling structure.
Return Value:
A pointer to the new code generator class.
Notes:
This method should be called only on placeholder nodes like struct / proc
interface, file etc.
----------------------------------------------------------------------------*/
{
XLAT_CTXT MyContext;
#ifdef trace_cg
printf("transforming...\n");
#endif
pReUseDict = new REUSE_DICT;
return pIL->ILxlate( &MyContext );
};
//--------------------------------------------------------------------
//
// node_library::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_library::ILxlate( XLAT_CTXT * pContext )
{
MEM_ITER MemIter(this);
#ifdef trace_cg
printf("..node_library,\t%s\n", GetSymName());
#endif
XLAT_CTXT MyContext( this, pContext);
if ( pCommand->IsNDR64Run() )
{
if ( !pCommand->NeedsNDRRun() )
{
SemError( this, MyContext , NDR64_ONLY_TLB, GetSymName() );
}
return NULL;
}
MyContext.SetAncestorBits(IL_IN_LIBRARY);
XLAT_CTXT ChildContext( MyContext );
// don't pass the interface attributes down...
// save them off elsewhere
ChildContext.SetInterfaceContext( &MyContext );
CG_LIBRARY * pLib = new CG_LIBRARY(this, MyContext);
named_node * pN;
CG_CLASS * pLast = NULL;
CG_CLASS * pChild = 0;
while ( ( pN = MemIter.GetNext() ) != 0 )
{
switch(pN->NodeKind())
{
case NODE_FORWARD:
{
node_interface_reference * pIRef = (node_interface_reference *)pN->GetChild();
if (pIRef)
{
if (pIRef->NodeKind() == NODE_INTERFACE_REFERENCE)
{
// create a CG_INTEFACE_REFERENCE node that points to this node
pChild = new CG_INTERFACE_REFERENCE(pIRef, ChildContext);
// make sure that the interface gets ILxlated.
CG_CLASS * pRef = pIRef->GetRealInterface()->ILxlate(&ChildContext);
pChild->SetSibling(pRef);
}
else
{
if (pIRef->NodeKind() == NODE_COCLASS)
{
// don't process this type early
pChild = NULL;
}
else
{
pChild = pN->ILxlate(&ChildContext);
if (pChild && pChild->GetSibling())
pChild = NULL;
}
}
}
else
{
pChild = 0;
}
}
break;
case NODE_INTERFACE:
{
pChild = pN->ILxlate(&ChildContext);
// skip over inherited interfaces
while (pChild && pChild->GetCGID() == ID_CG_INHERITED_OBJECT_INTERFACE)
pChild=pChild->GetSibling();
}
break;
default:
// create the appropriate CG node
pChild = pN->ILxlate(&ChildContext);
if (pChild && pChild->GetSibling()) // We must have already entered this one.
pChild = NULL;
break;
}
// attach the CG_NODE to the end of my child list
if (NULL != pChild && pChild != pLast)
{
if (pLast)
{
pLast->SetSibling(pChild);
}
else
{
pLib->SetChild(pChild);
}
pLast = pChild;
// advance past the end of the list
while (pLast->GetSibling())
pLast = pLast->GetSibling();
}
}
SetCG(FALSE, pLib);
SetCG(TRUE, pLib);
return pLib;
}
//--------------------------------------------------------------------
//
// node_module::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_module::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_module,\t%s\n", GetSymName());
#endif
CG_NDR * pcgModule = NULL;
CG_CLASS * pCG = NULL;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
MEM_ITER MemIter( this );
node_skl * pN;
XLAT_CTXT MyContext( this, pContext );
XLAT_CTXT ChildContext( MyContext );
MyContext.ExtractAttribute( ATTR_GUID );
MyContext.ExtractAttribute(ATTR_TYPEDESCATTR);
MyContext.ExtractAttribute( ATTR_HIDDEN );
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
while (MyContext.ExtractAttribute(ATTR_TYPE));
// clear member attributes
while (MyContext.ExtractAttribute(ATTR_MEMBER));
// don't pass the interface attributes down...
// save them off elsewhere
ChildContext.SetInterfaceContext( &MyContext );
// if we already got spit out, don't do it again...
if ( GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) ) )
return NULL;
// generate our CG node
pcgModule = new CG_MODULE(this, MyContext);
// store a pointer to our CG node
SetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY), pcgModule );
//
// for each of the members.
//
while ( ( pN = MemIter.GetNext() ) != 0 )
{
pChildCG = pN->ILxlate( &ChildContext );
if ( pChildCG )
{
if (NODE_PROC == pN->NodeKind())
{
((CG_PROC *)pChildCG)->SetProckind(PROC_STATIC);
}
AddToCGList( pChildCG, &pCG, &pPrevChildCG );
}
}
// consume all the interface attributes
MyContext.ClearAttributes();
pContext->ReturnSize( MyContext );
pcgModule->SetChild(pCG);
return pcgModule;
}
//--------------------------------------------------------------------
//
// node_coclass::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_coclass::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_coclass,\t%s\n", GetSymName());
#endif
CG_NDR * pcgCoclass = NULL;
CG_CLASS * pCG = NULL;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
MEM_ITER MemIter( this );
node_skl * pN;
XLAT_CTXT MyContext( this, pContext );
XLAT_CTXT ChildContext(MyContext);
MyContext.ExtractAttribute( ATTR_GUID );
MyContext.ExtractAttribute(ATTR_TYPEDESCATTR);
MyContext.ExtractAttribute( ATTR_HIDDEN );
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
while (MyContext.ExtractAttribute(ATTR_TYPE));
// clear member attributes
while (MyContext.ExtractAttribute(ATTR_MEMBER));
// don't pass the interface attributes down...
// save them off elsewhere
ChildContext.SetInterfaceContext( &MyContext );
// if we already got spit out, don't do it again...
if ( GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) ) )
return NULL ;
// generate our CG node
pcgCoclass = new CG_COCLASS(this, MyContext);
// store a pointer to our CG node
SetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY), pcgCoclass );
//
// for every member of the coclass
//
node_skl * pChild = 0;
while ( ( pN = MemIter.GetNext()) != 0 )
{
pChild = pN;
while(NODE_FORWARD == pChild->NodeKind() || NODE_HREF == pChild->NodeKind())
{
pChild = pChild->GetChild();
if ( !pChild )
{
XLAT_CTXT ChildErrContext( pN, &MyContext );
SemError( pN, ChildErrContext, UNSATISFIED_FORWARD, pN->GetSymName() );
exit( UNSATISFIED_FORWARD );
}
}
pChildCG = pChild->ILxlate( &ChildContext );
if (pChild->IsInterfaceOrObject())
{
// pChildCG = ((node_interface * )pChild)->GetCG(TRUE);
pChildCG = new CG_INTERFACE_POINTER(this, (node_interface *)pChild );
}
/*
if ( pChildCG && NODE_DISPINTERFACE == pChild->NodeKind())
{
pChildCG = new CG_INTERFACE_POINTER(this, pChild, NULL);
//((node_dispinterface *) pChild)->GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) );
}
*/
if ( pChildCG )
AddToCGList( pChildCG, &pCG, &pPrevChildCG );
}
// consume all the interface attributes
MyContext.ClearAttributes();
pContext->ReturnSize( MyContext );
pcgCoclass->SetChild(pCG);
return pcgCoclass;
}
//--------------------------------------------------------------------
//
// node_dispinterface::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_dispinterface::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_dispinterface,\t%s\n", GetSymName());
#endif
CG_NDR * pcgInterface = NULL;
CG_CLASS * pCG = NULL;
CG_CLASS * pChildCG = NULL;
CG_CLASS * pPrevChildCG = NULL;
CG_CLASS * pcgDispatch = NULL;
MEM_ITER MemIter( this );
node_skl * pN;
XLAT_CTXT MyContext( this, pContext );
XLAT_CTXT BaseContext( MyContext ); // context passed to IDispatch
XLAT_CTXT ChildContext( MyContext );
node_guid * pGuid = (node_guid *)
MyContext.ExtractAttribute( ATTR_GUID );
GUID_STRS GuidStrs;
NODE_T ChildKind;
node_interface * pBaseIntf;
MyContext.ExtractAttribute(ATTR_TYPEDESCATTR);
MyContext.ExtractAttribute( ATTR_HIDDEN );
while(MyContext.ExtractAttribute(ATTR_CUSTOM));
while (MyContext.ExtractAttribute(ATTR_TYPE));
// clear member attributes
while (MyContext.ExtractAttribute(ATTR_MEMBER));
if (pGuid)
GuidStrs = pGuid->GetStrs();
// don't pass the interface attributes down...
// save them off elsewhere
BaseContext.SetInterfaceContext( &MyContext );
ChildContext.SetInterfaceContext( &MyContext );
// if we already got spit out, don't do it again...
if ( GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) ) )
return NULL;
//
// ILxlate IDispatch
//
pcgDispatch = GetIDispatch()->ILxlate(&BaseContext);
pcgDispatch = ((node_interface *)GetIDispatch())->GetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY) );
// generate our CG node
pcgInterface = new CG_DISPINTERFACE(this, GuidStrs,(CG_OBJECT_INTERFACE *)pcgDispatch);
// store a pointer to our CG node
SetCG( MyContext.AnyAncestorBits(IL_IN_LIBRARY), pcgInterface );
// Either we have a single base interface, or we have no base interface.
pN = MemIter.GetNext();
if (pN)
{
ChildKind = pN->NodeKind();
if (ChildKind == NODE_FORWARD)
{
// We have a base interface
pBaseIntf = (node_interface *)GetMyBaseInterfaceReference();
// process the base interface
if (pBaseIntf)
{
pChildCG = pBaseIntf->ILxlate(&ChildContext);
if ( pChildCG )
AddToCGList( pChildCG, &pCG, &pPrevChildCG );
}
}
}
//
// for each of the procedures.
//
while( pN )
{
ChildKind = pN->NodeKind();
// proc nodes may hang under node_id's
if( (ChildKind == NODE_FIELD) ||
( ChildKind == NODE_PROC ) ||
( ( ChildKind == NODE_ID ) && ( pN->GetChild()->NodeKind() == NODE_PROC ) ) )
{
pChildCG = pN->ILxlate( &ChildContext );
if ( pChildCG )
AddToCGList( pChildCG, &pCG, &pPrevChildCG );
}
pN = MemIter.GetNext();
}
// consume all the interface attributes
MyContext.ClearAttributes();
pContext->ReturnSize( MyContext );
pcgInterface->SetChild(pCG);
return pcgInterface;
}
//--------------------------------------------------------------------
//
// node_pipe::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_pipe::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_pipe,\t%s\n", GetSymName());
#endif
CG_CLASS * pChildCG;
XLAT_CTXT MyContext( this, pContext );
CG_PIPE * pCG = new CG_PIPE (
this,
MyContext
);
// if /deny is not specified, ignore [range]
// if [range] is not ignored, new format string is
// generated for pipes.
if ( pCommand->IsSwitchDefined( SWITCH_ROBUST ) )
{
pCG->SetRangeAttribute( ( node_range_attr* ) MyContext.ExtractAttribute( ATTR_RANGE ) );
}
pChildCG = GetChild()->ILxlate( &MyContext );
pContext->ReturnSize( MyContext );
pCG->SetChild( pChildCG );
return pCG;
};
//--------------------------------------------------------------------
//
// node_safearray::ILxlate
//
// Notes:
//
//
//
//--------------------------------------------------------------------
CG_CLASS *
node_safearray::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_safearray,\t%s\n", GetSymName());
#endif
CG_CLASS * pChildCG;
XLAT_CTXT MyContext( this, pContext );
CG_SAFEARRAY * pCG = new CG_SAFEARRAY(this, MyContext);
// SAFEARRAY, being defined in the public IDL files, has a known
// alignment of 4. Now the struct etc. that embeds the SAFEARRAY
// may have a different alignment but the struct code will make it
// right by choosing min(ZeePee, max(children)).
// The child of the node is a type specifier from SAFEARRAY(type).
// The type alias is the LPSAFEARRAY
pCG->SetMemoryAlignment( 4 );
MyContext.GetMemAlign() = 4;
pContext->ReturnSize( MyContext );
pChildCG = GetChild()->ILxlate( &MyContext );
pCG->SetChild( pChildCG );
// If the SAFEARRAY was not used in a proxy, just pass up the SAFEARRAY class.
if ( ! fInProxy )
return pCG;
// If the SAFEARRAY was used in a proxy, pass up the the annoted node for
// LPSAFEARRAY.
CG_NDR *pTypeAliasCG = (CG_NDR*) ( GetTypeAlias()->ILxlate( pContext ) );
MIDL_ASSERT( pTypeAliasCG->GetCGID() == ID_CG_USER_MARSHAL );
CG_USER_MARSHAL *pUserMarshalCG = (CG_USER_MARSHAL *)pTypeAliasCG;
pUserMarshalCG->SetTypeDescGenerator( pCG );
return pUserMarshalCG;
}
CG_CLASS*
node_async_handle::ILxlate( XLAT_CTXT * pContext )
{
#ifdef trace_cg
printf("..node_async_handle,\t%s\n", GetSymName());
#endif
XLAT_CTXT MyContext( this, pContext );
CG_ASYNC_HANDLE* pAsyncHdl = new CG_ASYNC_HANDLE( this, MyContext );
return pAsyncHdl;
}
CG_CLASS*
node_midl_pragma::ILxlate( XLAT_CTXT* )
{
return 0;
}
CG_CLASS*
node_decl_guid::ILxlate( XLAT_CTXT* )
{
return 0;
}