windows-xp/Source/XPSP1/NT/com/rpc/midl/inc/nodeskl.hxx

// Copyright (c) 1993-1999 Microsoft Corporation

#ifndef __NODESKL_HXX__
#define __NODESKL_HXX__

#pragma warning ( disable : 4710 4706 )

#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"

class node_guid;

/***
 *** 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_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_pipe_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;

enum TypeSet
    {
    ts_UnsignedFixedPoint,
    ts_FixedPoint,
    ts_FloatingPoint,
    ts_Character,
    ts_String,
    ts_Interface,
    };

class MODIFIER_SET
{
private:
   unsigned _int64 ModifierBits;   // Modifier bits
   unsigned short Align;           // alignment from __declspec(align(N))
   char * pUnknownTxt;             // Text for unknown __declspec"
public:
   BOOL IsFlagAModifier(ATTR_T flag) const; 
   BOOL IsModifierSet(ATTR_T flag) const;
   BOOL AnyModifiersSet() const;
   void SetModifier(ATTR_T flag);
   void ClearModifier(ATTR_T flag);
   void SetDeclspecAlign( unsigned short NewAlign);
   unsigned short GetDeclspecAlign() const; 
   void SetDeclspecUnknown(char *pNewUnknownTxt);
   char *GetDeclspecUnknown() const;
   void Clear();
   void Merge(const MODIFIER_SET & MergeModifierSet);
   void PrintDebugInfo() const;
};

class INITIALIZED_MODIFIER_SET : public MODIFIER_SET
{
public:
   INITIALIZED_MODIFIER_SET() {Clear();}
   INITIALIZED_MODIFIER_SET( ATTR_T flag ) {Clear(); SetModifier( flag );}
};

struct FRONT_MEMORY_INFO
{
    unsigned long Size;      // Size of the item
    unsigned short Align;    // Required memory alignment
    BOOL IsMustAlign;        // Has __declspec(align())
    FRONT_MEMORY_INFO() 
        : Size(0),
          Align(1),
          IsMustAlign(FALSE)
    {
    }
    FRONT_MEMORY_INFO(unsigned long NewSize, unsigned short NewAlign, BOOL NewIsMustAlign)
        : Size(NewSize),
          Align(NewAlign),
          IsMustAlign(NewIsMustAlign)
    {
    }
    void Init(unsigned long NewSize, unsigned short NewAlign, BOOL NewIsMustAlign )
    {
        Size = NewSize; Align = NewAlign; IsMustAlign = NewIsMustAlign;
    }
};

class node_skl
    {
private:

    node_skl *      pChild;
    node_file *     pTLBFile;

    // ISSUE-2000/08/03-mikew
    // The ia64 compiler is optimizing bitfields badly.  The C guys said
    // it will be fixed in the next drop.

#ifdef IA64
    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;
#else // !IA64
    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;
#endif

    INITIALIZED_MODIFIER_SET    ModiferSet;

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;
                        }

    virtual unsigned long
                    GetInterfaceKey() { return IntfKey; };

    virtual void
                    SetInterfaceKey( unsigned long uIntfKey ) { IntfKey = uIntfKey; };

    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 && 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();

    MODIFIER_SET &  GetModifiers() { return ModiferSet;}
    
    BOOL            IsDef()
                        {
                        return ! GetModifiers().IsModifierSet(ATTR_TAGREF);
                        };

    void            SetEdgeType( EDGE_T Et )
                        {
                        if (Et == EDGE_USE)
                            {
                            GetModifiers().SetModifier( ATTR_TAGREF );
                            };
                        };

    virtual
    BOOL            FInSummary( ATTR_T  )
                        {
                        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            IsCompatibleType( TypeSet )
//                        {
//                        return FALSE;
//                        }

    virtual
    BOOL            IsInterfaceOrObject()
                        {
                        return FALSE;
                        }

    FRONT_MEMORY_INFO AdjustMemoryInfoForModifiers(FRONT_MEMORY_INFO OrigInfo);

    // For use by classes that just use the child memory size modified with
    // modifiers.
    FRONT_MEMORY_INFO GetModifiedMemoryInfoFromChild();
    
    FRONT_MEMORY_INFO GetInvalidMemoryInfo();

    virtual         
    FRONT_MEMORY_INFO GetMemoryInfo() = 0;

    unsigned long   GetSize() 
                       {
                       return GetMemoryInfo().Size;
                       }

    unsigned short  GetAlign()
                       {
                       return GetMemoryInfo().Align;
                       }

    BOOL            IsMustAlign()
                       {
                       return GetMemoryInfo().IsMustAlign;
                       }

    virtual
    void            PrintMemoryInfo(ISTREAM *pStream, BOOL bNewLine);

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

    virtual
    void            GetPositionInfo( tracked_node&  )
                        {
                        }

    virtual
    STATUS_T        DoPrintType( PRTFLAGS ,
                            BufferManager * ,
                            ISTREAM * ,
                            node_skl * ,
                            node_skl *  )
                        {
                        return STATUS_OK;
                        };
    virtual
    STATUS_T        DoPrintDecl( PRTFLAGS ,
                            BufferManager * ,
                            ISTREAM * ,
                            node_skl * ,
                            node_skl *  )
                        {
                        return STATUS_OK;
                        };

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

    void            EmitModifiers( BufferManager *, bool fSuppressConst);

    void            EmitProcModifiers( BufferManager *, PRTFLAGS );

    void            EmitModelModifiers( BufferManager *);

    virtual void    EmitPtrModifiers( BufferManager *, unsigned long ulFlags = 0 );

    void            CheckDeclspecAlign( SEM_ANALYSIS_CTXT & MyContext ); 

    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 );
                        }
    virtual
    node_skl*      GetDuplicateGuid (
                                    node_guid*,
                                    SymTable*
                                    );

    // returns true if context_handle attribute is present
    // semantic checks for context handle
    virtual bool    CheckContextHandle( SEM_ANALYSIS_CTXT& );

    };      //      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

protected:
    unsigned int    fBeingAnalyzed : 1;

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

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

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

    virtual void    CopyAttributes( named_node* pNode )
                        { 
                        AttrList = pNode->AttrList.Clone();         
                        // Clone reverses the order of the list.  Fix it.
                        AttrList.Reverse();
                        }

    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;
                        };

    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 );
                        };

    void            RemoveAttribute( ATTR_T atrib )
                        {
                        AttrList.Remove( atrib );
                        };

    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 ( GetModifiers().IsFlagAModifier(flag) )
                            {
                            result = GetModifiers().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 *)
                        {
                        return NULL;
                        }

    virtual char*
                    GetDeclSpecGuid();

// 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            RemoveLastMember();

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

    void            RemoveFirstMember()
                        {
                        if (pMembers) pMembers = pMembers->GetSibling();
                        }

    void            AddSecondMember( named_node* 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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetModifiedMemoryInfoFromChild();}

    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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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

class CG_PARAM;

// function formal parameters
class node_param : public named_node
    {
private:
    BOOL fOptional                : 1;     // odl attribute
    BOOL fRetval                  : 1;
    BOOL fLCID                    : 1;
    BOOL fExtraStatusParam        : 1;     // invisible fault or comm status
    BOOL fIsAsyncHandle           : 1;
    BOOL fGenDefaultValueExpr     : 1;
    BOOL fSaveForAsyncFinish      : 1;
    BOOL fHasCSSTag               : 1;
    BOOL fHasCSDRTag              : 1;
    BOOL fHasCSRTag               : 1;

    node_param*     pAsyncBeginSibling;
    node_param*     pAsyncFinishSibling;
    CG_PARAM*       pCGParam;

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 ),
                          fOptional         ( 0 ),
                          fLCID             ( 0 ),
                          fRetval           ( 0 ),
                          fExtraStatusParam ( 0 ),
                          HandleKind        ( 0 ),
                          fAppliedHere      ( 0 ),
                          fBindingParam     ( 0 ),
                          fDontCallFreeInst ( 0 ),
                          fIsAsyncHandle    ( 0 ),
                          fGenDefaultValueExpr( 0 ),
                          Statuses          ( STATUS_NONE ),
                          pAsyncBeginSibling( 0 ),
                          pAsyncFinishSibling( 0 ),
                          fSaveForAsyncFinish( 0 ),
                          fHasCSSTag        ( 0 ),
                          fHasCSDRTag       ( 0 ),
                          fHasCSRTag        ( 0 )
                        {
                        }

                    node_param()
                        : named_node( NODE_PARAM ),
                          fOptional         ( 0 ),
                          fLCID             ( 0 ),
                          fRetval           ( 0 ),
                          fExtraStatusParam ( 0 ),
                          HandleKind        ( 0 ),
                          fAppliedHere      ( 0 ),
                          fBindingParam     ( 0 ),
                          fDontCallFreeInst ( 0 ),
                          fIsAsyncHandle    ( 0 ),
                          fGenDefaultValueExpr( 0 ),
                          Statuses          ( STATUS_NONE ),
                          pAsyncBeginSibling( 0 ),
                          pAsyncFinishSibling( 0 ),
                          fSaveForAsyncFinish( 0 ),
                          fHasCSSTag        ( 0 ),
                          fHasCSDRTag       ( 0 ),
                          fHasCSRTag        ( 0 )
                        {
                        }

    virtual CG_PARAM*
                    GetCG()
                        {
                        return pCGParam;
                        }

    virtual void
                    SetCG( CG_PARAM* pCG )
                        {
                        pCGParam = pCG;
                        }


    virtual void    
                    SetAsyncBeginSibling( node_param* pParam ) { pAsyncBeginSibling = pParam; };
    virtual node_param*
                    GetAsyncBeginSibling( void ) { return pAsyncBeginSibling; };

    virtual void    
                    SetAsyncFinishSibling( node_param* pParam ) { pAsyncFinishSibling = pParam; };
    virtual node_param*
                    GetAsyncFinishSibling( void ) { return pAsyncFinishSibling; };

    virtual void    SaveForAsyncFinish( void ) { fSaveForAsyncFinish = TRUE; };
    virtual BOOL    IsSaveForAsyncFinish( void ) { return fSaveForAsyncFinish; };

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

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

    BOOL            IsBindingParam()
                        {
                        return ( fBindingParam );
                        }

    BOOL            IsExtraStatusParam()
                        {
                        return ( fExtraStatusParam );
                        }

    void            SetExtraStatusParam()
                        {
                        fExtraStatusParam = TRUE;
                        }

    BOOL            IsAsyncHandleParam()
                        {
                        return ( fIsAsyncHandle );
                        }

    void            SetIsAsyncHandleParam()
                        {
                        fIsAsyncHandle = 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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetModifiedMemoryInfoFromChild();}

    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;
                        }

    void            LCID(void)
                        {
                        fLCID = TRUE;
                        }

    BOOL            IsLCID(void)
                        {
                        return fLCID;
                        }

    void            GenDefaultValueExpr( BOOL fGen = TRUE )
                        {
                        fGenDefaultValueExpr = fGen;
                        }

    BOOL            HasGenDefaultValueExpr( void )
                        {
                        return fGenDefaultValueExpr;
                        }

    void            SetHasCSSTag()
                        {
                        fHasCSSTag = TRUE;
                        }

    void            SetHasCSDRTag()
                        {
                        fHasCSDRTag = TRUE;
                        }

    void            SetHasCSRTag()
                        {
                        fHasCSRTag = TRUE;
                        }

    BOOL            HasCSTag()
                        {
                        return fHasCSSTag | fHasCSRTag | fHasCSDRTag;
                        }
    };  //  end of class node_param

class CG_PROC;

// 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         
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();};

    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   fHasExtraStatusParam: 1; // has the "invisible" status param
    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
    unsigned long   fHasAsyncHandle     : 1;
    unsigned long   fHasDeny            : 1; // true on /deny 
    unsigned long   fHasServerCorr      : 1; // correlation on Server
    unsigned long   fHasClientCorr      : 1; // correlation on Client
    unsigned long   fHasAsyncUUID       : 1; // async_uuid 
    unsigned long   fIsBeginProc        : 1; // Begin_* 
    unsigned long   fIsFinishProc       : 1; // Finish_*
    unsigned long   fObjectProc         : 1; // object proc

    unsigned long   ulServerCorrCount;
    unsigned long   ulClientCorrCount;
    
    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
    node_proc*      pBeginProc;

    node_proc*      pCSTagRoutine;          // from [cs_tag_rtn]

    OPT_LEVEL_ENUM  OptimLevel;

public:
                    node_proc( short level, BOOL ) :
                          named_node            ( NODE_PROC ),
                          ProcNum               ( 0xffff ),
                          OptimFlags            ( 0 ),
                          ImportLevel           ( ( level > 15 ) ? 15 : level ),
                          fHasAtLeastOneIn      ( FALSE ),
                          fHasAtLeastOneOut     ( FALSE ),
                          fHasExplicitHandle    ( FALSE ),
                          fHasPointer           ( FALSE ),
                          fHasFullPointer       ( FALSE ),
                          fHasStatuses          ( FALSE ),
                          fHasExtraStatusParam  ( FALSE ),
                          fCallAsTarget         ( FALSE ),
                          RTStatuses            ( STATUS_NONE ),
                          fHasPipes             ( FALSE ),
                          fForcedI2             ( FALSE ),
                          fForcedS              ( FALSE ),
                          fHasAsyncHandle       ( FALSE ),
                          pCallAsType           ( NULL ),
                          OptimLevel            ( OPT_LEVEL_OS ),
                          fHasDeny              ( FALSE ),
                          fHasServerCorr        ( FALSE ),
                          fHasClientCorr        ( FALSE ),
                          fHasAsyncUUID         ( FALSE ),
                          fIsBeginProc          ( FALSE ),
                          fIsFinishProc         ( FALSE ),
                          ulClientCorrCount     ( 0 ),
                          ulServerCorrCount     ( 0 ),
                          pBeginProc            ( 0 ),
                          pCSTagRoutine         ( 0 ),
                          fObjectProc           ( FALSE )
                        {
                        }

                    node_proc( short level, BOOL , node_id_fe * pID)
                        : named_node            ( NODE_PROC, pID ),
                          ProcNum               ( 0xffff ),
                          OptimFlags            ( 0 ),
                          ImportLevel           ( ( level > 15 ) ? 15 : level ),
                          fHasAtLeastOneIn      ( FALSE ),
                          fHasAtLeastOneOut     ( FALSE ),
                          fHasExplicitHandle    ( FALSE ),
                          fHasPointer           ( FALSE ),
                          fHasFullPointer       ( FALSE ),
                          fHasStatuses          ( FALSE ),
                          fHasExtraStatusParam  ( FALSE ),
                          fCallAsTarget         ( FALSE ),
                          RTStatuses            ( STATUS_NONE ),
                          fHasPipes             ( FALSE ),
                          fForcedI2             ( FALSE ),
                          fForcedS              ( FALSE ),
                          fHasAsyncHandle       ( FALSE ),
                          pCallAsType           ( NULL ),
                          OptimLevel            ( OPT_LEVEL_OS ),
                          fHasDeny              ( FALSE ),
                          fHasServerCorr        ( FALSE ),
                          fHasClientCorr        ( FALSE ),
                          fHasAsyncUUID         ( FALSE ),
                          fIsBeginProc          ( FALSE ),
                          fIsFinishProc         ( FALSE ),
                          ulClientCorrCount     ( 0 ),
                          ulServerCorrCount     ( 0 ),
                          pBeginProc            ( 0 ),
                          pCSTagRoutine         ( 0 ),
                          fObjectProc           ( FALSE )
                        {
                        }

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

    BOOL            IsObjectProc() { return fObjectProc; };
    void            SetObjectProc( BOOL fObject = TRUE ) { fObjectProc = fObject; };


    node_proc*      GetBeginProc()
                    {
                    return pBeginProc;
                    }

    void            SetBeginProc( node_proc* pBegin )
                    {
                    pBeginProc = pBegin;
                    }

    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,
                                        unsigned int        uParamNumber = 1
                                        );
    void            AddFullAsyncHandle  (
                                        SEM_ANALYSIS_CTXT*  pParentCtxt,
                                        node_skl*           pType,
                                        char*               szType
                                        );

    // 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            SetHasExtraStatusParam()
                        {
                        return fHasExtraStatusParam = TRUE;
                        }

    BOOL            HasExtraStatusParam()
                        {
                        return fHasExtraStatusParam;
                        }

    BOOL            HasPointer()
                        {
                        return fHasPointer;
                        };

    BOOL            IsCallAsTarget()
                        {
                        return fCallAsTarget;
                        }

    BOOL            HasAtLeastOneShipped();

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

    void            SetHasAsyncHandle()
                        {
                        fHasAsyncHandle = TRUE;
                        }
    BOOL            HasAsyncHandle()
                        {
                        return fHasAsyncHandle;
                        }

    void            SetHasAsyncUUID()
                        {
                        fHasAsyncUUID = TRUE;
                        }
    BOOL            HasAsyncUUID()
                        {
                        return fHasAsyncUUID;
                        }

    void            SetHasServerCorr()
                        {
                        fHasServerCorr = TRUE;
                        }
    BOOL            HasServerCorr()
                        {
                        return fHasServerCorr;
                        }

    void            SetHasClientCorr()
                        {
                        fHasClientCorr = TRUE;
                        }
    BOOL            HasClientCorr()
                        {
                        return fHasClientCorr;
                        }

    void            SetIsBeginProc()
                        {
                        fIsBeginProc = TRUE;
                        }
    BOOL            IsBeginProc()
                        {
                        return fIsBeginProc;
                        }

    void            SetIsFinishProc()
                        {
                        fIsFinishProc = TRUE;
                        }
    BOOL            IsFinishProc()
                        {
                        return fIsFinishProc;
                        }

    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetReturnType()->GetMemoryInfo();}

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

    virtual unsigned long
                    GetServerCorrelationCount()
                        {
                        return ulServerCorrCount;
                        }

    virtual unsigned long
                    GetClientCorrelationCount()
                        {
                        return ulClientCorrCount;
                        }

    virtual void
                    SetServerCorrelationCount( unsigned long ulCount = 0 )
                        {
                        ulServerCorrCount = ulCount;
                        }

    virtual void
                    SetClientCorrelationCount( unsigned long ulCount = 0 )
                        {
                        ulClientCorrCount = ulCount;
                        }

    virtual void
                    IncServerCorrelationCount( unsigned long ulInc )
                        {
                        ulServerCorrCount += ulInc;
                        }

    virtual void
                    IncClientCorrelationCount( unsigned long ulInc )
                        {
                        ulClientCorrCount  += ulInc;
                        }

    void            SetCSTagRoutine(node_proc *p)
                        {
                        pCSTagRoutine = p;
                        }

    node_proc *     GetCSTagRoutine()
                        {
                        return pCSTagRoutine;
                        }
 
    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}
    
    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, key.GetString() )
                        {
                        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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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 
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetModifiedMemoryInfoFromChild();}

    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!

// structures and unions, and enums, too
class node_su_base : public named_node, public tracked_node, public MEMLIST
    {
protected:
    unsigned long   ZeePee                  : 16;
    unsigned long   Complexity              : 8;
    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;
                        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            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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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
    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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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
    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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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
    FRONT_MEMORY_INFO GetMemoryInfo();

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    void
    node_def::SemanticAnalysisForTransmit( SEM_ANALYSIS_CTXT *pMyContext,
                                           BOOL fPresented );

    void
    node_def::SemanticAnalysisForWireMarshal( SEM_ANALYSIS_CTXT *pMyContext,
                                              BOOL fPresented );
    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;
    __int64 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(__int64 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            fSemAnalyzed        : 1;
    BOOL            fPrintedDef         : 1;
    BOOL            fPrintedIID         : 1;
    BOOL            fHasOLEAutomation   : 1;
    BOOL            fIsAsyncClone       : 1;
    BOOL            fHasMSConfStructAttr: 1;
    BOOL            fIs2ndCodegen       : 1;
    CIDLIST         IdList;
    node_interface* pAsyncInterface;

    void            ResetCGIfNecessary();

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(__int64 lId, char * szName)
                        {
                        return IdList.AddId(lId, szName);
                        }
    
    virtual BOOL    IsAsyncClone()
                        {
                        return fIsAsyncClone;
                        }

    virtual void    SetIsAsyncClone()
                        {
                        fIsAsyncClone = TRUE;
                        }

    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;
                        }

    virtual
    node_file *     GetDefiningFile()
                        {
                        return pDefiningFile;
                        }

    void            SetHasProcsWithRpcSs()
                        {
                        fHasProcsWithRpcSs = 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)
                        {
                        ResetCGIfNecessary();
                        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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}

    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 BOOL    HasOLEAutomation() { return fHasOLEAutomation; };
    virtual void    HasOLEAutomation(BOOL fHas) { fHasOLEAutomation = fHas; };

    virtual node_interface*
                    GetAsyncInterface() { return pAsyncInterface; };
    virtual void
                    SetAsyncInterface( node_interface* pIF ) { pAsyncInterface = pIF; };

    };  //  end of class node_interface

class node_pipe;

// 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
    FRONT_MEMORY_INFO GetMemoryInfo( ) { return GetInvalidMemoryInfo();}


    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_interface_reference


/***
 *** 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         
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();};
    

    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
    {

    unsigned long   fHasCSType      : 1;    // An array of international chars

public:
                    npa_nodes( NODE_T Kind )
                        : node_skl( Kind, NULL )
                        {
                        fHasCSType = FALSE;
                        };

    void            SetHasCSType()
                        {
                        fHasCSType = TRUE;
                        }

    BOOL            HasCSType()
                        {
                        return fHasCSType;
                        }

    BOOL            FInSummary( ATTR_T flag )
                        {
                        BOOL result;

                        if ( flag >= ATTR_CPORT_ATTRIBUTES_START && flag <= ATTR_CPORT_ATTRIBUTES_END)
                            {
                            result = GetModifiers().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)
                        : npa_nodes( NODE_POINTER )
                        {
                        SetChild(pChild);
                        }

    virtual
    FRONT_MEMORY_INFO GetMemoryInfo();

    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;
                        }

    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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}

    virtual
    void            PrintMemoryInfo( ISTREAM *pStream, BOOL bNewLine );
    
    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetModifiedMemoryInfoFromChild();}


    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    };  //  end of class node_error

// Flag if the variable is used in a size_is, etc expression, and wether or not
// it's a cs_char array expression

enum SIZE_LENGTH_USAGE
    {
    NoSizeLengthUsage,
    CSSizeLengthUsage,
    NonCSSizeLengthUsage
    };

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

public:
                    node_base_type( NODE_T MyKind, ATTR_T attr )
                        : named_node( MyKind )
                        {
                        if ( attr != ATTR_NONE )
                            GetModifiers().SetModifier( attr );

//                        SizeLengthUsage = NoSizeLengthUsage;
                        };

                    node_base_type( const node_base_type * pOriginal )
                        : named_node( NODE_ILLEGAL )
                        {
                        *this = *pOriginal;
                        }
    virtual
    BOOL            IsBasicType()
                        {
                        return TRUE;
                        }

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

    BOOL            IsAssignmentCompatible( node_base_type * );
//    bool            IsCompatibleType( TypeSet     set );   Nishad
/*
BUGBUG: CG_INTERFACE_POINTER has a bug where it will case a node_base_type to
        a node_interface for QI.  It just happens to work at the momement but
        when the size for node_base_type is increased it causes the TLB code
        to AV.  Put this back when that is fixed.   -- MikeW

    SIZE_LENGTH_USAGE   GetSizeLengthUsage()
                        {
                        return SizeLengthUsage;
                        }
    void            SetSizeLengthUsage( SIZE_LENGTH_USAGE usage )
                        {
                        SizeLengthUsage = usage;
                        }
*/
    BOOL            RangeCheck( __int64 Val );

    BOOL            IsUnsigned();

    virtual
    EXPR_VALUE      ConvertMyKindOfValueToEXPR_VALUE( __int64 EXPR_VALUE );

    void            CheckVoidUsage( SEM_ANALYSIS_CTXT * pContext );

    void            CheckVoidUsageInDispinterface( 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
    FRONT_MEMORY_INFO GetMemoryInfo();

    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetModifiedMemoryInfoFromChild();}

    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 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 );

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

