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

 Module Name:

    expr.cxx

 Abstract:

    expression evaluator routines implementation.

 Notes:


 History:

    VibhasC     Aug-05-1993     Created

 ----------------------------------------------------------------------------*/

#pragma warning ( disable : 4514 )

/****************************************************************************
 *  include files
 ***************************************************************************/
#include "nulldefs.h"

extern "C"
    {
    #include <stdio.h>
    
    #include <string.h>
    }

#include "expr.hxx"
#include "listhndl.hxx"
#include "nodeskl.hxx"
#include "semantic.hxx"
#include "symtable.hxx"
#include "cmdana.hxx"
#include <excpt.h>
#include <float.h>

/****************************************************************************
 *  extern definitions
 ***************************************************************************/
/****************************************************************************
 *  extern data
 ***************************************************************************/
extern  SymTable        *   pBaseSymTbl;
extern  CMD_ARG         *   pCommand;

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

short
expr_node::MakeListOfVars(
    ITERATOR & 
    )
{
    return( 0 );
}

short
expr_named_constant::MakeListOfVars(
    ITERATOR & 
    )
{
    return( 0 );
}

short
expr_variable::MakeListOfVars(
    ITERATOR & pList
    )
{
    pList.Insert( this );
    return( 1 );
}

short
expr_op_unary::MakeListOfVars(
    ITERATOR & pList
    )
{
    short VarCount = 0;

    if ( GetLeft() )
        VarCount = GetLeft()->MakeListOfVars( pList );
    return( VarCount );
}

short
expr_sizeof::MakeListOfVars(
    ITERATOR & 
    )
/*++
    expr_sizeof is a unary_op but it doesn't have a child!
--*/
{
    return( 0 );
}

short
expr_alignof::MakeListOfVars(
    ITERATOR & 
    )
/*++
    expr_alignof is a unary_op but it doesn't have a child!
--*/
{
    return( 0 );
}

short
expr_op_binary::MakeListOfVars(
    ITERATOR & pList
    )
{
    short VarCount;

    VarCount = GetLeft()->MakeListOfVars( pList );
    if ( GetRight() )
        {
        VarCount = short( VarCount + GetRight()->MakeListOfVars( pList ) );
        }
    return( VarCount );
}

short
expr_ternary::MakeListOfVars(
    ITERATOR & pList
    )
{
    short VarCount;

    VarCount = GetLeft()->MakeListOfVars( pList );
    if ( GetRight() )
        {
        VarCount = short( VarCount + GetRight()->MakeListOfVars( pList ) );
        }
    if ( GetRelational() )
        {
        VarCount = short( VarCount + GetRelational()->MakeListOfVars( pList ) );
        }
    return( VarCount );
}

/***************************************************************************/
void
expr_node::DecorateWithPrefix(
    char *      pPrefix )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    This routine decorates all the variable nodes in the expression
    with a prefix.

 Arguments:

    pPrefix     - the prefix to be prepended to each variable

 Return Value:

 Notes:

----------------------------------------------------------------------------*/
{
    ITERATOR  VarList;
    expr_variable * pVarNode = 0;

    short VarCount = MakeListOfVars( VarList );
    if ( VarCount )
        {
        VarList.Init();
        while ( ITERATOR_GETNEXT( VarList, pVarNode ) )
            pVarNode->SetPrefix( pPrefix );
        }
    return;
}

expr_index::expr_index(
    expr_node * pL,
    expr_node * pR ) : expr_op_binary( OP_INDEX, pL, pR )
    {
    SetType( pL->GetType() );
    }

expr_param *
expr_proc_call::SetParam(
    expr_param  *   pParam )
    {
    expr_param  *   p   = GetFirstParam();

    IncrNoOfParams();
    if( p )
        {
        return p->SetLastPeerParam( pParam );
        }
    else
        return SetFirstParam( pParam );
    }
expr_param *
expr_proc_call::SetParam(
    expr_node * pExpr )
    {
    return SetParam( new expr_param( pExpr ));
    }

expr_param *
expr_param::SetLastPeerParam(
    expr_param  *   pParam )
    {
    expr_param  *   p   = GetNextParam();

    if( p )
        {
        return p->SetLastPeerParam( pParam );
        }
    else
        {
        return SetNextParam( pParam );
        }
    }


/**
 ** This routine attempts to recreate the string to be eaten by c compilers.
 ** If the user specified a string with a quote inside, substitute with an
 ** escape character. The new string with possible escapes will ALWAYS be
 ** smaller than the older one, so allocating the same amount of space is
 ** enough.
 **/

char *
MakeNewStringWithProperQuoting(
    char    *   pSrc )
    {
    char    *   pResult = new char [ strlen( pSrc ) + 1];
    char        ch;
    char    *   pDest   = pResult;

    while( ( ch = *pSrc++ ) != 0 )
        {

        *pDest = ch;

        if( ch == '\\')
            {
            if( ( ch = *pSrc++ ) != 0 )
                {
                if( (ch == '"') || ( ch == '\\') )
                    {
                    *pDest = ch;
                    }
                else
                    {
                    *pDest++ = '\\';
                    *pDest   = ch;
                    }
                }
            else
                break;
            }
        pDest++;
        }
    *pDest = '\0';
    return pResult;
    }

// routines for expr_variable...

// constructor - see if the type is constant
expr_variable::expr_variable( PNAME p, node_skl * pT )
{
    SetName( p );
    SetType( pT );
    SetConstant( FALSE );
    SetPrefix( NULL );
}

// resolve forwards on GetType
node_skl        *
expr_variable::GetType( void )
{
    if ( pType )
        {
        if ( pType->NodeKind() == NODE_FORWARD )
            {
            node_forward*   pFwd = (node_forward *) pType;
            // (permanently) resolve the forward
            pType = pFwd->ResolveFDecl();
            // if it couldn't be resolved, put back the forward
            if ( !pType )
                {
                pType = pFwd;
                }
            }
        }
    return pType;
}

// named constant routines...

// evaluate the variable if it is a constant
EXPR_VALUE
expr_named_constant::GetValue()
{
    node_skl *  pT      = GetType();
    NODE_T      Kind    = ( pT ) ? (NODE_T) pT->NodeKind()
                                 : (NODE_T) NODE_ILLEGAL;

    if ( !IsConstant() )
        return 0;

    // identifiers may be const... Forwards are assumed NOT const
    if ( Kind == NODE_ID )
        {
        node_id *       pId     = (node_id *) pT;
        node_skl    *   pType   = pId->GetBasicType();
        EXPR_VALUE      Result  = (pId->GetExpr()->GetValue() );

        return (pType) ? pType->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
        }
    else if ( Kind == NODE_LABEL )
        {
        return ( (node_label *) pT)->GetValue();
        }

    MIDL_ASSERT(FALSE);
    return 0; // for the compiler...
}

