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

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Copyright (c) 1989-1999 Microsoft Corporation

 Module Name:

    semantic.hxx

 Abstract:

    types for semantic analysis

 Notes:


 Author:

    GregJen Sep-24-1993     Created.

 Notes:


 ----------------------------------------------------------------------------*/
#ifndef __SEMANTIC_HXX__
#define __SEMANTIC_HXX__

#pragma warning ( disable : 4710 )

/****************************************************************************
 *      include files
 ***************************************************************************/

#include "listhndl.hxx"
#include "midlnode.hxx"
#include "attrlist.hxx"
#include "nodeskl.hxx"
#include "fldattr.hxx"
#include "walkctxt.hxx"
#include "gramutil.hxx"
#include "cmdana.hxx"

/****************************************************************************
 *      local data
 ***************************************************************************/

/****************************************************************************
 *      externs
 ***************************************************************************/

/****************************************************************************
 *      definitions
 ***************************************************************************/

/*
 *  here are flag bits passed down from parents to give info on the
 *  current path down the typegraph.  These are dynamic information only,
 *  and are NOT to be stored with the node.
 *
 *  Although a few of these bits are mutually exclusive, most may be used
 *  in combination.
 */

#define     IN_INTERFACE           0x0000000000000001 // in the base interface
#define     IN_PARAM_LIST          0x0000000000000002 // a descendant of a parameter
#define     IN_FUNCTION_RESULT     0x0000000000000004 // used as (part of) a return type
#define     IN_STRUCT              0x0000000000000008 // used in a struct
#define     IN_UNION               0x0000000000000010 // used in a union
#define     IN_ARRAY               0x0000000000000020 // used in an array
#define     IN_POINTER             0x0000000000000040 // below a pointer
#define     IN_RPC                 0x0000000000000080 // in an RPC call
#define     UNDER_IN_PARAM         0x0000000000000100 // in an IN parameter
#define     UNDER_OUT_PARAM        0x0000000000000200 // in an OUT parameter
#define     BINDING_SEEN           0x0000000000000400 // binding handle already seen
#define     IN_TRANSMIT_AS         0x0000000000000800 // the transmitted type of transmit_as
#define     IN_REPRESENT_AS        0x0000000000001000 // the "transmitted" type of represent_as
#define     IN_USER_MARSHAL        0x0000000000002000 // transmitted type of 
#define     IN_HANDLE              0x0000000000004000 // under generic or context hdl
#define     IN_NE_UNION            0x0000000000008000 // inside an non-encap union
#define     IN_INTERPRET           0x0000000000010000 // in an /Oi proc
#define     IN_NON_REF_PTR         0x0000000000020000 // under a series of unique/full ptrs
#define     UNDER_TOPLEVEL         0x0000000000040000 // top-level under param
#define     UNDER_TOPLVL_PTR       0x0000000000080000 // top-level under pointer param
#define     IN_BASE_CLASS          0x0000000000100000 // checking class derivation tree
#define     IN_PRESENTED_TYPE      0x0000000000200000 // the presented type of xmit/rep_as
#define     IN_ROOT_CLASS          0x0000000000400000 // a method/definition in the root class
#define     IN_ENCODE_INTF         0x0000000000800000 // inside an encode/decode only intf
#define     IN_RECURSIVE_DEF       0x0000000001000000 // inside of a recursive definition
#define     IN_OBJECT_INTF         0x0000000002000000 // in an object interface
#define     IN_LOCAL_PROC          0x0000000004000000 // in a [local] proc
#define     IN_INTERFACE_PTR       0x0000000008000000 // in the definition of an interface pointer
#define     IN_MODULE              0x0000000010000000 // in a module
#define     IN_COCLASS             0x0000000020000000 // in a coclass
#define     IN_LIBRARY             0x0000000040000000 // in a library
#define     IN_DISPINTERFACE       0x0000000080000000 // in a dispinterface
#define     HAS_OLEAUTOMATION      0x0000000100000000 // has [oleautomation] attr
#define     HAS_ASYNCHANDLE        0x0000000200000000 // has [async] attribute
#define     HAS_AUTO_HANDLE        0x0000000400000000 // has auto_handle
#define     HAS_EXPLICIT_HANDLE    0x0000000800000000 // has explicit_handle
#define     HAS_IMPLICIT_HANDLE    0x0000001000000000 // has implicit_handle
#define     IN_IADVISESINK         0x0000002000000000 // processing the children of IAdviseSink(*)
#define     HAS_ASYNC_UUID         0x0000004000000000 // interface has [async_uuid]
#define     HAS_MESSAGE            0x0000008000000000 // interface has [message]
#define     UNDER_HIDDEN_STATUS    0x0000010000000000 // hidden status param
#define     UNDER_PARTIAL_IGNORE_PARAM   0x0000020000000000 // Up to first ptr under partial_ignore

