/*****************************************************************************/
/**                       Microsoft LAN Manager                             **/
/**              Copyright(c) Microsoft Corp., 1987-1999                    **/
/*****************************************************************************/
/*****************************************************************************
File    : attrnode.hxx
Title   : attribute node definitions
History :
            08-Aug-1991     VibhasC Created

*****************************************************************************/

#ifndef __attrnode_hxx__
#define __attrnode_hxx__

/**
 ** We classify attributes into these classes:
 **
 **     A) IDL attributes and B) ACF attributes.
 **
 ** IDL Attributes, are further divided into:
 **
 **   . bit_attributes( whose presence is indicated by a bit in the summary
 **                     vector and which requre no further info. ( BA )
 **       . non-bit attributes ( whic have some info conatained in them. (NBA)
 **
 ** There is no such classification in acf attributes. All acf attributes
 ** have attribute class instances.
 **
 ** BAs are further divided into:
 **
 ** 1. size-based attributes (SA), size_is, length_is etc, except string
 ** 2. type-based attributes(TA) switch_type, transmit_as etc
 ** 3. acf attributes (AA)
 ** 4. miscellaneous attributes (MA) guid, endpoint, switch_is etc
 **
 ** The classification is loosely based on the semantic checks needed. size_is
 ** length_is etc have almost similar semantic checks, so we group them
 ** together. The miscellaneous attributes are completely unrelated to each
 ** other and so such we just group them into one.
 **/

#include "expr.hxx"
#include "midlnode.hxx"
#include "stream.hxx"
#include "nodeskl.hxx"


class node_e_attr       : public node_base_attr
    {
public:
    node_e_attr() : node_base_attr( ATTR_NONE )
    {
    }

    node_e_attr( node_e_attr * pOld ) : node_base_attr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr* pNew = new node_e_attr(this);
        return pNew;
        }
    };

class nbattr    : public node_base_attr
    {
public:
    nbattr( ATTR_T At ) : node_base_attr( At )
        {
        }
    };

/****************************************************************************
        size - related attributes
 ****************************************************************************/

class expr_node;

class size_attr : public nbattr
    {
private:
    class expr_node *   pExpr;
public:
    size_attr( expr_node * pE, ATTR_T  A)
            : nbattr( A )
        {
        pExpr   = pE;
        }

    virtual
    class node_base_attr *  Clone()
        {
        size_attr   *   pNew = new size_attr( NULL, GetAttrID() );
        *pNew = *this;
        if ( pExpr )
            {
            pNew->pExpr = pExpr->Clone();
            pExpr->CopyTo( pNew->pExpr );
            }
        return pNew;
        }

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

    expr_node   *   GetExpr()
        {
        return pExpr;
        }


    };

/****************************************************************************
        type - based attributes
 ****************************************************************************/

class ta : public nbattr
    {
private:
    node_skl    *   pType;
public:
    ta( node_skl *pT, ATTR_T A)
            : nbattr( A )
    {
    pType   = pT;
    }

    node_skl    *   GetType()
        {
        return pType;
        }
    };

class node_transmit : public ta
    {
public:
    node_transmit( node_skl * pTransmitAs )
            : ta( pTransmitAs, ATTR_TRANSMIT )
        {
        }

    node_transmit( node_transmit * pOld ) : ta( pOld->GetType(), pOld->GetAttrID() )
        {
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *       pNew = new node_transmit( this );
        return pNew;
        }

    node_skl    *   GetTransmitAsType()
        {
        return GetType();
        }
    };


/*
Rkk left just in case
*/

class node_wire_marshal : public ta
    {
public:
                        node_wire_marshal( node_skl * pN )
                            : ta( pN, ATTR_WIRE_MARSHAL )
                            {
                            }

                        node_wire_marshal( node_wire_marshal * pOld ) 
                                : ta( pOld->GetType(), pOld->GetAttrID() )
                            {
                            }

    virtual
    node_base_attr *    Clone()
                            {
                            node_base_attr  * pNew = new node_wire_marshal( this );
                            return pNew;
                            }

    node_skl       *    GetWireMarshalType()      // wire type, not local
                            {
                            return GetType();
                            }

    };

