NT4/private/rpc/midl20/include/nodeskl.hxx

#ifndef __NODESKL_HXX__
#define __NODESKL_HXX__

#include "common.hxx"
#include "errors.hxx"
#include "midlnode.hxx"
#include "symtable.hxx"
#include "symtable.hxx"
#include "stream.hxx"
#include "prttype.hxx"
#include "expr.hxx"
#include "attrlist.hxx"
#include "linenum.hxx"
#include "freelist.hxx"

/***
 *** Here is the class hierarcy for the typegraph nodes.
 *** (last updated 6/22/95)
 ***/

/*

node_skl
    named_node          \\nodes with siblings and names and attributes
        node_base_type
        node_com_server
        node_def
            node_def_fe
        node_e_status_t
        node_echo_string
            node_pragma_pack
        node_field
            node_bitfield
        node_file
        node_forward
        node_href
        node_id
            node_id_fe      \\ front-end version of node_id
        node_interface
            node_coclass
            node_dispinterface
            node_libarary
            node_module
            node_object
        node_interface_reference
        node_label
        node_param
        node_proc
        node_su_base
            node_enum
            node_struct
                node_en_struct
            node_union
                node_en_union
        node_wchar_t
    node_error
    node_source
    npa_nodes
        node_array
        node_pointer
        node_safearray

 */


/***
 *** The base node type all the nodes in the typegraph are derived from.
 *** This is a virtual class; there are no nodes directly of this type.
 *** It is used to describe the routines used to walk the typegraph.
 ***/

// forward class declarations
class CG_CLASS;
class XLAT_CTXT;
class SEM_ANALYSIS_CTXT;
class node_interface;
class node_file;
class gplistmgr;

extern unsigned short CurrentIntfKey;



class node_skl
    {
private:

    node_skl *      pChild;
    node_file *     pTLBFile;
    unsigned long   Kind        : 8;

protected:

    unsigned long   MiscBits    : 8;    // this field should be cleared by any
                                        // class that uses it
private:
    unsigned long   IntfKey     : 16;

public:

                    node_skl( )
                        {
                        Kind = (unsigned long) NODE_ILLEGAL;
                        pChild = NULL;
                        IntfKey = CurrentIntfKey;
                        pTLBFile = NULL;
                        }

                    node_skl( NODE_T NodeKind, node_skl * pCh = NULL)
                        {
                        Kind    = (unsigned long) NodeKind;
                        pChild  = pCh;
                        IntfKey = CurrentIntfKey;
                        pTLBFile = NULL;
                        }

                    // lightweight version for backend use
                    node_skl( node_skl * pCh, NODE_T NodeKind )
                        {
                        Kind    = (unsigned long) NodeKind;
                        pChild  = pCh;
                        IntfKey = 0;
                        pTLBFile = NULL;
                        }

    node_skl *      GetChild()
                        {
                        return pChild;
                        }

    node_skl *      SetChild(node_skl * pCh)
                        {
                        return pChild = pCh;
                        }

    node_skl *      GetBasicType();

    node_skl *      GetNonDefChild()
                        {
                        node_skl * p = pChild;
                        while ( p->NodeKind() == NODE_DEF )
                            p = p->GetChild();
                        return p;
                        }

    node_skl *      GetNonDefSelf()
                        {
                        node_skl * p = this;
                        while ( p->NodeKind() == NODE_DEF )
                            p = p->GetChild();
                        return p;
                        }


    node_skl *      SetBasicType(node_skl * pBT)
                        {
                        return pChild = pBT;
                        };

    NODE_T          NodeKind()
                        {
                        return (NODE_T) Kind;
                        };

    node_interface *GetMyInterfaceNode();

    virtual
    node_file *     GetDefiningFile();

    virtual
    BOOL            IsStringableType()
                        {
                        return FALSE;
                        }

    node_file *     GetDefiningTLB()
                        {
                        return pTLBFile;
                        }

    void            SetDefiningTLB(node_file *p)
                        {
                        pTLBFile = p;
                        }

    inline          // see sneaky definition for this below named_node
    char *          GetSymName();

    inline          // see sneaky definition for this below named_node
    char *          GetCurrentSpelling();

    virtual
    void            SetModifiers(long mod)
                        {
                        };

    virtual
    long            GetModifiers(long mod)
                        {
                        UNUSED( mod );

                        return 0;
                        };

    virtual
    BOOL            IsModifierSet( ATTR_T flag )
                        {
                        UNUSED( flag );
                        return FALSE;
                        };


    BOOL            IsDef()
                        {
                        return ! IsModifierSet(ATTR_TAGREF);
                        };

    void            SetEdgeType( EDGE_T Et )
                        {
                        if (Et == EDGE_USE)
                            {
                            SetModifiers( SetModifierBit( ATTR_TAGREF) );
                            };
                        };

    virtual
    BOOL            FInSummary( ATTR_T flag )
                        {
                        UNUSED( flag );
                        return FALSE;
                        };

    virtual
    BOOL            HasAttributes()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsEncapsulatedStruct()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsEncapsulatedUnion()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsPtrOrArray()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsStructOrUnion()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsBasicType()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsInterfaceOrObject()
                        {
                        return FALSE;
                        }


    virtual
    unsigned long   GetSize( unsigned long CurOffset, unsigned short ZeePee = 0);

    unsigned short  GetMscAlign(unsigned short ZeePee = 0);

    unsigned short  GetNdrAlign();

    virtual
    node_skl *      GetLargestElement();

    virtual
    node_skl *      GetLargestNdr();


    virtual
    EXPR_VALUE      ConvertMyKindOfValueToEXPR_VALUE( EXPR_VALUE value )
                        {
                        return value;
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        UNUSED( Posn );
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf )
                        {
                        UNUSED(Flags);
                        UNUSED(pBuffer);
                        UNUSED(pStream);
                        UNUSED(pParent);
                        UNUSED(pIntf);
                        return STATUS_OK;
                        };
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf )
                        {
                        UNUSED(Flags);
                        UNUSED(pBuffer);
                        UNUSED(pStream);
                        UNUSED(pParent);
                        UNUSED(pIntf);
                        return STATUS_OK;
                        };

    STATUS_T        PrintType(PRTFLAGS Flags,
                        ISTREAM * pStream,
                        node_skl * pParent = NULL,
                        node_skl * pIntf = NULL);

    void            EmitModifiers( BufferManager *);

    void            EmitProcModifiers( BufferManager *, PRTFLAGS );

    void            EmitModelModifiers( BufferManager *);

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    void *          operator new ( size_t size )
                        {
                        return AllocateOnceNew( size );
                        }

    void            operator delete( void * ptr )
                        {
                        AllocateOnceDelete( ptr );
                        }

    };      //      end of class node_skl