typedef __int64   ANCESTOR_FLAGS; // above enum goes into here

/*
 *  Here are flag bits returned UP from children to give info on the current
 *  path down the typegraph.  Again, these are dynamic information.
 */

#define HAS_STRING             0x0000000000000001 // has [string] attr
#define HAS_IN                 0x0000000000000002 // has [IN] attr
#define HAS_OUT                0x0000000000000004 // has [OUT] attr
#define HAS_HANDLE             0x0000000000000008 // is a handle
#define HAS_POINTER            0x0000000000000010 // has a pointer below
#define HAS_INCOMPLETE_TYPE    0x0000000000000020 // has incomplete type spec below
#define HAS_VAR_ARRAY          0x0000000000000040 // has varying array (incl string)
#define HAS_CONF_ARRAY         0x0000000000000080 // has conf array
#define HAS_CONF_VAR_ARRAY     0x0000000000000100 // has conf_var array
#define DERIVES_FROM_VOID      0x0000000000000200 // derives from void
#define HAS_UNSAT_REP_AS       0x0000000000000400 // has unsatisfied rep_as
#define HAS_CONTEXT_HANDLE     0x0000000000000800 // has context handle below
#define HAS_CONF_PTR           0x0000000000001000 // has conformant pointer
#define HAS_VAR_PTR            0x0000000000002000 // has varying pointer
#define HAS_CONF_VAR_PTR       0x0000000000004000 // has conformant varying pointer
#define HAS_TRANSMIT_AS        0x0000000000008000 // has transmit_as below
#define HAS_REPRESENT_AS       0x0000000000010000 // has represent_as below
#define HAS_E_STAT_T           0x0000000000020000 // has error_status_t below
#define HAS_UNION              0x0000000000040000 // has union below
#define HAS_ARRAY              0x0000000000080000 // has array below
#define HAS_INTERFACE_PTR      0x0000000000100000 // has an interface ptr below
#define HAS_DIRECT_CONF_OR_VAR 0x0000000000200000 // has direct conformance or variance
#define HAS_RECURSIVE_DEF      0x0000000000400000 // is defined recursively
#define HAS_ENUM               0x0000000000800000 // has an enum directly or embedded
#define HAS_FUNC               0x0000000001000000 // has a function below
#define HAS_FULL_PTR           0x0000000002000000 // has full pointers anywhere
#define HAS_TOO_BIG_HDL        0x0000000004000000 // is /Oi but handle is too big
#define HAS_STRUCT             0x0000000008000000 // has struct
#define HAS_MULTIDIM_SIZING    0x0000000010000000 // has multi-dimensions
#define HAS_ARRAY_OF_REF       0x0000000020000000 // has array of ref pointers
#define HAS_HRESULT            0x0000000040000000 // has HRESULT
#define HAS_PIPE               0x0000000080000000 // has a PIPE
#define HAS_DEFAULT_VALUE      0x0000000100000000 // has [defaultvalue] attribute
#define HAS_SERVER_CORRELATION 0x0000000200000000 // server correlation
#define HAS_CLIENT_CORRELATION 0x0000000400000000 // client correlation
#define HAS_MULTIDIM_VECTOR    0x0000000800000000 // has multi dim array or sized ptrs
#define HAS_SIZED_ARRAY        0x0000001000000000 // not a fixed array
#define HAS_SIZED_PTR          0x0000002000000000 // 
#define HAS_IN_CSTYPE          0x0000004000000000 // has in international chars
#define HAS_OUT_CSTYPE         0x0000008000000000 // has out international chars
#define HAS_DRTAG              0x0000010000000000 // some param has [cs_drtag]
#define HAS_RTAG               0x0000020000000000 // some param has [cs_rtag]
#define HAS_STAG               0x0000040000000000 // some param has [cs_stag]
#define HAS_PARTIAL_IGNORE     0x0000080000000000 // some param has [partial_ignore]
#define HAS_FORCEALLOCATE      0x0000100000000000 // some param has [force_allocate]
#define HAS_ARRAYOFPOINTERS    0x0000200000000000 // has an array of pointers

typedef __int64   DESCENDANT_FLAGS;   // above defines goes into here

/*
 * Here is the context information passed down from parent to child.
 * These will be allocated on the stack during the traversal
 */

class node_interface;
class type_node_list;
class ATTRLIST;

