windows-nt-4.0/private/sdktools/vctools/nmake/rpn.c

/***  RPN.C -- expression evaluator ********************************************
*
*	Copyright (c) 1988-1990, Microsoft Corporation.  All rights reserved.
*
* Purpose:
*  This module contains NMAKE's expression evaluator routines.
*
* Revision History:
*  15-Nov-1993 JdR Major speed improvements
*  15-Oct-1993 HV Use tchar.h instead of mbstring.h directly, change STR*() to _ftcs*()
*  10-May-1993 HV Add include file mbstring.h
*                 Change the str* functions to STR*
*  04-Dec-1989 SB Add prototype for match() and chkInvokeAndPush()
*  09-Oct-1989 SB Added HACK to handle pointer arithmetic quirks; Done to
*		  avoid rewriting entire module
*  08-Oct-1989 SB '!if' expressions can be decimal, octal or hex now
*  05-Apr-1989 SB made all funcs NEAR; Reqd to make all function calls NEAR
*  19-Sep-1988 RB Split ptr_to_string().  Process ESCH in program invocations.
*  17-Aug-1988 RB Clean up.
*  28-Jun-1988 rj Added doCmd parameter to execLine.
*  23-Jun-1988 rj Add parameter to execLine (no echo of command).
*  25-May-1988 rb Change isspace to _istspace, isdigit to _istdigit.
*
*******************************************************************************/

#include "nmake.h"
#include "nmmsg.h"
#include "proto.h"
#include "globals.h"
#include "grammar.h"
#pragma hdrstop
#include "rpn.h"
/*  ----------------------------------------------------------------------------
 *  function prototypes  
 *
 */

LOCAL char _FAR * NEAR GetEndQuote(void);
LOCAL char _FAR * NEAR GetEndBracket(void);
LOCAL void	 NEAR check_syntax_error(UCHAR);
LOCAL void	 NEAR type_and_val(UCHAR, long);
LOCAL void	 NEAR pushIntoList(void);
LOCAL void	 NEAR printList(void);
LOCAL BOOL	 NEAR handleExpr(void);
LOCAL BOOL	 NEAR handleExists(char*);
LOCAL BOOL	 NEAR handleDefines(char*);
LOCAL void	 NEAR getTok(void);
LOCAL BOOL	 NEAR do_binary_op(UCHAR);
LOCAL BOOL	 NEAR do_unary_op(UCHAR);
LOCAL UCHAR	 NEAR match(char *tokPtr);
LOCAL void	 NEAR chkInvocAndPush(RPNINFO *pListPtr);

/*  ----------------------------------------------------------------------------
 *  macros that deal w/ the operand/temporary stack 
 */

#define TEMPSTACKSIZE	512		  /* size of temporary stack	      */
#define LISTSIZE	512		  /* size of list of rpn-form items   */

RPNINFO 	tempStack[TEMPSTACKSIZE];	/* temporary/operand stack    */
RPNINFO 	rpnList[LISTSIZE];		/* list of items in rpn order */
LOCAL char    * text;			 /* pointer to expr text in lbufPtr   */
LOCAL UCHAR	prevTok;		 /* initial token put on tempstack    */
LOCAL BOOL	done;			 /* true if there are no more tokens  */
LOCAL UCHAR	errRow; 		 /* first token is '(' so error table
					    row val is 3. See check_syntax....*/
LOCAL RPNINFO * pTop;			 /* top item on tempStack	      */
LOCAL RPNINFO * pList;			 /* next free slot in list	      */
LOCAL RPNINFO * pEnd	 = &(tempStack[TEMPSTACKSIZE-1]);
LOCAL RPNINFO * pListEnd = &(rpnList[LISTSIZE-1]);
LOCAL RPNINFO	tokRec;



/*  -------------------------------------------------------------------------
 *  do_binary_op() - do operation on two stack operands
 *
 *  arguments:      type - operator type code
 *
 *  actions  :      pops first operand from the stack (tempStack).
 *		    checks the types of the two operands (the operand 
 *		    that was popped as well as the operand currently
 *		    on top of the stack).
 *		    if both operands are integers then do the operation
 *		    else if both operands are strings and operation is
 *			    the equality operation then do it.
 *		    else return FALSE ( illegal operation )
 *
 *  modifies :      tempStack - top element will now be the result of
 *			        the operation.
 *                  
 */