// evaluate the variable if it is a constant
expr_node *
expr_named_constant::GetExpr()
{
    node_skl *  pT      = GetType();
    NODE_T      Kind    = ( pT ) ? (NODE_T) pT->NodeKind()
                                 : (NODE_T) NODE_ILLEGAL;

    if ( !IsConstant() )
        return 0;

    // identifiers may be const... Forwards are assumed NOT const
    if ( Kind == NODE_ID )
        {
        node_id *       pId = (node_id *) pT;

        return pId->GetExpr();
        }
    else if ( Kind == NODE_LABEL )
        {
        return ( (node_label *) pT)->pExpr;
        }

    MIDL_ASSERT(FALSE);
    return 0; // for the compiler...
}

/******************************************************************************
 *  expression list handler
 *****************************************************************************/
expr_list::expr_list()
    {
    SetConstant( TRUE );
    }

STATUS_T
expr_list::GetPeer(
    expr_node   **  ppExpr )
    {
    return (GetNext( (void **)ppExpr ) );
    }
STATUS_T
expr_list::SetPeer(
    expr_node   *   pExpr )
    {
    if ( pExpr && !pExpr->IsConstant() )
        SetConstant( FALSE );

    return Insert( (void *) pExpr );
    }

EXPR_VALUE
expr_u_arithmetic::GetValue()
{
        EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
        EXPR_VALUE  Result;

        switch ( GetOperator() )
            {
            case OP_UNARY_PLUS:
                {
                Result = LeftValue;
                break;
                }
            case OP_UNARY_MINUS:
                {
                if (IsStringConstant())
                    {
                    char * szVal = (char *)LeftValue;
                    char * szNewVal = new char[strlen(szVal)+2];
                    szNewVal[0] = '-';
                    strcpy(szNewVal + 1, szVal);
                    Result = (EXPR_VALUE) szNewVal;
                    }
                else
                    {
                    Result = -LeftValue;
                    }    
                break;
                }
            default:
                {
                Result = 0;
                break;
                }
            }
        return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
}

EXPR_VALUE
expr_u_not::GetValue()
{
    EXPR_VALUE  Result = !GetLeft()->GetValue();

    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
}

EXPR_VALUE
expr_u_complement::GetValue()
{
    EXPR_VALUE  Result = ~ GetLeft()->GetValue();

    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
}

EXPR_VALUE
expr_cast::GetValue()
{
    return GetType()->
                ConvertMyKindOfValueToEXPR_VALUE(GetLeft()->GetValue());
}

EXPR_VALUE
expr_constant::GetValue()
{
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Value.I64) 
                       : Value.I64;
}


EXPR_VALUE
expr_sizeof::GetValue()
    {
    return  (pType) ? pType->GetSize() : 0;
    }

EXPR_VALUE
expr_alignof::GetValue()
    {
    return  (pType) ? pType->GetAlign() : 0;  
    }

EXPR_VALUE
expr_b_arithmetic::GetValue()
    {
    EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
    EXPR_VALUE  RightValue  = GetRight()->GetValue();
    EXPR_VALUE  Result;

    switch ( GetOperator() )
        {
        case OP_PLUS:
            {
            Result = LeftValue + RightValue;
            break;
            }
        case OP_MINUS:
            {
            Result = LeftValue - RightValue;
            break;
            }
        case OP_STAR:
            {
            Result = LeftValue * RightValue;
            break;
            }
        case OP_SLASH:
            {
            if (RightValue == 0)
                Result = 1;
            else
                Result = LeftValue / RightValue;
            break;
            }
        case OP_MOD:
            {
                        if ( 0 == RightValue )
                                Result = 1;
                        else
                    Result = LeftValue % RightValue;
            break;
            }
        default:
            {
            Result = 0;
            break;
            }
        }
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result ;
    }

EXPR_VALUE
expr_b_logical::GetValue()
    {
    EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
    EXPR_VALUE  RightValue  = GetRight()->GetValue();
    EXPR_VALUE  Result;

    switch ( GetOperator() )
        {
        case OP_LOGICAL_AND:
            {
            Result = LeftValue && RightValue;
            break;
            }
        case OP_LOGICAL_OR:
            {
            Result = LeftValue || RightValue;
            break;
            }
        default:
            {
            Result = 0;
            break;
            }
        }
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result ;
    }

EXPR_VALUE
expr_relational::GetValue()
    {
    EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
    EXPR_VALUE  RightValue  = GetRight()->GetValue();
    EXPR_VALUE  Result;

    switch ( GetOperator() )
        {
        // gaj - we implicitly assume signed types
        case OP_LESS:
            {
            Result = LeftValue < RightValue;
            break;
            }
        case OP_LESS_EQUAL:
            {
            Result = LeftValue <= RightValue;
            break;
            }
        case OP_GREATER_EQUAL:
            {
            Result = LeftValue >= RightValue;
            break;
            }
        case OP_GREATER:
            {
            Result = LeftValue > RightValue;
            break;
            }
        case OP_EQUAL:
            {
            Result = LeftValue == RightValue;
            break;
            }
        case OP_NOT_EQUAL:
            {
            Result = LeftValue != RightValue;
            break;
            }
        default:
            {
            Result = 0;
            break;
            }
        }
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
    }

EXPR_VALUE
expr_shift::GetValue()
    {
    EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
    EXPR_VALUE  RightValue  = GetRight()->GetValue();
    EXPR_VALUE  Result;

    switch ( GetOperator() )
        {
        // gaj - we implicitly assume signed types
        case OP_LEFT_SHIFT:
            {
            Result = LeftValue << RightValue;
            break;
            }
        case OP_RIGHT_SHIFT:
            {
            Result = LeftValue >> RightValue;
            break;
            }
        default:
            {
            Result = 0;
            break;
            }
        }
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
    }

EXPR_VALUE
expr_bitwise::GetValue()
    {
    EXPR_VALUE  LeftValue   = GetLeft()->GetValue();
    EXPR_VALUE  RightValue  = GetRight()->GetValue();
    EXPR_VALUE  Result;

    switch ( GetOperator() )
        {
        // gaj - we implicitly assume signed types
        case OP_AND:
            {
            Result = LeftValue & RightValue;
            break;
            }
        case OP_OR:
            {
            Result = LeftValue | RightValue;
            break;
            }
        case OP_XOR:
            {
            Result = LeftValue ^ RightValue;
            break;
            }
        default:
            {
            Result = 0;
            break;
            }
        }
    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result ;
    }

