able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/midl/expr/expr.cxx

2075 lines
53 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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);
}
Reference in a new issue Copy permalink