--- ray/src/common/calfunc.c	2003/02/22 02:07:21	2.8
+++ ray/src/common/calfunc.c	2021/09/16 23:48:47	2.26
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char	RCSid[] = "$Id: calfunc.c,v 2.8 2003/02/22 02:07:21 greg Exp $";
+static const char	RCSid[] = "$Id: calfunc.c,v 2.26 2021/09/16 23:48:47 greg Exp $";
 #endif
 /*
  *  calfunc.c - routines for calcomp using functions.
@@ -10,74 +10,19 @@ static const char	RCSid[] = "$Id: calfunc.c,v 2.8 2003
  *  2/19/03	Eliminated conditional compiles in favor of esupport extern.
  */
 
-/* ====================================================================
- * The Radiance Software License, Version 1.0
- *
- * Copyright (c) 1990 - 2002 The Regents of the University of California,
- * through Lawrence Berkeley National Laboratory.   All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *         notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in
- *       the documentation and/or other materials provided with the
- *       distribution.
- *
- * 3. The end-user documentation included with the redistribution,
- *           if any, must include the following acknowledgment:
- *             "This product includes Radiance software
- *                 (http://radsite.lbl.gov/)
- *                 developed by the Lawrence Berkeley National Laboratory
- *               (http://www.lbl.gov/)."
- *       Alternately, this acknowledgment may appear in the software itself,
- *       if and wherever such third-party acknowledgments normally appear.
- *
- * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
- *       and "The Regents of the University of California" must
- *       not be used to endorse or promote products derived from this
- *       software without prior written permission. For written
- *       permission, please contact radiance@radsite.lbl.gov.
- *
- * 5. Products derived from this software may not be called "Radiance",
- *       nor may "Radiance" appear in their name, without prior written
- *       permission of Lawrence Berkeley National Laboratory.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ====================================================================
- *
- * This software consists of voluntary contributions made by many
- * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
- * information on Lawrence Berkeley National Laboratory, please see
- * <http://www.lbl.gov/>.
- */
+#include "copyright.h"
 
 #include  <stdio.h>
-
+#include  <string.h>
 #include  <errno.h>
-
 #include  <math.h>
 
+#include  "rterror.h"
 #include  "calcomp.h"
 
 				/* bits in argument flag (better be right!) */
 #define  AFLAGSIZ	(8*sizeof(unsigned long))