EXPR_VALUE
expr_ternary::GetValue()
    {
    EXPR_VALUE  RelValue    = GetRelational()->GetValue();
    EXPR_VALUE  Result;

    if ( RelValue )
        Result = GetLeft()->GetValue();
    else
        Result = GetRight()->GetValue();

    return (GetType()) ? GetType()->ConvertMyKindOfValueToEXPR_VALUE(Result) : Result;
    }

////////////////////////////////////////////////////////////////////////
// analysis of expressions
//

void
expr_node::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {
    pExprCtxt->SetUpFlags( EX_VALUE_INVALID );
    }

//
// determine the type of the expression
//

void
expr_op_unary::DetermineType()
{
    node_skl    *   pLeftType;

    if ( !GetLeft() )
        {
        return;
        }

    pLeftType = GetLeft()->AlwaysGetType();
    SetConstant( GetLeft()->IsConstant() );

    switch ( GetOperator() )
        {
        case OP_UNARY_PLUS:
        case OP_UNARY_COMPLEMENT:
        case OP_UNARY_MINUS:
        case OP_PRE_INCR:
        case OP_PRE_DECR:
        case OP_POST_INCR:
        case OP_POST_DECR:
            {
            // same type
            SetType( pLeftType );
            break;
            }
        case OP_UNARY_NOT:
            {
            node_skl *  pTmpType;

            GetBaseTypeNode( &pTmpType, SIGN_UNDEF, SIZE_UNDEF, TYPE_BOOLEAN );

            SetType( pTmpType );
            break;
            }
        case OP_UNARY_CAST:
            {
            SetType( GetType() );
            break;
            }
        case OP_UNARY_SIZEOF:
                case OP_UNARY_ALIGNOF:
            {
            node_skl *  pTmpType;

            GetBaseTypeNode( &pTmpType, SIGN_SIGNED, SIZE_UNDEF, TYPE_INT );

            SetType( pTmpType );
            SetConstant( TRUE );
            break;
            }
        case OP_UNARY_INDIRECTION:
            {
            node_skl *  pNode = pLeftType;

            if ( pNode->NodeKind() != NODE_POINTER )
                {
                // probably the param or field; look down
                pNode = pNode->GetBasicType();
                }

            // now get the pointee
            pNode = pNode->GetBasicType();

            SetType( pNode );
            break;
            }
        case OP_UNARY_AND:
            {
            node_pointer    *   pPtr    = new node_pointer;

            pPtr->SetChild( pLeftType );
            SetType( pPtr );
            break;
            }
        default:
            {
            break;
            }
        }   // end of switch
}