#define SZ_ASYNCPIPEDEFPREFIX "ASYNC_"

class node_pipe : public named_node
    {
private:
    bool            fGenAsyncPipeFlavor;

protected:
    bool
                    GenAsyncPipeFlavor() { return fGenAsyncPipeFlavor; }
    void
                    SetGenAsyncPipeFlavor( bool fGen = true ) { fGenAsyncPipeFlavor = fGen; }
    STATUS_T        PrintDeclaration(
                                    PRTFLAGS        Flags,
                                    BufferManager*  pBuffer,
                                    ISTREAM*        pStream,
                                    node_skl*       pParent,
                                    node_skl*       pIntf,
                                    char*           szPrefix
                                    );
public:
                    // constructors
                    node_pipe()
                        : named_node( NODE_PIPE ),
                        fGenAsyncPipeFlavor( false )
                    {
                    }

                    node_pipe(node_skl * pType)
                        : named_node( NODE_PIPE ),
                        fGenAsyncPipeFlavor( false )
                    {
                    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
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}

    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:
        // this maintains a reference to LPSAFEARRAY. This is
        // necessary to generate the appropriate code when
        // SAFEARRAY(type) construct is used outside the library block
        named_node* pSafeArrayTypedef;
        
        BOOL fInProxy;
public:
                    // constructors
                    node_safearray()
                        : npa_nodes( NODE_SAFEARRAY ),
                        pSafeArrayTypedef( 0 ),
                        fInProxy(0)
                        {
                        }

                    node_safearray(node_skl * pType)
                        : npa_nodes( NODE_SAFEARRAY ),
                        pSafeArrayTypedef( 0 ),
                        fInProxy(0)
                        {
                        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
    FRONT_MEMORY_INFO GetMemoryInfo();

    virtual
    void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

    virtual
    CG_CLASS *      ILxlate( XLAT_CTXT * pContext );

    virtual
    void            SetTypeAlias( named_node* pAlias) { pSafeArrayTypedef = pAlias; };

    virtual
    named_node*     GetTypeAlias( void ) { return pSafeArrayTypedef; };

    };  //  end of class node_pointer


class node_async_handle : public named_node
    {
    private:
    public:

        node_async_handle( char* szName ) : named_node( szName, NODE_ASYNC_HANDLE )
            {
            }
        STATUS_T        DoPrintDecl(PRTFLAGS        Flags,
                                    BufferManager*  pBuffer,
                                    ISTREAM*        pStream,
                                    node_skl*       pParent,
                                    node_skl*       pIntf );
        STATUS_T        DoPrintType(PRTFLAGS        Flags,
                                    BufferManager*  pBuffer,
                                    ISTREAM*        pStream,
                                    node_skl*       pParent,
                                    node_skl*       pIntf);
        virtual
        FRONT_MEMORY_INFO GetMemoryInfo( ) { return GetInvalidMemoryInfo();}

        CG_CLASS*       ILxlate( XLAT_CTXT*  pContext );
        void            SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt );

        }; // node_async_handle