class node_switch_type : public ta
    {
public:
    node_switch_type( class node_skl *  pSwitchType)
            : ta( pSwitchType, ATTR_SWITCH_TYPE )
        {
        }

    node_switch_type( node_switch_type * pOld ) 
            : ta( pOld->GetType(), pOld->GetAttrID() )
        {
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *       pNew = new node_switch_type(this);
        return pNew;
        }

    node_skl    *   GetSwitchType()
        {
        return GetType();
        }

    };


/****************************************************************************
        other miscellaneous attributes
 ****************************************************************************/
class ma    : public nbattr
    {
public:
    ma( ATTR_T At ) : nbattr( At )
        {
        }
    };

typedef struct _INTERNAL_UUID
    {
    unsigned long   Data1;
    unsigned short  Data2;
    unsigned short  Data3;
    unsigned char   Data4[8];
    } INTERNAL_UUID;

class GUID_STRS
    {

public:
    INTERNAL_UUID   Value;

    char    *   str1,
            *   str2,
            *   str3,
            *   str4,
            *   str5;

    GUID_STRS()
        {
        }

    GUID_STRS( char *p1, char *p2, char *p3, char *p4, char *p5 )
        {
        str1 = p1;
        str2 = p2;
        str3 = p3;
        str4 = p4;
        str5 = p5;
        SetValue();
        }

    void    SetStrs( char *p1, char *p2, char *p3, char *p4, char *p5 )
        {
        str1 = p1;
        str2 = p2;
        str3 = p3;
        str4 = p4;
        str5 = p5;
        SetValue();
        }

    void    GetStrs( char *&p1, char *&p2, char *&p3, char *&p4, char *&p5 )
        {
        p1 = str1;
        p2 = str2;
        p3 = str3;
        p4 = str4;
        p5 = str5;
        }

    void    SetValue();

    };

struct _GUID;

class node_guid : public ma
    {
private:
    char        *   guidstr;
    GUID_STRS       cStrs;
public:
    node_guid( char*, char*, char*, char*, char*, ATTR_T At = ATTR_GUID );
    node_guid( char*, ATTR_T At = ATTR_GUID );

    node_guid(node_guid * pOld) : ma( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *       pNew = new node_guid(this);
        return pNew;
        }

    char    *   GetGuidString()
        {
        return guidstr;
        }

    void    CheckAndSetGuid( char *,char *,char *,char *, char * );

    void    GetStrs( char **, char **, char **, char **, char ** );

    void    GetGuid(_GUID &);

    GUID_STRS & GetStrs()
        {
        return cStrs;
        }
    };

class node_version  : public nbattr
    {
private:
    unsigned long   major;
    unsigned long   minor;
public:
    node_version( unsigned long, unsigned long );

    node_version( char *p );

    node_version(node_version * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *       pNew = new node_version(this);
        return pNew;
        }


    STATUS_T    GetVersion( unsigned short *, unsigned short * );

    // we want to delete these two

    STATUS_T    GetVersion( short *, short * );

    STATUS_T    GetVersion( int *pma, int *pmi )
        {
        *pma = (int) major;
        *pmi = (int) minor;
        return STATUS_OK;
        }

    };


/////////////////////////////////////////////////////////////////////////////
// inherited pointer type.
/////////////////////////////////////////////////////////////////////////////

typedef unsigned short PTRTYPE;

//
// Initialized value (pointer type not yet determined).
//

#define PTR_UNKNOWN     0x0

// [REF] pointer.

#define PTR_REF         0x1

// [UNIQUE] pointer

#define PTR_UNIQUE      0x2

// [FULL] pointer

#define PTR_FULL        0x3