void
expr_op_unary::ExprAnalyze( EXPR_CTXT * pExprCtxt )
{
    EXPR_CTXT           LeftCtxt( pExprCtxt );

    if ( GetLeft() )
        {
        GetLeft()->ExprAnalyze( &LeftCtxt );
        pExprCtxt->MergeUpFlags( &LeftCtxt );
        SetConstant( GetLeft()->IsConstant() );
        }
    else if ( GetOperator() != OP_UNARY_SIZEOF && GetOperator() != OP_UNARY_ALIGNOF)
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );

    // do type compatibility stuff

    switch ( GetOperator() )
        {
        case OP_UNARY_PLUS:
        case OP_UNARY_COMPLEMENT:
            {
            // same type
            pExprCtxt->pType = LeftCtxt.pType;
            pExprCtxt->TypeInfo = LeftCtxt.TypeInfo;
            pExprCtxt->fIntegral = LeftCtxt.fIntegral;
            SetType( pExprCtxt->pType );
            break;
            }
        case OP_UNARY_MINUS:
            {
            node_skl    *   pTmp;

            pExprCtxt->pType = LeftCtxt.pType;
            pExprCtxt->TypeInfo = LeftCtxt.TypeInfo;
            pExprCtxt->TypeInfo.TypeSign = SIGN_SIGNED;
            pExprCtxt->fIntegral = LeftCtxt.fIntegral;
            GetBaseTypeNode( &pTmp, pExprCtxt->TypeInfo );
            if ( pTmp )
                pExprCtxt->pType = pTmp;

            SetType( pExprCtxt->pType );
            break;
            }
        case OP_UNARY_NOT:
            {
            pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
            pExprCtxt->TypeInfo.BaseType = TYPE_BOOLEAN;
            pExprCtxt->TypeInfo.TypeSign = SIGN_UNDEF;
            GetBaseTypeNode( &(pExprCtxt->pType ), pExprCtxt->TypeInfo );

            pExprCtxt->fIntegral = TRUE;
            SetType( pExprCtxt->pType );
            break;
            }
        case OP_UNARY_CAST:
            {
            SetType( GetType() );
            break;
            }
        case OP_UNARY_SIZEOF:
                case OP_UNARY_ALIGNOF:
            {
            pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
            pExprCtxt->TypeInfo.BaseType = TYPE_INT;
            pExprCtxt->TypeInfo.TypeSign = SIGN_SIGNED;
            GetBaseTypeNode( &(pExprCtxt->pType ), pExprCtxt->TypeInfo);

            pExprCtxt->fIntegral = TRUE;
            SetType( pExprCtxt->pType );
            break;
            }
        case OP_UNARY_INDIRECTION:
            {
            node_skl    *       pNode       = GetLeft()->GetType();
            node_skl    *       pOrigNode   = pNode;
            node_ptr_attr   *   pPtrAttr;
            PTRTYPE             PtrKind     = PTR_UNKNOWN;

            if ( pNode->FInSummary( ATTR_PTR_KIND ) )
                {
                pPtrAttr = (node_ptr_attr *)
                            ((named_node *)pNode)->GetAttribute( ATTR_PTR_KIND );
                PtrKind = pPtrAttr->GetPtrKind();
                }

            if ( pNode->FInSummary( ATTR_IGNORE ) )
                {
                SEM_ANALYSIS_CTXT * pCtxt = pExprCtxt->GetCtxt();

                // Only complain about this on the actual type, not every
                // single use of the type.

                if ( !pCtxt->AnyAncestorBits( IN_PARAM_LIST ) )
                    {
                    SemError( 
                            pNode, 
                            *pCtxt, 
                            CORRELATION_DERIVES_FROM_IGNORE_POINTER, 
                            NULL );
                    }
                }

            if ( pNode->NodeKind() != NODE_POINTER )
                {
                // probably the param or field; look down
                pNode = pNode->GetBasicType();
                }

            if ( pNode->NodeKind() != NODE_POINTER )
                {
                // error
                pNode = NULL;
                }
            else
                {
                // check things about type of pointer
                if ( PtrKind == PTR_UNKNOWN )
                    {
                    node_interface  *   pIntf   = pOrigNode->GetMyInterfaceNode();

                    if ( pOrigNode->NodeKind() == NODE_PARAM )
                        PtrKind = PTR_REF;
                    else if ( pIntf->FInSummary( ATTR_PTR_KIND ) )
                        {
                        pPtrAttr = (node_ptr_attr *)
                                        pIntf->GetAttribute( ATTR_PTR_KIND );
                        PtrKind = pPtrAttr->GetPtrKind();
                        }
                    else
                        {
                        pIntf = pExprCtxt->GetCtxt()->GetInterfaceNode();
                        if ( pIntf->FInSummary( ATTR_PTR_KIND ) )
                            {
                            pPtrAttr = (node_ptr_attr *)
                                            pIntf->GetAttribute( ATTR_PTR_KIND );
                            PtrKind = pPtrAttr->GetPtrKind();
                            }
                        else
                            {
                            if (pCommand->IsSwitchDefined( SWITCH_MS_EXT ) )
                                {
                                PtrKind = PTR_UNIQUE;
                                }
                            else
                                {
                                PtrKind = PTR_FULL;
                                }
                            }
                        }
                    }

                if ( ( PtrKind == PTR_FULL ) ||
                     ( PtrKind == PTR_UNIQUE ) )
                    {
                    SEM_ANALYSIS_CTXT * pCtxt   = pExprCtxt->GetCtxt();

                    pExprCtxt->SetUpFlags( EX_PTR_FULL_UNIQUE );
                    SemError( pCtxt->GetParent(),
                              *pCtxt,
                              SIZE_LENGTH_SW_UNIQUE_OR_FULL,
                              NULL );
                    }

                pNode = pNode->GetBasicType();
                }

            SetType( pNode );
            break;
            }
        case OP_UNARY_AND:
            {
            if ( GetType() )
                break;

            node_pointer    *   pPtr    = new node_pointer;

            pPtr->SetChild( GetLeft()->GetType() );
            SetType( pPtr );
            break;
            }
        case OP_PRE_INCR:
        case OP_PRE_DECR:
        case OP_POST_INCR:
        case OP_POST_DECR:
            {
            SetType( GetLeft()->GetType() );
            break;
            }
        default:
            {
            break;
            }
        }   // end of switch

    pExprCtxt->pType = GetType();

    // compute the value
    if ( !pExprCtxt->AnyUpFlags( EX_VALUE_INVALID ) )
        {
        // tbd - update value from LeftCtxt
        EXPR_VALUE  &   LeftValue   = LeftCtxt.Value();
        EXPR_VALUE  &   Result      = pExprCtxt->Value();


        switch ( GetOperator() )
            {
            case OP_UNARY_PLUS:
                {
                Result = LeftValue;
                break;
                }
            case OP_UNARY_MINUS:
                {
                Result = -LeftValue;
                break;
                }
            case OP_UNARY_NOT:
                {
                Result = !LeftValue;
                break;
                }
            case OP_UNARY_COMPLEMENT:
                {
                Result = ~LeftValue;
                break;
                }
            case OP_UNARY_CAST:
                {
                Result = LeftValue;
                break;
                }
            case OP_UNARY_SIZEOF:
                        case OP_UNARY_ALIGNOF:
                {
                Result = GetValue();
                break;
                }
            case OP_UNARY_INDIRECTION:
            case OP_UNARY_AND:
            case OP_PRE_INCR:
            case OP_PRE_DECR:
            case OP_POST_INCR:
            case OP_POST_DECR:
                {
                SetConstant( FALSE );
                pExprCtxt->SetUpFlags( EX_VALUE_INVALID );
                break;
                }
            default:
                {
                SetConstant( FALSE );
                Result = 0;
                break;
                }
            }   // end of case

        }  // end of if valid


}

//
// determine the type of the expression
//

void
expr_op_binary::DetermineType()
{
    node_skl    *   pLeftType   = NULL;
    node_skl    *   pRightType  = NULL;


    if ( GetLeft() )
        pLeftType   = GetLeft()->AlwaysGetType();
    if ( GetRight() )
        pRightType  = GetRight()->AlwaysGetType();

    SetConstant( GetRight()->IsConstant() && GetLeft()->IsConstant() );

    ////////////////////////////////////////////////////////////////////////
    // do type compatibility stuff

    switch ( GetOperator() )
        {
        case OP_PLUS:
        case OP_MINUS:
        case OP_STAR:
        case OP_MOD:
        // gaj - we implicitly assume signed types
        case OP_LEFT_SHIFT:
        case OP_RIGHT_SHIFT:
        case OP_AND:
        case OP_OR:
        case OP_XOR:
        case OP_SLASH:
            {
            // tbd - for now, just grab one of the types
            if ( !pRightType ||
                 (pLeftType &&
                        (pLeftType->GetSize() >= pRightType->GetSize() ) ) )
                {
                SetType( pLeftType );
                }
            else if ( pRightType )
                {
                SetType( pRightType );
                }

            break;
            }
        case OP_LOGICAL_AND:
        case OP_LOGICAL_OR:
        // gaj - we implicitly assume signed types
        case OP_LESS:
        case OP_LESS_EQUAL:
        case OP_GREATER_EQUAL:
        case OP_GREATER:
        case OP_EQUAL:
        case OP_NOT_EQUAL:
            {
            node_skl *  pTmpType;

            GetBaseTypeNode( &pTmpType, SIGN_UNDEF, SIZE_UNDEF, TYPE_BOOLEAN );

            SetType( pTmpType );
            break;
            }
        default:
            {
            break;
            }
        }



}