LOCAL BOOL NEAR
do_binary_op(type)
UCHAR type;
{
    long *left, *right;
    RPNINFO *pOldTop;

    pOldTop = pTop--;		  /* pop one item off stack, with a ptr to it */
    right = &(pOldTop->valPtr);
    left = &(pTop->valPtr);

    if (pOldTop->type == INTEGER && pTop->type == INTEGER) {
	switch (type) {
	  case LOGICAL_OR   : *left = *left || *right;
			      break;
	  case LOGICAL_AND  : *left = *left && *right;
			      break;
	  case BIT_OR	    : *left |= *right;
			      break;
	  case BIT_XOR	    : *left ^= *right;
			      break;
	  case BIT_AND	    : *left &= *right;
			      break;
	  case NOT_EQUAL    : *left = *right != *left;
			      break;
	  case EQUAL	    : *left = *right == *left;
			      break;
	  case GREATER_THAN : *left = *left > *right;
			      break;
	  case LESS_THAN    : *left = *left < *right;
			      break;
	  case GREATER_EQ   : *left = *left >= *right;
			      break;
	  case LESS_EQ	    : *left = *left <= *right;
			      break;
	  case SHFT_RIGHT   : *left >>= *right;
			      break;
	  case SHFT_LEFT    : *left <<= *right;
			      break;
	  case BINARY_MINUS : *left -= *right;
			      break;
	  case ADD	    : *left += *right;
			      break;
	  case MODULUS	    : if (!*right)
				  makeError(line, DIVIDE_BY_ZERO);
			      *left %= *right;
			      break;
	  case DIVIDE	    : if (!*right)
				  makeError(line, DIVIDE_BY_ZERO);
			      *left /= *right;
			      break;
	  case MULTIPLY     : *left *= *right;
			      break;
	  default	    : return(FALSE);
			      break;
	}
    }
    else if (pOldTop->type == STR
	     && pTop->type == STR
	     && (type == EQUAL || type == NOT_EQUAL)) {
	pTop->type = INTEGER;
	*left = !(_ftcscmp((char*)*left, (char*)*right));
	if (type == NOT_EQUAL)
	    if (!do_unary_op(LOGICAL_NOT))
		return(FALSE);
    }
    else return(FALSE);
    return(TRUE);
}



/*  -------------------------------------------------------------------------
 *  do_unary_op() - do operation on top stack operand
 *
 *  arguments:      type - operator type code
 *
 *  actions  :      checks the type of the top operand on the stack
 *		    if operand is an integer then do the operation
 *		    else return FALSE ( illegal operation )
 *
 *  modifies :      tempStack - top element will now be the result of
 *			        the operation.
 *                  
 */


LOCAL BOOL NEAR
do_unary_op(type)
UCHAR type;
{
    long *top;

    top = &(pTop->valPtr);

    if (pTop->type == INTEGER)
	switch (type) {
	  case UNARY_MINUS: *top = -*top;
			    break;
	  case COMPLEMENT : *top = ~*top;
			    break;
	  case LOGICAL_NOT: *top = !*top;
			    break;
	  default	  : return(FALSE);
			    break;
    }
    else return(FALSE);
    return(TRUE);
}



/*  --------------------------------------------------------------------------
 *  GetEndQuote
 *
 *  Return the pointer to the next double-quote character in text.  A
 *  double-quote followed immediately by a double-quote is skipped.
 *  
 *  text : the global ptr to the buffer is moved up beyond this string.
 */

LOCAL char _FAR * NEAR
GetEndQuote()
{
    char *pStart;

    for (pStart = ++text; *text; ++text)
	if (*text == '\"') {
	    if (text[1] == '\"')
		++text;
	    else
		break;
	}

    if (!*text)
	makeError(line, SYNTAX_MISSING_END_CHAR, '\"');

    *text++ = '\0';	     /* null byte over closing quote */
    return(pStart);
}
/*  --------------------------------------------------------------------------
 *  GetEndBracket
 *
 * 
 *  Lexes a program invocation.
 *  
 *  Program invocation is of the form: [ prog <arglist> ].
 *  Process escaped ']' here because this is where we do the lexing.
 *  
 *  text : the global ptr to the buffer is moved up beyond this string.
 */

