mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
893 lines
17 KiB
893 lines
17 KiB
#ifndef __NODESKL_HXX__
|
|
#define __NODESKL_HXX__
|
|
|
|
#include "common.hxx"
|
|
#include "errors.hxx"
|
|
#include "midlnode.hxx"
|
|
#include "attrdict.hxx"
|
|
#include "listhndl.hxx"
|
|
#include "tlnmgr.hxx"
|
|
|
|
class node_skl;
|
|
class type_node_list;
|
|
class node_array;
|
|
class node_base_attr;
|
|
class BadUseInfo;
|
|
|
|
class MopStream;
|
|
|
|
|
|
/***
|
|
*** The mother of all inventions.
|
|
***/
|
|
class node_0
|
|
{
|
|
private:
|
|
|
|
#ifdef MIDL_INTERNAL
|
|
|
|
unsigned short NDMask;
|
|
|
|
#endif // MIDL_INTERNAL
|
|
|
|
class node_skl * pSibling,
|
|
* pChild;
|
|
public:
|
|
node_0();
|
|
~node_0() { };
|
|
|
|
#ifdef MIDL_INTERNAL
|
|
|
|
unsigned short GetNDMask()
|
|
{
|
|
return NDMask;
|
|
}
|
|
unsigned short SetNDMask( unsigned short m )
|
|
{
|
|
return NDMask = m;
|
|
}
|
|
#endif // MIDL_INTERNAL
|
|
|
|
node_skl * GetChild()
|
|
{
|
|
return pChild;
|
|
};
|
|
|
|
STATUS_T GetChild( node_skl **p )
|
|
{
|
|
if( *p = pChild )
|
|
return STATUS_OK;
|
|
else
|
|
return I_ERR_NO_MEMBER;
|
|
}
|
|
|
|
node_skl * SetChild( node_skl * pCh )
|
|
{
|
|
return pChild = pCh;
|
|
};
|
|
|
|
node_skl * GetSibling()
|
|
{
|
|
return pSibling;
|
|
};
|
|
node_skl * SetSibling( node_skl * pS )
|
|
{
|
|
return pSibling = pS;
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
** this node is a temporary, as a stop gap for the real node skl
|
|
**/
|
|
|
|
class node_skl : public node_0
|
|
{
|
|
private:
|
|
|
|
#ifdef MIDL_INTERNAL
|
|
char * pTempName;
|
|
#endif // MIDL_INTERNAL
|
|
|
|
node_state NodeState;
|
|
PATTR_SUMMARY pAttrKey;
|
|
type_node_list * pAttrList;
|
|
char * pSymName;
|
|
unsigned int NodeType : 8;
|
|
unsigned int Edge : 2;
|
|
unsigned int fUseTreeBuffer : 1;
|
|
unsigned int fHasTreeBuffer : 1;
|
|
unsigned int ClientRefCount : 1;
|
|
unsigned int ServerRefCount : 1;
|
|
unsigned int fAllocateAlign : 1;
|
|
unsigned int fRecursiveType : 1;
|
|
public:
|
|
|
|
#ifdef MIDL_INTERNAL
|
|
|
|
short Dump( short );
|
|
|
|
#endif // MIDL_INTERNAL
|
|
node_skl( NODE_T );
|
|
~node_skl(){ };
|
|
|
|
NODE_T GetNodeType()
|
|
{
|
|
return (NODE_T) NodeType;
|
|
};
|
|
STATUS_T GetNodeType( NODE_T *p )
|
|
{
|
|
*p = (NODE_T) NodeType;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
NODE_T SetNodeType( NODE_T Nt )
|
|
{
|
|
return (NODE_T)(NodeType = Nt);
|
|
};
|
|
|
|
NODE_T NodeKind()
|
|
{
|
|
return (NODE_T) NodeType;
|
|
};
|
|
|
|
char * GetNodeNameString();
|
|
|
|
node_state GetNodeState()
|
|
{
|
|
return NodeState;
|
|
};
|
|
|
|
STATUS_T GetNodeState( node_state *p )
|
|
{
|
|
*p = NodeState;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
node_state SetNodeState( node_state Ns )
|
|
{
|
|
return NodeState |= Ns;
|
|
};
|
|
|
|
node_state ResetNodeState( node_state Ns )
|
|
{
|
|
return NodeState &= ~Ns;
|
|
};
|
|
STATUS_T GetEdgeType( EDGE_T *pE )
|
|
{
|
|
*pE = (EDGE_T) Edge;
|
|
return STATUS_OK;
|
|
};
|
|
|
|
EDGE_T GetEdgeType()
|
|
{
|
|
return (EDGE_T) Edge;
|
|
};
|
|
|
|
|
|
void SetEdgeType( EDGE_T e )
|
|
{
|
|
Edge = e;
|
|
};
|
|
|
|
|
|
BOOL HasAnySizeAttributes();
|
|
|
|
BOOL HasAnyLengthAttributes();
|
|
|
|
BOOL HasAnyHandleSpecification()
|
|
{
|
|
return ( HasAnyHdlTSpecification() ||
|
|
HasAnyCtxtHdlSpecification() );
|
|
}
|
|
|
|
BOOL HasAnyCtxtHdlSpecification()
|
|
{
|
|
return (BOOL)
|
|
((GetNodeState() & NODE_STATE_CONTEXT_HANDLE) !=
|
|
0);
|
|
}
|
|
|
|
BOOL HasAnyHdlTSpecification()
|
|
{
|
|
return (BOOL)
|
|
((GetNodeState() & NODE_STATE_HANDLE) !=
|
|
0);
|
|
}
|
|
|
|
BOOL HasManyChildren()
|
|
{
|
|
return ( GetChild() &&
|
|
(GetChild()->GetSibling()
|
|
!= (node_skl *)NULL ) );
|
|
}
|
|
|
|
BOOL IsBaseTypeNode()
|
|
{
|
|
return IS_BASE_TYPE_NODE( NodeType );
|
|
}
|
|
// virtual
|
|
BOOL IsEdgeSetUp()
|
|
{
|
|
return
|
|
((GetNodeState() & NODE_STATE_EDGE_SET_UP ) != 0 );
|
|
}
|
|
void EdgeSetUp()
|
|
{
|
|
SetNodeState( NODE_STATE_EDGE_SET_UP );
|
|
}
|
|
|
|
node_state ResetSemanticsInProgress()
|
|
{
|
|
return ResetNodeState( NODE_STATE_SEM_IN_PROGRESS);
|
|
}
|
|
|
|
node_state SetSemanticsDone()
|
|
{
|
|
return SetNodeState( NODE_STATE_SEMANTICS_DONE);
|
|
}
|
|
|
|
node_state SetPostSemanticsDone()
|
|
{
|
|
return SetNodeState( NODE_STATE_POST_SEMANTICS_DONE);
|
|
}
|
|
node_state SetAllSemanticsDone()
|
|
{
|
|
return SetNodeState( NODE_STATE_SEMANTICS_DONE |
|
|
NODE_STATE_POST_SEMANTICS_DONE);
|
|
}
|
|
|
|
BOOL DerivesFromUnion()
|
|
{
|
|
return ((GetNodeState() & NODE_STATE_UNION) != 0);
|
|
}
|
|
|
|
virtual
|
|
BOOL IsFixedSizedArray();
|
|
|
|
BOOL IsFundamentalTypeByteOrChar();
|
|
|
|
node_skl * GetFundamentalType();
|
|
|
|
#if 0
|
|
BOOL IsImproperConstruct()
|
|
{
|
|
return
|
|
((GetNodeState() & NODE_STATE_IMPROPER_IN_CONSTRUCT)
|
|
!= 0 );
|
|
}
|
|
#endif // 0
|
|
|
|
node_state ImproperConstruct()
|
|
{
|
|
return
|
|
SetNodeState( NODE_STATE_IMPROPER_IN_CONSTRUCT);
|
|
}
|
|
|
|
node_state ResetImproperConstruct()
|
|
{
|
|
return ResetNodeState(
|
|
NODE_STATE_IMPROPER_IN_CONSTRUCT );
|
|
}
|
|
|
|
BOOL IsNonRPCAble();
|
|
|
|
node_state ResetNonRPCAble()
|
|
{
|
|
return
|
|
ResetNodeState( NODE_STATE_IS_NON_RPCABLE_TYPE |
|
|
NODE_STATE_HAS_NON_RPCABLE_TYPE );
|
|
}
|
|
|
|
node_state SetNonRPCAble()
|
|
{
|
|
return SetNodeState( NODE_STATE_IS_NON_RPCABLE_TYPE);
|
|
}
|
|
|
|
BOOL SemanticsInProgress()
|
|
{
|
|
return
|
|
((NodeState & NODE_STATE_SEM_IN_PROGRESS) != 0);
|
|
}
|
|
|
|
BOOL AreSemanticsDone();
|
|
|
|
void SetSemanticsInProgress()
|
|
{
|
|
SetNodeState( NODE_STATE_SEM_IN_PROGRESS );
|
|
}
|
|
BOOL NeedsUseProcessing()
|
|
{
|
|
return
|
|
((GetNodeState() & NODE_STATE_NEEDS_USE_PROCESSING) != 0 );
|
|
}
|
|
virtual
|
|
void UseProcessing();
|
|
|
|
void SetUseProcessingNeeded()
|
|
{
|
|
SetNodeState( NODE_STATE_NEEDS_USE_PROCESSING );
|
|
}
|
|
|
|
virtual
|
|
void UseProcessingAction();
|
|
|
|
|
|
BOOL AreForwardDeclarationsPresent()
|
|
{
|
|
return ( GetNodeState() & NODE_STATE_RESOLVE );
|
|
}
|
|
virtual
|
|
void RegFDAndSetE();
|
|
|
|
|
|
PATTR_SUMMARY GetAttrKey()
|
|
{
|
|
return pAttrKey;
|
|
};
|
|
|
|
void SetAttrKey( PATTR_SUMMARY pA )
|
|
{
|
|
pAttrKey = pA;
|
|
};
|
|
|
|
node_base_attr * GetAttribute( ATTR_T );
|
|
|
|
STATUS_T GetAttribute( ATTR_SUMMARY * );
|
|
|
|
STATUS_T GetAttribute( node_skl **p, ATTR_T At )
|
|
{
|
|
*p = (node_skl *)GetAttribute( At );
|
|
return STATUS_OK;
|
|
}
|
|
|
|
type_node_list * GetAttributeList( void );
|
|
|
|
|
|
void NewAttributeSummary( PATTR_SUMMARY );
|
|
|
|
void SetAttribute( ATTR_T );
|
|
|
|
void SetAttribute( node_base_attr * );
|
|
|
|
virtual
|
|
void SetAttribute( type_node_list * );
|
|
|
|
BOOL FInSummary( ATTR_T );
|
|
|
|
void ResetAttribute( ATTR_T );
|
|
|
|
virtual
|
|
unsigned long GetSize( unsigned long );
|
|
|
|
virtual
|
|
unsigned long GetBasicSize();
|
|
|
|
virtual
|
|
node_skl * GetLargestElement();
|
|
|
|
virtual
|
|
node_skl * GetLargestNdr();
|
|
|
|
virtual
|
|
unsigned short GetMscAlign();
|
|
|
|
virtual
|
|
unsigned short GetNdrAlign();
|
|
|
|
virtual
|
|
node_skl * GetBasicType();
|
|
|
|
virtual
|
|
STATUS_T SetBasicType( node_skl * );
|
|
|
|
node_skl * GetFirstMember()
|
|
{
|
|
return GetChild();
|
|
}
|
|
|
|
node_skl * GetLastMember ( void );
|
|
node_skl * GetNamedMember( char * pNameToFind );
|
|
|
|
STATUS_T GetMembers( class type_node_list * );
|
|
|
|
STATUS_T GetMembers( node_skl **ppNode )
|
|
{
|
|
return GetChild( ppNode );
|
|
}
|
|
|
|
node_skl * GetMembers()
|
|
{
|
|
return GetChild();
|
|
}
|
|
|
|
short GetMemberCount();
|
|
|
|
STATUS_T SetMembers( type_node_list * );
|
|
|
|
void SetOneMember( node_skl *p )
|
|
{
|
|
SetChild( p );
|
|
}
|
|
|
|
|
|
BOOL HasPointer( void );
|
|
|
|
BOOL HasInterfacePointer( short );
|
|
|
|
virtual
|
|
node_state PreSCheck( class BadUseInfo *);
|
|
|
|
virtual
|
|
node_state SCheck( class BadUseInfo *);
|
|
|
|
virtual
|
|
node_state PostSCheck( class BadUseInfo *);
|
|
|
|
virtual
|
|
node_state SemReturn( node_state );
|
|
|
|
virtual
|
|
void UpdateBadUseInfo( class BadUseInfo * );
|
|
|
|
virtual
|
|
void PrintReasonWhyImproperConstruct( class BadUseInfo * );
|
|
|
|
virtual
|
|
void PrintReasonWhyNotRPCAble( class BadUseInfo * );
|
|
|
|
char * GetSymName();
|
|
|
|
STATUS_T GetSymName( char **p );
|
|
|
|
char * SetSymName( char *pName )
|
|
{
|
|
if( pSymName )
|
|
delete pSymName;
|
|
return (pSymName = pName);
|
|
};
|
|
|
|
virtual
|
|
node_skl * Clone();
|
|
|
|
node_skl * CloneAction( node_skl * );
|
|
|
|
virtual
|
|
void RegisterFDeclUse();
|
|
|
|
node_skl * GetSwitchIsType();
|
|
|
|
node_skl * GetSwitchType();
|
|
|
|
void PrintSizeofString( class BufferManager * );
|
|
|
|
HDL_TYPE GetBasicHandle( node_skl ** );
|
|
|
|
BOOL UseTreeBuffer( void )
|
|
{
|
|
return fUseTreeBuffer;
|
|
};
|
|
|
|
BOOL HasTreeBuffer( void )
|
|
{
|
|
return fHasTreeBuffer;
|
|
};
|
|
|
|
unsigned short GetClientRefCount( void )
|
|
{
|
|
return ClientRefCount;
|
|
};
|
|
|
|
unsigned short GetServerRefCount( void )
|
|
{
|
|
return ServerRefCount;
|
|
};
|
|
|
|
BOOL AllocateAlign( void )
|
|
{
|
|
return fAllocateAlign;
|
|
};
|
|
|
|
BOOL RecursiveType( void )
|
|
{
|
|
return fRecursiveType;
|
|
};
|
|
|
|
void MarkRecursive( void )
|
|
{
|
|
fRecursiveType = TRUE;
|
|
};
|
|
|
|
void ExitRecursive( void )
|
|
{
|
|
fRecursiveType = FALSE;
|
|
};
|
|
|
|
BOOL HasRef( void );
|
|
|
|
BOOL HasPtr( void );
|
|
|
|
BOOL IsPersistent( void );
|
|
|
|
unsigned short CheckAlign( unsigned long *, unsigned long * );
|
|
|
|
virtual
|
|
node_skl * StaticSize( SIDE_T, NODE_T, unsigned long * );
|
|
|
|
virtual
|
|
node_skl * UpperBoundNode( SIDE_T, NODE_T, unsigned long * );
|
|
|
|
virtual
|
|
node_skl * UpperBoundTree( SIDE_T, NODE_T, unsigned long * );
|
|
|
|
virtual
|
|
STATUS_T EmitProc( SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T WalkTree( ACTION_T, SIDE_T, NODE_T, BufferManager * );
|
|
|
|
virtual
|
|
STATUS_T CalcSize( SIDE_T, NODE_T, BufferManager * );
|
|
|
|
virtual
|
|
STATUS_T SendNode( SIDE_T, NODE_T, BufferManager * );
|
|
|
|
virtual
|
|
STATUS_T RecvNode(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T PeekNode(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T InitNode(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T FreeNode(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T PrintType(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
STATUS_T PrintDecl(SIDE_T, NODE_T, BufferManager *);
|
|
|
|
virtual
|
|
node_state AcfSCheck();
|
|
|
|
virtual
|
|
void CountUsage( SIDE_T, BOOL );
|
|
|
|
virtual
|
|
BOOL CountAlloc( BOOL);
|
|
|
|
virtual
|
|
void AllocBlock( NODE_T, class BufferManager * );
|
|
|
|
virtual
|
|
void EmitSpecifier( class BufferManager * );
|
|
|
|
virtual
|
|
void EmitQualifier( SIDE_T, class BufferManager * );
|
|
|
|
virtual
|
|
void EmitModifier( class BufferManager * );
|
|
|
|
virtual
|
|
void EmitModifierWOInLine( class BufferManager * );
|
|
|
|
|
|
virtual
|
|
void SetUpUnionSwitch( class BufferManager * p);
|
|
|
|
char * GetByteCountParamName();
|
|
|
|
virtual
|
|
class expr_node * GetSwitchIsExpr();
|
|
|
|
virtual
|
|
short GetAllocateDetails();
|
|
|
|
class node_array * GetConfArrayNode();
|
|
|
|
node_skl * GetAttributeExprType( ATTR_T );
|
|
|
|
BOOL IsAttributeExprConstant( ATTR_T );
|
|
|
|
STATUS_T ConvNode( class BufferManager *);
|
|
|
|
STATUS_T ConvTree( class BufferManager *);
|
|
|
|
virtual
|
|
node_skl * GetOneNEUnionSwitchType();
|
|
|
|
short GetNEUnionSwitchType( type_node_list * );
|
|
|
|
BOOL CheckNodeStateInMembers( node_state );
|
|
|
|
virtual
|
|
BOOL HasOnlyFirstLevelRefPtr()
|
|
{
|
|
return (BOOL)
|
|
((GetNodeState() & NODE_STATE_FIRST_LEVEL_REF)
|
|
== NODE_STATE_FIRST_LEVEL_REF );
|
|
}
|
|
virtual
|
|
BOOL HasAnyNETransmitAsType()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_TRANSMIT_AS )
|
|
== NODE_STATE_TRANSMIT_AS );
|
|
}
|
|
|
|
virtual
|
|
BOOL HasPtrToAnyNEArray()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_PTR_TO_ANY_ARRAY )
|
|
== NODE_STATE_PTR_TO_ANY_ARRAY );
|
|
}
|
|
|
|
virtual
|
|
BOOL HasPtrToCompWEmbeddedPtr()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_PTR_TO_EMBEDDED_PTR )
|
|
== NODE_STATE_PTR_TO_EMBEDDED_PTR );
|
|
}
|
|
|
|
BOOL HasCompWEmbeddedPtr()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_EMBEDDED_PTR )
|
|
== NODE_STATE_EMBEDDED_PTR );
|
|
}
|
|
|
|
virtual
|
|
BOOL HasSizedComponent()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_SIZE )
|
|
== NODE_STATE_SIZE );
|
|
}
|
|
virtual
|
|
BOOL HasLengthedComponent()
|
|
{
|
|
return (BOOL)
|
|
(( GetNodeState() & NODE_STATE_LENGTH )
|
|
== NODE_STATE_LENGTH );
|
|
}
|
|
|
|
void UpdateUseOfCDecls( class BadUseInfo * );
|
|
|
|
virtual
|
|
void CheckBadConstructs( class BadUseInfo * )
|
|
{
|
|
}
|
|
|
|
void SetUsedInAnExpression()
|
|
{
|
|
SetNodeState( NODE_STATE_USED_IN_EXPRESSION );
|
|
}
|
|
|
|
BOOL IsUsedInAnExpression()
|
|
{
|
|
return (BOOL) ((GetNodeState() &
|
|
NODE_STATE_USED_IN_EXPRESSION )
|
|
== NODE_STATE_USED_IN_EXPRESSION);
|
|
}
|
|
|
|
virtual
|
|
short GetTopLevelNames( TLNDICT * pDict, BOOL fReportError )
|
|
{
|
|
UNUSED( pDict );
|
|
UNUSED( fReportError );
|
|
return 0;
|
|
}
|
|
|
|
BOOL IsNamedNode();
|
|
|
|
short GetOrdinalNumberOfMember( class node_skl * );
|
|
|
|
BOOL IsClonedNode();
|
|
|
|
virtual
|
|
node_skl * GetOriginalNode( node_skl * )
|
|
{
|
|
return this;
|
|
}
|
|
|
|
void SetUseProcessingInProgress()
|
|
{
|
|
SetNodeState( NODE_STATE_USE_PROC_IN_PROGRESS );
|
|
}
|
|
|
|
void ResetUseProcessingInProgress()
|
|
{
|
|
ResetNodeState( NODE_STATE_USE_PROC_IN_PROGRESS );
|
|
}
|
|
|
|
BOOL IsUseProcessingInProgress()
|
|
{
|
|
return
|
|
((GetNodeState() & NODE_STATE_USE_PROC_IN_PROGRESS ) == NODE_STATE_USE_PROC_IN_PROGRESS );
|
|
}
|
|
|
|
void ThisIsTheBindingHandle()
|
|
{
|
|
SetNodeState( NODE_STATE_THIS_IS_BINDING_HANDLE );
|
|
}
|
|
BOOL IsThisTheBindingHandle()
|
|
{
|
|
return
|
|
((GetNodeState() & NODE_STATE_THIS_IS_BINDING_HANDLE ) == NODE_STATE_THIS_IS_BINDING_HANDLE );
|
|
}
|
|
virtual
|
|
BOOL IsEncapsulatedStruct()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
BOOL IsEncapsulatedUnion()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
void SetLastMemberIsEncapUnion()
|
|
{
|
|
}
|
|
|
|
virtual
|
|
BOOL IsLastMemberEncapUnion()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
void PropogateOriginalName( char *p )
|
|
{
|
|
UNUSED( p );
|
|
}
|
|
|
|
BOOL Has8ByteElementWithZp8();
|
|
|
|
virtual
|
|
void SetForcedAlignment( unsigned short s )
|
|
{
|
|
}
|
|
virtual
|
|
unsigned short GetForcedAlignment()
|
|
{
|
|
return 0;
|
|
}
|
|
virtual
|
|
unsigned short AllocWRTOtherAttrs()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
void MarkUsage()
|
|
{
|
|
}
|
|
|
|
virtual
|
|
BOOL DerivesFromTransmitAs()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
BOOL HasEmbeddedFixedArrayOfStrings()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
node_skl * GetBasicTransmissionType();
|
|
|
|
virtual
|
|
BOOL IsItARealConformantArray()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
STATUS_T MopCodeGen(
|
|
MopStream * pStream,
|
|
node_skl * pParent,
|
|
BOOL fMemory );
|
|
|
|
STATUS_T MopContextHandleCodeGen( MopStream *, int IOCode );
|
|
|
|
unsigned short MopGetParamOrFieldOffset( char * pNameToFind );
|
|
|
|
virtual
|
|
unsigned long MopGetBufferSize( unsigned long CurrentSize);
|
|
|
|
virtual
|
|
unsigned long MopGetStackSize( unsigned long CurrentOffset );
|
|
|
|
virtual
|
|
unsigned long MopGetSizePadding( BOOL fMemory, unsigned long Offset);
|
|
|
|
virtual
|
|
void MopSizeDebugDump(
|
|
node_skl * pParent,
|
|
BOOL fMemory,
|
|
unsigned long Offset,
|
|
char * Text );
|
|
|
|
};
|
|
|
|
class node_base_attr /* : public node_0 */
|
|
{
|
|
private:
|
|
ATTR_T AttrID;
|
|
char * pSymName;
|
|
public:
|
|
node_base_attr( ATTR_T);
|
|
~node_base_attr() { };
|
|
|
|
BOOL IsAttrID( ATTR_T );
|
|
|
|
ATTR_T GetAttrID()
|
|
{
|
|
return AttrID;
|
|
};
|
|
virtual
|
|
BOOL IsBitAttr();
|
|
|
|
virtual
|
|
node_state AcfSCheck();
|
|
|
|
virtual
|
|
class expr_node * GetExpr();
|
|
|
|
char * GetNodeNameString();
|
|
|
|
virtual
|
|
node_state SCheck();
|
|
|
|
virtual
|
|
class node_base_attr * Clone()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
virtual
|
|
BOOL IsAcfAttr()
|
|
{
|
|
return FALSE;
|
|
}
|
|
virtual
|
|
STATUS_T MopCodeGen(
|
|
MopStream * pStream,
|
|
node_skl * pParent,
|
|
BOOL fMemory,
|
|
unsigned long AddOffset );
|
|
|
|
};
|
|
|
|
class node_e_attr : public node_base_attr
|
|
{
|
|
public:
|
|
node_e_attr() : node_base_attr( ATTR_NONE )
|
|
{
|
|
}
|
|
};
|
|
|
|
class battr : public node_base_attr
|
|
{
|
|
public:
|
|
battr( ATTR_T At ) : node_base_attr( At )
|
|
{
|
|
}
|
|
|
|
virtual
|
|
BOOL IsBitAttr();
|
|
|
|
};
|
|
|
|
class nbattr : public node_base_attr
|
|
{
|
|
public:
|
|
nbattr( ATTR_T At ) : node_base_attr( At )
|
|
{
|
|
};
|
|
};
|
|
|
|
#endif // __NODESKL_HXX__
|