void
expr_op_binary::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {
    EXPR_CTXT           LeftCtxt( pExprCtxt );
    EXPR_CTXT           RightCtxt( pExprCtxt );

    if ( GetLeft() )
        {
        GetLeft()->ExprAnalyze( &LeftCtxt );
        pExprCtxt->MergeUpFlags( &LeftCtxt );
        SetConstant( IsConstant() && GetLeft()->IsConstant() );
        }
    else
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );

    if ( GetRight() )
        {
        GetRight()->ExprAnalyze( &RightCtxt );
        pExprCtxt->MergeUpFlags( &RightCtxt );
        SetConstant( IsConstant() && GetRight()->IsConstant() );

        // check here for div by zero ( could be var / 0 )
        if ( !RightCtxt.AnyUpFlags( EX_VALUE_INVALID ) &&
             ( GetOperator() == OP_SLASH ) &&
             ( RightCtxt.Value() == 0 ) )
            {
            SemError( pExprCtxt->GetNode(),
                      *(pExprCtxt->GetCtxt()),
                      EXPR_DIV_BY_ZERO,
                      NULL );
            pExprCtxt->SetUpFlags( EX_VALUE_INVALID );
            }
        }
    else
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );


    ////////////////////////////////////////////////////////////////////////
    // do type compatibility stuff

    switch ( GetOperator() )
        {
        case OP_PLUS:
        case OP_MINUS:
        case OP_STAR:
        case OP_MOD:
        // gaj - we implicitly assume signed types
        case OP_LEFT_SHIFT:
        case OP_RIGHT_SHIFT:
        case OP_AND:
        case OP_OR:
        case OP_XOR:
        case OP_SLASH:
            {
            // tbd - for now, just grab the bigger of the types
            if ( !RightCtxt.pType ||
                 (LeftCtxt.pType &&
                        (LeftCtxt.pType->GetSize() >= RightCtxt.pType->GetSize() ) ) )
                {
                pExprCtxt->pType = LeftCtxt.pType;
                pExprCtxt->TypeInfo = LeftCtxt.TypeInfo;
                pExprCtxt->fIntegral = LeftCtxt.fIntegral;
                SetType( pExprCtxt->pType );
                }
            else if ( RightCtxt.pType )
                {
                pExprCtxt->pType = RightCtxt.pType;
                pExprCtxt->TypeInfo = RightCtxt.TypeInfo;
                pExprCtxt->fIntegral = RightCtxt.fIntegral;
                SetType( pExprCtxt->pType );
                }

            break;
            }
        case OP_LOGICAL_AND:
        case OP_LOGICAL_OR:
        // gaj - we implicitly assume signed types
        case OP_LESS:
        case OP_LESS_EQUAL:
        case OP_GREATER_EQUAL:
        case OP_GREATER:
        case OP_EQUAL:
        case OP_NOT_EQUAL:
            {
            pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
            pExprCtxt->TypeInfo.BaseType = TYPE_BOOLEAN;
            pExprCtxt->TypeInfo.TypeSign = SIGN_UNDEF;
            GetBaseTypeNode( &(pExprCtxt->pType ), pExprCtxt->TypeInfo );

            pExprCtxt->fIntegral = TRUE;
            SetType( pExprCtxt->pType );
            break;
            }
        default:
            {
            break;
            }
        }


    ////////////////////////////////////////////////////////////////////////
    // compute the value

    if ( !pExprCtxt->AnyUpFlags( EX_VALUE_INVALID ) )
        {
        // update value directly from LeftCtxt and RightCtxt
        EXPR_VALUE  &       LeftValue   = LeftCtxt.Value();
        EXPR_VALUE  &       RightValue  = RightCtxt.Value();
        EXPR_VALUE  &       Result      = pExprCtxt->Value();

        switch ( GetOperator() )
            {
            case OP_PLUS:
                {
                Result = LeftValue + RightValue;
                break;
                }
            case OP_MINUS:
                {
                Result = LeftValue - RightValue;
                break;
                }
            case OP_STAR:
                {
                Result = LeftValue * RightValue;
                break;
                }
            case OP_SLASH:
                {
                if (RightValue == 0)
                    Result = 0;
                else
                    Result = LeftValue / RightValue;
                break;
                }
            case OP_MOD:
                {
                Result = LeftValue % RightValue;
                break;
                }
            case OP_LOGICAL_AND:
                {
                Result = LeftValue && RightValue;
                break;
                }
            case OP_LOGICAL_OR:
                {
                Result = LeftValue || RightValue;
                break;
                }
            // gaj - we implicitly assume signed types
            case OP_LESS:
                {
                Result = LeftValue < RightValue;
                break;
                }
            case OP_LESS_EQUAL:
                {
                Result = LeftValue <= RightValue;
                break;
                }
            case OP_GREATER_EQUAL:
                {
                Result = LeftValue >= RightValue;
                break;
                }
            case OP_GREATER:
                {
                Result = LeftValue > RightValue;
                break;
                }
            case OP_EQUAL:
                {
                Result = LeftValue == RightValue;
                break;
                }
            case OP_NOT_EQUAL:
                {
                Result = LeftValue != RightValue;
                break;
                }
            // gaj - we implicitly assume signed types
            case OP_LEFT_SHIFT:
                {
                Result = LeftValue << RightValue;
                break;
                }
            case OP_RIGHT_SHIFT:
                {
                Result = LeftValue >> RightValue;
                break;
                }
            case OP_AND:
                {
                Result = LeftValue & RightValue;
                break;
                }
            case OP_OR:
                {
                Result = LeftValue | RightValue;
                break;
                }
            case OP_XOR:
                {
                Result = LeftValue ^ RightValue;
                break;
                }
            default:
                {
                Result = 0;
                break;
                }
            }

        }

    }

//
// determine the type of the expression
//

void
expr_ternary::DetermineType()
{
    node_skl    *   pLeftType   = NULL;
    node_skl    *   pRightType  = NULL;


    if ( GetLeft() )
        pLeftType   = GetLeft()->AlwaysGetType();
    if ( GetRight() )
        pRightType  = GetRight()->AlwaysGetType();

    SetConstant( GetRight()->IsConstant() && GetLeft()->IsConstant() );

    if ( pLeftType )
        SetType( pLeftType );
    else if ( pRightType )
        SetType( pRightType );

}