-#define  ALISTSIZ	6	/* maximum saved argument list */
+#define  ALISTSIZ	8	/* maximum saved argument list */
 
 typedef struct activation {
     char  *name;		/* function name */
@@ -89,18 +34,20 @@ typedef struct activation {
 
 static ACTIVATION  *curact = NULL;
 
-static double  libfunc();
+static double  libfunc(char *fname, VARDEF *vp);
 
 #ifndef  MAXLIB
 #define  MAXLIB		64	/* maximum number of library functions */
 #endif
 
-static double  l_if(), l_select(), l_rand();
-static double  l_floor(), l_ceil();
-static double  l_sqrt();
-static double  l_sin(), l_cos(), l_tan();
-static double  l_asin(), l_acos(), l_atan(), l_atan2();
-static double  l_exp(), l_log(), l_log10();
+static double  l_if(char *), l_select(char *);
+static double  l_min(char *), l_max(char *);
+static double  l_rand(char *);
+static double  l_floor(char *), l_ceil(char *);
+static double  l_sqrt(char *);
+static double  l_sin(char *), l_cos(char *), l_tan(char *);
+static double  l_asin(char *), l_acos(char *), l_atan(char *), l_atan2(char *);
+static double  l_exp(char *), l_log(char *), l_log10(char *);
 
 			/* functions must be listed alphabetically */
 static LIBR  library[MAXLIB] = {
@@ -115,6 +62,8 @@ static LIBR  library[MAXLIB] = {
     { "if", 3, ':', l_if },
     { "log", 1, ':', l_log },
     { "log10", 1, ':', l_log10 },
+    { "max", 1, ':', l_max },
+    { "min", 1, ':', l_min },
     { "rand", 1, ':', l_rand },
     { "select", 1, ':', l_select },
     { "sin", 1, ':', l_sin },
@@ -122,17 +71,18 @@ static LIBR  library[MAXLIB] = {
     { "tan", 1, ':', l_tan },
 };
 
-static int  libsize = 16;
+static int  libsize = 18;
 
 #define  resolve(ep)	((ep)->type==VAR?(ep)->v.ln:argf((ep)->v.chan))
 
 
 int
-fundefined(fname)		/* return # of arguments for function */
-char  *fname;
+fundefined(			/* return # of req'd arguments for function */
+	char  *fname
+)
 {
-    register LIBR  *lp;
-    register VARDEF  *vp;
+    LIBR  *lp;
+    VARDEF  *vp;
 
     if ((vp = varlookup(fname)) != NULL && vp->def != NULL
 		&& vp->def->v.kid->type == FUNC)
@@ -145,22 +95,26 @@ char  *fname;
 
 
 double
-funvalue(fname, n, a)		/* return a function value to the user */
-char  *fname;
-int  n;
-double  *a;
+funvalue(			/* return a function value to the user */
+	char  *fname,
+	int  n,
+	double  *a
+)
 {
     ACTIVATION  act;
-    register VARDEF  *vp;
+    VARDEF  *vp;
     double  rval;
 					/* push environment */
     act.name = fname;
     act.prev = curact;
     act.ap = a;
-    if (n >= AFLAGSIZ)
-	act.an = ~0;
-    else
+    if (n < AFLAGSIZ)
 	act.an = (1L<<n)-1;
+    else {
+	act.an = ~0;
+	if (n > AFLAGSIZ)
+	    wputs("Excess arguments in funvalue()\n");
+    }
     act.fun = NULL;
     curact = &act;
 
@@ -176,43 +130,42 @@ double  *a;
 
 
 void
-funset(fname, nargs, assign, fptr)	/* set a library function */
-char  *fname;
-int  nargs;
-int  assign;
-double  (*fptr)();
+funset(				/* set a library function */
+	char  *fname,
+	int  nargs,
+	int  assign,
+	double  (*fptr)(char *)
+)
 {
     int  oldlibsize = libsize;
     char *cp;
-    register LIBR  *lp;
+    LIBR  *lp;
 						/* check for context */
     for (cp = fname; *cp; cp++)
 	;
     if (cp == fname)
 	return;
-    if (cp[-1] == CNTXMARK)
+    while (cp[-1] == CNTXMARK) {
 	*--cp = '\0';
+	if (cp == fname) return;
+    }
     if ((lp = liblookup(fname)) == NULL) {	/* insert */
+	if (fptr == NULL)
+		return;				/* nothing! */
 	if (libsize >= MAXLIB) {
 	    eputs("Too many library functons!\n");
 	    quit(1);
 	}
 	for (lp = &library[libsize]; lp > library; lp--)
-	    if (strcmp(lp[-1].fname, fname) > 0) {
-		lp[0].fname = lp[-1].fname;
-		lp[0].nargs = lp[-1].nargs;
-		lp[0].atyp = lp[-1].atyp;
-		lp[0].f = lp[-1].f;
-	    } else
+	    if (strcmp(lp[-1].fname, fname) > 0)
+		lp[0] = lp[-1];
+	    else
 		break;
 	libsize++;
     }
     if (fptr == NULL) {				/* delete */
 	while (lp < &library[libsize-1]) {
-	    lp[0].fname = lp[1].fname;
-	    lp[0].nargs = lp[1].nargs;
-	    lp[0].atyp = lp[1].atyp;
-	    lp[0].f = lp[1].f;
+	    lp[0] = lp[1];
 	    lp++;
 	}
 	libsize--;
@@ -228,9 +181,9 @@ double  (*fptr)();
 
 
 int
-nargum()			/* return number of available arguments */
+nargum(void)			/* return number of available arguments */
 {
-    register int  n;
+    int  n;
 
     if (curact == NULL)
 	return(0);
@@ -244,30 +197,31 @@ nargum()			/* return number of available arguments */
 
 
 double
-argument(n)			/* return nth argument for active function */
-register int  n;
+argument(int n)			/* return nth argument for active function */
 {
-    register ACTIVATION  *actp = curact;
-    register EPNODE  *ep;
+    ACTIVATION  *actp = curact;
+    EPNODE  *ep = NULL;
     double  aval;
 
-    if (actp == NULL || --n < 0) {
+    if (!n)					/* asking for # arguments? */
+	return((double)nargum());
+
+    if (!actp | (--n < 0)) {
 	eputs("Bad call to argument!\n");
 	quit(1);
     }
-						/* already computed? */
-    if (n < AFLAGSIZ && 1L<<n & actp->an)
+    if ((n < AFLAGSIZ) & actp->an >> n)		/* already computed? */
 	return(actp->ap[n]);
 
-    if (actp->fun == NULL || (ep = ekid(actp->fun, n+1)) == NULL) {
+    if (!actp->fun || !(ep = ekid(actp->fun, n+1))) {
 	eputs(actp->name);
 	eputs(": too few arguments\n");
 	quit(1);
     }
-    curact = actp->prev;			/* pop environment */
+    curact = actp->prev;			/* previous context */
     aval = evalue(ep);				/* compute argument */
-    curact = actp;				/* push back environment */
-    if (n < ALISTSIZ) {				/* save value */
+    curact = actp;				/* put back calling context */
+    if (n < ALISTSIZ) {				/* save value if room */
 	actp->ap[n] = aval;
 	actp->an |= 1L<<n;
     }
@@ -276,11 +230,10 @@ register int  n;
 
 
 VARDEF *
-argf(n)				/* return function def for nth argument */
-int  n;
+argf(int n)			/* return function def for nth argument */
 {
-    register ACTIVATION  *actp;
-    register EPNODE  *ep;
+    ACTIVATION  *actp;
+    EPNODE  *ep;
 
     for (actp = curact; actp != NULL; actp = actp->prev) {
 
@@ -310,25 +263,24 @@ badarg:
     eputs(actp->name);
     eputs(": argument not a function\n");
     quit(1);
+	return NULL; /* pro forma return */
 }
 
 
 char *
-argfun(n)			/* return function name for nth argument */
-int  n;
+argfun(int n)			/* return function name for nth argument */
 {
     return(argf(n)->name);
 }
 
 
 double
-efunc(ep)				/* evaluate a function */
-register EPNODE  *ep;
+efunc(EPNODE *ep)			/* evaluate a function */
 {
     ACTIVATION  act;
     double  alist[ALISTSIZ];
     double  rval;
-    register VARDEF  *dp;
+    VARDEF  *dp;
 					/* push environment */
     dp = resolve(ep->v.kid);
     act.name = dp->name;
@@ -349,11 +301,10 @@ register EPNODE  *ep;
 
 
 LIBR *
-liblookup(fname)		/* look up a library function */
-char  *fname;
+liblookup(char *fname)		/* look up a library function */
 {
     int  upper, lower;
-    register int  cm, i;
+    int  cm, i;
 
     lower = 0;
     upper = cm = libsize;
@@ -378,11 +329,12 @@ char  *fname;
 
 
 static double
-libfunc(fname, vp)			/* execute library function */
-char  *fname;
-VARDEF  *vp;
+libfunc(				/* execute library function */
+	char  *fname,
+	VARDEF  *vp
+)
 {
-    register LIBR  *lp;
+    LIBR  *lp;
     double  d;
     int  lasterrno;
 
@@ -398,14 +350,15 @@ VARDEF  *vp;
     lasterrno = errno;
     errno = 0;
     d = (*lp->f)(lp->fname);
-#ifdef  IEEE
-    if (errno == 0)
+#ifdef  isnan
+    if (errno == 0) {
 	if (isnan(d))
 	    errno = EDOM;
 	else if (isinf(d))
 	    errno = ERANGE;
+    }
 #endif
-    if (errno) {
+    if (errno == EDOM || errno == ERANGE) {
 	wputs(fname);
 	if (errno == EDOM)
 		wputs(": domain error\n");
@@ -426,7 +379,7 @@ VARDEF  *vp;
 
 
 static double
-l_if()			/* if(cond, then, else) conditional expression */
+l_if(char *nm)		/* if(cond, then, else) conditional expression */
 			/* cond evaluates true if greater than zero */
 {
     if (argument(1) > 0.0)
@@ -437,24 +390,55 @@ l_if()			/* if(cond, then, else) conditional expressio
 
 
 static double
-l_select()		/* return argument #(A1+1) */
+l_select(char *nm)	/* return argument #(A1+1) */
 {
-	register int  n;
+	int	narg = nargum();
+	double	a1 = argument(1);
+	int  n = (int)(a1 + .5);
 
-	n = argument(1) + .5;
-	if (n == 0)
-		return(nargum()-1);
-	if (n < 1 || n > nargum()-1) {
+	if (a1 < -.5 || n >= narg) {
 		errno = EDOM;
 		return(0.0);
 	}
+	if (!n)		/* asking max index? */
+		return(narg-1);
 	return(argument(n+1));
 }
 
 
 static double
-l_rand()		/* random function between 0 and 1 */
+l_max(char *nm)		/* general maximum function */
 {
+	int  n = nargum();
+	double  vmax = argument(1);
+
+	while (--n) {
+		double  v = argument(n);
+		if (vmax < v)
+			vmax = v;
+	}
+	return(vmax);
+}
+
+
+static double
+l_min(char *nm)		/* general minimum function */
+{
+	int  n = nargum();
+	double  vmin = argument(1);
+
+	while (--n) {
+		double  v = argument(n);
+		if (vmin > v)
+			vmin = v;
+	}
+	return(vmin);
+}
+
+
+static double
+l_rand(char *nm)		/* random function between 0 and 1 */
+{
     double  x;
 
     x = argument(1);
@@ -466,91 +450,91 @@ l_rand()		/* random function between 0 and 1 */
 
 
 static double
-l_floor()		/* return largest integer not greater than arg1 */
+l_floor(char *nm)		/* return largest integer not greater than arg1 */
 {
     return(floor(argument(1)));
 }
 
 
 static double
-l_ceil()		/* return smallest integer not less than arg1 */
+l_ceil(char *nm)		/* return smallest integer not less than arg1 */
 {
     return(ceil(argument(1)));
 }
 
 
 static double
-l_sqrt()
+l_sqrt(char *nm)
 {
     return(sqrt(argument(1)));
 }
 
 
 static double
-l_sin()
+l_sin(char *nm)
 {
     return(sin(argument(1)));
 }
 
 
 static double
-l_cos()
+l_cos(char *nm)
 {
     return(cos(argument(1)));
 }
 
 
 static double
-l_tan()
+l_tan(char *nm)
 {
     return(tan(argument(1)));
 }
 
 
 static double
-l_asin()
+l_asin(char *nm)
 {
     return(asin(argument(1)));
 }
 
 
 static double
-l_acos()
+l_acos(char *nm)
 {
     return(acos(argument(1)));
 }
 
 
 static double
-l_atan()
+l_atan(char *nm)
 {
     return(atan(argument(1)));
 }
 
 
 static double
-l_atan2()
+l_atan2(char *nm)
 {
     return(atan2(argument(1), argument(2)));
 }
 
 
 static double
-l_exp()
+l_exp(char *nm)
 {
     return(exp(argument(1)));
 }
 
 
 static double
-l_log()
+l_log(char *nm)
 {
     return(log(argument(1)));
 }
 
 
 static double
-l_log10()
+l_log10(char *nm)
 {
     return(log10(argument(1)));
 }