436 lines
14 KiB
C++
436 lines
14 KiB
C++
/*****************************************************************************/
|
|
/** Microsoft LAN Manager **/
|
|
/** Copyright(c) Microsoft Corp., 1987-1999 **/
|
|
/*****************************************************************************/
|
|
/*****************************************************************************
|
|
File : acfattr.hxx
|
|
Title : acf attribute node definition file
|
|
Description : this file contains all the definitions of the
|
|
: acfattribute nodes
|
|
History :
|
|
24-Aug-1991 VibhasC Create
|
|
*****************************************************************************/
|
|
#ifndef __ACFATTR__HXX
|
|
#define __ACFATTR__HXX
|
|
|
|
|
|
#include "linenum.hxx"
|
|
#include "cmdana.hxx"
|
|
|
|
#define ALLOCATE_SINGLE_NODE (0x0001)
|
|
#define ALLOCATE_ALL_NODES (0x0002)
|
|
#define ALLOCATE_DONT_FREE (0x0004)
|
|
#define ALLOCATE_FREE (0x0008)
|
|
#define ALLOCATE_ALWAYS (0x0010)
|
|
#define ALLOCATE_ON_NULL (0x0020)
|
|
#define ALLOCATE_ALL_NODES_ALIGNED (0x0102)
|
|
|
|
#define IS_ALLOCATE( AllocateType, CheckType ) ( AllocateType & CheckType )
|
|
|
|
//
|
|
// scenarios where allocate is illegal.
|
|
//
|
|
|
|
#define TRANSMIT_AS_WITH_ALLOCATE (0x0001)
|
|
#define HANDLES_WITH_ALLOCATE (0x0002)
|
|
|
|
// introduce a common base class for all the ACF attributes, since we need to store
|
|
// line number info for them
|
|
|
|
class acf_attr : public nbattr
|
|
{
|
|
|
|
public:
|
|
tracked_node Position;
|
|
|
|
|
|
|
|
|
|
|
|
acf_attr( ATTR_T At ) : nbattr ( At )
|
|
{
|
|
}
|
|
|
|
BOOL IsAcfAttr()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
};
|
|
|
|
class node_represent_as : public acf_attr
|
|
{
|
|
protected:
|
|
char * pRepresentName;
|
|
node_skl * pType;
|
|
public:
|
|
node_represent_as( char *p ):
|
|
acf_attr( ATTR_REPRESENT_AS )
|
|
{
|
|
pRepresentName = p;
|
|
pType = NULL;
|
|
}
|
|
|
|
node_represent_as( char *p,
|
|
node_skl * pT,
|
|
ATTR_T Attr = ATTR_REPRESENT_AS ):
|
|
acf_attr( Attr )
|
|
{
|
|
pRepresentName = p;
|
|
pType = pT;
|
|
}
|
|
|
|
node_represent_as( node_represent_as * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
char * GetRepresentationName()
|
|
{
|
|
return pRepresentName;
|
|
}
|
|
|
|
node_skl * GetRepresentationType()
|
|
{
|
|
return pType;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone()
|
|
{
|
|
return new node_represent_as( this );
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// user_marshal attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_user_marshal : public node_represent_as
|
|
{
|
|
public:
|
|
node_user_marshal( char * pName, node_skl * pN )
|
|
:
|
|
node_represent_as( pName, pN, ATTR_USER_MARSHAL )
|
|
{
|
|
}
|
|
|
|
node_user_marshal( node_user_marshal * pOld )
|
|
:
|
|
node_represent_as( (node_represent_as *)pOld )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone()
|
|
{
|
|
node_base_attr * pNew = new node_user_marshal( this );
|
|
return pNew;
|
|
}
|
|
|
|
node_skl * GetUserMarshalType()
|
|
{
|
|
return pType;
|
|
}
|
|
|
|
};
|
|
|
|
class node_call_as : public acf_attr
|
|
{
|
|
private:
|
|
char * pCallAsName;
|
|
node_proc * pType;
|
|
|
|
public:
|
|
node_call_as( char *p ):
|
|
acf_attr( ATTR_CALL_AS )
|
|
{
|
|
pCallAsName = p;
|
|
pType = NULL;
|
|
}
|
|
|
|
node_call_as( char *p, node_skl * pT ):
|
|
acf_attr( ATTR_CALL_AS )
|
|
{
|
|
pCallAsName = p;
|
|
pType = (node_proc *) pT;
|
|
}
|
|
|
|
node_call_as( node_call_as * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
char * GetCallAsName()
|
|
{
|
|
return pCallAsName;
|
|
}
|
|
|
|
void SetCallAsName( char* szName )
|
|
{
|
|
pCallAsName = szName;
|
|
}
|
|
|
|
node_proc * GetCallAsType()
|
|
{
|
|
return pType;
|
|
}
|
|
|
|
node_proc * SetCallAsType( node_skl * pT)
|
|
{
|
|
return ( pType = (node_proc *) pT );
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone()
|
|
{
|
|
return new node_call_as( this );
|
|
}
|
|
|
|
};
|
|
|
|
class node_byte_count : public acf_attr
|
|
{
|
|
private:
|
|
node_param * pByteCountParam;
|
|
public:
|
|
node_byte_count( node_param *p ) :
|
|
acf_attr( ATTR_BYTE_COUNT )
|
|
{
|
|
pByteCountParam = p;
|
|
}
|
|
|
|
node_byte_count( node_byte_count * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone()
|
|
{
|
|
return new node_byte_count( this );
|
|
}
|
|
|
|
node_param * GetByteCountParam()
|
|
{
|
|
return pByteCountParam;
|
|
}
|
|
virtual void SetByteCountParam( node_param* pNew )
|
|
{
|
|
pByteCountParam = pNew;
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// optimization attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
extern OPT_LEVEL_ENUM
|
|
ParseAcfOptimizationAttr( char * pOptString, unsigned short * pOptFlags );
|
|
|
|
|
|
class node_optimize : public acf_attr
|
|
{
|
|
OPT_LEVEL_ENUM OptimizationLevel;
|
|
unsigned short OptimizationFlags;
|
|
|
|
public:
|
|
node_optimize( OPT_LEVEL_ENUM OptLevel,
|
|
unsigned short OptFlags )
|
|
: acf_attr( ATTR_OPTIMIZE ),
|
|
OptimizationLevel( OptLevel ),
|
|
OptimizationFlags( OptFlags )
|
|
{
|
|
}
|
|
|
|
node_optimize( node_optimize * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone();
|
|
|
|
unsigned short GetOptimizationFlags()
|
|
{
|
|
return OptimizationFlags;
|
|
}
|
|
|
|
OPT_LEVEL_ENUM GetOptimizationLevel()
|
|
{
|
|
return OptimizationLevel;
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// ptr_size attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_ptr_size : public acf_attr
|
|
{
|
|
public:
|
|
node_ptr_size() : acf_attr( ATTR_PTRSIZE )
|
|
{
|
|
}
|
|
|
|
node_ptr_size( node_ptr_size * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone();
|
|
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// enable_allocate attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// implicit handle attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_id;
|
|
class CG_CLASS;
|
|
class XLAT_CTXT;
|
|
|
|
class node_implicit : public acf_attr
|
|
{
|
|
public:
|
|
node_id * pHandleID;
|
|
node_skl * pHandleType;
|
|
public:
|
|
node_implicit( node_skl *, node_id *);
|
|
|
|
node_implicit( node_implicit * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone();
|
|
|
|
void ImplicitHandleDetails( node_skl**, node_id **);
|
|
|
|
BOOL IsHandleTypeDefined();
|
|
|
|
virtual
|
|
CG_CLASS * ILxlate( XLAT_CTXT * pContext );
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// allocate attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_allocate : public acf_attr
|
|
{
|
|
private:
|
|
short AllocateDetails;
|
|
public:
|
|
node_allocate( short Details)
|
|
: acf_attr( ATTR_ALLOCATE )
|
|
{
|
|
AllocateDetails = Details;
|
|
}
|
|
|
|
|
|
node_allocate( node_allocate * pOld )
|
|
: acf_attr( pOld->GetAttrID() )
|
|
{
|
|
*this = *pOld;
|
|
}
|
|
|
|
virtual
|
|
node_base_attr * Clone()
|
|
{
|
|
return new node_allocate( this );
|
|
}
|
|
|
|
short GetAllocateDetails()
|
|
{
|
|
return AllocateDetails;
|
|
};
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// cs_char attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_cs_char : public acf_attr
|
|
{
|
|
private:
|
|
|
|
// The type node for the user type
|
|
node_skl *pUserType;
|
|
|
|
// The size of the user type (not set until ILxlate is done)
|
|
long ElementSize;
|
|
|
|
public:
|
|
node_cs_char( node_skl *p )
|
|
: acf_attr( ATTR_CSCHAR )
|
|
{
|
|
pUserType = p;
|
|
}
|
|
|
|
node_skl * GetUserType()
|
|
{
|
|
return pUserType;
|
|
}
|
|
|
|
PNAME GetUserTypeName()
|
|
{
|
|
return pUserType->GetSymName();
|
|
}
|
|
|
|
void SetElementSize( long size )
|
|
{
|
|
MIDL_ASSERT( size >= 0 && size <= 255 );
|
|
ElementSize = size;
|
|
}
|
|
|
|
long GetElementSize()
|
|
{
|
|
return ElementSize;
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// cs_tag_rtn attribute
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class node_cs_tag_rtn : public acf_attr
|
|
{
|
|
private:
|
|
|
|
node_proc * pCSTagRoutine;
|
|
|
|
public:
|
|
node_cs_tag_rtn( node_skl *p )
|
|
: acf_attr( ATTR_CSTAGRTN )
|
|
{
|
|
MIDL_ASSERT( NODE_PROC == p->NodeKind() );
|
|
pCSTagRoutine = (node_proc *) p;
|
|
}
|
|
|
|
node_proc * GetCSTagRoutine()
|
|
{
|
|
return pCSTagRoutine;
|
|
}
|
|
};
|
|
|
|
#endif // __ACFATTR__HXX
|
|
|