void
expr_ternary::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {
    EXPR_CTXT           LeftCtxt( pExprCtxt );
    EXPR_CTXT           RightCtxt( pExprCtxt );
    EXPR_CTXT           RelCtxt( pExprCtxt );

    if ( GetLeft() )
        {
        GetLeft()->ExprAnalyze( &LeftCtxt );
        pExprCtxt->MergeUpFlags( &LeftCtxt );
        SetConstant( IsConstant() && GetLeft()->IsConstant() );
        }
    else
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );

    if ( GetRight() )
        {
        GetRight()->ExprAnalyze( &RightCtxt );
        pExprCtxt->MergeUpFlags( &RightCtxt );
        SetConstant( IsConstant() && GetRight()->IsConstant() );
        }
    else
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );

    if ( GetRelational() )
        {
        GetRelational()->ExprAnalyze( &RelCtxt );
        pExprCtxt->MergeUpFlags( &RelCtxt );
        SetConstant( IsConstant() && GetRelational()->IsConstant() );
        }
    else
        pExprCtxt->SetUpFlags( EX_VALUE_INVALID );


    // tbd - get the type from the left or right of the ':'
    if ( LeftCtxt.pType )
        {
        pExprCtxt->pType = LeftCtxt.pType;
        pExprCtxt->TypeInfo = LeftCtxt.TypeInfo;
        pExprCtxt->fIntegral = LeftCtxt.fIntegral;
        SetType( pExprCtxt->pType );
        }
    else if ( RightCtxt.pType )
        {
        pExprCtxt->pType = RightCtxt.pType;
        pExprCtxt->TypeInfo = RightCtxt.TypeInfo;
        pExprCtxt->fIntegral = RightCtxt.fIntegral;
        SetType( pExprCtxt->pType );
        }
    else
        SetType( NULL );

    ////////////////////////////////////////////////////////////////////////
    // compute the value

    if ( !pExprCtxt->AnyUpFlags( EX_VALUE_INVALID ) )
        {
        // update value directly from LeftCtxt and RightCtxt
        EXPR_VALUE  &       LeftValue   = LeftCtxt.Value();
        EXPR_VALUE  &       RightValue  = RightCtxt.Value();
        EXPR_VALUE  &       RelValue    = RelCtxt.Value();
        EXPR_VALUE  &       Result      = pExprCtxt->Value();

        Result = (RelValue) ? LeftValue : RightValue;

        }

    }

//
// determine the type of the expression
//

void
expr_variable::DetermineType()
{
    if ( pType->NodeKind() == NODE_FORWARD )
        {
        node_forward *  pFwd = (node_forward *) pType;
        // (permanently) resolve the forward
        pType = pFwd->ResolveFDecl();

        // This appears to be a better fix for the problem of unresolved
        // variables in async size expressions than the NULL type pointer check
        // in Fixup[Begin|Finish]ProcExpr in front\copyto.cxx.  However, at this
        // time we don't fully understand the implications of this change while
        // the other is localized to the async_uuid interfaces only.
        // e.g. ([in] long size, [in, size_is(huh)] long *p)
        // 03-May-99 MikeW
/*
        // if it couldn't be resolved, put back the forward
        if ( !pType )
            {
            pType = pFwd;
            }
*/
        }
}

void
expr_variable::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {
    pExprCtxt->SetUpFlags( EX_VALUE_INVALID );
    pExprCtxt->SetUpFlags( EX_NON_NUMERIC );

    if ( !pType )
        {
        pExprCtxt->SetUpFlags( EX_UNSAT_FWD );
        return;
        }

    if ( pType->NodeKind() == NODE_FORWARD )
        {
        node_forward *  pFwd = (node_forward *) pType;
        // (permanently) resolve the forward
        pType = pFwd->ResolveFDecl();
        // if it couldn't be resolved, put back the forward
        if ( !pType )
            {
            pExprCtxt->SetUpFlags( EX_UNSAT_FWD );
            pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
            pExprCtxt->TypeInfo.BaseType = TYPE_INT;
            pExprCtxt->TypeInfo.TypeSign = SIGN_SIGNED;
            GetBaseTypeNode( &pType, pExprCtxt->TypeInfo);
            pExprCtxt->pType = pType;
            return;
            }
        }

    // do type compatibility stuff
    pExprCtxt->pType = pType;
    pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
    pExprCtxt->TypeInfo.BaseType = TYPE_UNDEF;
    pExprCtxt->TypeInfo.TypeSign = SIGN_UNDEF;
    pExprCtxt->fIntegral = FALSE; // for now...

    if ( ( pType->NodeKind() == NODE_PARAM ) &&
          pType->FInSummary( ATTR_OUT ) &&
         !pType->FInSummary( ATTR_IN ) )
        pExprCtxt->SetUpFlags( EX_OUT_ONLY_PARAM );

    }

//
// determine the type of the expression
//

void
expr_named_constant::DetermineType()
{
    // do type compatibility stuff
    if ( !GetType() )
        {
        SetType( GetExpr()->AlwaysGetType() );
        }

}

void
expr_named_constant::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {
    // named constants shouldn't be folded away
    pExprCtxt->SetUpFlags( EX_NON_NUMERIC );

    // update value
    pExprCtxt->Value() = GetValue();

    // do type compatibility stuff
    if ( GetType() )
        {
        pExprCtxt->pType = GetType();
        pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
        pExprCtxt->TypeInfo.BaseType = TYPE_UNDEF;
        pExprCtxt->TypeInfo.TypeSign = SIGN_UNDEF;
        pExprCtxt->fIntegral = FALSE; // for now...
        }
    else
        {
        EXPR_CTXT       LeftCtxt( pExprCtxt );
        expr_node   *   pExpr   = GetExpr();

        pExpr->ExprAnalyze( &LeftCtxt );

        pExprCtxt->pType = LeftCtxt.pType;
        pExprCtxt->TypeInfo = LeftCtxt.TypeInfo;
        pExprCtxt->fIntegral = LeftCtxt.fIntegral;
        SetType( pExprCtxt->pType );
        }


    }

//
// determine the type of the expression
//