class SEM_ANALYSIS_CTXT: public WALK_CTXT
    {
    private:
    unsigned long   ulCorrelations;

public:
    struct _current_ctxt {
        // down stuff
        ANCESTOR_FLAGS   AncestorBits;  // where am I? stuff

        // up stuff

        DESCENDANT_FLAGS DescendantBits;
        } CurrentCtxt;

                    // constructor and destructor
                    SEM_ANALYSIS_CTXT(node_skl * Me)
                        : WALK_CTXT( Me )
                        {
                        GetAncestorBits()   = 0;
                        GetDescendantBits() = 0;
                        ulCorrelations      = 0;
                        }

                    SEM_ANALYSIS_CTXT(node_skl * Me,
                            SEM_ANALYSIS_CTXT * pParentCtxt )
                        : WALK_CTXT( Me, pParentCtxt )
                        {
                        // clone information from parent node
                        CurrentCtxt = pParentCtxt->CurrentCtxt;
                        // get fresh information from our children
                        GetDescendantBits() = 0;

                        // remove any inapplicable attributes
                        CheckAttributes();

                        ulCorrelations = 0;
                        }

                    SEM_ANALYSIS_CTXT(SEM_ANALYSIS_CTXT * pParentCtxt )
                        : WALK_CTXT( pParentCtxt )
                        {
                        // clone information from parent node
                        CurrentCtxt = pParentCtxt->CurrentCtxt;
                        // get fresh information from our children
                        GetDescendantBits() = 0;

                        ulCorrelations = 0;
                        }

    ANCESTOR_FLAGS& GetAncestorBits()
                        {
                        return CurrentCtxt.AncestorBits;
                        }

    ANCESTOR_FLAGS& SetAncestorBits( ANCESTOR_FLAGS f )
                        {
                        CurrentCtxt.AncestorBits |= f;
                        return CurrentCtxt.AncestorBits;
                        }

    ANCESTOR_FLAGS& ClearAncestorBits( ANCESTOR_FLAGS f )
                        {
                        CurrentCtxt.AncestorBits &= ~f;
                        return CurrentCtxt.AncestorBits;
                        }

    BOOL            AnyAncestorBits( ANCESTOR_FLAGS f )
                        {
                        return ((CurrentCtxt.AncestorBits & f) != 0);
                        }

    BOOL            AllAncestorBits( ANCESTOR_FLAGS f )
                        {
                        return ((CurrentCtxt.AncestorBits & f) == f);
                        }

    DESCENDANT_FLAGS& GetDescendantBits()
                        {
                        return CurrentCtxt.DescendantBits;
                        }

    DESCENDANT_FLAGS& SetDescendantBits( DESCENDANT_FLAGS f )
                        {
                        CurrentCtxt.DescendantBits |= f;
                        return CurrentCtxt.DescendantBits;
                        }

    DESCENDANT_FLAGS& ClearDescendantBits( DESCENDANT_FLAGS f )
                        {
                        CurrentCtxt.DescendantBits &= ~f;
                        return CurrentCtxt.DescendantBits;
                        }

    DESCENDANT_FLAGS& ClearAllDescendantBits( )
                        {
                        CurrentCtxt.DescendantBits = 0;
                        return CurrentCtxt.DescendantBits;
                        }

    BOOL            AnyDescendantBits( DESCENDANT_FLAGS f )
                        {
                        return ( ( CurrentCtxt.DescendantBits & f ) != 0 );
                        }

    BOOL            AllDescendantBits( DESCENDANT_FLAGS f )
                        {
                        return ((CurrentCtxt.DescendantBits & f) == f);
                        }

    void            ReturnValues( SEM_ANALYSIS_CTXT & ChildCtxt )
                        {
                        // pass up the return context
                        GetDescendantBits() |= ChildCtxt.GetDescendantBits();
                        ulCorrelations += ChildCtxt.GetCorrelationCount();
                        }

    unsigned long   GetCorrelationCount( void )
                        {
                        return ulCorrelations;
                        }

    void            IncCorrelationCount( unsigned long ulInc = 1 )
                        {
                        ulCorrelations += ulInc;
                        }

    void            ResetCorrelationCount()
                        {
                        ulCorrelations = 0;
                        }

    void            ResetDownValues( SEM_ANALYSIS_CTXT & ParentCtxt )
                        {
                        // reset the down values from the parent
                        // (semantically different, but really the same code )
                        ReturnValues( ParentCtxt );
                        }

    void            CheckAttributes();

    void            RejectAttributes();

    };  // end of class SEM_ANALYSIS_CTXT