LOCAL char _FAR * NEAR
GetEndBracket()
{
    char *pStart;

    for (pStart = ++text; *text; ++text)
	if (*text == ESCH && text[1] == ']')
	    memmove(text, text + 1, 1 + _ftcslen(text + 1));
	else if (*text == ']')
	    break;

    if (!*text)
	makeError(line, SYNTAX_MISSING_END_CHAR, ']');

    *text++ = '\0';	     /* null byte over closing bracket */
    return(pStart);
}



/*  --------------------------------------------------------------------------
 *  check_syntax_error()  - check if there is a syntax error in expr
 *
 *  arguments:  type  - type of the current token
 *
 *  actions:    checks the type of the current token against the type 
 *              of the previous token. 
 *
 *  ERROR_TABLE :
 *			      2nd tok
 *  
 *  		alpha	 op	unary_op	(	)
 *  	       ------------------------------------------------
 *      alpha |   0   |   1   |    0      |     0   |   1     | 
 *            -------------------------------------------------
 *        op  |	  1   |	  0   |	   1      |     1   |	0     |
 *            -------------------------------------------------
 *   unary_op |	  1   |	  0   |	   0      |	1   |	0     |
 *            -------------------------------------------------
 *	  (   |	  1   |	  0   |	   1      |	1   |	0     |
 *            -------------------------------------------------
 *        )   |	  0   |	  1   |	   0      |	0   |	1     |
 *            -------------------------------------------------
 *   1st tok.
 *
 *    alpha : a primary ( integer, str, prog. invoc. )
 *       op : a binary operator
 * unary_op : a unary operator ( ~, !, - ). A  ZERO in the slot => error
 *
 * NOTE: ANY CHANGES TO THE TYPE VALUES WILL AFFECT THIS ROUTINE.
 */

LOCAL void NEAR
check_syntax_error(newTok)
UCHAR newTok;
{
    extern UCHAR errTable[5][5];
    extern UCHAR errRow;
    UCHAR errCol;

    if (newTok == LEFT_PAREN) errCol = 3;
    else if (newTok == RIGHT_PAREN) errCol = 4;
    else if (newTok > LOGICAL_NOT) errCol = 0;
    else if (newTok > MULTIPLY) errCol = 2;
    else errCol = 1;

    if (!errTable[errRow][errCol])
	makeError(line, SYNTAX_INVALID_EXPR);
    errRow = errCol;	  /* this becomes the first token the next time */
}



/*  --------------------------------------------------------------------------
 *  type_and_val()
 *
 *  arguments:   type - the type code of the present operator.
 *	 	 val  - ptr to a str/or integer 
 *  
 *  initialises a record with the type code, after checking for any
 *  syntax errors. The new token is checked against the previous token
 *  for illegal combinations of tokens.
 *  initialises the record with the integer value/string ptr.
 *
 */
LOCAL void NEAR
type_and_val(type, val)
UCHAR type;
long val;
{
    extern RPNINFO tokRec;		 /* returned to handleExpr */
    extern UCHAR prevTok;		 /* token last seen	   */

    check_syntax_error(type);
    prevTok = type;
    tokRec.type = type;
    tokRec.valPtr = val;
}


/*  --------------------------------------------------------------------------
 *  match()
 * 
 *  arguments:   tokPtr - ptr to a token string ( in tokTable )
 *
 *  actions  :   looks for a substring in the expression buffer
 *		 pointed to by 'text', that matches the given token.
 *		 if substring found, returns TRUE, else returns FALSE.
 *	         
 */
LOCAL UCHAR NEAR
match(tokPtr)
char *tokPtr;
{
    extern char *text;
    char *t = text;

    while (*tokPtr && (*t == *tokPtr)) {
	t++;
	tokPtr++;
    }
    if (!*tokPtr) {
	text = t;
	return(TRUE);
    }
    return(FALSE);
}



