|
|
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 1993 Microsoft Corporation
Module Name:
unionndr.hxx
Abstract:
Contains routines for the generation of the new NDR format strings for unions, and the new NDR marshalling and unmarshalling calls.
Notes:
History:
DKays Nov-1993 Created. ----------------------------------------------------------------------------*/ #include "becls.hxx"
#pragma hdrstop
void CG_ENCAPSULATED_STRUCT::GenNdrFormat( CCB * pCCB ) /*++
Routine Description :
Generates the format string for an encapsulated union.
Arguments :
pCCB - pointer to the code control block
Return : None.
--*/ { FORMAT_STRING * pFormatString; CG_BASETYPE * pSwitchIsNode; CG_UNION * pUnion; unsigned long SwitchType;
if ( GetFormatStringOffset() != -1 ) return;
pFormatString = pCCB->GetFormatString();
//
// The child of the struct's first field node is the switch_is node.
//
pSwitchIsNode = (CG_BASETYPE *) GetChild()->GetChild();
//
// The child of the struct's second field node is the union node.
//
pUnion = (CG_UNION *) GetChild()->GetSibling()->GetChild();
SetFormatStringOffset( pFormatString->GetCurrentOffset() );
pFormatString->PushFormatChar( FC_ENCAPSULATED_UNION );
//
// The switch type field in the format string has the size of the switch_is
// field (including any needed pading) in the upper four bits and the
// actual switch_is type in the lower four bits.
//
//
// Get the amount to increment the memory pointer to the encapsulated
// union's struct to get to the actual union. This is the total struct
// size minus the union's size (this may not simply be the size of the
// switch_is member because of possible padding).
//
CG_FIELD * pSwitchField; CG_FIELD * pUnionField;
pSwitchField = (CG_FIELD *) GetChild(); pUnionField = (CG_FIELD *) pSwitchField->GetSibling();
//
// Set the memory increment part of the SwitchType field.
//
SwitchType = ( pUnionField->GetMemOffset() - pSwitchField->GetMemOffset() ) << 4;
if ( pSwitchIsNode->GetFormatChar() == FC_ENUM16 ) SwitchType |= FC_ENUM16; else SwitchType |= pSwitchIsNode->GetSignedFormatChar();
pFormatString->PushByte( SwitchType );
pUnion->GenNdrSizeAndArmDescriptions( pCCB );
SetFormatStringEndOffset( pFormatString->GetCurrentOffset() ); // SetFormatStringOffset( pFormatString->OptimizeFragment( this ) );
}
void CG_UNION::GenNdrFormat( CCB * pCCB ) /*++
Routine Description :
Generates the format string for a non-encapsulated union.
Arguments :
pCCB - pointer to the code control block
Return : None.
--*/ { FORMAT_STRING * pFormatString; long Offset;
SetCCB( pCCB );
if ( GetFormatStringOffset() != -1 ) return;
pFormatString = pCCB->GetFormatString();
SetFormatStringOffset( pFormatString->GetCurrentOffset() );
pFormatString->PushFormatChar( FC_NON_ENCAPSULATED_UNION );
// The switch type's signed format char type.
if (NULL == pCGSwitchType && pCommand->IsHookOleEnabled()) { RpcError(NULL, 0, NO_SWITCH_IS_HOOKOLE, GetSymName()); exit(NO_SWITCH_IS_HOOKOLE); }
if ( ((CG_BASETYPE *)pCGSwitchType)->GetFormatChar() == FC_ENUM16 ) pFormatString->PushFormatChar( FC_ENUM16 ); else { FORMAT_CHARACTER SwitchTypeFc;
// Note that we take the signed format character this time.
SwitchTypeFc = ((CG_BASETYPE *)pCGSwitchType)->GetSignedFormatChar();
#if defined(TARGET_RKK)
if ( pCommand->GetTargetSystem() == NT35 && SwitchTypeFc == FC_USMALL ) { // The NT 807 NDR engine doesn't know about usmall.
pFormatString->PushFormatChar( FC_BYTE ); pFormatString->PushFormatChar( FC_SMALL ); } else #endif
pFormatString->PushFormatChar( SwitchTypeFc ); }
GenNdrSwitchIsDescription( pCCB );
Offset = pFormatString->GetCurrentOffset();
pFormatString->PushShortOffset( 0 );
GenNdrSizeAndArmDescriptions( pCCB );
pFormatString->PushShort( GetNdrSizeAndArmDescriptionOffset() - Offset, Offset );
SetFormatStringEndOffset( pFormatString->GetCurrentOffset() ); // SetFormatStringOffset( pFormatString->OptimizeFragment( this ) );
}
void CG_UNION::GenNdrFormatArms( CCB * pCCB ) /*++
Routine Description :
Generates the format string for the arms of an encapsulated or a non-encapsulated union.
Arguments :
pCCB - pointer to the code control block
Return : None.
--*/ { CG_ITERATOR Iterator; CG_CASE * pCase; CG_NDR * pNdr;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pCase ) ) { if ( ! pCase->GetChild() ) continue;
//
// The child of the CG_CASE is a CG_FIELD.
// The child of the CG_FIELD is the actual NDR entity.
//
pNdr = (CG_NDR *) pCase->GetChild()->GetChild();
if ( ! pNdr ) continue;
if ( pNdr && ! pNdr->IsSimpleType() ) pNdr->GenNdrFormat( pCCB ); } }
void CG_UNION::GenNdrSizeAndArmDescriptions( CCB * pCCB ) /*++
Routine Description :
Generates the memory size and arm description portion of the format string for an encapsulated or a non-encapsulated union.
Arguments :
pCCB - pointer to the code control block
Return : None.
--*/ { FORMAT_STRING * pFormatString; unsigned short UnionArms; long FormatOffset;
if ( GetNdrSizeAndArmDescriptionOffset() != -1 ) return;
pFormatString = pCCB->GetFormatString();
SetNdrSizeAndArmDescriptionOffset( pFormatString->GetCurrentOffset() );
//
// Set aside the space for the union's description. Then we generate
// the format string description for all the union's arms, and then
// we go back and patch up the the union's description to have the
// proper offsets. This must be done to handle self referencing union
// types.
//
// Memory size.
pFormatString->PushShort( (short) GetMemorySize() );
//
// union_arms<2>
//
UnionArms = (unsigned short) GetNumberOfArms();
if ( GetUnionFlavor() == UNION_NONENCAP_MS ) { //
// Microsoft union support.
// Set the upper four bits of the union_arm<2> field with the
// the alignment of the largest aligned union arm.
//
UnionArms |= (CvtAlignPropertyToAlign(GetWireAlignment()) - 1) << 12; }
pFormatString->PushShort( (short) UnionArms );
// Get union arms again since we may have just munged it.
UnionArms = (short) GetNumberOfArms();
// The arms.
for ( ; UnionArms-- > 0; ) { pFormatString->PushLong( 0 ); pFormatString->PushShortOffset( 0 ); }
// default_arm_description<2>
pFormatString->PushShortOffset( 0 );
//
// Generate the format string descriptions of the arms.
//
GenNdrFormatArms( pCCB );
// Find out where the arms' descriptions begin.
FormatOffset = GetNdrSizeAndArmDescriptionOffset() + 4;
CG_ITERATOR Iterator; CG_CASE * pCase; CG_NDR * pNdr; CG_NDR * pNdrDefaultCase; BOOL DefaultCaseFound; GetMembers( Iterator );
pNdrDefaultCase = NULL; DefaultCaseFound = FALSE;
while ( ITERATOR_GETNEXT( Iterator, pCase ) ) { //
// Check for the default case first.
//
if ( pCase->GetCGID() == ID_CG_DEFAULT_CASE ) { pNdrDefaultCase = pCase->GetChild() ? (CG_NDR *) pCase->GetChild()->GetChild() : 0;
DefaultCaseFound = TRUE; continue; }
//
// Fill in the arm's case value.
//
if (NULL == pCase->GetExpr()) { RpcError(NULL, 0, NO_CASE_EXPR, GetSymName()); exit(NO_CASE_EXPR); } pFormatString->PushLong( pCase->GetExpr()->GetValue(), FormatOffset ); FormatOffset += 4;
//
// Check for a non-default case with an empty (;) arm.
//
if ( ! pCase->GetChild() || ! pCase->GetChild()->GetChild() ) { //
// Increment the FormatOffset past the arm description, which
// simply remains zero.
//
FormatOffset += 2; continue; }
//
// Else it's a regular case with a valid arm.
//
pNdr = (CG_NDR *) pCase->GetChild()->GetChild();
if ( pNdr && pNdr->IsSimpleType() ) { short s; //
// The offset in this case is the actual format character for
// the base type, but with a 1 in the upper bit of the short, to
// make it look negative.
//
s = (short) ((CG_BASETYPE *)pNdr)->GetFormatChar(); s |= MAGIC_UNION_SHORT;
pFormatString->PushShort( s, FormatOffset ); } else { //
// Remember that the offset that gets pushed here is an unsigned
// short offset to the description.
//
pFormatString->PushShort( pNdr->GetFormatStringOffset() - FormatOffset, FormatOffset ); }
FormatOffset += 2; }
//
// Finally, handle the default case.
//
if ( ! DefaultCaseFound ) { pFormatString->PushShort( (short) 0xffff, FormatOffset ); } else { if ( ! pNdrDefaultCase ) pFormatString->PushShort( (short) 0, FormatOffset ); else { if ( pNdrDefaultCase->IsSimpleType() ) { short s; s = (short) ((CG_BASETYPE *)pNdrDefaultCase)->GetFormatChar(); s |= MAGIC_UNION_SHORT; pFormatString->PushShort( s, FormatOffset ); } else pFormatString->PushShort( pNdrDefaultCase->GetFormatStringOffset() - FormatOffset, FormatOffset ); } } }
BOOL CG_UNION::CanUseBuffer() { CG_ITERATOR Iterator; CG_CASE * pCase; CG_NDR * pNdr; unsigned long Size; long Align; long TempBufAlign;
//
// We will be very strict, since there is not much room for
// leeway. Only return TRUE if all arms have the same size, the same
// wire alignment, and matching wire/memory alignments & sizes.
//
// The real scenario we're after is a union with all pointer arms or
// longs. This is fairly common in NT.
//
GetMembers( Iterator );
Size = 0; Align = 0; while ( ITERATOR_GETNEXT( Iterator, pCase ) ) { if ( ! pCase->GetChild() || ! (pNdr = (CG_NDR *) pCase->GetChild()->GetChild()) ) continue;
TempBufAlign = CvtAlignPropertyToAlign( pNdr->GetWireAlignment() ); if ( (pNdr->GetWireSize() != pNdr->GetMemorySize()) || (pNdr->GetMemoryAlignment() != TempBufAlign) ) return FALSE;
if ( ! Size ) { Size = pNdr->GetWireSize(); Align = TempBufAlign; continue; } if ( (Size != pNdr->GetWireSize()) || (Align != TempBufAlign) ) return FALSE; }
return TRUE; }
void CG_UNION::GenNdrSwitchIsDescription( CCB * pCCB ) /*++
Routine Description :
This routine generates the switch_type<1> and switch_is_description<4> field for a non-encapsulated union.
Arguments :
pCCB - pointer to the code control block
Return : None.
--*/ { CG_NDR * pParamOrField; CG_FIELD * pField; expr_node * pSwitchExpr; BOOL IsPointer;
pParamOrField = pCCB->GetLastPlaceholderClass();
//
// Get the switch is expression.
//
switch ( pParamOrField->GetCGID() ) { case ID_CG_PARAM : pSwitchExpr = ((CG_PARAM *)pParamOrField)->GetSwitchExpr();
// If it's top level param then this flag doesn't matter.
IsPointer = FALSE;
break;
case ID_CG_FIELD : pField = (CG_FIELD *) pParamOrField;
pSwitchExpr = pField->GetSwitchExpr(); // Check if the field is actually a pointer to a union.
IsPointer = ((CG_NDR *)pField->GetChild())->IsPointer(); break;
default : assert(0); }
GenNdrFormatAttributeDescription( pCCB, NULL, pSwitchExpr, IsPointer, TRUE, FALSE, FALSE ); }
void CG_UNION::SetFormatStringOffset( long Offset ) { CCB * pCCB; CG_NDR * pParamOrFieldNode;
pCCB = GetCCB();
pParamOrFieldNode = pCCB->GetLastPlaceholderClass();
if ( pParamOrFieldNode->GetCGID() == ID_CG_PARAM ) ((CG_PARAM *)pParamOrFieldNode)->SetUnionFormatStringOffset( Offset ); else ((CG_FIELD *)pParamOrFieldNode)->SetUnionFormatStringOffset( Offset ); }
long CG_UNION::GetFormatStringOffset() { CCB * pCCB; CG_NDR * pParamOrFieldNode;
pCCB = GetCCB();
pParamOrFieldNode = pCCB->GetLastPlaceholderClass();
if ( pParamOrFieldNode->GetCGID() == ID_CG_PARAM ) return ((CG_PARAM *)pParamOrFieldNode)->GetUnionFormatStringOffset(); else return ((CG_FIELD *)pParamOrFieldNode)->GetUnionFormatStringOffset(); }
void CG_ENCAPSULATED_STRUCT::GenNdrPointerFixUp( CCB * pCCB, CG_STRUCT * pStruct ) { //
// For an encapsulated struct, call this method on the actual union.
// Remember that the encap struct's child is a CG_FIELD whose sibling's
// child will be the actual union.
//
((CG_UNION*)(GetChild()->GetSibling()->GetChild()))-> GenNdrPointerFixUp( pCCB, pStruct ); }
void CG_UNION::GenNdrPointerFixUp( CCB * pCCB, CG_STRUCT * pStruct ) { CG_ITERATOR Iterator; CG_NDR * pMember; CG_NDR * pNdr; long OffsetOffset;
if ( IsInFixUp() ) return;
SetFixUpLock( TRUE );
OffsetOffset = GetNdrSizeAndArmDescriptionOffset() + 4;
GetMembers( Iterator );
while ( ITERATOR_GETNEXT( Iterator, pMember ) ) { if ( ! pMember->GetChild() || ! pMember->GetChild()->GetChild() ) { OffsetOffset += 6; continue; }
//
// Child of the case is a CG_FIELD - get it's child to get the
// actual Ndr entity.
//
pNdr = (CG_NDR *) pMember->GetChild()->GetChild();
if ( pNdr == pStruct ) { //
// Patch up the offset.
//
OffsetOffset += 4;
pCCB->GetFormatString()->PushShort( pStruct->GetFormatStringOffset() - OffsetOffset, OffsetOffset );
OffsetOffset += 2; continue; }
if ( (pNdr->GetCGID() == ID_CG_PTR) || (pNdr->GetCGID() == ID_CG_SIZE_PTR) || (pNdr->GetCGID() == ID_CG_SIZE_LENGTH_PTR) ) { CG_POINTER * pPointer = (CG_POINTER *) pNdr;
//
// Check if we're ready for this guy yet.
//
if ( pPointer->GetFormatStringOffset() == -1 ) continue;
// Get the pointee.
pNdr = (CG_NDR *) pNdr->GetChild();
//
// If the pointer's pointee is the struct we're checking for,
// then patch up the pointer's offset_to_description<2> field.
//
if ( pNdr == pStruct ) { long PointerOffset;
//
// Get the offset in the format string where the
// offset_to_description<2> field of the pointer is.
//
PointerOffset = pPointer->GetFormatStringOffset() + 2;
pCCB->GetFormatString()->PushShort( pStruct->GetFormatStringOffset() - PointerOffset, PointerOffset );
OffsetOffset += 6; continue; } }
//
// Continue the chase if necessary.
//
if ( pNdr->IsStruct() || pNdr->IsUnion() || pNdr->IsArray() ) pNdr->GenNdrPointerFixUp( pCCB, pStruct );
OffsetOffset += 6; }
SetFixUpLock( FALSE ); }
|