void
expr_constant::DetermineType()
{
    node_skl* pNewType = 0;

    // do type compatibility stuff
    if ( GetType() )
        return;

    // do type compatibility stuff
    switch (Format)
        {
        case VALUE_TYPE_STRING:
            {
            node_skl    *   pBottomType;
            GetBaseTypeNode( &pBottomType,
                             SIGN_SIGNED,
                             SIZE_CHAR,
                             TYPE_INT );
            pNewType = new node_pointer;
            pNewType->SetChild( pBottomType );
            break;
            }
        case VALUE_TYPE_WSTRING:
            {
            node_skl    *   pBottomType;
            SymKey  SKey( "wchar_t", NAME_DEF );

            pBottomType = pBaseSymTbl->SymSearch( SKey );
            pNewType = new node_pointer;
            pNewType->SetChild( pBottomType );
            break;
            }
        case VALUE_TYPE_CHAR:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_SIGNED,
                             SIZE_CHAR,
                             TYPE_INT );
            break;
            }
        case VALUE_TYPE_WCHAR:
            {
            SymKey  SKey( "wchar_t", NAME_DEF );

            pNewType    = pBaseSymTbl->SymSearch( SKey );
            break;
            }
        case VALUE_TYPE_NUMERIC:
        case VALUE_TYPE_HEX:
        case VALUE_TYPE_OCTAL:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_SIGNED,
                             SIZE_UNDEF,
                             TYPE_INT );
            break;
            }
        case VALUE_TYPE_NUMERIC_U:
        case VALUE_TYPE_HEX_U:
        case VALUE_TYPE_OCTAL_U:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_UNSIGNED,
                             SIZE_SHORT,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_NUMERIC_LONG:
        case VALUE_TYPE_HEX_LONG:
        case VALUE_TYPE_OCTAL_LONG:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_SIGNED,
                             SIZE_LONG,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_NUMERIC_ULONG:
        case VALUE_TYPE_HEX_ULONG:
        case VALUE_TYPE_OCTAL_ULONG:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_UNSIGNED,
                             SIZE_LONG,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_BOOL:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_BOOLEAN );
            break;
            }

        case VALUE_TYPE_FLOAT:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_FLOAT );
            break;
            }
        case VALUE_TYPE_DOUBLE:
            {
            GetBaseTypeNode( &pNewType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_DOUBLE );
            break;
            }

        default:
            break;
        }
    SetType( pNewType );
}

void
expr_constant::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {

    // update value
    pExprCtxt->Value() = GetValue();

    if ( GetType() )
        {
        pExprCtxt->pType = GetType();
        pExprCtxt->TypeInfo.TypeSize = SIZE_UNDEF;
        pExprCtxt->TypeInfo.BaseType = TYPE_UNDEF;
        pExprCtxt->TypeInfo.TypeSign = SIGN_UNDEF;
        pExprCtxt->fIntegral = FALSE; // for now...
        return;
        }

    // do type compatibility stuff
    switch (Format)
        {
        case VALUE_TYPE_STRING:
            {
            node_skl    *   pBottomType;
            GetBaseTypeNode( &pBottomType,
                             SIGN_SIGNED,
                             SIZE_CHAR,
                             TYPE_INT );
            pExprCtxt->pType = new node_pointer;
            pExprCtxt->pType->SetChild( pBottomType );
            break;
            }
        case VALUE_TYPE_WSTRING:
            {
            node_skl    *   pBottomType;
            SymKey  SKey( "wchar_t", NAME_DEF );

            pBottomType = pBaseSymTbl->SymSearch( SKey );
            pExprCtxt->pType = new node_pointer;
            pExprCtxt->pType->SetChild( pBottomType );
            break;
            }
        case VALUE_TYPE_CHAR:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_SIGNED,
                             SIZE_CHAR,
                             TYPE_INT );
            break;
            }
        case VALUE_TYPE_WCHAR:
            {
            SymKey  SKey( "wchar_t", NAME_DEF );

            pExprCtxt->pType    = pBaseSymTbl->SymSearch( SKey );
            break;
            }
        case VALUE_TYPE_NUMERIC:
        case VALUE_TYPE_HEX:
        case VALUE_TYPE_OCTAL:
            {
            short   RealSize    = SIZE_HYPER;
            __int64 val         = GetValue();

            if ( (val <= 127) && (val >= -128 ) )
                RealSize = SIZE_CHAR;
            else if ( (val <= _I16_MAX) && (val >= _I16_MIN ) )
                RealSize = SIZE_SHORT;
            else if ( (val <= _I32_MAX) && (val >= _I32_MIN ) )
                RealSize = SIZE_LONG;

            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_SIGNED,
                             RealSize,
                             TYPE_INT );
            break;
            }
        case VALUE_TYPE_NUMERIC_U:
        case VALUE_TYPE_HEX_U:
        case VALUE_TYPE_OCTAL_U:
            {
            short RealSize      = SIZE_LONG;
            unsigned long  val  = (unsigned long) GetValue();

            if ( val <= 255 )
                RealSize = SIZE_CHAR;
            else if ( val <= 65536 )
                RealSize = SIZE_SHORT;

            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_UNSIGNED,
                             RealSize,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_NUMERIC_LONG:
        case VALUE_TYPE_HEX_LONG:
        case VALUE_TYPE_OCTAL_LONG:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_SIGNED,
                             SIZE_LONG,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_NUMERIC_ULONG:
        case VALUE_TYPE_HEX_ULONG:
        case VALUE_TYPE_OCTAL_ULONG:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_UNSIGNED,
                             SIZE_LONG,
                             TYPE_INT );
            break;
            }

        case VALUE_TYPE_BOOL:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_BOOLEAN );
            break;
            }

        case VALUE_TYPE_FLOAT:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_FLOAT );
            break;
            }
        case VALUE_TYPE_DOUBLE:
            {
            GetBaseTypeNode( &pExprCtxt->pType,
                             SIGN_UNDEF,
                             SIZE_UNDEF,
                             TYPE_DOUBLE );
            break;
            }

        default:
            break;
        }
    SetType( pExprCtxt->pType );
    }

//
// determine the type of the expression
//

void
expr_init_list::DetermineType()
{
    SetType( pExpr->AlwaysGetType() );
}

void
expr_init_list::ExprAnalyze( EXPR_CTXT * pExprCtxt )
    {

    // tbd - for now only process first element
    pExpr->ExprAnalyze( pExprCtxt );
    SetConstant( pExpr->IsConstant() );
    SetType( pExpr->GetType() );

    }

short
expr_op_binary::MakeListOfDerefedVars( ITERATOR& List )
    {
    if( GetLeft() )
        GetLeft()->MakeListOfDerefedVars( List );

    if( GetRight() )
        GetRight()->MakeListOfDerefedVars( List );
    return (short) ITERATOR_GETCOUNT( List );
    }

short
expr_u_deref::MakeListOfDerefedVars( ITERATOR& List )
    {
    expr_node * pLeft = GetLeft();

    if( !pLeft ) return 0;

    if( pLeft->IsAVariable() )
        ITERATOR_INSERT( List, pLeft );
    else if( pLeft->GetOperator() == OP_UNARY_INDIRECTION )
        pLeft->MakeListOfDerefedVars( List );

    return ITERATOR_GETCOUNT( List );
    }