class node_ptr_attr : public nbattr
    {
private:
    PTRTYPE Kind;
public:
    node_ptr_attr( PTRTYPE K )
            : nbattr( ATTR_PTR_KIND )
        {
        Kind = K;
        }

    node_ptr_attr(node_ptr_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *   pNew = new node_ptr_attr(this);
        return pNew;
        }


    PTRTYPE GetPtrKind()
        {
        return Kind;
        }

    };

typedef struct _endptpair
    {

    char    *   pString1;
    char    *   pString2;

    } ENDPT_PAIR;

class node_endpoint : public nbattr
    {
private:
    gplistmgr   EndPointStringList;
public:
    node_endpoint( char * );

    node_endpoint(node_endpoint * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *   pNew = new node_endpoint(this);
        return pNew;
        }


    void    SetEndPointString( char *p );

    // don't destroy the iterator returned here; just use it in place
    // it is an iterator of ENDPT_PAIR nodes defined above.
    ITERATOR &  GetEndPointPairs();

    };

class node_switch_is    : public nbattr
    {
private:
    class expr_node *   pExpr;
public:
    node_switch_is( class expr_node * pE )
            : nbattr( ATTR_SWITCH_IS )
        {
        pExpr   = pE;
        }

    node_switch_is(node_switch_is * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *   pNew = new node_switch_is(this);
        ((node_switch_is*)pNew)->pExpr = pExpr->Clone();
        pExpr->CopyTo( ((node_switch_is*)pNew)->pExpr );
        return pNew;
        }


    node_skl    *   GetSwitchIsType()
        {
        return pExpr->GetType();
        }

    expr_node   *   GetExpr()
        {
        return pExpr;
        }
    };