/***
 *** Here are the direct descendents of node_skl;  nodes with symtab entries
 *** and nodes without them
 ***/

// named nodes that can be on a list (have siblings)
class named_node : public node_skl
    {
private:

    char *          pName;
    char *          pCurrentSpelling;
    class named_node *pSibling;
    class ATTRLIST  AttrList;           // attributes dangle from here
    long            modifiers;

public:

                    // lightweight version for backend use
                    named_node( char * psz, NODE_T Kind )
                        : node_skl( NULL, Kind )
                        {
                        pCurrentSpelling =
                        pName       =   psz;
                        pSibling    =   NULL;
                        AttrList.MakeAttrList();
                        modifiers   =   0;
                        };

                    named_node( NODE_T Kind, char * psz  = NULL)
                        : node_skl( Kind, NULL )
                        {
                        pCurrentSpelling =
                        pName       =   psz;
                        pSibling    =   NULL;
                        AttrList.MakeAttrList();
                        modifiers   =   0;
                        };

                    // convert constructor (for node_id to other named_node)
                    named_node( NODE_T Kind, class named_node * pID )
                        : node_skl( Kind, pID->GetChild() )
                        {
                        pCurrentSpelling =
                        pName       = pID->pName;
                        pSibling    = pID->pSibling;
                        AttrList    = pID->AttrList;
                        modifiers   = pID->modifiers;
                        };

    char *          SetCurrentSpelling(char * sz)
                        {
                        return pCurrentSpelling = sz;
                        };
    
    char *          SetSymName(char * psz)
                        {
                        return pName = psz;
                        };

    class named_node * GetSibling()
                        {
                        return pSibling;
                        };

    class named_node * SetSibling(named_node * pSib)
                        {
                        return pSibling = pSib;
                        };

    virtual
    void            SetModifiers(long mod)
                        {
                        modifiers |= mod;
                        };

    virtual
    BOOL            IsModifierSet( ATTR_T flag )
                        {
                        return ( modifiers & SetModifierBit( flag ) );
                        };

    void            SetAttributes( ATTRLIST & AList )
                        {
                        AttrList = AList;
                        };

    void            SetAttribute( ATTR_T bit )
                        {
                        AttrList.Add( bit );
                        };

    void            SetAttribute( node_base_attr * attr )
                        {
                        AttrList.Add( attr );
                        };

    void            AddAttributes( ATTRLIST & AList )
                        {
                        AttrList.Merge( AList );
                        };

    node_base_attr * GetAttribute( ATTR_T flag )
                        {
                        return AttrList.GetAttribute( flag );
                        };

    ATTRLIST &      GetAttributeList( ATTRLIST & AList )
                        {
                        return (AList = AttrList);
                        }

    void            GetAttributeList( type_node_list * AList )
                        {
                        AttrList.GetAttributeList( AList );
                        }

    void            DumpAttributes( ISTREAM * pStream );

    virtual
    BOOL            HasAttributes()
                        {
                        return AttrList.NonNull();
                        }

    BOOL            FInSummary( ATTR_T flag )
                        {
                        BOOL    result;

                        if ( flag >= ATTR_CPORT_ATTRIBUTES_START && flag <= ATTR_CPORT_ATTRIBUTES_END)
                            {
                            result = IsModifierSet( flag );
                            }
                        else
                            {
                            result = AttrList.FInSummary( flag );
                            }

                        return result;
                        };

    BOOL            FMATTRInSummary( MATTR_T flag)
                        {
                        return AttrList.FMATTRInSummary(flag);
                        };

    BOOL            FTATTRInSummary( TATTR_T flag)
                        {
                        return AttrList.FTATTRInSummary(flag);
                        };

    BOOL            IsNamedNode();

    virtual
    node_file *     GetFileNode()
                        {
                        return NULL;
                        }

    virtual
    node_file *     SetFileNode(node_file * pF)
                        {
                        return NULL;
                        }

// to allow the below GetSymName to work
friend class node_skl;

    };      //      end of class named_node


inline
char * 
node_skl::GetCurrentSpelling()
    {
    if ( IS_NAMED_NODE(NodeKind()) )
        {
        return ((named_node *)this)->pCurrentSpelling;
        }
    else
        {
        return "";
        }
    }

inline
char *
node_skl::GetSymName()
    {
    if ( IS_NAMED_NODE(NodeKind()) )
        {
        return ((named_node *)this)->pName;
        }
    else
        {
        return "";
        }
    }


class SIBLING_LIST;

class MEMLIST
    {
protected:
    named_node *    pMembers;

public:
                    MEMLIST( named_node * pHead = NULL)
                        {
                        pMembers = pHead;
                        };

                    MEMLIST( MEMLIST * pList )
                        {
                        *this = *pList;
                        };

    void            SetMembers( SIBLING_LIST & MemList );

    STATUS_T        GetMembers( class type_node_list * MemList );

    node_skl *      GetFirstMember()
                        {
                        return pMembers;
                        }

    void            SetFirstMember( named_node * pNode  )
                        {
                        pMembers = pNode;
                        }

    short           GetNumberOfArguments();

    void            AddLastMember( named_node * pNode );

    void            AddFirstMember( named_node * pNode )
                        {
                        pNode->SetSibling( pMembers );
                        pMembers = pNode;
                        }

    void            MergeMembersToTail( SIBLING_LIST & MemList );

    void            MergeMembersToTail( MEMLIST & ML )
                        {
                        AddLastMember( ML.pMembers );
                        }

    void            MergeMembersToHead( MEMLIST & ML )
                        {
                        ML.MergeMembersToTail( *this );
                        pMembers = ML.pMembers;
                        }

    };

class MEM_ITER : public MEMLIST
    {
private:
    named_node *    pCur;

public:
                    MEM_ITER( MEMLIST * pList )
                        : MEMLIST( pList )
                        {
                        pCur = pMembers;
                        }

    named_node *    GetNext()
                        {
                        named_node * Ret = pCur;
                        pCur = (pCur) ? pCur->GetSibling() : NULL;
                        return Ret;
                        }

    void            Init()
                        {
                        pCur = pMembers;
                        }

    };