/*  --------------------------------------------------------------------------
 *  getTok()
 *
 *  arguments: none
 *
 *  gets a token from the expression buffer.
 *  if the current char from the buffer is a space/tab, skip space/tabs
 *	until we get a non-space char ( could be NULL char ).
 *  Check if we are now at the beginning of one of the tokens in the
 *	tokenTable. This covers most tokens.
 *  Check if we have a minus. If a minus and the previous token was an
 *	integer, this is a binary minus, else a unary minus.
 *  If the current char is a double-quote, we are at the start of a
 *      string-token.
 *  If the current char is a '[', we are at the start of a program
 *	invocation. In both cases, the escape character is '\\'.
 *  If current char is a digit, we have a constant ( integer ).
 *  Else we have defined(ID).
 *  If none of the above, if current char is NULL, break out, else
 *	report error ( illegal character string has been found ).
 *
 *  If we came to the NULL char at the end of the buffer, set global
 *     flag 'done' to TRUE, return a RIGHT_PAREN to match the opening
 *     LEFT_PAREN.
 *
 *
 *  modifies:  text  : ptr to expression buffer.
 *	      prevTok: thru' calls to type_and_val().
 *	        done : at end of buffer
 *	      errRow : index into error table, thru calls to
 *			type_and_val()
 *  returns : token in tokRec(global, static to the module). The
 *	      token has the new type/integer/ptr values.
 *
 */



LOCAL void NEAR
getTok()
{
    extern UCHAR prevTok;
    extern BOOL done;
    char c;
    struct tok_tab_rec *p;
    char *ptr;
    long constant;
 
    c = *text;
    if (c == ' ' || c == '\t')
	while(_istspace(c)) c = *++text;			 /* skip white spaces */
    if (IS_OPERATORCHAR(c)) {
    	for (p = tokTable; p->op_str && !match(p->op_str); p++);
    }
    else {
    	// make p point to last entry in table
    	p = &tokTable[(sizeof(tokTable) / sizeof(struct tok_tab_rec)) - 1];
    }
    if (p->op_str)
	type_and_val(p->op, 0L);
    /* now check if binary or unary minus to be returned */
    else if (c == '-') {
	text++;
	if (prevTok == INTEGER)
	    type_and_val(BINARY_MINUS, 0L);
	else type_and_val(UNARY_MINUS, 0L);
    }
    else if (c == '\"')
	type_and_val(STR, (long) GetEndQuote());
    else if (c == '[')
	type_and_val(PROG_INVOC_STR, (long) GetEndBracket());
    else {
	/* integers and IDs handled here */
	if (_istdigit(c)) {
	    char *pNumber = text;

	    errno = 0;
	    //Accept decimal, octal or hex no (richgi)
	    constant = strtol(text, &text, 0);
	    if (errno == ERANGE) {
		*text = '\0';
		makeError(line, CONST_TOO_BIG, pNumber);
	    }
	    if (_totupper(*text) == 'L')
		text++;
	    type_and_val(INTEGER, constant);
	}
	else /* defined(ID) comes here */
	    if (c) {
		if (!_ftcsnicmp(text, "DEFINED", 7)) {
		    if (!(ptr = _ftcschr(text, '(')))
			makeError(line, SYNTAX_INVALID_EXPR);
		    ptr++;
		    text = ptr + _ftcscspn(ptr, ")");
		    *text++ = '\0';
		    type_and_val(INTEGER, (long)handleDefines(ptr));
		}
		else if (!_ftcsnicmp(text, "EXIST", 5)) {
		    if (!(ptr = _ftcschr(text, '(')))
			makeError(line, SYNTAX_INVALID_EXPR);
		    ptr++;
		    // XXXXX
		    text = ptr + _ftcscspn(ptr, ")");
		    //text = ptr + _ftcscspn(ptr, ")");
		    *text++ = '\0';
		    type_and_val(INTEGER, (long)handleExists(ptr));
		}
		else makeError(line, SYNTAX_INVALID_EXPR);
	    }	/* we are now at the end of the string */
	    else {   /* c is NULL */
		done = TRUE;
		type_and_val(RIGHT_PAREN, 0L); /* this is the last token */
	    }
	}
}  /* getTok */



