--- ray/src/common/calexpr.c	2003/07/03 22:41:44	2.23
+++ ray/src/common/calexpr.c	2019/03/04 18:16:18	2.37
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char	RCSid[] = "$Id: calexpr.c,v 2.23 2003/07/03 22:41:44 schorsch Exp $";
+static const char	RCSid[] = "$Id: calexpr.c,v 2.37 2019/03/04 18:16:18 greg Exp $";
 #endif
 /*
  *  Compute data values using expression parser
@@ -26,6 +26,9 @@ static const char	RCSid[] = "$Id: calexpr.c,v 2.23 200
 #include  <math.h>
 #include  <stdlib.h>
 
+#include  "rtmisc.h"
+#include  "rtio.h"
+#include  "rterror.h"
 #include  "calcomp.h"
 
 #define	 MAXLINE	256		/* maximum line length */
@@ -34,17 +37,20 @@ static const char	RCSid[] = "$Id: calexpr.c,v 2.23 200
 
 #define	 isdecimal(c)	(isdigit(c) || (c) == '.')
 
-static double  euminus(), eargument(), enumber();
-static double  echannel();
-static double  eadd(), esubtr(), emult(), edivi(), epow();
-static double  ebotch();
+static double  euminus(EPNODE *), eargument(EPNODE *), enumber(EPNODE *);
+static double  echannel(EPNODE *);
+static double  eadd(EPNODE *), esubtr(EPNODE *),
+               emult(EPNODE *), edivi(EPNODE *),
+               epow(EPNODE *);
+static double  ebotch(EPNODE *);
 
 unsigned int  esupport =		/* what to support */
 		E_VARIABLE | E_FUNCTION ;
 
+int  eofc = 0;				/* optional end-of-file character */
 int  nextc;				/* lookahead character */
 
