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.
377 lines
11 KiB
377 lines
11 KiB
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ndrcls.cxx
|
|
|
|
Abstract:
|
|
|
|
Routines for the ndrcls code generation class.
|
|
|
|
Notes:
|
|
|
|
|
|
History:
|
|
|
|
Aug-31-1993 VibhasC Created.
|
|
----------------------------------------------------------------------------*/
|
|
|
|
/****************************************************************************
|
|
* include files
|
|
***************************************************************************/
|
|
#include "becls.hxx"
|
|
#pragma hdrstop
|
|
|
|
/****************************************************************************
|
|
* local definitions
|
|
***************************************************************************/
|
|
/****************************************************************************
|
|
* local data
|
|
***************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* externs
|
|
***************************************************************************/
|
|
/****************************************************************************/
|
|
|
|
expr_node *
|
|
CG_NDR::PresentedLengthExpression( CCB* )
|
|
{
|
|
expr_sizeof * pExpr = new expr_sizeof( GetType() );
|
|
return pExpr;
|
|
}
|
|
|
|
expr_node *
|
|
CG_NDR::PresentedSizeExpression( CCB* )
|
|
{
|
|
expr_sizeof * pExpr = new expr_sizeof( GetType() );
|
|
return pExpr;
|
|
}
|
|
expr_node *
|
|
CG_NDR::PresentedFirstExpression( CCB* )
|
|
{
|
|
return new expr_constant(0L);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
utility functions
|
|
****************************************************************************/
|
|
CG_STATUS
|
|
CG_NDR::SizeAnalysis( ANALYSIS_INFO * pAna )
|
|
{
|
|
pAna;
|
|
return CG_OK;
|
|
}
|
|
CG_STATUS
|
|
CG_NDR::MarshallAnalysis( ANALYSIS_INFO * pAna )
|
|
{
|
|
pAna;
|
|
return CG_OK;
|
|
}
|
|
|
|
node_skl *
|
|
CG_NDR::GetBasicType()
|
|
{
|
|
node_skl * pT = GetType();
|
|
|
|
switch (pT->NodeKind())
|
|
{
|
|
case NODE_ID:
|
|
case NODE_FIELD:
|
|
case NODE_PARAM:
|
|
case NODE_DEF:
|
|
return pT->GetBasicType();
|
|
}
|
|
return pT;
|
|
}
|
|
|
|
CG_STATUS
|
|
CG_NDR::RefCheckAnalysis(
|
|
ANALYSIS_INFO * pAna )
|
|
{
|
|
CG_NDR * pC = (CG_NDR *)GetChild();
|
|
|
|
if( pC )
|
|
pC->RefCheckAnalysis( pAna );
|
|
|
|
return CG_OK;
|
|
}
|
|
|
|
CG_STATUS
|
|
CG_NDR::InLocalAnalysis(
|
|
ANALYSIS_INFO * pAna )
|
|
{
|
|
CG_NDR * pC = (CG_NDR *)GetChild();
|
|
|
|
if( pC )
|
|
pC->InLocalAnalysis( pAna );
|
|
|
|
return CG_OK;
|
|
}
|
|
|
|
CG_STATUS
|
|
CG_NDR::S_GenInitInLocals(
|
|
CCB * pCCB )
|
|
{
|
|
CG_NDR * pC = (CG_NDR *)GetChild();
|
|
|
|
if( pC )
|
|
pC->S_GenInitInLocals( pCCB );
|
|
|
|
return CG_OK;
|
|
}
|
|
|
|
CG_STATUS
|
|
CG_NDR::GenRefChecks(
|
|
CCB * pCCB )
|
|
{
|
|
CG_NDR * pC = (CG_NDR *)GetChild();
|
|
|
|
if( pC )
|
|
pC->GenRefChecks( pCCB );
|
|
|
|
return CG_OK;
|
|
}
|
|
|
|
extern CMD_ARG * pCommand;
|
|
|
|
void
|
|
CG_NDR::GetNdrParamAttributes( CCB *pCCB, PARAM_ATTRIBUTES *attributes)
|
|
{
|
|
CG_PARAM * pParam;
|
|
CG_NDR * pChild;
|
|
CG_PROC * pProc;
|
|
|
|
pChild = (CG_NDR *) GetChild();
|
|
|
|
if ( pChild && (pChild->GetCGID() == ID_CG_GENERIC_HDL) )
|
|
pChild = (CG_NDR *) pChild->GetChild();
|
|
|
|
pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();
|
|
|
|
pProc = (CG_PROC *) pCCB->GetCGNodeContext();
|
|
|
|
if ( IsPipeOrPipeReference() )
|
|
{
|
|
// Pipe parameters are never sized.
|
|
|
|
attributes->MustSize = 0;
|
|
}
|
|
else
|
|
attributes->MustSize = (unsigned short) pParam->GetInterpreterMustSize();
|
|
|
|
attributes->IsIn = (unsigned short) pParam->IsParamIn();
|
|
attributes->IsOut = (unsigned short) pParam->IsParamOut();
|
|
attributes->IsReturn = ( pParam->GetCGID() == ID_CG_RETURN )
|
|
|| ( pProc->HasComplexReturnType()
|
|
&& NULL == pParam->GetSibling() );
|
|
attributes->IsPartialIgnore = pParam->IsParamPartialIgnore();
|
|
attributes->IsForceAllocate = pParam->IsForceAllocate();
|
|
attributes->IsBasetype = 0;
|
|
// SAFEARRAY(FOO) is being generated as ID_CG_SAFEARRAY. It's in fact user
|
|
// marshal on the wire.
|
|
attributes->IsByValue =
|
|
IsStruct() ||
|
|
IsUnion() ||
|
|
( GetCGID() == ID_CG_TRANSMIT_AS ) ||
|
|
( GetCGID() == ID_CG_REPRESENT_AS ) ||
|
|
( GetCGID() == ID_CG_USER_MARSHAL ) ||
|
|
( GetCGID() == ID_CG_SAFEARRAY ) ||
|
|
( GetCGID() == ID_CG_CS_TAG ) ;
|
|
attributes->IsSimpleRef =
|
|
(pParam->GetCGID() != ID_CG_RETURN) &&
|
|
IsPointer() &&
|
|
((CG_POINTER *)this)->IsBasicRefPointer();
|
|
attributes->IsDontCallFreeInst = (unsigned short) pParam->GetDontCallFreeInst();
|
|
attributes->IsPipe = (unsigned short) IsPipeOrPipeReference();
|
|
attributes->SaveForAsyncFinish = (unsigned short) pParam->IsSaveForAsyncFinish();
|
|
|
|
if ( (attributes->IsPipe) || (GetCGID() == ID_CG_CONTEXT_HDL) ||
|
|
(IsPointer() && pChild && (pChild->GetCGID() == ID_CG_CONTEXT_HDL)))
|
|
attributes->MustFree = 0;
|
|
else
|
|
attributes->MustFree = 1;
|
|
|
|
attributes->ServerAllocSize = 0;
|
|
|
|
if ( GetCGID() == ID_CG_PTR )
|
|
{
|
|
long Size = 0;
|
|
|
|
(void)
|
|
((CG_POINTER *)this)->InterpreterAllocatesOnStack( pCCB,
|
|
pParam,
|
|
&Size );
|
|
|
|
attributes->ServerAllocSize = unsigned short(Size / 8);
|
|
}
|
|
|
|
//
|
|
// Now make a final check for a simple ref pointer to a basetype and for
|
|
// a ref pointer to pointer.
|
|
//
|
|
// We mark pointers to basetypes as being both a basetype and a simple
|
|
// ref pointer. Kind of an anomoly, but it works out well in the
|
|
// interpreter.
|
|
//
|
|
// For both of these cases the pointer must have no allocate attributes
|
|
// and can not be a return value.
|
|
//
|
|
if (
|
|
IsPointer() &&
|
|
(((CG_POINTER *)this)->GetPtrType() == PTR_REF) &&
|
|
|
|
! IS_ALLOCATE( ((CG_POINTER *)this)->GetAllocateDetails(),
|
|
ALLOCATE_ALL_NODES ) &&
|
|
! IS_ALLOCATE( ((CG_POINTER *)this)->GetAllocateDetails(),
|
|
ALLOCATE_DONT_FREE ) &&
|
|
|
|
(pParam->GetCGID() != ID_CG_RETURN)
|
|
)
|
|
{
|
|
//
|
|
// Now make sure it's a pointer to basetype and that it is either
|
|
// [in] or [in,out] (in which case we use the buffer to hold it) or
|
|
// that it is [out] and there is room for it on the interpreter's
|
|
// stack. We don't mark enum16s as SimpleRef-Basetype because of
|
|
// their special handling (i.e. wire size != memory size).
|
|
//
|
|
if ( ((CG_POINTER *)this)->IsPointerToBaseType() &&
|
|
( pParam->IsParamIn() ||
|
|
(((CG_POINTER *)this)->GetFormatAttr() & FC_ALLOCED_ON_STACK) ) )
|
|
{
|
|
if ( ((CG_BASETYPE *)pChild)->GetFormatChar() != FC_ENUM16 )
|
|
{
|
|
attributes->IsBasetype = 1;
|
|
attributes->IsSimpleRef = 1;
|
|
}
|
|
attributes->MustFree = 0;
|
|
}
|
|
|
|
// we give a warning here because pointer to range doesn't work on
|
|
// w2k sp2 and xp 2600 and before. There is a NDR bug that doesn't
|
|
// allocate memory for poitner to range case.
|
|
if (pChild &&
|
|
pChild->IsSimpleType() &&
|
|
((CG_BASETYPE *)pChild)->GetRangeAttribute() != NULL &&
|
|
!pCommand->IsNDR64Run() )
|
|
{
|
|
RpcError( NULL, 0, TOP_LEVEL_POINTER_RANGE, pParam->GetSymName() );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void
|
|
CG_NDR::GenNdrParamDescription( CCB * pCCB )
|
|
{
|
|
FORMAT_STRING * pProcFormatString;
|
|
PARAM_ATTRIBUTES Attributes;
|
|
long FormatStringOffset;
|
|
CG_PARAM * pParam;
|
|
CG_NDR * pChild;
|
|
|
|
pChild = (CG_NDR *) GetChild();
|
|
|
|
if ( pChild && (pChild->GetCGID() == ID_CG_GENERIC_HDL) )
|
|
pChild = (CG_NDR *) pChild->GetChild();
|
|
|
|
pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();
|
|
|
|
pProcFormatString = pCCB->GetProcFormatString();
|
|
|
|
// Attributes.
|
|
|
|
GetNdrParamAttributes( pCCB, &Attributes );
|
|
|
|
pProcFormatString->PushParamFlagsShort( *((short *)&Attributes) );
|
|
|
|
// Stack offset as number of ints.
|
|
pProcFormatString->PushUShortStackOffsetOrSize(
|
|
pParam->GetStackOffset( pCCB, I386_STACK_SIZING ) );
|
|
|
|
//
|
|
// If we found a pointer to a basetype, make sure and emit the basetype's
|
|
// param format.
|
|
//
|
|
if ( Attributes.IsSimpleRef && Attributes.IsBasetype )
|
|
{
|
|
pProcFormatString->PushFormatChar(
|
|
((CG_BASETYPE *)pChild)->GetFormatChar() );
|
|
pProcFormatString->PushByte( 0 );
|
|
return;
|
|
}
|
|
|
|
if ( Attributes.IsSimpleRef )
|
|
{
|
|
CG_POINTER * pPointer;
|
|
|
|
pPointer = (CG_POINTER *) this;
|
|
|
|
switch ( pPointer->GetCGID() )
|
|
{
|
|
case ID_CG_STRING_PTR :
|
|
if ( ((CG_STRING_POINTER *)pPointer)->IsStringableStruct() )
|
|
FormatStringOffset = GetFormatStringOffset();
|
|
else
|
|
FormatStringOffset = pPointer->GetFormatStringOffset() + 2;
|
|
break;
|
|
|
|
case ID_CG_SIZE_STRING_PTR :
|
|
if ( ((CG_STRING_POINTER *)pPointer)->IsStringableStruct() )
|
|
FormatStringOffset = GetFormatStringOffset();
|
|
else
|
|
FormatStringOffset = pPointer->GetPointeeFormatStringOffset();
|
|
break;
|
|
|
|
case ID_CG_STRUCT_STRING_PTR :
|
|
FormatStringOffset = GetFormatStringOffset();
|
|
break;
|
|
|
|
default :
|
|
FormatStringOffset = pPointer->GetPointeeFormatStringOffset();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FormatStringOffset = GetFormatStringOffset();
|
|
}
|
|
|
|
//
|
|
// Push the offset in the type format string to the param's description.
|
|
//
|
|
pProcFormatString->PushShortTypeOffset( FormatStringOffset );
|
|
}
|
|
|
|
void
|
|
CG_NDR::GenNdrParamDescriptionOld( CCB * pCCB )
|
|
{
|
|
FORMAT_STRING * pProcFormatString;
|
|
CG_PARAM * pParam;
|
|
long StackSize;
|
|
long StackElem;
|
|
|
|
pProcFormatString = pCCB->GetProcFormatString();
|
|
|
|
pParam = (CG_PARAM *) pCCB->GetLastPlaceholderClass();
|
|
|
|
if ( pCommand->Is64BitEnv() )
|
|
StackElem = 8;
|
|
else
|
|
StackElem = 4;
|
|
|
|
StackSize = pParam->GetStackSize();
|
|
|
|
StackSize = (StackSize + StackElem - 1) & ~ (StackElem - 1);
|
|
|
|
pProcFormatString->PushSmallStackSize( (char) (StackSize / StackElem) );
|
|
|
|
//
|
|
// Push the offset in the type format string to the param's description.
|
|
//
|
|
pProcFormatString->PushShortTypeOffset( GetFormatStringOffset() );
|
|
}
|
|
|