class node_case : public nbattr
    {
private:
    class expr_list *   pExprList;
public:
    node_case( expr_list * pL )
            : nbattr( ATTR_CASE )
        {
        pExprList   = pL;
        }

    node_case(node_case * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual
    class node_base_attr *  Clone()
        {
        node_base_attr  *       pNew = new node_case(this);
        return pNew;
        }


    class expr_list *   GetExprList()
        {
        return pExprList;
        }
    };


//+---------------------------------------------------------------------------
//
//  Class:      node_constant_attr
//
//  Purpose:    Used by attributes that are associated with constant data
//              such as: id(x), helpcontext(x), lcid(x), fdescattr etc.
//
//----------------------------------------------------------------------------

class node_constant_attr : public nbattr
    {
private:
    class expr_node *   _pExprNode;
public:
    node_constant_attr(expr_node * pN, ATTR_T attr)
            : nbattr(attr)
        {
        if (pN->AlwaysGetType()->NodeKind() == NODE_POINTER && attr != ATTR_DEFAULTVALUE )
            ParseError( ILLEGAL_EXPRESSION_TYPE, (char *)0 );
        _pExprNode = pN;
        }

    node_constant_attr(node_constant_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        node_base_attr * pNew = new node_constant_attr(this);
        return pNew;
        }

    class expr_node * GetExpr(void)
        {
        return _pExprNode;
        }
    };

//+---------------------------------------------------------------------------
//
//  Function:   TranslateEscapeSequences
//
//  Purpose:    Replaces a string's escape sequences with the appropriate 
//              ASCII characters.
//
//              NOTE: this can be done in place because the resulting string
//              length will always be shorter than or equal to the input string 
//              length.
//
//----------------------------------------------------------------------------

void TranslateEscapeSequences(char * sz);

//+---------------------------------------------------------------------------
//
//  Class:      node_text_attr
//
//  Purpose:    Used by attributes that are associated with string data
//              such as: helpstring("foo"), helpfile("foo"), dllname("foo"), etc.
//
//----------------------------------------------------------------------------

class node_text_attr : public nbattr
    {
private:
    char * _szText;
public:
    node_text_attr(char * szText, ATTR_T attr)
            : nbattr(attr)
        {
        _szText = szText;
        }

    node_text_attr(node_text_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        node_base_attr * pNew = new node_text_attr(this);
        return pNew;
        }

    char * GetText(void)
        {
        return _szText;
        }
    };


//+---------------------------------------------------------------------------
//
//  Class:      node_custom_attr
//
//  Purpose:    extensible custom attribute support for new ODL syntax
//
//----------------------------------------------------------------------------

class node_custom_attr : public nbattr
    {
private:
    node_guid * pGuid;
    expr_node * pExpr;
public:
    node_custom_attr( node_guid * pg, expr_node * px)
            : nbattr(ATTR_CUSTOM)
        {
        pGuid = pg;
        pExpr = px;
        }

    node_guid * GetGuid(void)
        {
        return pGuid;
        }

    expr_node * GetVal(void)
        {
        return pExpr;
        }
    };

//+---------------------------------------------------------------------------
//
//  Class:      node_entry_attr
//
//  Purpose:    Used by the entry attribute who's parameter is either an
//                              index or a named library entry point.
//
//----------------------------------------------------------------------------

class node_entry_attr : public nbattr
    {
private:
    char    * _szVal;
    LONG_PTR  _lVal;
    BOOL      _fNumeric;
public:
    node_entry_attr(LONG_PTR lVal)
            : nbattr(ATTR_ENTRY)
        {
        _lVal = lVal;
        _fNumeric = TRUE;
        }

    node_entry_attr(char * sz)
            : nbattr(ATTR_ENTRY)
        {
        _szVal = sz;
        _fNumeric = FALSE;
        }

    node_entry_attr(node_entry_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        node_base_attr * pNew = new node_entry_attr(this);
        return pNew;
        }

    BOOL IsNumeric(void)
        {
        return _fNumeric;
        }

    char * GetSz(void)
        {
        return _szVal;
        }

    LONG_PTR GetID(void)
        {
        return _lVal;
        }
};

//+---------------------------------------------------------------------------
//
//  Class:      node_type_attr
//
//  Purpose:    Used whenever an ODL bit attribute is seen that only may be
//                              applied to TYPEATTRs.
//
//----------------------------------------------------------------------------
class node_type_attr : public nbattr
    {
private:
    TATTR_T _attr;
public:
    node_type_attr(TATTR_T attr)
            : nbattr(ATTR_TYPE)
        {
        _attr = attr;
        }

    node_type_attr(node_type_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        node_base_attr * pNew = new node_type_attr(this);
        return pNew;
        }

    TATTR_T GetAttr(void)
        {
        return _attr;
        }
    };

//+---------------------------------------------------------------------------
//
//  Class:      node_member_attr
//
//  Purpose:    Used whenever an ODL bit attribute is seen that only may be
//                              applied to FUNCDESCs or VARDESCs.
//
//----------------------------------------------------------------------------
class node_member_attr : public nbattr
    {
private:
    MATTR_T _attr;
public:
    node_member_attr(MATTR_T attr)
            : nbattr(ATTR_MEMBER)
        {
        _attr = attr;
        }

    node_member_attr(node_member_attr * pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        node_base_attr * pNew = new node_member_attr(this);
        return pNew;
        }

    MATTR_T GetAttr(void)
        {
        return _attr;
        }
    };

//+---------------------------------------------------------------------------
//
//  Class:      node_range_attr
//
//  Purpose:    Used by attribute range(min, max).
//
//----------------------------------------------------------------------------

class node_range_attr : public nbattr
    {
private:
    class expr_node*   _pMinExpr;
    class expr_node*   _pMaxExpr;
public:
    node_range_attr(expr_node* pMinExpr, expr_node* pMaxExpr)
            : nbattr(ATTR_RANGE), _pMinExpr(pMinExpr), _pMaxExpr(pMaxExpr)
        {
        }

    node_range_attr(node_range_attr* pOld) : nbattr( pOld->GetAttrID() )
        {
        *this = *pOld;
        }

    virtual class node_base_attr * Clone()
        {
        return new node_range_attr(this);
        }

    class expr_node * GetMinExpr(void)
        {
        return _pMinExpr;
        }
    class expr_node * GetMaxExpr(void)
        {
        return _pMaxExpr;
        }
    };

#endif //  __attrnode_hxx__