BOOL
expr_b_arithmetic::GetExprValue( SExprValue& v )
    {
    SExprValue  LeftValue  = {VALUE_TYPE_UNDEFINED, 0};
    SExprValue  RightValue = {VALUE_TYPE_UNDEFINED, 0};
    BOOL        fSuccess;

    fSuccess =  GetLeft()->GetExprValue( LeftValue ) &&
                GetRight()->GetExprValue( RightValue ) &&
                (LeftValue.format == VALUE_TYPE_DOUBLE || LeftValue.format == VALUE_TYPE_DOUBLE) && 
                (RightValue.format == VALUE_TYPE_DOUBLE || RightValue.format == VALUE_TYPE_DOUBLE);

    if (fSuccess)
        {
        v.format = LeftValue.format == VALUE_TYPE_DOUBLE || RightValue.format == VALUE_TYPE_DOUBLE ?
                    VALUE_TYPE_DOUBLE : VALUE_TYPE_FLOAT ;
        double l = LeftValue.format == VALUE_TYPE_DOUBLE ? LeftValue.d : LeftValue.f ;
        double r = RightValue.format == VALUE_TYPE_DOUBLE ? RightValue.d : RightValue.f ;
    
        switch ( GetOperator() )
            {
            case OP_PLUS:
                l += r;
                break;
            case OP_MINUS:
                l -= r;
                break;
            case OP_STAR:
                l *= r;
                break;
            case OP_SLASH:
                __try 
                    {
                    l /= r;
                    }
                __except (EXCEPTION_EXECUTE_HANDLER)
                    {
                    fSuccess = FALSE;
                    }
                break;
            }
        if (v.format == VALUE_TYPE_FLOAT)
            {
            v.f = (float) l;
            }
        else if (v.format == VALUE_TYPE_DOUBLE)
            {
            v.d = l;
            }
        }
    return fSuccess;
    }

BOOL
expr_u_arithmetic::GetExprValue( SExprValue& v )
{
    SExprValue  LeftValue = {VALUE_TYPE_UNDEFINED, 0};
    BOOL        fSuccess  = GetLeft()->GetExprValue( LeftValue );

    if (fSuccess)
        {
        v = LeftValue;
        if (GetOperator() == OP_UNARY_MINUS)
            {
            switch ( v.format )
                {
                case VALUE_TYPE_FLOAT:
                    v.f = -LeftValue.f;
                    break;
                case VALUE_TYPE_DOUBLE:
                    v.d = -LeftValue.d;
                    break;
                default:
                    fSuccess = FALSE;
                    break;
                }
            }
        }
    return fSuccess;
}

void
expr_node::CopyTo( expr_node* lhs )
    {
    DetermineType();
    lhs->pType       = pType;
    lhs->fFloatExpr  = fFloatExpr;
    lhs->fConstant   = fConstant;
    }

void
expr_constant::CopyTo( expr_node* pExpr )
    {
    expr_constant* lhs = (expr_constant*) pExpr;
    expr_node::CopyTo( lhs );
    lhs->Format = Format;
    lhs->Value  = Value;
    }

void
expr_init_list::CopyTo( expr_node* pExpr )
    {
    expr_init_list* lhs = (expr_init_list*) pExpr;
    expr_node::CopyTo( lhs );
    lhs->pSibling = (expr_init_list*)pSibling->Clone();
    pSibling->CopyTo(lhs->pSibling);
    lhs->pExpr = pExpr->Clone();
    pExpr->CopyTo(lhs->pExpr);
    }

void
expr_operator::CopyTo( expr_node* pExpr )
    {
    expr_operator* lhs = (expr_operator*) pExpr;
    expr_node::CopyTo( lhs );
    lhs->Operator = Operator;
    }

void
expr_op_binary::CopyTo( expr_node* pExpr )
    {
    expr_op_binary* lhs = (expr_op_binary*) pExpr;
    expr_operator::CopyTo( lhs );
    lhs->pLeft = pLeft->Clone();
    pLeft->CopyTo(lhs->pLeft);
    lhs->pRight = pRight->Clone();
    pRight->CopyTo(lhs->pRight);
    }

void
expr_param::CopyTo( expr_node* pExpr )
    {
    expr_param* lhs = (expr_param*) pExpr;
    expr_op_binary::CopyTo( lhs );
    _STRDUP( lhs->pName, pName );
    }

void
expr_op_unary::CopyTo( expr_node* pExpr )
    {
    expr_op_unary* lhs = (expr_op_unary*) pExpr;
    expr_operator::CopyTo( lhs );
    lhs->pLeft = pLeft->Clone();
    pLeft->CopyTo(lhs->pLeft);
    }

void
expr_cast::CopyTo( expr_node* pExpr )
    {
    expr_cast* lhs = (expr_cast*) pExpr;
    expr_op_unary::CopyTo( lhs );
    lhs->fEmitModifiers  = fEmitModifiers;
    lhs->pCastType       = pCastType;
    }

void
expr_proc_call::CopyTo( expr_node* pExpr )
    {
    expr_proc_call* lhs = (expr_proc_call*) pExpr;
    expr_op_unary::CopyTo( lhs );
    _STRDUP( lhs->pName, pName );
    lhs->NoOfParams = NoOfParams;
    }

void
expr_sizeof::CopyTo( expr_node* pExpr )
    {
    expr_sizeof* lhs = (expr_sizeof*) pExpr;
    expr_op_unary::CopyTo( lhs );
    lhs->pType = pType;
    }

void
expr_alignof::CopyTo( expr_node* pExpr )
    {
    expr_alignof* lhs = (expr_alignof*) pExpr;
    expr_op_unary::CopyTo( lhs );
    lhs->pType = pType;
    }

void
expr_ternary::CopyTo( expr_node* pExpr )
    {
    expr_ternary* lhs = (expr_ternary*) pExpr;
    expr_operator::CopyTo( lhs );
    lhs->pLeft = pLeft->Clone();
    pLeft->CopyTo(lhs->pLeft);
    lhs->pRight = pRight->Clone();
    pRight->CopyTo(lhs->pRight);
    lhs->pRelational = pRelational->Clone();
    pRelational->CopyTo(lhs->pRelational);
    }

void
expr_variable::CopyTo( expr_node* pExpr )
    {
    expr_variable* lhs = (expr_variable*) pExpr;
    expr_node::CopyTo( lhs );
    _STRDUP( lhs->pIDName, pIDName );
    _STRDUP( lhs->pPrefix, pPrefix );
    }

expr_node*
expr_ternary::Clone()
    {
    return new expr_ternary(OP_ILLEGAL,0,0,0);
    }