}/********************************************************************************* printValue - print out value*/LOCAL void printValue (pValue)    FAST VALUE *pValue;    {    if (pValue->side == LHS)	{	if (checkLv (pValue) && checkRv (pValue))	    {	    printLv (pValue);	    printf (": value = ");	    printRv (pValue);	    printf ("\n");	    }	else	    {	    printf ("invalid lhs.\n");	    SET_ERROR;	    }	}    else if (checkRv (pValue))	{	printf ("value = ");	printRv (pValue);	printf ("\n");	}    else	{	printf ("invalid rhs.\n");	SET_ERROR;	}    }/* TYPE SUPPORT */LOCAL VALUE evalUnknown ();LOCAL VALUE evalByte ();LOCAL VALUE evalWord ();LOCAL VALUE evalInt ();LOCAL VALUE evalFloat ();LOCAL VALUE evalDouble ();typedef struct		/* EVAL_TYPE */    {    VALUE (*eval) ();    } EVAL_TYPE;LOCAL EVAL_TYPE evalType [] =    {    /*	eval		type		*/    /*	---------------	--------------	*/      { evalUnknown,	/* T_UNKNOWN*/	},      { evalByte,	/* T_BYTE   */	},      { evalWord,	/* T_WORD   */	},      { evalInt,	/* T_INT    */	},#ifndef	_WRS_NO_TGT_SHELL_FP      { evalFloat,	/* T_FLOAT  */	},      { evalDouble,	/* T_DOUBLE */	},#endif	/* _WRS_NO_TGT_SHELL_FP */    };/********************************************************************************* evalExp - evaluate expression*/LOCAL VALUE evalExp (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {    VALUE *p1 = pValue1;    VALUE *p2 = pValue2;    if (pValue2 == NULLVAL) /* unary expresions must set pValue2 to something */	p2 = pValue2 = pValue1;    /* make sure values have the same type */    if ((int)p1->type > (int)p2->type)	typeConvert (p2, p1->type, p1->side);    else	typeConvert (p1, p2->type, p2->side);    return ((evalType[(int)pValue1->type].eval) (pValue1, op, pValue2));    }/********************************************************************************* evalUnknown - evaluate for unknown result** ARGSUSED*/LOCAL VALUE evalUnknown (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {    printf ("evalUnknown: bad evaluation.\n");    SET_ERROR;    return (*pValue1);	/* have to return something */    }/********************************************************************************* evalByte - evaluate for byte result*/LOCAL VALUE evalByte (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {    VALUE *p1 = pValue1;    VALUE *p2 = pValue2;    VALUE result;    /* evaluate as integers and then convert back */    typeConvert (p1, T_INT, RHS);    typeConvert (p2, T_INT, RHS);    result = evalInt (p1, op, p2);    typeConvert (&result, T_BYTE, RHS);    return (result);    }/********************************************************************************* evalWord - evaluate for word result*/LOCAL VALUE evalWord (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {    VALUE *p1 = pValue1;    VALUE *p2 = pValue2;    VALUE result;    /* evaluate as integers and then convert back */    typeConvert (p1, T_INT, RHS);    typeConvert (p2, T_INT, RHS);    result = evalInt (p1, op, p2);    typeConvert (&result, T_WORD, RHS);    return (result);    }/********************************************************************************* evalInt - evaluate for integer result*/LOCAL VALUE evalInt (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {#define	OP_INT(op)	rv = e1 op e2; break#define	OP_INT_U(op)	rv = op e1; break    FAST int e1 = pValue1->value.rv;    FAST int e2 = pValue2->value.rv;    FAST int rv;    VALUE result;    switch (op)	{	case ADDA:	case '+':	    OP_INT(+);	case SUBA:	case '-':	    OP_INT(-);	case MULA:	case '*':	    OP_INT(*);	case DIVA:	case '/':	    OP_INT(/);	case '!':	    OP_INT_U(!);	case '~':	    OP_INT_U(~);	case MODA:	case '%':	    OP_INT(%);	case ANDA:	case '&':	    OP_INT(&);	case XORA:	case '^':	    OP_INT(^);	case ORA:	case '|':	    OP_INT(|);	case '<':	    OP_INT(<);	case '>':	    OP_INT(>);	case OR:	    OP_INT(||);	case AND:	    OP_INT(&&);	case EQ:	    OP_INT(==);	case NE:	    OP_INT(!=);	case GE:	    OP_INT(>=);	case LE:	    OP_INT(<=);	case INCR:	    OP_INT_U(++);	case DECR:	    OP_INT_U(--);	case SHLA:	case ROT_LEFT:	    OP_INT(<<);	case SHRA:	case ROT_RIGHT:	    OP_INT(>>);	case UMINUS:	    OP_INT_U(-);	default:	    rv = 0;	    printf ("operands have incompatible types.\n");	    SET_ERROR;	}    result.side     = RHS;    result.type     = pValue1->type;    result.value.rv = rv;    return (result);    }#ifndef	_WRS_NO_TGT_SHELL_FP/********************************************************************************* evalFloat - evaluate for float result*/LOCAL VALUE evalFloat (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {    VALUE *p1 = pValue1;    VALUE *p2 = pValue2;    VALUE result;    /* evaluate as doubles and then convert back */    typeConvert (p1, T_DOUBLE, RHS);    typeConvert (p2, T_DOUBLE, RHS);    result = evalDouble (p1, op, p2);    typeConvert (&result, T_FLOAT, RHS);    return (result);    }/********************************************************************************* evalDouble - evaluate for double result*/LOCAL VALUE evalDouble (pValue1, op, pValue2)    VALUE *pValue1;    int op;    VALUE *pValue2;    {#define	OP_DOUBLE(op)	dp = e1 op e2; break#define	OP_DOUBLE_U(op)	dp = op e1; break    FAST double e1 = pValue1->value.dp;    FAST double e2 = pValue2->value.dp;    FAST double dp;    VALUE result;    switch (op)	{	case ADDA:	case '+':	    OP_DOUBLE(+);	case SUBA:	case '-':	    OP_DOUBLE(-);	case MULA:	case '*':	    OP_DOUBLE(*);	case DIVA:	case '/':	    OP_DOUBLE(/);	case '!':	    OP_DOUBLE_U(!);	case '<':	    OP_DOUBLE(<);	case '>':	    OP_DOUBLE(>);	case OR:	    OP_DOUBLE(||);	case AND:	    OP_DOUBLE(&&);	case EQ:	    OP_DOUBLE(==);	case NE:	    OP_DOUBLE(!=);	case GE:	    OP_DOUBLE(>=);	case LE:	    OP_DOUBLE(<=);	case INCR:	    OP_DOUBLE_U(++);	case DECR:	    OP_DOUBLE_U(--);	case UMINUS:	    OP_DOUBLE_U(-);	default:	    dp = 0;	    printf ("operands have incompatible types.\n");	    SET_ERROR;	}    result.side     = RHS;    result.type     = T_DOUBLE;    result.value.dp = dp;    return (result);    }#endif	/* _WRS_NO_TGT_SHELL_FP *//* TYPE CONVERSION */LOCAL void convUnknown ();LOCAL void convByte ();LOCAL void convWord ();LOCAL void convInt ();#ifndef	_WRS_NO_TGT_SHELL_FPLOCAL void convFloat ();LOCAL void convDouble ();#endif	/* _WRS_NO_TGT_SHELL_FP */typedef void (*VOID_FUNCPTR) ();	/* ptr to a function returning void */LOCAL VOID_FUNCPTR convType [] =    {    /*  conversion	type	    */    /*  ----------	----------- */	convUnknown,	/* T_UNKNOWN*/	convByte,	/* T_BYTE   */	convWord,	/* T_WORD   */	convInt,	/* T_INT    */#ifndef	_WRS_NO_TGT_SHELL_FP	convFloat,	/* T_FLOAT  */	convDouble,	/* T_DOUBLE */#endif	/* _WRS_NO_TGT_SHELL_FP */    };/********************************************************************************* typeConvert - change value to specified type*/LOCAL void typeConvert (pValue, type, side)    FAST VALUE *pValue;    TYPE type;    SIDE side;    {    if (side == FHS)	{	pValue->side = RHS;	pValue->type = type;	}    else if (side == RHS)	{	if (pValue->side == LHS)	    pValue->type = type;	else	    (convType [(int) type]) (pValue);	}    else if (pValue->side == LHS)	pValue->type = type;    else	{	printf ("typeConvert: bad type.\n");	SET_ERROR;	}    }/********************************************************************************* convUnknown - convert value to unknown** ARGSUSED*/LOCAL void convUnknown (pValue)    VALUE *pValue;    {    printf ("convUnknown: bad type.\n");    SET_ERROR;    }/********************************************************************************* convByte - convert value to byte*/LOCAL void convByte (pValue)    FAST VALUE *pValue;    {    char value;    if ((int)pValue->type > (int)T_BYTE)	{	convWord (pValue);	value = pValue->value.word;	pValue->value.byte = value;	pValue->type = T_BYTE;	}    }/********************************************************************************* convWord - convert value to word*/LOCAL void convWord (pValue)    FAST VALUE *pValue;    {    short value;    if ((int)pValue->type < (int)T_WORD)	{	value = pValue->value.byte;	pValue->value.word = value;	pValue->type = T_WORD;	}    else if ((int)pValue->type > (int)T_WORD)	{	convInt (pValue);	value = pValue->value.rv;	pValue->value.word = value;	pValue->type = T_WORD;	}    }/********************************************************************************* convInt - convert value to integer*/LOCAL void convInt (pValue)    FAST VALUE *pValue;    {    int value;    if ((int)pValue->type < (int)T_INT)	{	convWord (pValue);	value = pValue->value.word;	pValue->value.rv = value;	pValue->type = T_INT;	}    else if ((int)pValue->type > (int)T_INT)	{#ifndef	_WRS_NO_TGT_SHELL_FP	convFloat (pValue);	value = pValue->value.fp;	pValue->value.rv = value;	pValue->type = T_INT;#endif	/* _WRS_NO_TGT_SHELL_FP */	}    }#ifndef	_WRS_NO_TGT_SHELL_FP/********************************************************************************* convFloat - convert value to float*/LOCAL void convFloat (pValue)    FAST VALUE *pValue;    {    float value;    if ((int)pValue->type < (int)T_FLOAT)	{	convInt (pValue);	value = pValue->value.rv;	pValue->value.fp = value;	pValue->type = T_FLOAT;	}    else if ((int)pValue->type > (int)T_FLOAT)	{	convDouble (pValue);	value = pValue->value.dp;	pValue->value.fp = value;	pValue->type = T_FLOAT;	}    }/********************************************************************************* convDouble - convert value to double*/LOCAL void convDouble (pValue)    FAST VALUE *pValue;    {    double value;    if ((int)pValue->type < (int)T_DOUBLE)	{	convFloat (pValue);	value = pValue->value.fp;	pValue->value.dp = value;	pValue->type = T_DOUBLE;	}    }#endif	/* _WRS_NO_TGT_SHELL_FP */