/*  ------------------------------------------------------------------------
 *  chkInvocAndPush()  - check if program invocation required
 *
 *  arguments:     pListPtr - might have a program invocation string
 *			      present.
 *	
 *  actions  :	   if this is a program invocation string, make the
 *		      program invocation.
 *		      the return value is got and placed on the stack.
 *		      the type of the new stack element is now INTEGER.
 *                 else place list item on stack.
 *
 *                 in either case it moves one item from list to stack.
 *
 */
       		   


LOCAL void NEAR
chkInvocAndPush(pListPtr)
RPNINFO *pListPtr;
{
    ++pTop;
    if (pListPtr->type == PROG_INVOC_STR) {
	pTop->valPtr = (long) execLine((char*)pListPtr->valPtr,
				       FALSE, TRUE, FALSE, NULL);
	pTop->type = INTEGER;
    }
    else *pTop = *pListPtr;
}
  


/*  ---------------------------------------------------------------------------
 *  processList()
 *
 *  arguments:    none
 *
 *  actions :     remove an item from the list.
 *		  if the item is an operand, place it on the operand
 *		     stack (tempStack).
 *		  if the operand is a program invocation string, make
 *		     the invocation, place the return code on stack.
 *		  if the item is an operator, call the function to
 *		     do the operation on one/two elements on tempStack.
 *		  
 *		  finally, check if there is exactly one item on stack.
 *		  if this item has a value of zero, return FALSE.
 *		     else return TRUE.
 *		  if more than one item on stack, abort with error.
 *
 *  modifies:     pTop    - ptr to top of tempStack.
 *		  pList   - ptr to next position in list.
 *  
 */



LOCAL BOOL NEAR
processList()
{
    extern RPNINFO *pList;
    extern RPNINFO *pTop;
    RPNINFO *pTemp;
    BOOL (NEAR * func)(UCHAR);

    for (pTemp = rpnList; pTemp < pList; pTemp++) {
	if (pTemp->type > LOGICAL_NOT)          /* operand */
	    chkInvocAndPush(pTemp);
	else {
	    if (pTemp->type > MULTIPLY)
		func = do_unary_op;
	    else func = do_binary_op;

	    if (!(*func)(pTemp->type))
		makeError(line, BAD_OP_TYPES);
	}
    } /* for */

    if ((pTop == tempStack) && (pTop->type == INTEGER))
	if (!pTop->valPtr) return(FALSE);
	else return(TRUE);
    else makeError(line, SYNTAX_INVALID_EXPR);
}



/*  ---------------------------------------------------------------------------
 *  pushIntoList()
 *
 *  arguments:    none
 *
 *  actions :     pops an item from the tempStack and pushes it onto 
 *		  the list. checks list for overflow ( internal error )
 *		  and tempStack for underflow ( syntax error in expr ).
 *
 *  modifies:     tempTop    - index of top of tempStack.
 *		  nextInList - index to next position in list.
 *  
 */

LOCAL void NEAR
pushIntoList()
{
    if (pTop < tempStack)
	makeError(line, SYNTAX_INVALID_EXPR);
    if (pList > pListEnd)
	makeError(line, EXPR_TOO_LONG_INTERNAL);
    *pList++ = *pTop--;
}



/*  ---------------------------------------------------------------------------
 *  handleExpr()
 *
 *  arguments:    text - pointer to the buffer that has the expression.
 *
 *  actions  :    calls getTok() to get tokens from the buffer. Places
 *		  tokens in a tempStack, and moves them into a list in
 *		  reverse-polish order. 
 *		  
 *		  We need the list so that ALL syntax errors are caught 
 *		  BEFORE processing of the expression begins (especially
 *		  program invocations that have side effects)
 *
 *		  Once the list is available, an operand stack is used
 *		  Items are popped and pushed from this stack by the  
 *		  evaluation routines (add, mult, negate etc.)
 *		  
 *		  we don't really need a separate operand stack. the 
 *		  tempStack has served its purpose when the list is
 *		  formed and so it may be used for operand processing.
 */