-double	(*eoper[])() = {		/* expression operations */
+double	(*eoper[])(EPNODE *) = {	/* expression operations */
 	ebotch,
 	evariable,
 	enumber,
@@ -79,8 +85,9 @@ static int  linepos;			/* position in buffer */
 
 
 EPNODE *
-eparse(expr)			/* parse an expression string */
-char  *expr;
+eparse(			/* parse an expression string */
+    char  *expr
+)
 {
     EPNODE  *ep;
 
@@ -94,10 +101,11 @@ char  *expr;
 
 
 double
-eval(expr)			/* evaluate an expression string */
-char  *expr;
+eval(			/* evaluate an expression string */
+    char  *expr
+)
 {
-    register EPNODE  *ep;
+    EPNODE  *ep;
     double  rval;
 
     ep = eparse(expr);
@@ -108,8 +116,10 @@ char  *expr;
 
 
 int
-epcmp(ep1, ep2)			/* compare two expressions for equivalence */
-register EPNODE  *ep1, *ep2;
+epcmp(			/* compare two expressions for equivalence */
+    EPNODE  *ep1,
+    EPNODE  *ep2
+)
 {
 	double  d;
 
@@ -125,7 +135,7 @@ register EPNODE  *ep1, *ep2;
 		if (ep2->v.num == 0)
 			return(ep1->v.num != 0);
 		d = ep1->v.num / ep2->v.num;
-		return(d > 1.000000000001 | d < 0.999999999999);
+		return((d > 1.000000000001) | (d < 0.999999999999));
 
 	case CHAN:
 	case ARG:
@@ -135,7 +145,7 @@ register EPNODE  *ep1, *ep2;
 	case ':':
 		return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
 
-	case TICK:
+	case CLKT:
 	case SYM:			/* should never get this one */
 		return(0);
 
@@ -156,10 +166,11 @@ register EPNODE  *ep1, *ep2;
 
 
 void
-epfree(epar)			/* free a parse tree */
-register EPNODE	 *epar;
+epfree(			/* free a parse tree */
+    EPNODE	 *epar
+)
 {
-    register EPNODE  *ep;
+    EPNODE  *ep;
 
     switch (epar->type) {
 
@@ -174,7 +185,7 @@ register EPNODE	 *epar;
 	case NUM:
 	case CHAN:
 	case ARG:
-	case TICK:
+	case CLKT:
 	    break;
 
 	default:
@@ -191,67 +202,75 @@ register EPNODE	 *epar;
 
 				/* the following used to be a switch */
 static double
-eargument(ep)
-EPNODE	*ep;
+eargument(
+    EPNODE	*ep
+)
 {
     return(argument(ep->v.chan));
 }
 
 static double
-enumber(ep)
-EPNODE	*ep;
+enumber(
+    EPNODE	*ep
+)
 {
     return(ep->v.num);
 }
 
 static double
-euminus(ep)
-EPNODE	*ep;
+euminus(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
 
     return(-evalue(ep1));
 }
 
 static double
-echannel(ep)
-EPNODE	*ep;
+echannel(
+    EPNODE	*ep
+)
 {
     return(chanvalue(ep->v.chan));
 }
 
 static double
-eadd(ep)
-EPNODE	*ep;
+eadd(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
 
     return(evalue(ep1) + evalue(ep1->sibling));
 }
 
 static double
-esubtr(ep)
-EPNODE	*ep;
+esubtr(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
 
     return(evalue(ep1) - evalue(ep1->sibling));
 }
 
 static double
-emult(ep)
-EPNODE	*ep;
+emult(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
 
     return(evalue(ep1) * evalue(ep1->sibling));
 }
 
 static double
-edivi(ep)
-EPNODE	*ep;
+edivi(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
     double  d;
 
     d = evalue(ep1->sibling);
@@ -264,19 +283,24 @@ EPNODE	*ep;
 }
 
 static double
-epow(ep)
-EPNODE	*ep;
+epow(
+    EPNODE	*ep
+)
 {
-    register EPNODE  *ep1 = ep->v.kid;
+    EPNODE  *ep1 = ep->v.kid;
     double  d;
     int	 lasterrno;
 
     lasterrno = errno;
     errno = 0;
     d = pow(evalue(ep1), evalue(ep1->sibling));
-#ifdef	IEEE
-    if (!finite(d))
-	errno = EDOM;
+#ifdef  isnan
+    if (errno == 0) {
+	if (isnan(d))
+	    errno = EDOM;
+	else if (isinf(d))
+	    errno = ERANGE;
+    }
 #endif
     if (errno == EDOM || errno == ERANGE) {
 	wputs("Illegal power\n");
@@ -287,8 +311,9 @@ EPNODE	*ep;
 }
 
 static double
-ebotch(ep)
-EPNODE	*ep;
+ebotch(
+    EPNODE	*ep
+)
 {
     eputs("Bad expression!\n");
     quit(1);
@@ -297,9 +322,10 @@ EPNODE	*ep;
 
 
 EPNODE *
-ekid(ep, n)			/* return pointer to a node's nth kid */
-register EPNODE	 *ep;
-register int  n;
+ekid(			/* return pointer to a node's nth kid */
+    EPNODE	 *ep,
+    int  n
+)
 {
 
     for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
@@ -311,10 +337,11 @@ register int  n;
 
 
 int
-nekids(ep)			/* return # of kids for node ep */
-register EPNODE	 *ep;
+nekids(			/* return # of kids for node ep */
+    EPNODE	 *ep
+)
 {
-    register int  n = 0;
+    int  n = 0;
 
     for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
 	n++;
@@ -324,10 +351,11 @@ register EPNODE	 *ep;
 
 
 void
-initfile(fp, fn, ln)		/* prepare input file */
-FILE  *fp;
-char  *fn;
-int  ln;
+initfile(		/* prepare input file */
+    FILE  *fp,
+    char  *fn,
+    int  ln
+)
 {
     static char	 inpbuf[MAXLINE];
 
@@ -342,10 +370,11 @@ int  ln;
 
 
 void
-initstr(s, fn, ln)		/* prepare input string */
-char  *s;
-char  *fn;
-int  ln;
+initstr(		/* prepare input string */
+    char  *s,
+    char  *fn,
+    int  ln
+)
 {
     infp = NULL;
     infile = fn;
@@ -357,11 +386,12 @@ int  ln;
 
 
 void
-getscanpos(fnp, lnp, spp, fpp)	/* return current scan position */
-char  **fnp;
-int  *lnp;
-char  **spp;
-FILE  **fpp;
+getscanpos(	/* return current scan position */
+    char  **fnp,
+    int  *lnp,
+    char  **spp,
+    FILE  **fpp
+)
 {
     if (fnp != NULL) *fnp = infile;
     if (lnp != NULL) *lnp = lineno;
@@ -371,9 +401,9 @@ FILE  **fpp;
 
 
 int
-scan()				/* scan next character, return literal next */
+scan(void)		/* scan next character, return literal next */
 {
-    register int  lnext = 0;
+    int  lnext = 0;
 
     do {
 	if (linbuf[linepos] == '\0')
@@ -388,6 +418,10 @@ scan()				/* scan next character, return literal next 
 	    nextc = linbuf[linepos++];
 	if (!lnext)
 		lnext = nextc;
+	if (nextc == eofc) {
+		nextc = EOF;
+		break;
+	}
 	if (nextc == '{') {
 	    scan();
 	    while (nextc != '}')
@@ -403,11 +437,12 @@ scan()				/* scan next character, return literal next 
 
 
 char *
-long2ascii(l)			      /* convert long to ascii */
-long  l;
+long2ascii(			      /* convert long to ascii */
+    long  l
+)
 {
     static char	 buf[16];
-    register char  *cp;
+    char  *cp;
     int	 neg = 0;
 
     if (l == 0)
@@ -429,10 +464,11 @@ long  l;
 
 
 void
-syntax(err)			/* report syntax error and quit */
-char  *err;
+syntax(			/* report syntax error and quit */
+    char  *err
+)
 {
-    register int  i;
+    int  i;
 
     if (infile != NULL || lineno != 0) {
 	if (infile != NULL) eputs(infile);
@@ -455,9 +491,10 @@ char  *err;
 
 
 void
-addekid(ep, ekid)			/* add a child to ep */
-register EPNODE	 *ep;
-EPNODE	*ekid;
+addekid(			/* add a child to ep */
+    EPNODE	 *ep,
+    EPNODE	*ekid
+)
 {
     if (ep->v.kid == NULL)
 	ep->v.kid = ekid;
@@ -471,10 +508,10 @@ EPNODE	*ekid;
 
 
 char *
-getname()			/* scan an identifier */
+getname(void)			/* scan an identifier */
 {
     static char	 str[RMAXWORD+1];
-    register int  i, lnext;
+    int  i, lnext;
 
     lnext = nextc;
     for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
@@ -488,9 +525,9 @@ getname()			/* scan an identifier */
 
 
 int
-getinum()			/* scan a positive integer */
+getinum(void)			/* scan a positive integer */
 {
-    register int  n, lnext;
+    int  n, lnext;
 
     n = 0;
     lnext = nextc;
@@ -503,9 +540,9 @@ getinum()			/* scan a positive integer */
 
 
 double
-getnum()			/* scan a positive float */
+getnum(void)			/* scan a positive float */
 {
-    register int  i, lnext;
+    int  i, lnext;
     char  str[RMAXWORD+1];
 
     i = 0;
@@ -524,10 +561,10 @@ getnum()			/* scan a positive float */
 	    lnext = scan();
 	}
     }
-    if ((lnext == 'e' | lnext == 'E') && i < RMAXWORD) {
+    if ((lnext == 'e') | (lnext == 'E') && i < RMAXWORD) {
 	str[i++] = lnext;
 	lnext = scan();
-	if ((lnext == '-' | lnext == '+') && i < RMAXWORD) {
+	if ((lnext == '-') | (lnext == '+') && i < RMAXWORD) {
 	    str[i++] = lnext;
 	    lnext = scan();
 	}
@@ -545,10 +582,10 @@ getnum()			/* scan a positive float */
 
 
 EPNODE *
-getE1()				/* E1 -> E1 ADDOP E2 */
+getE1(void)			/* E1 -> E1 ADDOP E2 */
 				/*	 E2 */
 {
-    register EPNODE  *ep1, *ep2;
+    EPNODE  *ep1, *ep2;
 
     ep1 = getE2();
     while (nextc == '+' || nextc == '-') {
@@ -567,10 +604,10 @@ getE1()				/* E1 -> E1 ADDOP E2 */
 
 
 EPNODE *
-getE2()				/* E2 -> E2 MULOP E3 */
+getE2(void)			/* E2 -> E2 MULOP E3 */
 				/*	 E3 */
 {
-    register EPNODE  *ep1, *ep2;
+    EPNODE  *ep1, *ep2;
 
     ep1 = getE3();
     while (nextc == '*' || nextc == '/') {
@@ -579,9 +616,28 @@ getE2()				/* E2 -> E2 MULOP E3 */
 	scan();
 	addekid(ep2, ep1);
 	addekid(ep2, getE3());
-	if (esupport&E_RCONST &&
-			ep1->type == NUM && ep1->sibling->type == NUM)
-		ep2 = rconst(ep2);
+	if (esupport&E_RCONST) {
+		EPNODE	*ep3 = ep1->sibling;
+		if (ep1->type == NUM && ep3->type == NUM) {
+			ep2 = rconst(ep2);
+		} else if (ep3->type == NUM) {
+			if (ep2->type == '/') {
+				if (ep3->v.num == 0)
+					syntax("divide by zero constant");
+				ep2->type = '*';	/* for speed */
+				ep3->v.num = 1./ep3->v.num;
+			} else if (ep3->v.num == 0) {
+				ep1->sibling = NULL;	/* (E2 * 0) */
+				epfree(ep2);
+				ep2 = ep3;
+			}
+		} else if (ep1->type == NUM && ep1->v.num == 0) {
+			epfree(ep3);		/* (0 * E3) or (0 / E3) */
+			ep1->sibling = NULL;
+			efree((char *)ep2);
+			ep2 = ep1;
+		}
+	}
 	ep1 = ep2;
     }
     return(ep1);
@@ -589,32 +645,45 @@ getE2()				/* E2 -> E2 MULOP E3 */
 
 
 EPNODE *
-getE3()				/* E3 -> E4 ^ E3 */
+getE3(void)			/* E3 -> E4 ^ E3 */
 				/*	 E4 */
 {
-    register EPNODE  *ep1, *ep2;
+	EPNODE  *ep1, *ep2;
 
-    ep1 = getE4();
-    if (nextc == '^') {
+	ep1 = getE4();
+	if (nextc != '^')
+		return(ep1);
 	ep2 = newnode();
 	ep2->type = nextc;
 	scan();
 	addekid(ep2, ep1);
 	addekid(ep2, getE3());
-	if (esupport&E_RCONST &&
-			ep1->type == NUM && ep1->sibling->type == NUM)
-		ep2 = rconst(ep2);
+	if (esupport&E_RCONST) {
+		EPNODE	*ep3 = ep1->sibling;
+		if (ep1->type == NUM && ep3->type == NUM) {
+			ep2 = rconst(ep2);
+		} else if (ep1->type == NUM && ep1->v.num == 0) {
+			epfree(ep3);		/* (0 ^ E3) */
+			ep1->sibling = NULL;
+			efree((char *)ep2);
+			ep2 = ep1;
+		} else if ((ep3->type == NUM && ep3->v.num == 0) ||
+				(ep1->type == NUM && ep1->v.num == 1)) {
+			epfree(ep2);		/* (E4 ^ 0) or (1 ^ E3) */
+			ep2 = newnode();
+			ep2->type = NUM;
+			ep2->v.num = 1;
+		}
+	}
 	return(ep2);
-    }
-    return(ep1);
 }
 
 
 EPNODE *
-getE4()				/* E4 -> ADDOP E5 */
+getE4(void)			/* E4 -> ADDOP E5 */
 				/*	 E5 */
 {
-    register EPNODE  *ep1, *ep2;
+    EPNODE  *ep1, *ep2;
 
     if (nextc == '-') {
 	scan();
@@ -624,8 +693,9 @@ getE4()				/* E4 -> ADDOP E5 */
 		return(ep2);
 	}
 	if (ep2->type == UMINUS) {	/* don't generate -(-E5) */
+	    ep1 = ep2->v.kid;
 	    efree((char *)ep2);
-	    return(ep2->v.kid);
+	    return(ep1);
 	}
 	ep1 = newnode();
 	ep1->type = UMINUS;
@@ -639,7 +709,7 @@ getE4()				/* E4 -> ADDOP E5 */
 
 
 EPNODE *
-getE5()				/* E5 -> (E1) */
+getE5(void)			/* E5 -> (E1) */
 				/*	 VAR */
 				/*	 NUM */
 				/*	 $N */
@@ -648,7 +718,7 @@ getE5()				/* E5 -> (E1) */
 {
 	int	 i;
 	char  *nam;
-	register EPNODE  *ep1, *ep2;
+	EPNODE  *ep1, *ep2;
 
 	if (nextc == '(') {
 		scan();
@@ -717,10 +787,11 @@ getE5()				/* E5 -> (E1) */
 
 
 EPNODE *
-rconst(epar)			/* reduce a constant expression */
-register EPNODE	 *epar;
+rconst(			/* reduce a constant expression */
+    EPNODE	 *epar
+)
 {
-    register EPNODE  *ep;
+    EPNODE  *ep;
 
     ep = newnode();
     ep->type = NUM;
@@ -735,10 +806,11 @@ register EPNODE	 *epar;
 
 
 int
-isconstvar(ep)			/* is ep linked to a constant expression? */
-register EPNODE	 *ep;
+isconstvar(			/* is ep linked to a constant expression? */
+    EPNODE	 *ep
+)
 {
-    register EPNODE  *ep1;
+    EPNODE  *ep1;
 
     if (esupport&E_FUNCTION && ep->type == FUNC) {
 	if (!isconstfun(ep->v.kid))
@@ -760,19 +832,21 @@ register EPNODE	 *ep;
 
 
 int
-isconstfun(ep)			/* is ep linked to a constant function? */
-register EPNODE	 *ep;
+isconstfun(			/* is ep linked to a constant function? */
+    EPNODE	 *ep
+)
 {
-    register EPNODE  *dp;
-    register LIBR  *lp;
+    EPNODE  *dp;
+    LIBR  *lp;
 
     if (ep->type != VAR)
 	return(0);
-    if ((dp = ep->v.ln->def) != NULL)
+    if ((dp = ep->v.ln->def) != NULL) {
 	if (dp->v.kid->type == FUNC)
 	    return(dp->type == ':');
 	else
 	    return(0);		/* don't identify masked library functions */
+    }
     if ((lp = ep->v.ln->lib) != NULL)
 	return(lp->atyp == ':');
     return(0);