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.6 by greg, Mon Sep 21 12:01:54 1992 UTC vs.
Revision 2.18 by greg, Sat Feb 22 02:07:21 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1992 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  Compute data values using expression parser
6		*
#	Line 16 | Line 13 | static char SCCSid[] = "$SunId$ LBL";
13		*  1/29/87  Made variables conditional (VARIABLE)
14		*
15		*  5/19/88  Added constant subexpression elimination (RCONST)
16	+	*
17	+	*  2/19/03     Eliminated conditional compiles in favor of esupport extern.
18		*/
19
20	+	/* ====================================================================
21	+	* The Radiance Software License, Version 1.0
22	+	*
23	+	* Copyright (c) 1990 - 2002 The Regents of the University of California,
24	+	* through Lawrence Berkeley National Laboratory.   All rights reserved.
25	+	*
26	+	* Redistribution and use in source and binary forms, with or without
27	+	* modification, are permitted provided that the following conditions
28	+	* are met:
29	+	*
30	+	* 1. Redistributions of source code must retain the above copyright
31	+	*         notice, this list of conditions and the following disclaimer.
32	+	*
33	+	* 2. Redistributions in binary form must reproduce the above copyright
34	+	*       notice, this list of conditions and the following disclaimer in
35	+	*       the documentation and/or other materials provided with the
36	+	*       distribution.
37	+	*
38	+	* 3. The end-user documentation included with the redistribution,
39	+	*           if any, must include the following acknowledgment:
40	+	*             "This product includes Radiance software
41	+	*                 (http://radsite.lbl.gov/)
42	+	*                 developed by the Lawrence Berkeley National Laboratory
43	+	*               (http://www.lbl.gov/)."
44	+	*       Alternately, this acknowledgment may appear in the software itself,
45	+	*       if and wherever such third-party acknowledgments normally appear.
46	+	*
47	+	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
48	+	*       and "The Regents of the University of California" must
49	+	*       not be used to endorse or promote products derived from this
50	+	*       software without prior written permission. For written
51	+	*       permission, please contact [email protected].
52	+	*
53	+	* 5. Products derived from this software may not be called "Radiance",
54	+	*       nor may "Radiance" appear in their name, without prior written
55	+	*       permission of Lawrence Berkeley National Laboratory.
56	+	*
57	+	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
58	+	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
59	+	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
60	+	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
61	+	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
62	+	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
63	+	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
64	+	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
65	+	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
66	+	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
67	+	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68	+	* SUCH DAMAGE.
69	+	* ====================================================================
70	+	*
71	+	* This software consists of voluntary contributions made by many
72	+	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
73	+	* information on Lawrence Berkeley National Laboratory, please see
74	+	* <http://www.lbl.gov/>.
75	+	*/
76	+
77		#include  <stdio.h>
78
79		#include  <ctype.h>
80
81		#include  <errno.h>
82
83	+	#include  <math.h>
84	+
85	+	#include  <stdlib.h>
86	+
87		#include  "calcomp.h"
88
89		#define  MAXLINE        256             /* maximum line length */
#	Line 32 | Line 92 | static char SCCSid[] = "$SunId$ LBL";
92
93		#define  isdecimal(c)   (isdigit(c) || (c) == '.')
94
95	<	#ifndef atof
96	<	extern double  atof();
37	<	#endif
38	<	extern double  pow();
39	<	extern char  *fgets(), *savestr();
40	<	extern char  *emalloc(), *ecalloc();
41	<	extern EPNODE  *curfunc;
42	<	extern double  efunc(), evariable();
43	<	static double  euminus(), echannel(), eargument(), enumber();
95	>	static double  euminus(), eargument(), enumber();
96	>	static double  echannel();
97		static double  eadd(), esubtr(), emult(), edivi(), epow();
98		static double  ebotch();
99
100	+	unsigned int  esupport =                /* what to support */
101	+	E_VARIABLE | E_FUNCTION | E_REDEFW;
102	+
103		int  nextc;                             /* lookahead character */
104
105		double  (*eoper[])() = {                /* expression operations */
106		ebotch,
51	–	#ifdef  VARIABLE
107		evariable,
53	–	#else
54	–	ebotch,
55	–	#endif
108		enumber,
109		euminus,
58	–	#ifdef  INCHAN
110		echannel,
60	–	#else
61	–	ebotch,
62	–	#endif
63	–	#ifdef  FUNCTION
111		efunc,
112		eargument,
66	–	#else
113		ebotch,
114		ebotch,
69	–	#endif
70	–	ebotch,
71	–	ebotch,
115		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
116		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
117		emult,
#	Line 100 | Line 143 | char  *expr;
143		EPNODE  *ep;
144
145		initstr(expr, NULL, 0);
103	–	#if  defined(VARIABLE) && defined(FUNCTION)
146		curfunc = NULL;
105	–	#endif
147		ep = getE1();
148		if (nextc != EOF)
149		syntax("unexpected character");
#	Line 124 | Line 165 | char  *expr;
165		}
166
167
168	+	int
169	+	epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
170	+	register EPNODE  *ep1, *ep2;
171	+	{
172	+	double  d;
173	+
174	+	if (ep1->type != ep2->type)
175	+	return(1);
176	+
177	+	switch (ep1->type) {
178	+
179	+	case VAR:
180	+	return(ep1->v.ln != ep2->v.ln);
181	+
182	+	case NUM:
183	+	if (ep2->v.num == 0)
184	+	return(ep1->v.num != 0);
185	+	d = ep1->v.num / ep2->v.num;
186	+	return(d > 1.000000000001 | d < 0.999999999999);
187	+
188	+	case CHAN:
189	+	case ARG:
190	+	return(ep1->v.chan != ep2->v.chan);
191	+
192	+	case '=':
193	+	case ':':
194	+	return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
195	+
196	+	case TICK:
197	+	case SYM:                       /* should never get this one */
198	+	return(0);
199	+
200	+	default:
201	+	ep1 = ep1->v.kid;
202	+	ep2 = ep2->v.kid;
203	+	while (ep1 != NULL) {
204	+	if (ep2 == NULL)
205	+	return(1);
206	+	if (epcmp(ep1, ep2))
207	+	return(1);
208	+	ep1 = ep1->sibling;
209	+	ep2 = ep2->sibling;
210	+	}
211	+	return(ep2 != NULL);
212	+	}
213	+	}
214	+
215	+
216	+	void
217		epfree(epar)                    /* free a parse tree */
218		register EPNODE  *epar;
219		{
#	Line 131 | Line 221 | register EPNODE         *epar;
221
222		switch (epar->type) {
223
134	–	#if  defined(VARIABLE) || defined(FUNCTION)
224		case VAR:
225		varfree(epar->v.ln);
226		break;
#	Line 139 | Line 228 | register EPNODE         *epar;
228		case SYM:
229		freestr(epar->v.name);
230		break;
142	–	#endif
231
232		case NUM:
233		case CHAN:
#	Line 148 | Line 236 | register EPNODE         *epar;
236		break;
237
238		default:
239	<	for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
239	>	while ((ep = epar->v.kid) != NULL) {
240	>	epar->v.kid = ep->sibling;
241		epfree(ep);
242	+	}
243		break;
244
245		}
#	Line 158 | Line 248 | register EPNODE         *epar;
248		}
249
250		/* the following used to be a switch */
161	–	#ifdef  FUNCTION
251		static double
252		eargument(ep)
253		EPNODE  *ep;
254		{
255		return(argument(ep->v.chan));
256		}
168	–	#endif
257
258		static double
259		enumber(ep)
#	Line 183 | Line 271 | EPNODE *ep;
271		return(-evalue(ep1));
272		}
273
186	–	#ifdef  INCHAN
274		static double
275		echannel(ep)
276		EPNODE  *ep;
277		{
278		return(chanvalue(ep->v.chan));
279		}
193	–	#endif
280
281		static double
282		eadd(ep)
#	Line 294 | Line 380 | register EPNODE         *ep;
380		}
381
382
383	+	void
384		initfile(fp, fn, ln)            /* prepare input file */
385		FILE  *fp;
386		char  *fn;
#	Line 311 | Line 398 | int  ln;
398		}
399
400
401	+	void
402		initstr(s, fn, ln)              /* prepare input string */
403		char  *s;
404		char  *fn;
#	Line 325 | Line 413 | int  ln;
413		}
414
415
416	+	void
417		getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
418		char  **fnp;
419		int  *lnp;
#	Line 371 | Line 460 | scan()                         /* scan next character, return literal next
460
461
462		char *
463	<	ltoa(l)                         /* convert long to ascii */
463	>	long2ascii(l)                         /* convert long to ascii */
464		long  l;
465		{
466		static char  buf[16];
#	Line 396 | Line 485 | long  l;
485		}
486
487
488	+	void
489		syntax(err)                     /* report syntax error and quit */
490		char  *err;
491		{
#	Line 405 | Line 495 | char  *err;
495		if (infile != NULL) eputs(infile);
496		if (lineno != 0) {
497		eputs(infile != NULL ? ", line " : "line ");
498	<	eputs(ltoa((long)lineno));
498	>	eputs(long2ascii((long)lineno));
499		}
500	<	eputs(": syntax error:\n");
500	>	eputs(":\n");
501		}
502		eputs(linbuf);
503		if (linbuf[strlen(linbuf)-1] != '\n')
#	Line 421 | Line 511 | char  *err;
511		}
512
513
514	+	void
515		addekid(ep, ekid)                       /* add a child to ep */
516		register EPNODE  *ep;
517		EPNODE  *ekid;
#	Line 436 | Line 527 | EPNODE *ekid;
527		}
528
529
439	–	#if  defined(VARIABLE) || defined(FUNCTION)
530		char *
531		getname()                       /* scan an identifier */
532		{
#	Line 452 | Line 542 | getname()                      /* scan an identifier */
542
543		return(str);
544		}
455	–	#endif
545
546
547		int
#	Line 485 | Line 574 | getnum()                       /* scan a positive float */
574		if (lnext == '.' && i < MAXWORD) {
575		str[i++] = lnext;
576		lnext = scan();
577	+	if (i == 1 && !isdigit(lnext))
578	+	syntax("badly formed number");
579		while (isdigit(lnext) && i < MAXWORD) {
580		str[i++] = lnext;
581		lnext = scan();
582		}
583		}
584	<	if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
584	>	if ((lnext == 'e' | lnext == 'E') && i < MAXWORD) {
585		str[i++] = lnext;
586		lnext = scan();
587	<	if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
587	>	if ((lnext == '-' | lnext == '+') && i < MAXWORD) {
588		str[i++] = lnext;
589		lnext = scan();
590		}
591	+	if (!isdigit(lnext))
592	+	syntax("missing exponent");
593		while (isdigit(lnext) && i < MAXWORD) {
594		str[i++] = lnext;
595		lnext = scan();
#	Line 521 | Line 614 | getE1()                                /* E1 -> E1 ADDOP E2 */
614		scan();
615		addekid(ep2, ep1);
616		addekid(ep2, getE2());
617	<	#ifdef  RCONST
618	<	if (ep1->type == NUM && ep1->sibling->type == NUM)
617	>	if (esupport&E_RCONST &&
618	>	ep1->type == NUM && ep1->sibling->type == NUM)
619		ep2 = rconst(ep2);
527	–	#endif
620		ep1 = ep2;
621		}
622		return(ep1);
#	Line 544 | Line 636 | getE2()                                /* E2 -> E2 MULOP E3 */
636		scan();
637		addekid(ep2, ep1);
638		addekid(ep2, getE3());
639	<	#ifdef  RCONST
640	<	if (ep1->type == NUM && ep1->sibling->type == NUM)
639	>	if (esupport&E_RCONST &&
640	>	ep1->type == NUM && ep1->sibling->type == NUM)
641		ep2 = rconst(ep2);
550	–	#endif
642		ep1 = ep2;
643		}
644		return(ep1);
#	Line 567 | Line 658 | getE3()                                /* E3 -> E4 ^ E3 */
658		scan();
659		addekid(ep2, ep1);
660		addekid(ep2, getE3());
661	<	#ifdef  RCONST
662	<	if (ep1->type == NUM && ep1->sibling->type == NUM)
661	>	if (esupport&E_RCONST &&
662	>	ep1->type == NUM && ep1->sibling->type == NUM)
663		ep2 = rconst(ep2);
573	–	#endif
664		return(ep2);
665		}
666		return(ep1);
#	Line 626 | Line 716 | getE5()                                /* E5 -> (E1) */
716		return(ep1);
717		}
718
719	<	#ifdef  INCHAN
630	<	if (nextc == '$') {
719	>	if (esupport&E_INCHAN && nextc == '$') {
720		scan();
721		ep1 = newnode();
722		ep1->type = CHAN;
723		ep1->v.chan = getinum();
724		return(ep1);
725		}
637	–	#endif
726
727	<	#if  defined(VARIABLE) || defined(FUNCTION)
728	<	if (isalpha(nextc) || nextc == CNTXMARK) {
729	<	nam = getname();
730	<	#if  defined(VARIABLE) && defined(FUNCTION)
731	<	ep1 = NULL;
732	<	if (curfunc != NULL)
727	>	if (esupport&(E_VARIABLE|E_FUNCTION) &&
728	>	(isalpha(nextc) || nextc == CNTXMARK)) {
729	>	nam = getname();
730	>	ep1 = NULL;
731	>	if ((esupport&(E_VARIABLE|E_FUNCTION)) == (E_VARIABLE|E_FUNCTION)
732	>	&& curfunc != NULL)
733		for (i = 1, ep2 = curfunc->v.kid->sibling;
734		ep2 != NULL; i++, ep2 = ep2->sibling)
735		if (!strcmp(ep2->v.name, nam)) {
#	Line 650 | Line 738 | getE5()                                /* E5 -> (E1) */
738		ep1->v.chan = i;
739		break;
740		}
741	<	if (ep1 == NULL)
654	<	#endif
655	<	{
741	>	if (ep1 == NULL) {
742		ep1 = newnode();
743		ep1->type = VAR;
744		ep1->v.ln = varinsert(nam);
745		}
746	<	#ifdef  FUNCTION
661	<	if (nextc == '(') {
746	>	if (esupport&E_FUNCTION && nextc == '(') {
747		ep2 = newnode();
748		ep2->type = FUNC;
749		addekid(ep2, ep1);
#	Line 670 | Line 755 | getE5()                                /* E5 -> (E1) */
755		if (nextc != ')')
756		syntax("')' expected");
757		scan();
758	<	}
674	<	#ifndef  VARIABLE
675	<	else
758	>	} else if (!(esupport&E_VARIABLE))
759		syntax("'(' expected");
760	<	#endif
678	<	#endif
679	<	#ifdef  RCONST
680	<	if (isconstvar(ep1))
760	>	if (esupport&E_RCONST && isconstvar(ep1))
761		ep1 = rconst(ep1);
682	–	#endif
762		return(ep1);
763		}
685	–	#endif
764
765		if (isdecimal(nextc)) {
766		ep1 = newnode();
#	Line 694 | Line 772 | getE5()                                /* E5 -> (E1) */
772		}
773
774
697	–	#ifdef  RCONST
775		EPNODE *
776		rconst(epar)                    /* reduce a constant expression */
777		register EPNODE  *epar;
#	Line 713 | Line 790 | register EPNODE         *epar;
790		}
791
792
793	+	int
794		isconstvar(ep)                  /* is ep linked to a constant expression? */
795		register EPNODE  *ep;
796		{
719	–	#ifdef  VARIABLE
797		register EPNODE  *ep1;
721	–	#ifdef  FUNCTION
798
799	<	if (ep->type == FUNC) {
799	>	if (esupport&E_FUNCTION && ep->type == FUNC) {
800		if (!isconstfun(ep->v.kid))
801		return(0);
802		for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
#	Line 728 | Line 804 | register EPNODE         *ep;
804		return(0);
805		return(1);
806		}
731	–	#endif
807		if (ep->type != VAR)
808		return(0);
809		ep1 = ep->v.ln->def;
810		if (ep1 == NULL || ep1->type != ':')
811		return(0);
812	<	#ifdef  FUNCTION
738	<	if (ep1->v.kid->type != SYM)
812	>	if (esupport&E_FUNCTION && ep1->v.kid->type != SYM)
813		return(0);
740	–	#endif
814		return(1);
742	–	#else
743	–	return(ep->type == FUNC);
744	–	#endif
815		}
816
817
818	<	#if  defined(FUNCTION) && defined(VARIABLE)
818	>	int
819		isconstfun(ep)                  /* is ep linked to a constant function? */
820		register EPNODE  *ep;
821		{
#	Line 754 | Line 824 | register EPNODE         *ep;
824
825		if (ep->type != VAR)
826		return(0);
827	<	if ((dp = ep->v.ln->def) != NULL && dp->v.kid->type == FUNC)
828	<	return(dp->type == ':');
827	>	if ((dp = ep->v.ln->def) != NULL)
828	>	if (dp->v.kid->type == FUNC)
829	>	return(dp->type == ':');
830	>	else
831	>	return(0);          /* don't identify masked library functions */
832		if ((lp = ep->v.ln->lib) != NULL)
833		return(lp->atyp == ':');
834		return(0);
835		}
763	–	#endif
764	–	#endif

Diff Legend

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