/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Copyright (c) 1989-1999 Microsoft Corporation Module Name: ptrcls.hxx Abstract: Contains definitions for base type related code generation class definitions. Notes: History: GregJen Sep-30-1993 Created. ----------------------------------------------------------------------------*/ #ifndef __PTRCLS_HXX__ #define __PTRCLS_HXX__ #pragma warning ( disable : 4238 4239 ) #include "nulldefs.h" extern "C" { #include } #include "ndrcls.hxx" #include "arraycls.hxx" // forwards class CG_TYPEDEF; ///////////////////////////////////////////////////////////////////////////// // the pointer type code generation classes. ///////////////////////////////////////////////////////////////////////////// // // This class corresponds to a vanilla pointer type. // class CG_POINTER : public CG_NDR, public CG_CLONEABLE { private: unsigned long fPointerShouldFree : 1; unsigned long fIsInMultiSized : 1; unsigned char FormatAttr; // the kind of the pointer (ref, unique or full) PTRTYPE PtrKind; // // allocate attributes (defined in acfattr.hxx) // short AllocateDetails; // // For Ndr format string generation. The offset of the pointee in the // format string. We can't just get the pointee's offset in the format // string by asking the CG_POINTER's child it's offset into the format // string, because size and length pointers produce their pointee format // string by creating temporary array CG classes. Thus their real CG // child will not have the correct offset in the format string, we must // record it here instead. // long PointeeFormatStringOffset; // // If we point to an array of cs_chars, the CG node for the array doesn't // get generated until we start generating the format string so save the // user type here // node_cs_char * pCSUserType; public: // // The constructor. // CG_POINTER( node_skl * pBT, PTRTYPE p, short AD ) : CG_NDR( pBT, XLAT_SIZE_INFO( (unsigned short)SIZEOF_MEM_PTR(), (unsigned short)SIZEOF_WIRE_PTR(), SIZEOF_MEM_PTR(), SIZEOF_WIRE_PTR() ) ) { SetPtrType( p ); PointeeFormatStringOffset = -1; SetAllocateDetails( AD ); SetPointerShouldFree( 1 ); SetIsInMultiSized( FALSE ); SetFormatAttr( 0 ); SetCSUserType( 0 ); } CG_POINTER( CG_POINTER * pNode ) : CG_NDR( pNode->GetType(), XLAT_SIZE_INFO( (unsigned short)SIZEOF_MEM_PTR(), (unsigned short)SIZEOF_WIRE_PTR(), SIZEOF_MEM_PTR(), SIZEOF_WIRE_PTR() ) ) { *this = *pNode; } virtual CG_CLASS * Clone() { return new CG_POINTER( *this ); } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } // // TYPEDESC generation routine // virtual CG_STATUS GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB); virtual ID_CG GetCGID() { return ID_CG_PTR; } // // Get and Set methods. // PTRTYPE GetPtrType() { return PtrKind; } PTRTYPE SetPtrType( PTRTYPE p ) { return (PtrKind = p); } short GetAllocateDetails() { return AllocateDetails; } short SetAllocateDetails( short AD ) { return (AllocateDetails = AD); } void SetFormatAttr( unsigned char Attr ) { FormatAttr = Attr; } unsigned char GetFormatAttr() { return FormatAttr; } void SetCSUserType( node_cs_char *p) { pCSUserType = p; } node_cs_char * GetCSUserType() { return pCSUserType; } // // individual synthesized queries // BOOL IsAllocateAllNodes() { return (BOOL) (IS_ALLOCATE(AllocateDetails, ALLOCATE_ALL_NODES) ); } BOOL IsAllocateDontFree() { return (BOOL) (IS_ALLOCATE(AllocateDetails, ALLOCATE_DONT_FREE ) ); } void SetPointerShouldFree( unsigned long Flag ) { fPointerShouldFree = Flag; } BOOL ShouldPointerFree() { return (BOOL)(fPointerShouldFree == 1); } BOOL IsRef() { return (PtrKind == PTR_REF); } BOOL IsUnique() { return (PtrKind == PTR_UNIQUE); } BOOL IsFull() { return (PtrKind == PTR_FULL); } virtual BOOL IsPointer() { return TRUE; } virtual BOOL IsPipeOrPipeReference() { if (GetChild()) return ((CG_NDR*)GetChild())->IsPipeOrPipeReference(); else return FALSE; } // // Common shortcuts. // BOOL IsPointerToBaseType(); BOOL IsPointerToPointer(); BOOL IsBasicRefPointer(); // // Is this a sized pointer of sized pointers. // BOOL IsMultiSize(); void SetIsInMultiSized( BOOL fSet ) { fIsInMultiSized = fSet; } BOOL IsInMultiSized() { return fIsInMultiSized; } // // Get number of dimensions if this is a sized pointer of sized pointers. // long SizedDimensions(); // server side stuff. virtual CG_STATUS S_GenInitOutLocals( CCB * pCCB ); // // Ndr format string generation method. // virtual void GenNdrFormat( CCB * pCCB ); // // Generate the description of the pointer when imbeded. Shared by // all classes which inherit CG_POINTER. // long GenNdrFormatEmbedded( CCB * pCCB ) { SetFormatStringOffset( pCCB->GetFormatString()->GetCurrentOffset() ); // 0 means pointee not generated yet. return GenNdrFormatAlways( pCCB ); } // // This routine always generates the format string for a pointer. Used // by GenNdrFormat and GenNdrImbededFormat(). // It returns the (absolute) pointee offset. // virtual long GenNdrFormatAlways( CCB * pCCB ); void RegisterRecPointerForFixup( CCB * pCCB, long OffsetAt ); // // This method is called to generate offline portions of a types // format string. // virtual void GenNdrParamOffline( CCB * pCCB ); // // Ndr format string generation for the pointee. // virtual void GenNdrFormatPointee( CCB * pCCB ); // // Prolog stuff for all classes which inherit CG_POINTER // void GenNdrPointerType( CCB * pCCB ); void GetTypeAndFlags( CCB *pCCB, NDR64_POINTER_FORMAT *format ); virtual BOOL ShouldFreeOffline(); virtual void GenFreeInline( CCB * pCCB ); // // Get and Set methods for the PointeeFormatStringOffset member. // void SetPointeeFormatStringOffset( long offset ) { PointeeFormatStringOffset = offset; } long GetPointeeFormatStringOffset() { return PointeeFormatStringOffset; } ////////////////////////////////////////////////////////////////// virtual CG_STATUS MarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS SizeAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS UnMarshallAnalysis( ANALYSIS_INFO * pAna ); long FixedBufferSize( CCB * pCCB ); BOOL InterpreterMustFree( CCB * ) { return TRUE; } BOOL InterpreterAllocatesOnStack( CCB * pCCB, CG_PARAM * pMyParam, long * pAllocSize ); virtual CG_STATUS S_OutLocalAnalysis( ANALYSIS_INFO * pAna ); virtual expr_node * GenBindOrUnBindExpression( CCB * pCCB, BOOL fBind ); CG_STATUS PtrMarshallAnalysis( ANALYSIS_INFO * pAna ); CG_STATUS PteMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS CorePteMarshallAnalysis( ANALYSIS_INFO * pAna ) { if (GetChild()) { return ((CG_NDR *)GetChild())->MarshallAnalysis( pAna ); } return CG_OK; } CG_STATUS PtrUnMarshallAnalysis( ANALYSIS_INFO * pAna ); CG_STATUS PteUnMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS FollowerMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS FollowerUnMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS GenConfVarianceEtcUnMarshall( CCB * ) { return CG_OK; } virtual CG_STATUS CorePteUnMarshallAnalysis( ANALYSIS_INFO * pAna ) { if ( GetChild() ) return ((CG_NDR *)GetChild())->UnMarshallAnalysis( pAna ); else return CG_OK; } virtual U_ACTION RecommendUAction( SIDE CurrentSide, BOOL fMemoryAllocated, BOOL fRefAllocated, BOOL fBufferReUsePossible, UAFLAGS AdditionalFlags ); BOOL IsQualifiedPointer() { return (GetCGID() != ID_CG_PTR ); } virtual CG_STATUS GenAllocateForUnMarshall( CCB * pCCB ); void PointerChecks( CCB * pCCB ); void EndPointerChecks( CCB * pCCB ); expr_node * FinalSizeExpression( CCB * pCCB ); expr_node * FinalLengthExpression( CCB * pCCB ); expr_node * FinalFirstExpression( CCB * pCCB ); virtual CG_STATUS GenRefChecks( CCB * pCCB ); virtual CG_STATUS InLocalAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS S_GenInitInLocals( CCB * pCCB ); }; // // This class corresponds to a byte_counted pointer type. // class CG_BYTE_COUNT_POINTER : public CG_POINTER { private: // the byte count param node_param * pByteCountParam; public: // // The constructor. // CG_BYTE_COUNT_POINTER( node_skl * pBT, PTRTYPE p, node_param * pParam ) : CG_POINTER( pBT, p, 0 ) { SetByteCountParam( pParam ); } CG_BYTE_COUNT_POINTER( CG_BYTE_COUNT_POINTER * pNode ) : CG_POINTER( pNode->GetType(), pNode->GetPtrType(), pNode->GetAllocateDetails() ) { *this = *pNode; } virtual CG_CLASS * Clone() { return new CG_BYTE_COUNT_POINTER( *this ); } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual ID_CG GetCGID() { return ID_CG_BC_PTR; } void GenNdrFormat( CCB * pCCB ); // // Get and Set methods. // node_param * GetByteCountParam() { return pByteCountParam; } node_param * SetByteCountParam( node_param * p ) { return (pByteCountParam = p); } }; // // This class corresponds to an [ignore]'d pointer type. // It is also used to help with marshaling handle_t in the -Oi interpreter // and -Os old style of parameter descriptors. // It derives from CG_NDR, but is really just a filler. // class CG_IGNORED_POINTER : public CG_NDR { private: public: // // The constructor. // CG_IGNORED_POINTER( node_skl * pBT ) : CG_NDR( pBT, XLAT_SIZE_INFO( (unsigned short) SIZEOF_MEM_PTR(), // MA (unsigned short)SIZEOF_WIRE_PTR(), // WA SIZEOF_MEM_PTR(), // MS SIZEOF_WIRE_PTR() ) )// WS { } CG_IGNORED_POINTER( CG_IGNORED_POINTER * pNode ) : CG_NDR( pNode->GetType(), XLAT_SIZE_INFO( (unsigned short) SIZEOF_MEM_PTR(), // MA (unsigned short)SIZEOF_WIRE_PTR(), // WA SIZEOF_MEM_PTR(), // MS SIZEOF_WIRE_PTR() ) // WS ) { *pNode = *this; } virtual CG_CLASS * Clone() { return new CG_IGNORED_POINTER( *this ); } virtual ID_CG GetCGID() { return ID_CG_IGN_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } // // Ndr format string generation method. // virtual void GenNdrFormat( CCB * pCCB ) { pCCB->GetFormatString()-> PushFormatChar( FC_IGNORE ); } }; //////////////////////////////////////////////////////////////////////////// // This class corresponds to a string pointer type. //////////////////////////////////////////////////////////////////////////// class CG_QUALIFIED_POINTER : public CG_POINTER { private: RESOURCE * pSizeResource; RESOURCE * pLengthResource; RESOURCE * pFirstResource; RESOURCE * pMinResource; unsigned long fUsedInArray; long Dimension; public: CG_QUALIFIED_POINTER( const CG_QUALIFIED_POINTER & Node ) : CG_POINTER( Node ) { pSizeResource = Node.pSizeResource; if (NULL != pSizeResource) pSizeResource = (RESOURCE*)pSizeResource->Clone(); pLengthResource = Node.pLengthResource; if (NULL != pLengthResource) pLengthResource = (RESOURCE*)pLengthResource->Clone(); pFirstResource = Node.pFirstResource; if (NULL != pFirstResource) pFirstResource = (RESOURCE*)pFirstResource->Clone(); pMinResource = Node.pMinResource; if (NULL != pMinResource) pMinResource = (RESOURCE*)pMinResource->Clone(); fUsedInArray = Node.fUsedInArray; Dimension = Node.Dimension; } CG_QUALIFIED_POINTER( node_skl * pBT, PTRTYPE p, short AD ) : CG_POINTER( pBT, p, AD ) { pSizeResource = 0; pLengthResource = 0; pFirstResource = 0; pMinResource = 0; fUsedInArray = 0; SetDimension(0); } CG_QUALIFIED_POINTER( CG_QUALIFIED_POINTER * pNode ) : CG_POINTER( pNode->GetType(), pNode->GetPtrType(), pNode->GetAllocateDetails() ) { *this = *pNode; } virtual CG_CLASS * Clone() { return new CG_QUALIFIED_POINTER( *this ); } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } void SetUsedInArray() { fUsedInArray = 1; } BOOL IsUsedInArray() { return (BOOL)(fUsedInArray == 1); } RESOURCE * SetSizeResource( RESOURCE * pR ) { return pSizeResource = pR; } RESOURCE * GetSizeResource() { return pSizeResource; } RESOURCE * SetLengthResource( RESOURCE * pR ) { return pLengthResource = pR; } RESOURCE * GetLengthResource() { return pLengthResource; } RESOURCE * SetFirstResource( RESOURCE * pR ) { return pFirstResource = pR; } RESOURCE * GetFirstResource() { return pFirstResource; } void SetDimension( long Dim ) { Dimension = Dim; } long GetDimension() { return Dimension; } virtual CG_STATUS CorePteMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS CorePteUnMarshallAnalysis( ANALYSIS_INFO * pAna ); virtual BOOL NeedsMaxCountMarshall() { return FALSE; } virtual BOOL NeedsFirstAndLengthMarshall() { return FALSE; } virtual BOOL NeedsExplicitFirst() { return TRUE; } virtual expr_node * GetQPFirstIsExpression() { return pFirstResource; } virtual expr_node * GetQPLengthIsExpression() { return pLengthResource; } virtual expr_node * GetQPMinIsExpression() { return pMinResource; } virtual expr_node * GetQPSizeIsExpression() { return pSizeResource; } }; class CG_STRING_POINTER : public CG_QUALIFIED_POINTER { BOOL fIsBSTR; public: // // The constructor. // CG_STRING_POINTER( node_skl * pBT, PTRTYPE p, short AD ) : CG_QUALIFIED_POINTER( pBT, p, AD ), fIsBSTR( FALSE ) { } CG_STRING_POINTER( CG_STRING_POINTER * pNode ) : CG_QUALIFIED_POINTER( pNode ) { *this = *pNode; } virtual CG_CLASS * Clone() { return new CG_STRING_POINTER( *this ); } virtual ID_CG GetCGID() { // // For regular string pointers only (not for // sized string pointers), we have a different // CG id for string structs. This is for all // of the places that we check for a GetCGID() // of ID_CG_STRING_PTR when it shouldn't apply // for stringable structs. // return IsStringableStruct() ? ID_CG_STRUCT_STRING_PTR : ID_CG_STRING_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } BOOL IsStringableStruct() { CG_NDR * pChild = (CG_NDR *) GetChild(); // pChild could be NULL if the CG node hasn't been // completely constructed yet. // The check for NULL keeps GetCGID from being called // on a NULL object (and crashing). return (NULL == pChild || pChild->GetCGID() != ID_CG_BT); } BOOL IsBStr() { return fIsBSTR; } void SetBStr() { fIsBSTR = TRUE; } // // TYPEDESC generation routine // virtual CG_STATUS GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB); // // Ndr format string generation method. // virtual void GenNdrFormat( CCB * pCCB ); // // This routine always generates the format string for a pointer. Used // by GenNdrFormat and GenNdrImbededFormat(). // virtual long GenNdrFormatAlways( CCB * pCCB ); // // Ndr format string generation for the pointee. // virtual void GenNdrFormatPointee( CCB * pCCB ); virtual CG_STATUS GenConfVarianceEtcUnMarshall( CCB * pCCB ); virtual BOOL NeedsMaxCountMarshall() { return TRUE; } virtual expr_node * GetQPFirstIsExpression() { return new expr_constant( 0L ); } virtual expr_node * GetQPMinIsExpression() { return new expr_constant( 0L ); } virtual BOOL NeedsFirstAndLengthMarshall() { return TRUE; } virtual BOOL NeedsExplicitFirst() { return FALSE; } virtual expr_node * PresentedSizeExpression( CCB * pCCB ); virtual expr_node * PresentedLengthExpression( CCB * pCCB ); virtual expr_node * PresentedFirstExpression( CCB * ) { return new expr_constant(0L); } }; // // This class corresponds to a sized string pointer type. // class CG_SIZE_STRING_POINTER : public CG_STRING_POINTER, public CG_CONF_ATTRIBUTE { private: public: // // The constructor. // CG_SIZE_STRING_POINTER( node_skl * pBT, PTRTYPE p, short AD , FIELD_ATTR_INFO * pFA ) : CG_STRING_POINTER( pBT, p, AD ), CG_CONF_ATTRIBUTE( pFA ) { } CG_SIZE_STRING_POINTER( CG_SIZE_STRING_POINTER * pNode ) : CG_STRING_POINTER( pNode ), CG_CONF_ATTRIBUTE( pNode ) { *this = *pNode; } virtual ID_CG GetCGID() { return ID_CG_SIZE_STRING_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS * Clone() { return new CG_SIZE_STRING_POINTER( *this ); } // // Ndr format string generation method. // virtual void GenNdrFormat( CCB * pCCB ); // // This routine always generates the format string for a pointer. Used // by GenNdrFormat and GenNdrImbededFormat(). // virtual long GenNdrFormatAlways( CCB * pCCB ); // // Ndr format string generation for the pointee. // virtual void GenNdrFormatPointee( CCB * pCCB ); virtual expr_node * GetQPFirstIsExpression() { return new expr_constant(0L); } virtual expr_node * GetQPMinIsExpression() { return new expr_constant(0L); } virtual expr_node * PresentedSizeExpression( CCB * pCCB ); }; // // This class corresponds to a sized pointer type. // class CG_SIZE_POINTER : public CG_QUALIFIED_POINTER, public CG_CONF_ATTRIBUTE { private: CG_ARRAY * pPointee; public: // // The constructor. // CG_SIZE_POINTER( node_skl * pBT, PTRTYPE p, short AD , FIELD_ATTR_INFO * pFA ) : CG_QUALIFIED_POINTER( pBT, p, AD ), CG_CONF_ATTRIBUTE( pFA ) { pPointee = 0; } CG_SIZE_POINTER( CG_SIZE_POINTER * pNode ) : CG_QUALIFIED_POINTER( pNode ), CG_CONF_ATTRIBUTE( pNode ) { *this = *pNode; } virtual ID_CG GetCGID() { return ID_CG_SIZE_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS * Clone() { return new CG_SIZE_POINTER( *this ); } void SetPointee( CG_ARRAY * P ) { pPointee = P; } CG_ARRAY * GetPointee() { return pPointee; } // // Sized pointers use inherited CG_POINTER GenNdrFormat virtual method. // // // Ndr format string generation for the pointee. // void GenNdrFormatPointee( CCB * pCCB ); virtual BOOL NeedsMaxCountMarshall() { return TRUE; } virtual BOOL NeedsFirstAndLengthMarshall() { return FALSE; } virtual expr_node * GetQPFirstIsExpression() { return new expr_constant(0L); } virtual expr_node * GetQPLengthIsExpression() { return new expr_constant(0L); } virtual expr_node * GetQPMinIsExpression() { return GetMinIsExpr(); } virtual expr_node * GetQPSizeIsExpression() { return GetSizeIsExpr(); } virtual expr_node * PresentedSizeExpression( CCB * pCCB ); virtual expr_node * PresentedFirstExpression( CCB * ) { return new expr_constant( 0L ); } }; // // This class corresponds to a lengthed pointer type. // class CG_LENGTH_POINTER : public CG_QUALIFIED_POINTER, public CG_VARY_ATTRIBUTE { private: public: // // The constructor. // CG_LENGTH_POINTER( node_skl * pBT, PTRTYPE p, short AD , FIELD_ATTR_INFO * pFA ) : CG_QUALIFIED_POINTER( pBT, p, AD ), CG_VARY_ATTRIBUTE( pFA ) { } CG_LENGTH_POINTER( CG_LENGTH_POINTER * pNode ) : CG_QUALIFIED_POINTER( pNode ), CG_VARY_ATTRIBUTE( pNode ) { *this = *pNode; } virtual ID_CG GetCGID() { return ID_CG_LENGTH_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS * Clone() { return new CG_LENGTH_POINTER( *this ); } virtual BOOL NeedsMaxCountMarshall() { return FALSE; } virtual BOOL NeedsFirstAndLengthMarshall() { return TRUE; } virtual expr_node * GetQPFirstIsExpression() { return GetFirstIsExpr(); } virtual expr_node * GetQPLengthIsExpression() { return GetLengthIsExpr(); } virtual expr_node * GetQPMinIsExpression() { return new expr_constant(0L); } virtual expr_node * GetQPSizeIsExpression() { return new expr_constant(0L); } virtual expr_node * PresentedLengthExpression( CCB * pCCB ); virtual expr_node * PresentedFirstExpression( CCB * pCCB ); }; // // This class corresponds to a sized and lengthed pointer type. // class CG_SIZE_LENGTH_POINTER : public CG_QUALIFIED_POINTER, public CG_CONF_ATTRIBUTE, public CG_VARY_ATTRIBUTE { private: CG_ARRAY * pPointee; public: // // The constructor. // CG_SIZE_LENGTH_POINTER( node_skl * pBT, PTRTYPE p, short AD, FIELD_ATTR_INFO * pFA ) : CG_QUALIFIED_POINTER( pBT, p, AD ), CG_CONF_ATTRIBUTE( pFA ), CG_VARY_ATTRIBUTE( pFA ) { pPointee = 0; } CG_SIZE_LENGTH_POINTER( CG_SIZE_LENGTH_POINTER * pNode ) : CG_QUALIFIED_POINTER( pNode ), CG_CONF_ATTRIBUTE( pNode ), CG_VARY_ATTRIBUTE( pNode ) { *this = *pNode; } virtual ID_CG GetCGID() { return ID_CG_SIZE_LENGTH_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS * Clone() { return new CG_SIZE_LENGTH_POINTER( *this ); } void SetPointee( CG_ARRAY * P ) { pPointee = P; } CG_ARRAY * GetPointee() { return pPointee; } // // Size-Length pointers use inherited CG_POINTER GenNdrFormat // virtual method. // // // Ndr format string generation for the pointee. // void GenNdrFormatPointee( CCB * pCCB ); virtual BOOL NeedsMaxCountMarshall() { return TRUE; } virtual BOOL NeedsFirstAndLengthMarshall() { return TRUE; } virtual expr_node * GetQPFirstIsExpression() { return GetFirstIsExpr(); } virtual expr_node * GetQPLengthIsExpression() { return GetLengthIsExpr(); } virtual expr_node * GetQPMinIsExpression() { return GetMinIsExpr(); } virtual expr_node * GetQPSizeIsExpression() { return GetSizeIsExpr(); } virtual expr_node * PresentedSizeExpression( CCB * pCCB ); virtual expr_node * PresentedLengthExpression( CCB * pCCB ); virtual expr_node * PresentedFirstExpression( CCB * pCCB ); }; // // This class corresponds to an interface pointer type. // interface with iid_is() corresponse to CG_IIDIS_INTERFACE_POINTER // class CG_INTERFACE_POINTER : public CG_POINTER { private: node_interface * pMyIntf; CG_TYPEDEF* pAlias; public: // // The constructor. // CG_INTERFACE_POINTER(node_skl * pBT, node_interface * pInt ) : CG_POINTER( pBT, PTR_REF, 0 ), pAlias(0) { SetTheInterface( pInt ); } CG_INTERFACE_POINTER( CG_INTERFACE_POINTER * pNode ) : CG_POINTER( pNode->GetType(), PTR_REF, 0 ), pAlias(0) { *this = *pNode; } virtual CG_TYPEDEF* GetTypeAlias() { return pAlias; }; virtual void SetTypeAlias( CG_TYPEDEF* pDef ) { pAlias = pDef; }; virtual CG_STATUS GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB); virtual CG_STATUS GenTypeInfo(CCB * pCCB); virtual void * CheckImportLib(); virtual ID_CG GetCGID() { return ID_CG_INTERFACE_PTR; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS* Clone() { return new CG_INTERFACE_POINTER( *this ); } virtual void GenNdrFormat( CCB * pCCB ); // This routine always generates the format string for a pointer. Used // by GenNdrFormat and GenNdrImbededFormat(). // virtual long GenNdrFormatAlways( CCB * pCCB ); // // Inherited from CG_NDR. // BOOL ShouldFreeOffline() { return TRUE; } node_interface * SetTheInterface( node_interface * pI ) { return ( pMyIntf = pI ); } node_interface * GetTheInterface() { return pMyIntf; } virtual BOOL IsInterfacePointer() { return TRUE; } virtual CG_STATUS S_OutLocalAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS MarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS UnMarshallAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS RefCheckAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS InLocalAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS S_GenInitOutLocals( CCB * pCCB ); virtual CG_STATUS S_GenInitInLocals( CCB * ) { return CG_OK; } virtual CG_STATUS GenRefChecks( CCB * ) { return CG_OK; } void GenNdrFormatForGuid( CCB * pCCB ); // // Ndr format string generation for the pointee. // virtual void GenNdrFormatPointee( CCB * ) { } }; // // This class corresponds to an interface pointer with iid_is() attribute // Note that the base class can be an interface OR a void * // class CG_IIDIS_INTERFACE_POINTER : public CG_POINTER { private: expr_node * pIIDExpr; node_skl * pMyBase; CG_TYPEDEF* pAlias; public: // // Get and Set methods. // CG_IIDIS_INTERFACE_POINTER(node_skl * pBT, node_skl * pInt, expr_node * pIIDEx) : CG_POINTER( pBT, PTR_REF, 0 ), pAlias(0) { SetIIDExpr( pIIDEx ); SetBaseInterface( pInt ); } CG_IIDIS_INTERFACE_POINTER( CG_IIDIS_INTERFACE_POINTER * pNode ) : CG_POINTER( pNode->GetType(), PTR_REF, 0 ), pAlias(0) { *this = *pNode; } virtual CG_TYPEDEF* GetTypeAlias() { return pAlias; }; virtual void SetTypeAlias( CG_TYPEDEF* pDef ) { pAlias = pDef; }; virtual CG_STATUS GetTypeDesc(TYPEDESC * &ptd, CCB * pCCB); virtual CG_STATUS GenTypeInfo(CCB * pCCB); virtual void * CheckImportLib(); virtual ID_CG GetCGID() { return ID_CG_IIDIS_INTERFACE_PTR; } expr_node * SetIIDExpr( expr_node * pE ) { return ( pIIDExpr = pE ); } expr_node * GetIIDExpr() { return pIIDExpr; } virtual BOOL IsInterfacePointer() { return TRUE; } virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } virtual CG_CLASS* Clone() { return new CG_IIDIS_INTERFACE_POINTER( *this ); } virtual void GenNdrFormat( CCB * pCCB ); // This routine always generates the format string for a pointer. Used // by GenNdrFormat and GenNdrImbededFormat(). // virtual long GenNdrFormatAlways( CCB * pCCB ); // // Inherited from CG_NDR. // BOOL ShouldFreeOffline() { return TRUE; } node_skl * SetBaseInterface( node_skl * pI ) { return ( pMyBase = pI ); } node_skl * GetBaseInterface() { return pMyBase; } virtual CG_STATUS S_OutLocalAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS MarshallAnalysis( ANALYSIS_INFO * pAna ); virtual CG_STATUS UnMarshallAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS RefCheckAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS InLocalAnalysis( ANALYSIS_INFO * ) { return CG_OK; } virtual CG_STATUS S_GenInitOutLocals( CCB * pCCB ); virtual CG_STATUS S_GenInitInLocals( CCB * ) { return CG_OK; } virtual CG_STATUS GenRefChecks( CCB * ) { return CG_OK; } virtual void GenNdrFormatPointee( CCB * ) { } }; // // New 64bit NDR pointer types. // #define DECLARE_COMPLEX_POINTER_CG_CLASS( NEWTYPE, BASETYPE ) \ class NEWTYPE : public BASETYPE \ { \ protected: \ NEWTYPE( const NEWTYPE & Node ) : \ BASETYPE( Node ) {} \ public: \ NEWTYPE( node_skl *pType, \ PTRTYPE p, \ short AD, \ FIELD_ATTR_INFO * pFA ) : \ BASETYPE( pType, \ p, \ AD, \ pFA ) \ { \ } \ virtual CG_CLASS* Clone() { return new NEWTYPE(*this); } \ virtual void Visit( CG_VISITOR *pVisitor ) { pVisitor->Visit( this ); } \ }; // Conformant pointers DECLARE_COMPLEX_POINTER_CG_CLASS( CG_COMPLEX_SIZE_POINTER, CG_SIZE_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FORCED_COMPLEX_SIZE_POINTER, CG_COMPLEX_SIZE_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FULL_COMPLEX_SIZE_POINTER, CG_COMPLEX_SIZE_POINTER ) // Varying pointers DECLARE_COMPLEX_POINTER_CG_CLASS( CG_COMPLEX_LENGTH_POINTER, CG_LENGTH_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FORCED_COMPLEX_LENGTH_POINTER, CG_COMPLEX_LENGTH_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FULL_COMPLEX_LENGTH_POINTER, CG_COMPLEX_LENGTH_POINTER ) // Conformant varying pointers DECLARE_COMPLEX_POINTER_CG_CLASS( CG_COMPLEX_SIZE_LENGTH_POINTER, CG_SIZE_LENGTH_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FORCED_COMPLEX_SIZE_LENGTH_POINTER, CG_COMPLEX_SIZE_LENGTH_POINTER ) DECLARE_COMPLEX_POINTER_CG_CLASS( CG_FULL_COMPLEX_SIZE_LENGTH_POINTER, CG_COMPLEX_SIZE_LENGTH_POINTER ) #endif // __PTRCLS_HXX__