LOCAL BOOL NEAR
handleExpr()
{
    extern RPNINFO tokRec;
    BOOL fRParen;			  /* was the token got a right paren? */
    extern BOOL done;
    extern RPNINFO *pTop, *pList;
    extern UCHAR errRow;
    extern UCHAR prevTok;

    pTop = tempStack;
    pList = rpnList;
    done = FALSE;
    errRow = 3; 		  /* row for the first token put in,left paren*/
    prevTok = LEFT_PAREN;
    type_and_val(LEFT_PAREN, 0L);
    *pTop = tokRec;

    while (!done) {		     /* while there are more tokens in buffer */
	getTok();
	fRParen = FALSE;
	if (tokRec.type != LEFT_PAREN)
	    while (precVector[tokRec.type] <= precVector[pTop->type]) {
		if (!precVector[tokRec.type]) { /* if RIGHT_PAREN */
	              /* pop till a left paren is seen */
		    while (pTop->type != LEFT_PAREN) pushIntoList();
		    fRParen = TRUE;
		    if (pTop < tempStack) makeError(line, SYNTAX_INVALID_EXPR);
		    else {
			pTop--;    /* pop the left paren */
			break;
		    }
		}
		else
		    pushIntoList();
	    } /* while */

	/* if token is a left paren, it has to go on the stack */
	if (!fRParen)
	    if (pTop == pEnd)
		makeError(line, EXPR_TOO_LONG_INTERNAL);
	    else
		*++pTop = tokRec;
    } /* while */

    /* check the stack here for not empty state */
// HACK: have to rewrite entire module
//	 to avoid pointer arithmetic
//	 pTop-- is potentially dangerous
//	    if tempStack is near segment boundary
    if (pTop != tempStack - 1)
	makeError(line, SYNTAX_INVALID_EXPR);
    return(processList());
}



/*  ---------------------------------------------------------------------------
 *  handleDefines()
 *
 *  arguments:    t    pointer to buffer that has the identifier
 *
 *  actions:      Checks if one of 'ID' is present.
 *		  Aborts with error if more IDs present.
 *		  Is called for ifdef/ifndef/defined(ID).
 *
 *  returns :     TRUE if ID found in table. FALSE otherwise.
 *
 */
LOCAL BOOL NEAR
handleDefines(t)
char *t;
{
    char *s;

    s = _ftcstok(t, " \t");
    if (_ftcstok(NULL, " \t"))
	makeError(line, SYNTAX_UNEXPECTED_TOKEN, s);
    if (!s)
	makeError(line, MISSING_ARG_BEFORE_PAREN);
    if (findMacro(s))
	return(TRUE);
    return(FALSE);
}

/*  ---------------------------------------------------------------------------
 *  handleExists()
 *
 *  arguments:    t    pointer to buffer that has the identifier
 *
 *  actions:	  Checks if 'name' is a valid file/directory
 *		  Aborts with error if more names present.
 *		  Is called for exist(name).
 *
 *  returns :     TRUE if ID found in table. FALSE otherwise.
 *
 */
LOCAL BOOL NEAR
handleExists(t)
char *t;
{
    char *s;
    char *szUnQuoted;
    BOOL fResult = FALSE;

    s = _ftcstok(t, " \t");
    if (_ftcstok(NULL, " \t"))
	makeError(line, SYNTAX_UNEXPECTED_TOKEN, s);
    //handle quoted names
    if (NULL == s || NULL == (szUnQuoted = unQuote(s)))
	makeError(line, MISSING_ARG_BEFORE_PAREN);
    if (!_access(szUnQuoted, 0x00)) {	// existence check
	fResult = TRUE;
    }
    FREE(szUnQuoted);
    return(fResult);
}



/*  ---------------------------------------------------------------------------
 *  evalExpr()
 *
 *  arguments:    t    pointer to buffer that has the expression
 *                kind specifies if it is if/ifdef/ifndef etc.
 *
 *
 *
 *  returns :     TRUE if expression evaluates to true.
 *                FALSE otherwise.
 */

BOOL NEAR
evalExpr(t, kind)
char *t;
UCHAR kind;
{

    if (!*t)
	makeError(line, SYNTAX_MISSING_DIRECTIVE);

    switch (kind) {
	case IFDEF_TYPE:
	case ELSE_IFDEF_TYPE:
	    return(handleDefines(t));
	case IFNDEF_TYPE:
	case ELSE_IFNDEF_TYPE:
	     return((BOOL)!handleDefines(t));
	default:
	     text = t;
	     return(handleExpr());
    }
}