// identifiers
class node_id : public named_node
    {
public:
    expr_node *     pInit;

                    // lightweight version for backend
                    node_id( char * pNewName)
                        : named_node( pNewName, NODE_ID )
                        {
                        pInit = NULL;
                        };

                    // heavier version for frontend
                    node_id( NODE_T Kind, char * pNewName)
                         : named_node( Kind, pNewName )
                         {
                         pInit           = NULL;
                         };

    expr_node *     GetInitList()
                        {
                        return pInit;
                        };

    expr_node *     GetExpr()
                        {
                        return pInit;
                        };

    void            SetExpr( expr_node * pExpr )
                        {
                        pInit = pExpr;
                        };

    // these two functions are only valid after the defining declaration is complete
    BOOL            IsConstant()
                        {
                        return (BOOL) ( pInit &&
                            pInit->IsConstant() &&
                            (FInSummary( ATTR_CONST ) || IsConstantString() ) );
                        }

    BOOL            IsConstantString();

    virtual
    STATUS_T        DoPrintType( PRTFLAGS            Flags,
                            BufferManager * pBuffer,
                            ISTREAM           * pStream,
                            node_skl          * pParent,
                            node_skl          * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS            Flags,
                            BufferManager * pBuffer,
                            ISTREAM           * pStream,
                            node_skl          * pParent,
                            node_skl          * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

// here is the use of the private memory allocator
private:

    static
    FreeListMgr     MyFreeList;


public:


    void *          operator new (size_t size)
                        {
                        return (MyFreeList.Get (size));
                        }

    void            operator delete (void * pX)
                        {
                        MyFreeList.Put (pX);
                        }

    };      //      end of class node_id

// this is what a node_id generated in the front-end looks like
// it has tracking added
class node_id_fe : public node_id, public tracked_node
    {
public:
                    node_id_fe( char * pNewName)
                        : node_id( NODE_ID, pNewName )
                        {
                        };

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

// here is the use of the private memory allocator
private:

    static
    FreeListMgr     MyFreeList;


public:


    void *          operator new (size_t size)
                        {
                        return (MyFreeList.Get (size));
                        }

    void            operator delete (void * pX)
                        {
                        MyFreeList.Put (pX);
                        }

    };

/***
 *** named nodes
 ***
 *** These nodes may be constructed
 ***/

// enum labels
class node_label : public named_node
    {
public:
    expr_node *     pExpr;

                    node_label( char * LabelName, expr_node * pNewExpr )
                        : named_node( NODE_LABEL, LabelName )
                        {
                        pExpr = pNewExpr;
                        };

    EXPR_VALUE      GetValue()
                        {
                        return pExpr->GetValue();
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS            Flags,
                            BufferManager * pBuffer,
                            ISTREAM           * pStream,
                            node_skl          * pParent,
                            node_skl          * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };      //      end of class node_label


// handle types stored for node_def and node_param
// these are in order of increasing precedence as binding handles
#define HDL_NONE    0x00
#define HDL_CTXT    0x01
#define HDL_GEN     0x02
#define HDL_PRIM    0x04

// comm/fault status kind
#define STATUS_NONE     0
#define STATUS_COMM     1
#define STATUS_FAULT    2
#define STATUS_BOTH     3

// function formal parameters
class node_param : public named_node
    {
private:
    BOOL fOptional  : 1;
    BOOL fRetval    : 1;

public:

    // the kind of handle, and whether it was applied to the
    // param node directly, or to the TypeSpecifier
    unsigned long   HandleKind      : 4;
    unsigned long   fAppliedHere    : 1;
    // true if the handle is an [in] handle
    unsigned long   fBindingParam   : 1;
    // for below field: bits 1=>toplevel 2=>non-toplevel
    unsigned long   fDontCallFreeInst : 2;
    unsigned long   Statuses        : 2; // comm/fault statuses

                    // copy fields from the pID
                    node_param( node_id_fe * pID)
                        : named_node( NODE_PARAM, pID )
                        {
                        HandleKind        = 0;
                        fAppliedHere      = 0;
                        Statuses          = STATUS_NONE;
                        fBindingParam     = 0;
                        fDontCallFreeInst = 0;
                        fOptional         = 0;
                        fRetval           = 0;
                        };

                    node_param()
                        : named_node( NODE_PARAM )
                        {
                        HandleKind        = 0;
                        fAppliedHere      = 0;
                        Statuses          = STATUS_NONE;
                        fBindingParam     = 0;
                        fDontCallFreeInst = 0;
                        fOptional         = 0;
                        fRetval           = 0;
                        };

    BOOL            HasExplicitHandle()
                        {
                        return (HandleKind != HDL_NONE);
                        }

    unsigned short  GetHandleKind()
                        {
                        return (unsigned short) HandleKind;
                        }

    BOOL            IsBindingParam()
                        {
                        return ( fBindingParam );
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM           * pStream,
                            node_skl          * pParent,
                            node_skl          * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM           * pStream,
                            node_skl          * pParent,
                            node_skl          * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    void            Optional(void)
                        {
                        fOptional = TRUE;
                        }

    BOOL            IsOptional(void)
                        {
                        return fOptional;
                        }

    void            Retval(void)
                        {
                        fRetval = TRUE;
                        }

    BOOL            IsRetval(void)
                        {
                        return fRetval;
                        }

    };  //  end of class node_param

// imported files
class node_file : public named_node, public MEMLIST
    {
private:
    char *          pActualFileName;
    short           ImportLevel;
    BOOL            fAcfInclude     : 1;
    BOOL            fIsXXXBaseIdl   : 1;
    BOOL            fHasComClasses  : 1;


public:
                    node_file( char *, short );

    short           GetImportLevel()
                        {
                        return ImportLevel;
                        }

    char *          GetFileName()
                        {
                        return pActualFileName;
                        }

    BOOL            AcfExists();
    void            AcfName( char * );
    void            SetFileName( char * );
    BOOL            IsAcfInclude()
                        {
                        return fAcfInclude;
                        }

    BOOL            HasComClasses()
                        {
                        return fHasComClasses;
                        }

    BOOL            SetHasComClasses( BOOL yes = TRUE )
                        {
                        return (fHasComClasses = yes);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    void            SetXXXBaseIdl()
                        {
                        fIsXXXBaseIdl = TRUE;
                        }

    BOOL            IsXXXBaseIdl()
                        {
                        return fIsXXXBaseIdl;
                        }

    };  //  end of class node_file


// functions and procs
class node_proc : public named_node, public tracked_node, public MEMLIST
    {
    unsigned long   ProcNum             : 16;
    unsigned long   OptimFlags          : 8;
    unsigned long   ImportLevel         : 4;
    unsigned long   fHasFullPointer     : 1;
    unsigned long   fHasAtLeastOneIn    : 1;
    unsigned long   fHasAtLeastOneOut   : 1;
    unsigned long   fHasExplicitHandle  : 1;
    unsigned long   fHasPointer         : 1; // ANYWHERE below us
    unsigned long   fHasStatuses        : 1; // has comm/fault status
    unsigned long   fCallAsTarget       : 1; // the target of a call_as
    unsigned long   RTStatuses          : 2; // return type statuses
    unsigned long   fHasPipes           : 1;
    unsigned long   fForcedI2           : 1; // true if -Oi2 mode has been forced
    unsigned long   fForcedS            : 1; // true if -Os mode has been forced
    class node_proc * pCallAsType;           // if this is a call_as function
                                             // then this pointer will be set to
                                             // points to its companion during
                                             // semantic analysis

    OPT_LEVEL_ENUM  OptimLevel;
    
public:
                    node_proc( short level, BOOL fLocInterface)
                        : named_node( NODE_PROC )
                        {
                        ImportLevel             = ( level > 15 ) ? 15 : level;
                        UNUSED(fLocInterface);
                        ProcNum                 = 0xffff;
                        fHasAtLeastOneIn        = FALSE;
                        fHasAtLeastOneOut       = FALSE;
                        fHasExplicitHandle      = FALSE;
                        fHasPointer             = FALSE;
                        fHasFullPointer         = FALSE;
                        fHasStatuses            = FALSE;
                        fCallAsTarget           = FALSE;
                        RTStatuses              = STATUS_NONE;
                        fHasPipes               = FALSE;
                        fForcedI2               = FALSE;
                        fForcedS                = FALSE;
                        OptimFlags              = 0;
                        OptimLevel              = OPT_LEVEL_OS_DEFAULT;
                        pCallAsType             = NULL;
                        };

                    node_proc( short level, BOOL fLocInterface, node_id_fe * pID)
                        : named_node( NODE_PROC, pID )
                        {
                        ImportLevel             = ( level > 15 ) ? 15 : level;
                        UNUSED(fLocInterface);
                        ProcNum                 = 0xffff;
                        fHasAtLeastOneIn        = FALSE;
                        fHasAtLeastOneOut       = FALSE;
                        fHasExplicitHandle      = FALSE;
                        fHasPointer             = FALSE;
                        fHasFullPointer         = FALSE;
                        fHasStatuses            = FALSE;
                        fCallAsTarget           = FALSE;
                        RTStatuses              = STATUS_NONE;
                        fHasPipes               = FALSE;
                        fForcedI2               = FALSE;
                        fForcedS                = FALSE;
                        OptimFlags              = 0;
                        OptimLevel              = OPT_LEVEL_OS_DEFAULT;
                        pCallAsType             = NULL;
                        };

                    node_proc( node_proc * pClone )
                        : named_node( NODE_PROC )
                        {
                        *this = *pClone;
                        };

    node_proc *     SetCallAsType(node_proc *p)
                        {
                        return (pCallAsType = p);
                        }
    node_proc *     GetCallAsType()
                        {
                        return (pCallAsType);
                        }


    STATUS_T        GetParameterList( class type_node_list * MemList )
                        {
                        return GetMembers( MemList );
                        };

    node_skl *      GetReturnType()
                        {
                        return GetChild();
                        };

    short           GetImportLevel()
                        {
                        return (short) ImportLevel;
                        }

    unsigned short  GetOptimizationFlags()
                        {
                        return (unsigned short)OptimFlags;
                        }

    unsigned short  SetOptimizationFlags( unsigned short OF )
                        {
                        return (unsigned short)(OptimFlags = OF);
                        }

    OPT_LEVEL_ENUM  GetOptimizationLevel()
                        {
                        return (OPT_LEVEL_ENUM) OptimLevel;
                        }

    OPT_LEVEL_ENUM  SetOptimizationLevel( OPT_LEVEL_ENUM  Level )
                        {
                        return OptimLevel = Level;
                        }

    BOOL            ForceNonInterpret();

    BOOL            ForceInterpret2();

    void            AddStatusParam( char * pName, ATTRLIST Alist );

    void            AddExplicitHandle( SEM_ANALYSIS_CTXT * pParentCtxt );

    // returns ATTR_NONE if none explicitly specified
    BOOL            GetCallingConvention( ATTR_T & Attr );

    BOOL            HasPipes()
                        {
                        return fHasPipes;
                        }

    BOOL            HasAtLeastOneIn()
                        {
                        return fHasAtLeastOneIn;
                        };

    BOOL            HasAtLeastOneOut()
                        {
                        return fHasAtLeastOneOut;
                        };

    BOOL            HasExplicitHandle()
                        {
                        return fHasExplicitHandle;
                        };

    BOOL            HasAtLeastOneHandle()
                        {
                        // for now....
                        return fHasExplicitHandle;
                        };

    BOOL            HasPointer()
                        {
                        return fHasPointer;
                        };

    BOOL            IsCallAsTarget()
                        {
                        return fCallAsTarget;
                        }

    BOOL            HasAtLeastOneShipped();

    BOOL            HasReturn()
                        {
                        node_skl * pCh = GetNonDefChild();
                        return (pCh) && (pCh->NodeKind() != NODE_VOID);
                        };

    BOOL            HasAParameter()
                        {
                        // check if the first one is different from void

                        node_skl * pParam = GetFirstMember();

                        if ( !pParam  ||  pParam->NodeKind() == NODE_VOID )
                            return FALSE;

                        if ( pParam->NodeKind() == NODE_DEF )
                            {
                            node_skl * pCh = pParam->GetNonDefChild();
                            if ( !pCh  ||  pCh->NodeKind() == NODE_VOID )
                                return FALSE;
                            }

                        return TRUE; 
                        };

    node_param *    GetParamNode( char * pName )
                        {
                        node_param * pCur = (node_param *) GetFirstMember();

                        while ( pCur )
                            {
                            if ( strcmp( pCur->GetSymName(), pName ) == 0 )
                                return pCur;
                            pCur = (node_param *) pCur->GetSibling();
                            }

                        return NULL;
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS   Flags,
                        BufferManager * pBuffer,
                        ISTREAM * pStream,
                        node_skl * pParent,
                        node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                        BufferManager * pBuffer,
                        ISTREAM  * pStream,
                        node_skl * pParent,
                        node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_proc

class SymTable;

// forward declarations -- may go away
class node_forward      : public named_node, public tracked_node
    {
    SymKey          SKey;
    SymTable *      pSymTbl;

public:
                    node_forward( SymKey  key, SymTable * pTbl )
                        : named_node( NODE_FORWARD )
                        {
                        SKey = key;
                        pSymTbl = pTbl;
                        pTbl->SetHasFwds();
                        MiscBits = 0;
                        };

    named_node *    ResolveFDecl();

    void            GetSymDetails( NAME_T * nm, char ** ppszName);


    BOOL            IsFirstPass()
                        {
                        return ( MiscBits == 0 );
                        }

    void            MarkSecondPass()
                        {
                        MiscBits = 1;
                        }

    void            MarkFirstPass()
                        {
                        MiscBits = 0;
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                        BufferManager * pBuffer,
                        ISTREAM * pStream,
                        node_skl * pParent,
                        node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };

// reference to a type defined in an importlib
class node_href : public named_node, public tracked_node
    {
    SymKey          SKey;
    SymTable *      pSymTbl;
    void *          pTypeInfo;
    node_file *     pFile;

public:
                    node_href( SymKey  key, SymTable * pTbl, void * pti, node_file * pf)
                        : named_node( NODE_HREF )
                        {
                        SKey = key;
                        pSymTbl = pTbl;
                        pTbl->SetHasFwds();
                        MiscBits = 0;
                        pTypeInfo = pti;
                        pFile = pf;
                        };

                    ~node_href();

    named_node *    Resolve();

    void            GetSymDetails( NAME_T * pTag, char ** ppszName)
                        {
                        *pTag = SKey.GetKind();
                        *ppszName = SKey.GetString();
                        };

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    virtual
    node_file *     GetDefiningFile()
                        {
                        return pFile;
                        };

    };

// fields in structures
class node_field : public named_node
    {
public:
                    node_field( char * pNewName = NULL )
                        : named_node( NODE_FIELD, pNewName )
                        {
                        MiscBits = 0;
                        };

                    node_field( node_id_fe * pId )
                        : named_node( NODE_FIELD, pId )
                        {
                        MiscBits = 0;
                        };

    BOOL            HasUnknownRepAs()
                        {
                        return (BOOL) MiscBits & 1;
                        };

    BOOL            SetHasUnknownRepAs()
                        {
                        return (BOOL) (MiscBits |= 1);
                        };


    BOOL            IsEmptyArm()
                        {
                        return (GetChild()->NodeKind() == NODE_ERROR);
                        };

    BOOL            IsLastField()
                        {
                        return !(GetSibling());
                        };

    virtual
    BOOL            IsBitField()
                        {
                        return FALSE;
                        }

    virtual
    short           GetFieldSize()
                        {
                        return 0;
                        };

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_field

// bitfields in structures
class node_bitfield : public node_field
    {
public:
    unsigned char   fBitField;

                    node_bitfield( char * pNewName = NULL)
                        : node_field( pNewName )
                        {
                        fBitField = 0;
                        };

                    node_bitfield( node_id_fe * pId )
                        : node_field( pId )
                        {
                        fBitField = 0;
                        };

    virtual
    BOOL            IsBitField()
                        {
                        return TRUE;
                        }

    virtual
    short           GetFieldSize()
                        {
                        return fBitField;
                        };

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_bitfield


// bits for different kinds of arrays as fields.
// if more than one bit is set, it is a complex array
#define FLD_PLAIN       0x0
#define FLD_VAR         0x1
#define FLD_CONF        0x2
#define FLD_CONF_VAR    0x4
#define FLD_COMPLEX     0x8     // don't check for equality here!

// bits for offlining decision
// for now, only boolean
#define NO_OFFLINE      0x0
#define MUST_OFFLINE    0x1

// structures and unions, and enums, too
class node_su_base : public named_node, public tracked_node, public MEMLIST
    {
protected:
    unsigned long   ZeePee                  : 8;
    unsigned long   Complexity              : 8;
    unsigned long   OffLine                 : 1;
    unsigned long   fHasAtLeastOnePointer   : 1;
    unsigned long   fSemAnalyzed            : 1;
    unsigned long   fHasConformance         : 1;
    char *          szTypeInfoName;

public:
                    node_su_base( NODE_T Kind, char * pName )
                        : named_node( Kind, pName )
                        {
                        fHasAtLeastOnePointer   = 0;
                        ZeePee                  = 0;
                        Complexity              = 0;
                        fSemAnalyzed            = 0;
                        OffLine                 = 0;
                        fHasConformance         = 0;
                        szTypeInfoName          = pName;
                        };

    unsigned short  SetZeePee( unsigned short zp )
                        {
                        return (unsigned short) (ZeePee = zp);
                        };

    unsigned short  GetZeePee()
                        {
                        return (unsigned short) ZeePee;
                        };

    unsigned short  SetHasAtLeastOnePointer( unsigned short HP )
                        {
                        return (unsigned short) (fHasAtLeastOnePointer = HP);
                        };

    unsigned short  HasAtLeastOnePointer()
                        {
                        return (unsigned short) fHasAtLeastOnePointer;
                        };

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    BOOL            IsOffline()
                        {
                        return ( OffLine != NO_OFFLINE );
                        }

    BOOL            HasConformance()
                        {
                        return fHasConformance;
                        }

    void            CheckLegalParent(SEM_ANALYSIS_CTXT & MyContext);
                
    void            SetTypeInfoName(char * szName)
                        {
                        szTypeInfoName = szName;
                        }
                        
    char *          GetTypeInfoName(void)
                        {
                        return szTypeInfoName;
                        }                                        
    };  //  end of class node_su_base

// enum and its tag
class node_enum : public node_su_base
    {
    BOOL            fLong : 1;
public:

                    node_enum( char * pTagName )
                        : node_su_base( NODE_ENUM, pTagName )
                        {
                        fLong    = FALSE;
                        };


    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_enum

// structures
class node_struct : public node_su_base
    {
public:
                    node_struct( char * pNewName )
                        : node_su_base( NODE_STRUCT, pNewName )
                        {
                        };

    virtual
    unsigned long   GetSize( unsigned long CurOffset, unsigned short ZeePee = 0);

    virtual
    node_skl *      GetLargestElement();

    virtual
    node_skl *      GetLargestNdr();

    virtual
    BOOL            IsEncapsulatedStruct()
                        {
                        return FALSE;
                        }

    virtual
    BOOL            IsStructOrUnion()
                        {
                        return TRUE;
                        }

    virtual
    BOOL            IsStringableType();

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_struct

class node_en_struct : public node_struct
    {
public:
                    node_en_struct( char * pNewName )
                        : node_struct( pNewName )
                        {
                        };

    BOOL            IsEncapsulatedStruct()
                        {
                        return TRUE;
                        }


    node_skl *      GetSwitchField()
                        {
                        return GetFirstMember();
                        }

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_en_struct


// unions
class node_union : public node_su_base
    {
public:
                    node_union( char * pNewName )
                        : node_su_base( NODE_UNION, pNewName )
                        {
                        };


    virtual
    unsigned long   GetSize( unsigned long CurOffset, unsigned short ZeePee = 0);

    virtual
    node_skl *      GetLargestElement();

    virtual
    node_skl *      GetLargestNdr();

    virtual
    BOOL            IsStructOrUnion()
                        {
                        return TRUE;
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_union


class node_en_union : public node_union
    {
public:
                    node_en_union( char * pNewName )
                        : node_union( pNewName )
                        {
                        };

    virtual
    BOOL            IsEncapsulatedUnion()
                        {
                        return TRUE;
                        }

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_en_union


#define HANDLE_KIND_MASK    0x7
#define HRESULT_FLAG_MASK   0x8

// typedef entries
class node_def : public named_node
    {

public:
                    // (lightweight version) make a typedef with a given name
                    node_def( char * pName  = NULL)
                        : named_node( pName, NODE_DEF )
                        {
                        SetHandleKind( HDL_NONE );
                        };

                    // make a typedef with a given name and child
                    node_def( char * pName, node_skl * pChld )
                        : named_node( NODE_DEF, pName )
                        {
                        MiscBits = 0;
                        SetHandleKind( HDL_NONE );
                        SetChild( pChld );
                        };

                    // make a typedef cloned from a node_id
                    node_def( node_id_fe * pIdent )
                        : named_node(  NODE_DEF, pIdent )
                        {
                        MiscBits = 0;
                        SetHandleKind( HDL_NONE );
                        };

                    // make a typedef node for (above) a proc
                    node_def( node_proc * pProc )
                        : named_node(  NODE_DEF, (node_id_fe *) pProc )
                        {
                        MiscBits = 0;
                        SetChild( pProc );
                        SetHandleKind( HDL_NONE );
                        };

    unsigned long   GetHandleKind()
                        {
                        return MiscBits & HANDLE_KIND_MASK;
                        }

    unsigned long   SetHandleKind( unsigned long H )
                        {
                        MiscBits = ( MiscBits & ~HANDLE_KIND_MASK ) | H;
                        return H;
                        }

    void            SetIsHResultOrSCode()
                        {
                        MiscBits |= HRESULT_FLAG_MASK;
                        }

    BOOL            IsHResultOrSCode()
                        {
                        return ( MiscBits & HRESULT_FLAG_MASK ) != 0;
                        }

    BOOL            HasAnyHandleSpecification()
                        {
                        return (GetHandleKind() != HDL_NONE);
                        };

    BOOL            HasAnyCtxtHdlSpecification()
                        {
                        return (GetHandleKind() == HDL_CTXT);
                        };

                    // return the transmit_as type (or NULL)
    node_skl *      GetTransmittedType();

                    // return the represent_as type (or NULL)
    char *          GetRepresentationName();

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    void            MarkDontCallFreeInst( SEM_ANALYSIS_CTXT * pCtxt );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_def

// front-end only version of node_def ( adds line number tracking )
class node_def_fe : public node_def, public tracked_node
    {
public:
                    // make a typedef with a given name and child
                    node_def_fe( char * pName, node_skl * pChld )
                        : node_def( pName, pChld )
                        {
                        }

                    // make a typedef cloned from a node_id
                    node_def_fe( node_id_fe * pIdent )
                        : node_def(  pIdent )
                        {
                        }

                    // make a typedef node for (above) a proc
                    node_def_fe( node_proc * pProc )
                        : node_def(  pProc )
                        {
                        };

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                        Posn = * ((tracked_node *) this);
                        }


    };  //  end of class node_def_fe

typedef struct tagIDLISTMEM
{
    struct tagIDLISTMEM * pNext;
    char * szName;
    long lId;
} IDLISTMEM;

// class for checking for duplicate dispatch ids
class CIDLIST 
{
private:
    IDLISTMEM * pHead;
public:
    
    CIDLIST() 
    {
        pHead = NULL;
    };

    ~CIDLIST()
    {
        while (pHead)
        {
            IDLISTMEM * pThis = pHead;
            pHead = pHead->pNext;
            delete pThis;
        }
    };

    BOOL AddId(long lId, char * szName);
};


// the interface
class node_interface : public named_node, public MEMLIST, public tracked_node
    {
protected:

    named_node *    pBaseIntf;      // base interface if derived intf
    node_file *     pDefiningFile;
    CG_CLASS *      pMyCG;
    CG_CLASS *      pMyTlbCG;       // CG node generated in library block
    SymTable *      pProcTbl;
    unsigned short  ProcCount;
    unsigned short  CallBackProcCount;
    unsigned short  OptimFlags;
    OPT_LEVEL_ENUM  OptimLevel;
    BOOL            fIAmIUnknown        : 1;
    BOOL            fPickle             : 1;
    BOOL            fHasProcsWithRpcSs  : 1;
    BOOL            fHasHookOle         : 1;
    BOOL            fSemAnalyzed        : 1;
    BOOL            fPrintedDef         : 1;
    BOOL            fPrintedIID         : 1;
    CIDLIST         IdList;

public:
                    node_interface( NODE_T Kind = NODE_INTERFACE );

    unsigned short  &GetProcCount()
                        {
                        return ProcCount;
                        }

    unsigned short  &GetCallBackProcCount()
                        {
                        return CallBackProcCount;
                        }

    void            GetVersionDetails( unsigned short * Maj,
                            unsigned short * Min );

    BOOL            AddId(long lId, char * szName)
                        {
                        return IdList.AddId(lId, szName);
                        }

    virtual
    BOOL            IsInterfaceOrObject()
                        {
                        return TRUE;
                        }

    BOOL            IsValidRootInterface()
                        {
                        return fIAmIUnknown;
                        }

    void            SetValidRootInterface()
                        {
                        fIAmIUnknown = TRUE;
                        }

    BOOL            IsPickleInterface()
                        {
                        return fPickle;
                        }

    void            SetPickleInterface()
                        {
                        fPickle = TRUE;
                        }

    BOOL            GetHasProcsWithRpcSs()
                        {
                        return fHasProcsWithRpcSs;
                        }

    BOOL            GetHasHookOle()
                        {
                        return fHasHookOle;
                        }
    virtual
    node_file *     GetDefiningFile()
                        {
                        return pDefiningFile;
                        }

    void            SetHasProcsWithRpcSs()
                        {
                        fHasProcsWithRpcSs = TRUE;
                        }

    void            SetHasHookOle()
                        {
                        fHasHookOle = TRUE;
                        }

    BOOL            PrintedDef()
                        {
                        return fPrintedDef;
                        }
    
    void            SetPrintedDef()
                        {
                        fPrintedDef = TRUE;
                        }

    BOOL            PrintedIID()
                        {
                        return fPrintedIID;
                        }
    
    void            SetPrintedIID()
                        {
                        fPrintedIID = TRUE;
                        }

    node_interface *GetMyBaseInterface();

                    // note that my base interface reference may be
                    // a fwd or null
    named_node *    GetMyBaseInterfaceReference()
                        {
                        return pBaseIntf;
                        }

    named_node *    SetMyBaseInterfaceReference( named_node * pIF )
                        {
                        return (pBaseIntf = pIF);
                        }

    virtual
    node_file *     GetFileNode()
                        {
                        return pDefiningFile;
                        }

    virtual
    node_file *     SetFileNode(node_file * pF)
                        {
                        return (pDefiningFile = pF);
                        }

    CG_CLASS *      GetCG(BOOL fInLibrary)
                        {
                        if (fInLibrary)
                            return pMyTlbCG;
                        else
                            return pMyCG;
                        }

    CG_CLASS *      SetCG(BOOL fInLibrary, CG_CLASS * pF)
                        {
                        if (fInLibrary)
                            return (pMyTlbCG = pF);
                        else
                            return (pMyCG = pF);
                        }

    SymTable *      GetProcTbl()
                        {
                        return pProcTbl;
                        }

    SymTable *      SetProcTbl( SymTable * pS )
                        {
                        return (pProcTbl = pS);
                        }

    unsigned short  GetOptimizationFlags()
                        {
                        return OptimFlags;
                        }

    unsigned short  SetOptimizationFlags(unsigned short F)
                        {
                        return (OptimFlags = F);
                        }

    OPT_LEVEL_ENUM  GetOptimizationLevel()
                        {
                        return (OPT_LEVEL_ENUM) OptimLevel;
                        }

    OPT_LEVEL_ENUM  SetOptimizationLevel( OPT_LEVEL_ENUM  Level )
                        {
                        return OptimLevel = Level;
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                        Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_interface

// the interface
class node_object : public node_interface
    {
protected:

    type_node_list *pBaseIntfList;

public:
                    node_object()
                        : node_interface( NODE_OBJECT )
                        {
                        pBaseIntfList = NULL;
                        }


    type_node_list *SetMyBaseInterfaceList( type_node_list * pIF )
                        {
                        return (pBaseIntfList = pIF);
                        }

    type_node_list *GetMyBaseInterfaceList()
                        {
                        return (pBaseIntfList);
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_object



// the interface
class node_interface_reference : public named_node
    {
private:

public:
                    node_interface_reference( node_interface * pIntf )
                        : named_node( NODE_INTERFACE_REFERENCE )
                        {
                        SetChild( pIntf );
                        SetSymName( pIntf->GetSymName() );
                        }

    node_interface *GetRealInterface()
                        {
                        return (node_interface *)GetChild();
                        }

    named_node *    GetMyBaseInterfaceReference()
                        {
                        return ((node_interface *)GetChild())->
                            GetMyBaseInterfaceReference();
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_interface_reference

#define COM_SERVER_IS_DLL   0
#define COM_SERVER_IS_EXE   1

// the interface
class node_com_server : public named_node, public tracked_node
    {
protected:
    type_node_list *pClassList;     // list of classes going into the dll
    node_file      *pDefiningFile;  // the file node containing this
    short           fServerType;    // exe or dll server flag

public:
                    node_com_server( char * pServerName )
                        : named_node( NODE_COM_SERVER, pServerName )
                        {
                        pClassList  = NULL;
                        fServerType = 0;
                        }

    short           SetServerType( short typ )
                        {
                        return ( fServerType = typ);
                        }

    BOOL            IsDll()
                        {
                        return (fServerType == COM_SERVER_IS_DLL);
                        }

    BOOL            IsExe()
                        {
                        return (fServerType == COM_SERVER_IS_EXE);
                        }

    type_node_list *SetClassList( type_node_list * pTN )
                        {
                        return (pClassList = pTN );
                        }

    type_node_list *GetClassList()
                        {
                        return pClassList;
                        }

    virtual
    node_file *     GetFileNode()
                        {
                        return pDefiningFile;
                        }

    virtual
    node_file *     SetFileNode(node_file * pF)
                        {
                        return (pDefiningFile = pF);
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    virtual
    BOOL            IsInterfaceOrObject()
                        {
                        return TRUE;
                        }

    };

/***
 *** unnamed nodes
 ***/

// the root of the typegraph
class node_source : public node_skl, public MEMLIST
    {
public:

                    node_source()
                        : node_skl( NODE_SOURCE, NULL )
                        {
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_source

// pointers and arrays
class npa_nodes : public node_skl
    {

private:
    long            modifiers;
public:
                    npa_nodes( NODE_T Kind )
                        : node_skl( Kind, NULL )
                        {
                        modifiers = 0;
                        };

    virtual
    void            SetModifiers(long mod)
                        {
                        modifiers |= mod;
                        }

    virtual
    BOOL            IsModifierSet( ATTR_T flag )
                        {
                        return ( modifiers & SetModifierBit( flag ) );
                        };

    BOOL            FInSummary( ATTR_T flag )
                        {
                        BOOL result;

                        if ( flag >= ATTR_CPORT_ATTRIBUTES_START && flag <= ATTR_CPORT_ATTRIBUTES_END)
                            {
                            result = IsModifierSet( flag );
                            }
                        else
                            {
                            result = FALSE;
                            }

                        return result;
                        };


    BOOL            IsPtrOrArray()
                        {
                        return TRUE;
                        }

    };  //  end of class npa_nodes

// pointers
class node_pointer : public npa_nodes
    {
private:

public:
                    // constructors
                    node_pointer()
                        : npa_nodes( NODE_POINTER )
                        {
                        }

                    node_pointer(node_skl * pChild, long mod = 0)
                        : npa_nodes( NODE_POINTER )
                        {
                        SetModifiers( mod );
                        SetChild(pChild);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_pointer

// array
class node_array : public npa_nodes
    {
    expr_node *     pUpperBound;
    expr_node *     pLowerBound;
    unsigned long   fConformant     : 1;
    unsigned long   fMaybeVarying   : 1;    // set during semantic analysis
    unsigned long   fHasPointer     : 1;

public:
                    node_array( expr_node * pLower, expr_node * pUpper )
                        : npa_nodes( NODE_ARRAY )
                        {
                        pUpperBound     = pUpper;
                        pLowerBound     = pLower;
                        fMaybeVarying   = TRUE;
                        fConformant     = (pUpper == (expr_node *) -1);
                        fHasPointer     = FALSE;
                        }

    virtual
    unsigned long   GetSize( unsigned long CurOffset, unsigned short ZeePee );

    BOOL            HasPointer()
                        {
                        return fHasPointer;
                        };



    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_array

// misc strings to echo directly
class node_echo_string : public named_node
    {
protected:
    char *          pString;

public:
                    node_echo_string( char * pStr )
                        : named_node( NODE_ECHO_STRING )
                        {
                        pString = pStr;
                        SetChild( NULL );
                        };

    char *          GetEchoString()
                        {
                        return pString;
                        };

    virtual
    void            PrintSelf( ISTREAM * pStream );

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_echo_string

// #pragma pack(...) string node

#define PRAGMA_PACK_GARBAGE 0
#define PRAGMA_PACK_PUSH    1
#define PRAGMA_PACK_POP     2
#define PRAGMA_PACK_SET     3
#define PRAGMA_PACK_RESET   4

class node_pragma_pack  : public node_echo_string
    {
private:

    node_pragma_pack *  pStackLink;
    unsigned short      PackType;
    unsigned short      usPackingLevel;
    unsigned short      usNewLevel;

public:

                    node_pragma_pack( char * ID,
                            unsigned short lvl,
                            unsigned short PT,
                            unsigned short nlvl = 0 )
                        : node_echo_string( ID )
                        {
                        usPackingLevel  = lvl;
                        PackType        = PT;
                        usNewLevel      = nlvl;
                        }

    unsigned short  GetZeePee()
                        {
                        return usPackingLevel;
                        }

    // link self on as new top node
    void            Push( node_pragma_pack *& pTop );

    // search for matching push and pop it off, returning new ZP
    unsigned short  Pop( node_pragma_pack *& pTop );

    virtual
    void            PrintSelf( ISTREAM * pStream );


    };

class node_e_status_t : public named_node
    {
public:
    node_e_status_t();

    void            VerifyParamUsage( SEM_ANALYSIS_CTXT * pCtxt );

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_e_status_t

// error status -- may go away
class node_error : public node_skl
    {
public:
                    node_error()
                        : node_skl( NODE_ERROR, NULL )
                        {
                        }

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_error

// base types e.g. char, long
class node_base_type : public named_node
    {

public:
                    node_base_type( NODE_T MyKind, ATTR_T attr )
                        : named_node( MyKind )
                        {
                        if ( attr != ATTR_NONE )
                            SetModifiers( SetModifierBit( attr ) );
                        };

    virtual
    BOOL            IsBasicType()
                        {
                        return TRUE;
                        }

    virtual
    BOOL            IsStringableType()
                        {
                        return ( NodeKind() == NODE_CHAR ) ||
                            ( NodeKind() == NODE_BYTE );
                        }

    BOOL            IsAssignmentCompatible( node_base_type * );

    BOOL            RangeCheck( long Val );

    BOOL            IsUnsigned();

    virtual
    EXPR_VALUE      ConvertMyKindOfValueToEXPR_VALUE( long EXPR_VALUE );

    void            CheckVoidUsage( SEM_ANALYSIS_CTXT * pContext );

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_base_type

// character width specifier
class node_wchar_t : public named_node
    {
public:
                    node_wchar_t();

    virtual
    BOOL            IsStringableType()
                        {
                        return TRUE;
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_wchar_t

class node_library : public node_interface
    {
private:
public:
                    node_library()
                        : node_interface( NODE_LIBRARY )
                        {
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                        Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    virtual
    node_file *     SetFileNode(node_file * pF)
                        {
                        named_node * pN;
                        MEM_ITER MemIter(this);
                        while ( pN = MemIter.GetNext() )
                            {
                            pN->SetFileNode( pF );
                            }
                        return (pDefiningFile = pF);
                        }
    };  //  end of class node_library

class node_coclass : public node_interface
    {
private:
    BOOL            fNotCreatable;

protected:

public:
                    node_coclass()
                        : node_interface( NODE_COCLASS )
                        {
                            fNotCreatable = FALSE;
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    BOOL            IsNotCreatable(void)
                        {
                        return fNotCreatable;
                        }

    BOOL            SetNotCreatable(BOOL f)
                        {
                        return (fNotCreatable = f);
                        }

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_coclass

class node_module : public node_interface
    {
private:

protected:

public:
                    node_module()
                        : node_interface( NODE_MODULE )
                        {
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_module

class node_dispinterface : public node_interface
    {
    named_node *    pDispatch;
protected:

public:
                    node_dispinterface()
                        : node_interface( NODE_DISPINTERFACE )
                        {
                        }

    virtual
    void            GetPositionInfo( tracked_node & Posn )
                        {
                        if (this->HasTracking() )
                            Posn = * ((tracked_node *) this);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    named_node *    GetIDispatch()
                        {
                        return pDispatch;
                        }
    };  //  end of class node_dispinterface

class node_pipe : public named_node
    {
private:

public:
                    // constructors
                    node_pipe()
                        : named_node( NODE_PIPE )
                    {
                    }

                    node_pipe(node_skl * pType)
                        : named_node( NODE_PIPE )
                    {
                    SetChild(pType);
                    }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_pipe

class node_safearray : public npa_nodes
    {
private:

public:
                    // constructors
                    node_safearray()
                        : npa_nodes( NODE_SAFEARRAY )
                        {
                        }

                    node_safearray(node_skl * pType)
                        : npa_nodes( NODE_SAFEARRAY )
                        {
                        SetChild(pType);
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS Flags,
                            BufferManager * pBuffer,
                            ISTREAM * pStream,
                            node_skl * pParent,
                            node_skl * pIntf );

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_pointer

#endif // __NODESKL_HXX__