/***
*eval.c - if expression evaluator
*
* Copyright (c) 1992-2001, Microsoft Corporation. All rights reserved.
*
*Purpose:
* produce truth values and simplified conditions from compound if
* statements.
*
*Revision History:
* 09-30-92 MAL Original version
* 10-13-93 SKS Recognize comments of the form /-*IFSTRIP=IGN*-/ to
* override ifstrip behavior.
* 09-01-94 SKS Add support for more operators: == != < > <= >=
* Add terseflag (-t) to suppress mesgs about directives
* 10-04-94 SKS Add support for more operators: EQ NE LT GT LE NE
* @ is an identifier character (e.g., MASM's @Version)
* 01-04-00 GB Add support for internal crt builds
*
*******************************************************************************/
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "eval.h" /* Header for this module */
#include "symtab.h" /* Symbol table access */
#include "constant.h" /* Constants for tokens etc */
#include "errormes.h" /* Errors and Warning messages */
/* Types */
typedef struct condrec
{
int truth;
char *condition;
} condrec, *cond;
/* Global variables */
extern int terseFlag; /* controls display of forced directives */
extern char **comments; /* Language dependent comment strings */
extern int *commlen; /* Lengths of above strings */
extern int nonumbers; /* allow numeric expressions */
extern enum {NON_CRT = 0, CRT = 1} progtype;
char *operators[] = {
"!", "(", ")", "||", "&&", "defined" ,
"==" , "!=" , "<" , ">" , "<=" , ">=" ,
"EQ" , "NE" , "LT" , "GT" , "LE" , "GE" };
int oplengths[] = {
1 , 1 , 1 , 2 , 2 , 7 ,
2 , 2 , 1 , 1 , 2 , 2 ,
2 , 2 , 2 , 2 , 2 , 2 };
/* # significant chars */
#define numoperators 18
/* These tokens must be in the same order as 'operators' */
#define NOT 0
#define OPENPARENTHESIS 1
#define CLOSEPARENTHESIS 2
#define OR 3
#define AND 4
#define DEFINEDFN 5
#define EQUALS 6
#define NOTEQUALS 7
#define LESSTHAN 8
#define LESSOREQ 9
#define GREATERTHAN 10
#define GREATEROREQ 11
#define EQUALS_ASM 12
#define NOTEQUALS_ASM 13
#define LESSTHAN_ASM 14
#define LESSOREQ_ASM 15
#define GREATERTHAN_ASM 16
#define GREATEROREQ_ASM 17
#define UINT 100
#define ID 101
#define ENDOFLINE 102
#define UNKNOWN 103
/* Global state */
/* String holding input, the current pointer into it, and the current token */
char conditions[MAXLINELEN], *tokenptr, currenttoken[MAXCONDLEN];
int token = -1;
/* Function prototypes */
cond evaluateexpression(void);
cond orexpression(void);
cond andexpression(void);
cond unaryexpression(void);
cond parenthesesexpression(void);
cond atomicexpression(void);
cond createcondition(void);
void destroycondition(cond);
char *createstring(int);
void destroystring(char *);
void gettoken(void);
int issymbolchar(char);
/* CFW - added complex expression warning */
void evalwarn()
{
warning("cannot parse expression - ignoring", conditions);
}
/*
* Comments may be in the input source which contain IFSTRIP Directives:
*
* For C source they should look like:
*
* #if foo>bar !*IFSTRIP=DEF*! '!' here stands for '/'
*
* and for Assembler source they should look like:
*
* if foo ;;IFSTRIP=UND;;
*
* Note that the directive and an optional preceding blank or tab
* are deleted from the input source. The directive can thus be
* followed by a backslash to continue the line, another comment, etc.
*/
static char IfStripCStr[] =
"/*IFSTRIP="; /* -*IFSTRIP=IGN*- */
static char IfStripAStr[] =
/*0123456789*- -* 0123456789012345 */
";;IFSTRIP="; /* ;;IFSTRIP=IGN;; */
/* IGN may also be DEF or UND */
#define IFSTRIPVALOFF 10
#define IFSTRIPVALEND 13
#define IFSTRIPVALLEN 15
void evaluate(char *outputstring, int *value, char *inputstring)
{
int forcevalue = IGNORE;
cond result;
strcpy(conditions, inputstring); /* Prepare the string for tokenising */
tokenptr = conditions;
gettoken(); /* Read in the first token of input */
result = evaluateexpression();
/* check for bad/complex expression */
if (token != ENDOFLINE)
{
char *adir = NULL;
char *cdir = NULL;
if(((cdir = strstr(inputstring, IfStripCStr)) && cdir[IFSTRIPVALEND] == '*' && cdir[IFSTRIPVALEND+1] == '/')
|| ((adir = strstr(inputstring, IfStripAStr)) && adir[IFSTRIPVALEND] == ';' && adir[IFSTRIPVALEND+1] == ';'))
{
char *pstr;
char *ifstr;
/* fprintf(stderr,"<< evaluate(): (%s)\n", inputstring); */
pstr = ifstr = ( adir ? adir : cdir ) ;
/*
* Have recognized the /-*-IFSTRIP= directive, interpret its argument
* and remove the directive comment from the input/output text.
* Back up exactly one white space character (blank or tab) if possible.
*/
if(pstr > inputstring && (pstr[-1] == '\t' || pstr[-1] == ' '))
-- pstr;
if(!memcmp(ifstr+IFSTRIPVALOFF, "DEF", 3)) /* DEFINED */
forcevalue = DEFINED;
else if(!memcmp(ifstr+IFSTRIPVALOFF, "UND", 3)) /* UNDEFINED */
forcevalue = UNDEFINED;
else if(memcmp(ifstr+IFSTRIPVALOFF, "IGN", 3)) /* IGNORE */
warning("cannot recognize IFSTRIP: directive - ignoring", conditions);
/* else "IGNORE" -- forcevalue is already set by default to IGNORE */
if(!terseFlag)
warning("ifstrip directive forced evaluation", conditions);
/* remove the directive comment (and preceding blank or tab) from the input line */
strcpy(pstr, ifstr + IFSTRIPVALLEN); /* "C" comments have closing -*-/- */
/* fprintf(stderr,">> evaluate(): (%s)\n", inputstring); */
}
else
evalwarn();
if (result)
{
destroycondition(result);
result = NULL;
}
}
/* bad/complex expression, return IGNORE and entire expression */
if (!result)
{
*value = forcevalue;
strcpy(outputstring, inputstring);
return;
}
*value = result -> truth;
if(!result -> condition)
* outputstring = '\0';
else
strcpy(outputstring, result -> condition);
/* Convert from internal to external representation */
destroycondition(result);
}
cond evaluateexpression()
{
return orexpression();
}
cond orexpression()
{
cond condition1, condition2;
char *output;
condition1 = andexpression();
if (!condition1)
return NULL;
while (token == OR)
{
gettoken();
condition2 = andexpression();
if (!condition2)
{
destroycondition(condition1);
return NULL;
}
switch (condition1 -> truth)
{
case DEFINED: /* DEFINED || x == DEFINED */
/* condition1 set up correctly for next pass */
destroycondition(condition2);
break;
case UNDEFINED:
switch (condition2 -> truth)
{
case DEFINED: /* UNDEFINED || DEFINED == DEFINED */
destroycondition(condition1);
condition1 = condition2;
break;
case UNDEFINED: /* UNDEFINED || UNDEFINED == UNDEFINED */
destroycondition(condition2);
/* condition1 set up correctly for next pass */
break;
case IGNORE: /* UNDEFINED || IGNORE == IGNORE */
destroycondition(condition1);
condition1 = condition2;
break;
}
break;
case IGNORE:
switch (condition2 -> truth)
{
case DEFINED: /* IGNORE || DEFINED == DEFINED */
destroycondition(condition1);
condition1 = condition2;
break;
case UNDEFINED: /* IGNORE || UNDEFINED == IGNORE */
/* condition1 set up correctly for next pass */
destroycondition(condition2);
break;
case IGNORE: /* IGNORE || IGNORE == IGNORE */
output = createstring(strlen(condition1 -> condition)
+ strlen (condition2 -> condition)
+ (sizeof(" || ") - 1));
strcpy(output, condition1 -> condition);
strcat(output, " || ");
strcat(output, condition2 -> condition);
/* Build up the condition string */
destroystring(condition1 -> condition);
condition1 -> condition = output;
/* Place the new string in condition1 */
destroycondition(condition2);
break;
}
break;
}
}
return condition1;
}
cond andexpression()
{
cond condition1, condition2;
char *output;
condition1 = unaryexpression();
if (!condition1)
return NULL;
while (token == AND)
{
gettoken();
condition2 = unaryexpression();
if (!condition2)
{
destroycondition(condition1);
return NULL;
}
switch (condition1 -> truth)
{
case DEFINED:
switch (condition2 -> truth)
{
case DEFINED: /* DEFINED && DEFINED == DEFINED */
destroycondition(condition2);
/* condition1 set up correctly for next pass */
break;
case UNDEFINED: /* DEFINED && UNDEFINED == UNDEFINED */
destroycondition(condition1);
condition1 = condition2;
break;
case IGNORE: /* DEFINED && IGNORE == IGNORE */
destroycondition(condition1);
condition1 = condition2;
break;
}
break;
case UNDEFINED: /* UNDEFINED && x == UNDEFINED */
/* condition1 set up correctly for next pass */
destroycondition(condition2);
break;
case IGNORE:
switch (condition2 -> truth)
{
case DEFINED: /* IGNORE && DEFINED == IGNORE */
/* condition1 set up correctly for next pass */
destroycondition(condition2);
break;
case UNDEFINED: /* IGNORE && UNDEFINED == UNDEFINED */
destroycondition(condition1);
condition1 = condition2;
break;
case IGNORE: /* IGNORE && IGNORE == IGNORE */
output = createstring(strlen(condition1 -> condition)
+ strlen (condition2 -> condition)
+ (sizeof(" && ") - 1));
strcpy(output, condition1 -> condition);
strcat(output, " && ");
strcat(output, condition2 -> condition);
/* Build up the condition string */
destroystring(condition1 -> condition);
condition1 -> condition = output;
/* Place the new string in condition1 */
destroycondition(condition2);
break;
}
break;
}
}
return condition1;
}
cond unaryexpression()
{
cond condition1;
char *output;
switch (token)
{
case NOT:
gettoken();
condition1 = unaryexpression();
if (!condition1)
return NULL;
if ((condition1 -> truth) == IGNORE)
{
output = createstring(strlen(condition1 -> condition) + 1);
*output = '!';
strcpy(output + 1, condition1 -> condition);
destroystring(condition1 -> condition);
condition1 -> condition = output;
}
else
condition1 -> truth = negatecondition(condition1 -> truth);
break;
case DEFINEDFN:
gettoken();
condition1 = parenthesesexpression();
if (!condition1)
return NULL;
if ((condition1 -> truth) == IGNORE)
{
output = createstring(strlen(condition1 -> condition)
+ (sizeof("defined ") - 1));
strcpy(output, "defined ");
strcat(output, condition1 -> condition);
destroystring(condition1 -> condition);
condition1 -> condition = output;
}
break;
default:
condition1 = parenthesesexpression();
if (!condition1)
return NULL;
break;
}
return condition1;
}
cond parenthesesexpression()
{
cond condition1;
char *output;
if (token == OPENPARENTHESIS)
{
gettoken();
condition1 = evaluateexpression();
if (!condition1)
return NULL;
if (token != CLOSEPARENTHESIS)
{
/* check for bad/complex expression */
evalwarn();
destroycondition(condition1);
return NULL;
}
gettoken();
if ((condition1 -> truth) == IGNORE)
{
output = createstring(strlen(condition1 -> condition) + 2);
*output = '(';
strcpy(output + 1, condition1 -> condition);
strcat(output, ")");
destroystring(condition1 -> condition);
condition1 -> condition = output;
}
}
else
condition1 = atomicexpression();
return condition1;
}
cond atomicexpression()
{
cond condition1 = createcondition();
switch (token)
{
case UINT:
if ( progtype == 1)
condition1 -> truth = DEFINED;
else
condition1 -> truth = (atoi(currenttoken) == 0) ? UNDEFINED : DEFINED;
break;
case ID:
condition1 -> truth = lookupsym(currenttoken);
if ((condition1 -> truth) == NOTPRESENT)
{
warning("Switch unlisted - ignoring", currenttoken);
condition1 -> truth = IGNORE;
}
if ((condition1 -> truth) == IGNORE) {
condition1 -> condition = createstring(strlen(currenttoken));
strcpy(condition1 -> condition, currenttoken);
}
break;
default:
/* bad/complex expression */
evalwarn();
destroycondition(condition1);
return NULL;
break;
}
gettoken();
return condition1;
}
/* Negate condition (MAL) */
__inline int negatecondition(int condvalue) /* inline for speed */
{
switch (condvalue)
{
case DEFINED:
return UNDEFINED;
case UNDEFINED:
return DEFINED;
default:
return condvalue;
};
}
/* Allocate the memory for an empty condition structure and return a pointer to it */
__inline cond createcondition()
{
cond retvalue;
retvalue = (cond) malloc(sizeof(condrec));
if (retvalue == NULL)
error("Memory overflow","");
retvalue -> condition = NULL;
return retvalue;
}
/* Destroy a condition structure */
__inline void destroycondition(cond condition1)
{
if (condition1 -> condition)
free(condition1 -> condition);
free(condition1);
}
/* Allocate the memory for a string of given length (not including terminator) and return the pointer */
__inline char *createstring(int length)
{
char *retvalue;
retvalue = (char *) malloc(length + 1);
if (retvalue == NULL)
error("Memory overflow","");
return retvalue;
}
/* Destroy a string */
__inline void destroystring(char *string)
{
free(string);
}
int iscomment(char *tokenptr)
{
int cindex;
for (cindex = 0; cindex < maxcomment; cindex++)
{
if (commlen[cindex] &&
!_strnicmp(tokenptr, comments[cindex], commlen[cindex]))
return TRUE;
}
return FALSE;
}
void gettoken()
{
int numofwhitespace, comparetoken = 0, found = FALSE, isnumber = TRUE;
char *digitcheck;
numofwhitespace = strspn(tokenptr, " \t");
/* CFW - skips comments, assumes comment is last thing on line */
if (numofwhitespace == (int) strlen(tokenptr))
token = ENDOFLINE;
else
{
tokenptr += numofwhitespace;
if (iscomment(tokenptr))
{
token = ENDOFLINE;
}
else
{
do
{
if (!_strnicmp(tokenptr, operators[comparetoken], oplengths[comparetoken]))
found = TRUE;
else
comparetoken++;
} while ( (!found) && (comparetoken < numoperators) );
if (found)
{
tokenptr += oplengths[comparetoken];
token = comparetoken;
/* currenttoken is left blank for all but UINTs and IDs */
}
else
{
digitcheck = tokenptr;
if (!nonumbers && isdigit(*digitcheck))
{
while (isdigit(*digitcheck))
digitcheck++;
strncpy(currenttoken, tokenptr, digitcheck - tokenptr);
tokenptr = digitcheck;
token = UINT;
}
else if (issymbolchar(*digitcheck))
{
while (issymbolchar(*digitcheck))
digitcheck++;
strncpy(currenttoken, tokenptr, digitcheck - tokenptr);
*(currenttoken + (digitcheck - tokenptr)) = '\0';
tokenptr = digitcheck;
token = ID;
}
else
token = UNKNOWN;
}
}
}
}
__inline int issymbolchar(char c)
{
return (iscsym(c) || (c == '$') || (c == '?') || (c == '@'));
}