typedef enum __PragmaType
{
    mp_MessageDisable,
    mp_MessageEnable
} PragmaType;

class node_midl_pragma : public named_node
{
private:
    PragmaType  m_PragmaType;
    gplistmgr*  m_pMsgList;
public:
    node_midl_pragma( PragmaType pt, gplistmgr* pList ) :
        named_node( NODE_MIDL_PRAGMA, "midl_pragma" ),
        m_PragmaType( pt ),
        m_pMsgList( pList )
    {
    }
    virtual
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}
    void        SemanticAnalysis( SEM_ANALYSIS_CTXT* );
    CG_CLASS*   ILxlate( XLAT_CTXT*  pContext );
    void        ProcessPragma();

};  // node_midl_pragma

class node_decl_guid : public named_node
{
public:
    node_decl_guid( char* szName, node_guid* guid ) : named_node( NODE_DECL_GUID, szName ),
        pGuid( guid )
        {
        }

    virtual 
    FRONT_MEMORY_INFO GetMemoryInfo() {return GetInvalidMemoryInfo();}

    void        SemanticAnalysis( SEM_ANALYSIS_CTXT* );
    CG_CLASS*   ILxlate( XLAT_CTXT*  pContext );
    STATUS_T
    DoPrintType (
                PRTFLAGS,
                BufferManager*,
                ISTREAM*,
                node_skl*,
                node_skl*
                );
    STATUS_T
    DoPrintDecl (
                PRTFLAGS,
                BufferManager*,
                ISTREAM*,
                node_skl*,
                node_skl*
                );
private:
    node_guid*   pGuid;
};

#endif // __NODESKL_HXX__