ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/calexpr.c

Comparing ray/src/common/calexpr.c (file contents):
Revision 2.28 by schorsch, Fri Nov 14 17:22:06 2003 UTC vs.
Revision 2.50 by greg, Tue Feb 27 01:24:10 2024 UTC

#	Line 19 | Line 19 | static const char      RCSid[] = "$Id$";
19
20		#include "copyright.h"
21
22	–	#include  <stdio.h>
23	–	#include  <string.h>
22		#include  <ctype.h>
23		#include  <errno.h>
24		#include  <math.h>
25		#include  <stdlib.h>
26
27	+	#include  "rtmisc.h"
28	+	#include  "rtio.h"
29		#include  "rterror.h"
30		#include  "calcomp.h"
31
#	Line 33 | Line 33 | static const char      RCSid[] = "$Id$";
33
34		#define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
35
36	<	#define  isdecimal(c)   (isdigit(c) || (c) == '.')
36	>	#define  isdecimal(c)   (isdigit(c) | ((c) == '.'))
37
38	<	static double  euminus(EPNODE *), eargument(EPNODE *), enumber(EPNODE *);
38	>	#define  envalue(ep)    ((ep)->type==NUM ? (ep)->v.num : evalue(ep))
39	>
40	>	static double  euminus(EPNODE *), enumber(EPNODE *);
41		static double  echannel(EPNODE *);
42		static double  eadd(EPNODE *), esubtr(EPNODE *),
43		emult(EPNODE *), edivi(EPNODE *),
#	Line 45 | Line 47 | static double  ebotch(EPNODE *);
47		unsigned int  esupport =                /* what to support */
48		E_VARIABLE | E_FUNCTION ;
49
50	+	int  eofc = 0;                          /* optional end-of-file character */
51		int  nextc;                             /* lookahead character */
52
53		double  (*eoper[])(EPNODE *) = {        /* expression operations */
#	Line 102 | Line 105 | eval(                  /* evaluate an expression string */
105		char  *expr
106		)
107		{
108	<	register EPNODE  *ep;
108	>	int  prev_support = esupport;
109	>	EPNODE  *ep;
110		double  rval;
111
112	+	esupport &= ~E_RCONST;      /* don't bother reducing constant expr */
113		ep = eparse(expr);
114	+	esupport = prev_support;    /* as you were */
115		rval = evalue(ep);
116	<	epfree(ep);
116	>	epfree(ep,1);
117		return(rval);
118		}
119
120
121		int
122		epcmp(                  /* compare two expressions for equivalence */
123	<	register EPNODE  *ep1,
124	<	register EPNODE  *ep2
123	>	EPNODE  *ep1,
124	>	EPNODE  *ep2
125		)
126		{
127		double  d;
#	Line 142 | Line 148 | epcmp(                 /* compare two expressions for equivalence */
148		case ':':
149		return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
150
151	<	case TICK:
151	>	case CLKT:
152		case SYM:                       /* should never get this one */
153		return(0);
154
#	Line 164 | Line 170 | epcmp(                 /* compare two expressions for equivalence */
170
171		void
172		epfree(                 /* free a parse tree */
173	<	register EPNODE      *epar
173	>	EPNODE       *epar,
174	>	int         frep
175		)
176		{
177	<	register EPNODE  *ep;
177	>	EPNODE      *ep;
178
179		switch (epar->type) {
180
#	Line 182 | Line 189 | epfree(                        /* free a parse tree */
189		case NUM:
190		case CHAN:
191		case ARG:
192	<	case TICK:
192	>	case CLKT:
193		break;
194
195		default:
196	<	while ((ep = epar->v.kid) != NULL) {
197	<	epar->v.kid = ep->sibling;
198	<	epfree(ep);
199	<	}
196	>	if (epar->nkids < 0) {
197	>	ep = epar->v.kid - epar->nkids;
198	>	while (ep > epar->v.kid)
199	>	epfree(--ep, 0);
200	>	efree(ep);      /* free array space */
201	>	} else
202	>	while ((ep = epar->v.kid) != NULL) {
203	>	epar->v.kid = ep->sibling;
204	>	epfree(ep, 1);
205	>	}
206		break;
207
208		}
209	+	if (frep)
210	+	efree(epar);
211	+	else
212	+	memset(epar, 0, sizeof(EPNODE));
213	+	}
214
215	<	efree((char *)epar);
215	>
216	>	static void
217	>	epflatten(                      /* flatten hierarchies for '+', '*' */
218	>	EPNODE *epar
219	>	)
220	>	{
221	>	EPNODE      *ep;
222	>
223	>	if (epar->nkids < 0)        /* can't handle array allocations */
224	>	return;
225	>
226	>	for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
227	>	while (ep->type == epar->type && ep->nkids > 0) {
228	>	EPNODE      *ep1 = ep->v.kid;
229	>	while (ep1->sibling != NULL)
230	>	ep1 = ep1->sibling;
231	>	ep1->sibling = ep->sibling;
232	>	epar->nkids += ep->nkids - 1;
233	>	ep1 = ep->v.kid;
234	>	*ep = *ep1;
235	>	efree(ep1);         /* not epfree()! */
236	>	}
237		}
238
239	<	/* the following used to be a switch */
240	<	static double
241	<	eargument(
242	<	EPNODE      *ep
239	>
240	>	void
241	>	epoptimize(                     /* flatten operations, lists -> arrays */
242	>	EPNODE  *epar
243		)
244		{
245	<	return(argument(ep->v.chan));
245	>	EPNODE      *ep;
246	>
247	>	if ((epar->type == '+') | (epar->type == '*'))
248	>	epflatten(epar);        /* flatten associative operations */
249	>
250	>	if (epar->nkids)            /* do children if any */
251	>	for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
252	>	epoptimize(ep);
253	>
254	>	if (epar->nkids > 4) {      /* make list into array if > 4 kids */
255	>	int     n = 1;
256	>	epar->v.kid = (EPNODE *)erealloc(epar->v.kid,
257	>	sizeof(EPNODE)*epar->nkids);
258	>	while (n < epar->nkids) {
259	>	ep = epar->v.kid[n-1].sibling;
260	>	epar->v.kid[n] = *ep;
261	>	efree(ep);          /* not epfree()! */
262	>	epar->v.kid[n-1].sibling = epar->v.kid + n;
263	>	n++;
264	>	}
265	>	epar->nkids = -n;
266	>	}
267		}
268
269	+	/* the following used to be a switch */
270		static double
271		enumber(
272		EPNODE      *ep
#	Line 219 | Line 280 | euminus(
280		EPNODE      *ep
281		)
282		{
283	<	register EPNODE  *ep1 = ep->v.kid;
283	>	EPNODE  *ep1 = ep->v.kid;
284
285		return(-evalue(ep1));
286		}
#	Line 237 | Line 298 | eadd(
298		EPNODE      *ep
299		)
300		{
301	<	register EPNODE  *ep1 = ep->v.kid;
301	>	double  sum = 0;
302	>	EPNODE  *ep1 = ep->v.kid;
303
304	<	return(evalue(ep1) + evalue(ep1->sibling));
304	>	do
305	>	sum += envalue(ep1);
306	>	while ((ep1 = ep1->sibling) != NULL);
307	>
308	>	return(sum);
309		}
310
311		static double
#	Line 247 | Line 313 | esubtr(
313		EPNODE      *ep
314		)
315		{
316	<	register EPNODE  *ep1 = ep->v.kid;
316	>	EPNODE  *ep1 = ep->v.kid;
317	>	EPNODE  *ep2 = ep1->sibling;
318
319	<	return(evalue(ep1) - evalue(ep1->sibling));
319	>	return(envalue(ep1) - envalue(ep2));
320		}
321
322		static double
#	Line 257 | Line 324 | emult(
324		EPNODE      *ep
325		)
326		{
327	<	register EPNODE  *ep1 = ep->v.kid;
327	>	double  prod = 1;
328	>	EPNODE  *ep1 = ep->v.kid;
329
330	<	return(evalue(ep1) * evalue(ep1->sibling));
330	>	do
331	>	prod *= envalue(ep1);
332	>	while ((ep1 = ep1->sibling) != NULL);
333	>
334	>	return(prod);
335		}
336
337		static double
#	Line 267 | Line 339 | edivi(
339		EPNODE      *ep
340		)
341		{
342	<	register EPNODE  *ep1 = ep->v.kid;
343	<	double  d;
342	>	EPNODE  *ep1 = ep->v.kid;
343	>	double  den = evalue(ep1->sibling);
344
345	<	d = evalue(ep1->sibling);
274	<	if (d == 0.0) {
345	>	if (den == 0.0) {
346		wputs("Division by zero\n");
347		errno = ERANGE;
348		return(0.0);
349		}
350	<	return(evalue(ep1) / d);
350	>	return(envalue(ep1) / den);
351		}
352
353		static double
#	Line 284 | Line 355 | epow(
355		EPNODE      *ep
356		)
357		{
358	<	register EPNODE  *ep1 = ep->v.kid;
358	>	EPNODE  *ep1 = ep->v.kid;
359		double  d;
360		int  lasterrno;
361
362		lasterrno = errno;
363		errno = 0;
364		d = pow(evalue(ep1), evalue(ep1->sibling));
365	<	#ifdef  IEEE
366	<	if (!finite(d))
367	<	errno = EDOM;
365	>	#ifdef  isnan
366	>	if (errno == 0) {
367	>	if (isnan(d))
368	>	errno = EDOM;
369	>	else if (isinf(d))
370	>	errno = ERANGE;
371	>	}
372		#endif
373	<	if (errno == EDOM || errno == ERANGE) {
373	>	if ((errno == EDOM) | (errno == ERANGE)) {
374		wputs("Illegal power\n");
375		return(0.0);
376		}
#	Line 316 | Line 391 | ebotch(
391
392		EPNODE *
393		ekid(                   /* return pointer to a node's nth kid */
394	<	register EPNODE      *ep,
395	<	register int  n
394	>	EPNODE       *ep,
395	>	int  n
396		)
397		{
398	<
399	<	for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
400	<	if (--n < 0)
401	<	break;
402	<
398	>	if (ep->nkids < 0) {        /* allocated array? */
399	>	if (n >= -ep->nkids)
400	>	return(NULL);
401	>	return(ep->v.kid + n);
402	>	}
403	>	ep = ep->v.kid;             /* else get from list */
404	>	while (n-- > 0)
405	>	if ((ep = ep->sibling) == NULL)
406	>	break;
407		return(ep);
408		}
409
410
332	–	int
333	–	nekids(                 /* return # of kids for node ep */
334	–	register EPNODE      *ep
335	–	)
336	–	{
337	–	register int  n = 0;
338	–
339	–	for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
340	–	n++;
341	–
342	–	return(n);
343	–	}
344	–
345	–
411		void
412		initfile(               /* prepare input file */
413		FILE  *fp,
#	Line 396 | Line 461 | getscanpos(    /* return current scan position */
461		int
462		scan(void)              /* scan next character, return literal next */
463		{
464	<	register int  lnext = 0;
464	>	int  lnext = 0;
465
466		do {
467		if (linbuf[linepos] == '\0')
#	Line 411 | Line 476 | scan(void)             /* scan next character, return literal nex
476		nextc = linbuf[linepos++];
477		if (!lnext)
478		lnext = nextc;
479	+	if (nextc == eofc) {
480	+	nextc = EOF;
481	+	break;
482	+	}
483		if (nextc == '{') {
484		scan();
485		while (nextc != '}')
#	Line 431 | Line 500 | long2ascii(                          /* convert long to ascii */
500		)
501		{
502		static char  buf[16];
503	<	register char  *cp;
503	>	char  *cp;
504		int  neg = 0;
505
506		if (l == 0)
#	Line 457 | Line 526 | syntax(                        /* report syntax error and quit */
526		char  *err
527		)
528		{
529	<	register int  i;
529	>	int  i;
530
531	<	if (infile != NULL || lineno != 0) {
531	>	if ((infile != NULL) | (lineno != 0)) {
532		if (infile != NULL) eputs(infile);
533		if (lineno != 0) {
534		eputs(infile != NULL ? ", line " : "line ");
#	Line 481 | Line 550 | syntax(                        /* report syntax error and quit */
550
551		void
552		addekid(                        /* add a child to ep */
553	<	register EPNODE      *ep,
554	<	EPNODE      *ekid
553	>	EPNODE       *ep,
554	>	EPNODE      *ek
555		)
556		{
557	+	if (ep->nkids < 0) {
558	+	eputs("Cannot add kid to EPNODE array\n");
559	+	quit(1);
560	+	}
561	+	ep->nkids++;
562		if (ep->v.kid == NULL)
563	<	ep->v.kid = ekid;
563	>	ep->v.kid = ek;
564		else {
565		for (ep = ep->v.kid; ep->sibling != NULL; ep = ep->sibling)
566		;
567	<	ep->sibling = ekid;
567	>	ep->sibling = ek;
568		}
569	<	ekid->sibling = NULL;
569	>	ek->sibling = NULL;         /* shouldn't be necessary */
570		}
571
572
#	Line 500 | Line 574 | char *
574		getname(void)                   /* scan an identifier */
575		{
576		static char  str[RMAXWORD+1];
577	<	register int  i, lnext;
577	>	int  i, lnext;
578
579		lnext = nextc;
580		for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
#	Line 516 | Line 590 | getname(void)                  /* scan an identifier */
590		int
591		getinum(void)                   /* scan a positive integer */
592		{
593	<	register int  n, lnext;
593	>	int  n, lnext;
594
595		n = 0;
596		lnext = nextc;
#	Line 531 | Line 605 | getinum(void)                  /* scan a positive integer */
605		double
606		getnum(void)                    /* scan a positive float */
607		{
608	<	register int  i, lnext;
608	>	int  i, lnext;
609		char  str[RMAXWORD+1];
610
611		i = 0;
#	Line 540 | Line 614 | getnum(void)                   /* scan a positive float */
614		str[i++] = lnext;
615		lnext = scan();
616		}
617	<	if (lnext == '.' && i < RMAXWORD) {
617	>	if ((lnext == '.') & (i < RMAXWORD)) {
618		str[i++] = lnext;
619		lnext = scan();
620		if (i == 1 && !isdigit(lnext))
#	Line 571 | Line 645 | getnum(void)                   /* scan a positive float */
645
646
647		EPNODE *
648	<	getE1(void)                             /* E1 -> E1 ADDOP E2 */
648	>	getE1(void)                     /* E1 -> E1 ADDOP E2 */
649		/*       E2 */
650		{
651	<	register EPNODE  *ep1, *ep2;
651	>	EPNODE  *ep1, *ep2;
652
653		ep1 = getE2();
654	<	while (nextc == '+' || nextc == '-') {
654	>	while ((nextc == '+') | (nextc == '-')) {
655		ep2 = newnode();
656		ep2->type = nextc;
657		scan();
658		addekid(ep2, ep1);
659		addekid(ep2, getE2());
660		if (esupport&E_RCONST &&
661	<	ep1->type == NUM && ep1->sibling->type == NUM)
661	>	(ep1->type == NUM) & (ep1->sibling->type == NUM))
662		ep2 = rconst(ep2);
663		ep1 = ep2;
664		}
#	Line 593 | Line 667 | getE1(void)                            /* E1 -> E1 ADDOP E2 */
667
668
669		EPNODE *
670	<	getE2(void)                             /* E2 -> E2 MULOP E3 */
670	>	getE2(void)                     /* E2 -> E2 MULOP E3 */
671		/*       E3 */
672		{
673	<	register EPNODE  *ep1, *ep2;
673	>	EPNODE  *ep1, *ep2;
674
675		ep1 = getE3();
676	<	while (nextc == '*' || nextc == '/') {
676	>	while ((nextc == '*') | (nextc == '/')) {
677		ep2 = newnode();
678		ep2->type = nextc;
679		scan();
680		addekid(ep2, ep1);
681		addekid(ep2, getE3());
682	<	if (esupport&E_RCONST &&
683	<	ep1->type == NUM && ep1->sibling->type == NUM)
684	<	ep2 = rconst(ep2);
682	>	if (esupport&E_RCONST) {
683	>	EPNODE  *ep3 = ep1->sibling;
684	>	if ((ep1->type == NUM) & (ep3->type == NUM)) {
685	>	ep2 = rconst(ep2);
686	>	} else if (ep3->type == NUM) {
687	>	if (ep2->type == '/') {
688	>	if (ep3->v.num == 0)
689	>	syntax("divide by zero constant");
690	>	ep2->type = '*';        /* for speed */
691	>	ep3->v.num = 1./ep3->v.num;
692	>	} else if (ep3->v.num == 0) {
693	>	ep1->sibling = NULL;    /* (E2 * 0) */
694	>	epfree(ep2,1);
695	>	ep2 = ep3;
696	>	}
697	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
698	>	epfree(ep3,1);          /* (0 * E3) or (0 / E3) */
699	>	ep1->sibling = NULL;
700	>	efree(ep2);
701	>	ep2 = ep1;
702	>	}
703	>	}
704		ep1 = ep2;
705		}
706		return(ep1);
#	Line 615 | Line 708 | getE2(void)                            /* E2 -> E2 MULOP E3 */
708
709
710		EPNODE *
711	<	getE3(void)                             /* E3 -> E4 ^ E3 */
711	>	getE3(void)                     /* E3 -> E4 ^ E3 */
712		/*       E4 */
713		{
714	<	register EPNODE  *ep1, *ep2;
714	>	EPNODE  *ep1, *ep2;
715
716	<	ep1 = getE4();
717	<	if (nextc == '^') {
716	>	ep1 = getE4();
717	>	if (nextc != '^')
718	>	return(ep1);
719		ep2 = newnode();
720		ep2->type = nextc;
721		scan();
722		addekid(ep2, ep1);
723		addekid(ep2, getE3());
724	<	if (esupport&E_RCONST &&
725	<	ep1->type == NUM && ep1->sibling->type == NUM)
726	<	ep2 = rconst(ep2);
724	>	if (esupport&E_RCONST) {
725	>	EPNODE  *ep3 = ep1->sibling;
726	>	if ((ep1->type == NUM) & (ep3->type == NUM)) {
727	>	ep2 = rconst(ep2);
728	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
729	>	epfree(ep3,1);          /* (0 ^ E3) */
730	>	ep1->sibling = NULL;
731	>	efree(ep2);
732	>	ep2 = ep1;
733	>	} else if ((ep3->type == NUM && ep3->v.num == 0) |
734	>	(ep1->type == NUM && ep1->v.num == 1)) {
735	>	epfree(ep2,0);          /* (E4 ^ 0) or (1 ^ E3) */
736	>	ep2->type = NUM;
737	>	ep2->v.num = 1;
738	>	} else if (ep3->type == NUM && ep3->v.num == 1) {
739	>	efree(ep3);     /* (E4 ^ 1) */
740	>	ep1->sibling = NULL;
741	>	efree(ep2);
742	>	ep2 = ep1;
743	>	}
744	>	}
745		return(ep2);
634	–	}
635	–	return(ep1);
746		}
747
748
749		EPNODE *
750	<	getE4(void)                             /* E4 -> ADDOP E5 */
750	>	getE4(void)                     /* E4 -> ADDOP E5 */
751		/*       E5 */
752		{
753	<	register EPNODE  *ep1, *ep2;
753	>	EPNODE  *ep1, *ep2;
754
755		if (nextc == '-') {
756		scan();
#	Line 650 | Line 760 | getE4(void)                            /* E4 -> ADDOP E5 */
760		return(ep2);
761		}
762		if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
763	<	efree((char *)ep2);
764	<	return(ep2->v.kid);
763	>	ep1 = ep2->v.kid;
764	>	efree(ep2);
765	>	return(ep1);
766		}
767		ep1 = newnode();
768		ep1->type = UMINUS;
#	Line 674 | Line 785 | getE5(void)                    /* E5 -> (E1) */
785		{
786		int      i;
787		char  *nam;
788	<	register EPNODE  *ep1, *ep2;
788	>	EPNODE  *ep1, *ep2;
789
790		if (nextc == '(') {
791		scan();
#	Line 684 | Line 795 | getE5(void)                    /* E5 -> (E1) */
795		scan();
796		return(ep1);
797		}
687	–
798		if (esupport&E_INCHAN && nextc == '$') {
799		scan();
800		ep1 = newnode();
#	Line 692 | Line 802 | getE5(void)                    /* E5 -> (E1) */
802		ep1->v.chan = getinum();
803		return(ep1);
804		}
695	–
805		if (esupport&(E_VARIABLE|E_FUNCTION) &&
806	<	(isalpha(nextc) || nextc == CNTXMARK)) {
806	>	(isalpha(nextc) | (nextc == CNTXMARK))) {
807		nam = getname();
808		ep1 = NULL;
809		if ((esupport&(E_VARIABLE|E_FUNCTION)) == (E_VARIABLE|E_FUNCTION)
#	Line 730 | Line 839 | getE5(void)                    /* E5 -> (E1) */
839		ep1 = rconst(ep1);
840		return(ep1);
841		}
733	–
842		if (isdecimal(nextc)) {
843		ep1 = newnode();
844		ep1->type = NUM;
#	Line 744 | Line 852 | getE5(void)                    /* E5 -> (E1) */
852
853		EPNODE *
854		rconst(                 /* reduce a constant expression */
855	<	register EPNODE      *epar
855	>	EPNODE       *epar
856		)
857		{
858	<	register EPNODE  *ep;
858	>	EPNODE  *ep;
859
860		ep = newnode();
861		ep->type = NUM;
862		errno = 0;
863		ep->v.num = evalue(epar);
864	<	if (errno == EDOM || errno == ERANGE)
864	>	if ((errno == EDOM) | (errno == ERANGE))
865		syntax("bad constant expression");
866	<	epfree(epar);
866	>	epfree(epar,1);
867
868		return(ep);
869		}
#	Line 763 | Line 871 | rconst(                        /* reduce a constant expression */
871
872		int
873		isconstvar(                     /* is ep linked to a constant expression? */
874	<	register EPNODE      *ep
874	>	EPNODE       *ep
875		)
876		{
877	<	register EPNODE  *ep1;
877	>	EPNODE  *ep1;
878
879		if (esupport&E_FUNCTION && ep->type == FUNC) {
880		if (!isconstfun(ep->v.kid))
#	Line 789 | Line 897 | isconstvar(                    /* is ep linked to a constant expression
897
898		int
899		isconstfun(                     /* is ep linked to a constant function? */
900	<	register EPNODE      *ep
900	>	EPNODE       *ep
901		)
902		{
903	<	register EPNODE  *dp;
904	<	register LIBR  *lp;
903	>	EPNODE  *dp;
904	>	LIBR  *lp;
905
906		if (ep->type != VAR)
907		return(0);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)