inline void
RpcSemError( node_skl * pNode,
             SEM_ANALYSIS_CTXT & Ctxt,
             STATUS_T ErrNum,
             char * pExtra )
    {
    if ( Ctxt.AnyAncestorBits( IN_RPC ) &&
            !Ctxt.AnyAncestorBits( IN_LOCAL_PROC ) )
        SemError( pNode, Ctxt, ErrNum, pExtra );
    }


inline void
TypeSemError( node_skl * pNode,
              SEM_ANALYSIS_CTXT & Ctxt,
              STATUS_T ErrNum,
              char * pExtra )
    {
    if ( !Ctxt.AnyAncestorBits( IN_LOCAL_PROC ) )
        SemError( pNode, Ctxt, ErrNum, pExtra );
    }


// prototype for semantic advice routines
inline void
SemAdvice( node_skl * pNode,
           WALK_CTXT & Ctxt,
           STATUS_T ErrVal,
           char * pSuffix )
    {
    if ( pCommand->IsMintRun() )
        SemError( pNode, Ctxt, ErrVal, pSuffix );
    }

class acf_attr;

extern void
AcfError( acf_attr*, node_skl *, WALK_CTXT &, STATUS_T, char * );

/////////////////////////////////////////////
//
// expression analysis flags (passed up)

enum _EXPR_UP_FLAGS
    {
    EX_NONE             =   0x0000,
    EX_VALUE_INVALID    =   0x0001, // value is NOT valid
    EX_UNSAT_FWD        =   0x0002, // there is an unsatisfied fwd
    EX_NON_NUMERIC      =   0x0004, // expr not entirely numerics
                                    // (can not be constant folded)
    EX_OUT_ONLY_PARAM   =   0x0008, // expression includes an out-only param
    EX_PTR_FULL_UNIQUE  =   0x0010, // has ptr deref of full or unique ptr
    EX_HYPER_IN_EXPR    =   0x0020, // expr has a hyper item in it
    };

typedef unsigned short EXPR_UP_FLAGS;

////////////////////////////////////////////
// expression context block

class EXPR_CTXT;

class EXPR_CTXT
    {
private:
    // passed down
    EXPR_CTXT *         pParent;
    SEM_ANALYSIS_CTXT * pSemCtxt;

    // passed up
    EXPR_VALUE          CurValue;
    EXPR_UP_FLAGS       Flags;

public:

    // type info
    node_skl *          pType;
    struct  _type_ana   TypeInfo;
    BOOL                fIntegral;              // type is an integral type (above are valid)


    EXPR_CTXT( EXPR_CTXT * pMy ) : pType( 0 ), fIntegral( FALSE )
                            {
                            TypeInfo.TypeSize =
                            TypeInfo.BaseType =
                            TypeInfo.TypeSign = 
                            TypeInfo.TypeAttrib = 0;
                            pParent  = pMy;
                            pSemCtxt = pMy->pSemCtxt;
                            CurValue = 0;
                            Flags    = EX_NONE;
                            }

                        EXPR_CTXT( SEM_ANALYSIS_CTXT * pSCtxt ) : pType( 0 ), fIntegral( FALSE )
                            {
                            TypeInfo.TypeSize =
                            TypeInfo.BaseType =
                            TypeInfo.TypeSign = 
                            TypeInfo.TypeAttrib = 0;
                            pParent  = NULL;
                            pSemCtxt = pSCtxt;
                            CurValue = 0;
                            Flags    = EX_NONE;
                            }

                        // automatically pass up the flags
                        ~EXPR_CTXT()
                            {
                            if ( pParent )
                            pParent->Flags |= Flags;
                            }

    EXPR_VALUE&         Value()
                            {
                            return CurValue;
                            }

    EXPR_UP_FLAGS&      MergeUpFlags( EXPR_CTXT * pC )
                            {
                            Flags |= pC->Flags;
                            return Flags;
                            }

    EXPR_UP_FLAGS&      SetUpFlags( EXPR_UP_FLAGS f )
                            {
                            Flags |= f;
                            return Flags;
                            }

    EXPR_UP_FLAGS&      ClearUpFlags( EXPR_UP_FLAGS f )
                            {
                            Flags &= ~f;
                            return Flags;
                            }

    BOOL                AnyUpFlags( EXPR_UP_FLAGS f )
                            {
                            return (Flags & f);
                            }

    BOOL                AllUpFlags( EXPR_UP_FLAGS f )
                            {
                            return ((Flags & f) == f);
                            }

    node_skl*           GetNode()
                            {
                            return pSemCtxt->GetParent();
                            }

    SEM_ANALYSIS_CTXT * GetCtxt()
                            {
                            return pSemCtxt;
                            }

    };

#endif // __SEMANTIC_HXX__