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 1.13 by greg, Thu Aug 8 12:11:19 1991 UTC vs.
Revision 2.6 by greg, Mon Sep 21 12:01:54 1992 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1986 Regents of the University of California */
1	>	/* Copyright (c) 1992 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 26 | Line 26 | static char SCCSid[] = "$SunId$ LBL";
26
27		#include  "calcomp.h"
28
29	<	#define  MAXLINE        256             /* maximum line length */
29	>	#define  MAXLINE        256             /* maximum line length */
30
31	<	#define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
31	>	#define  newnode()      (EPNODE *)ecalloc(1, sizeof(EPNODE))
32
33	<	#define  isdecimal(c)   (isdigit(c) || (c) == '.')
33	>	#define  isdecimal(c)   (isdigit(c) || (c) == '.')
34
35	<	extern double  atof(), pow();
35	>	#ifndef atof
36	>	extern double  atof();
37	>	#endif
38	>	extern double  pow();
39		extern char  *fgets(), *savestr();
40		extern char  *emalloc(), *ecalloc();
41		extern EPNODE  *curfunc;
#	Line 40 | Line 43 | extern double  efunc(), evariable();
43		static double  euminus(), echannel(), eargument(), enumber();
44		static double  eadd(), esubtr(), emult(), edivi(), epow();
45		static double  ebotch();
43	–	extern int  errno;
46
47		int  nextc;                             /* lookahead character */
48
49	<	double  (*eoper[])() = {                /* expression operations */
49	>	double  (*eoper[])() = {                /* expression operations */
50		ebotch,
51	<	#ifdef  VARIABLE
51	>	#ifdef  VARIABLE
52		evariable,
53		#else
54		ebotch,
55		#endif
56		enumber,
57		euminus,
58	<	#ifdef  INCHAN
58	>	#ifdef  INCHAN
59		echannel,
60		#else
61		ebotch,
62		#endif
63	<	#ifdef  FUNCTION
63	>	#ifdef  FUNCTION
64		efunc,
65		eargument,
66		#else
#	Line 123 | Line 125 | char  *expr;
125
126
127		epfree(epar)                    /* free a parse tree */
128	<	register EPNODE  *epar;
128	>	register EPNODE  *epar;
129		{
130		register EPNODE  *ep;
131
#	Line 133 | Line 135 | register EPNODE  *epar;
135		case VAR:
136		varfree(epar->v.ln);
137		break;
136	–	#endif
138
139		case SYM:
140		freestr(epar->v.name);
141		break;
142	+	#endif
143
144		case NUM:
145		case CHAN:
#	Line 156 | Line 158 | register EPNODE  *epar;
158		}
159
160		/* the following used to be a switch */
161	<	#ifdef  FUNCTION
161	>	#ifdef  FUNCTION
162		static double
163		eargument(ep)
164	<	EPNODE  *ep;
164	>	EPNODE  *ep;
165		{
166		return(argument(ep->v.chan));
167		}
#	Line 167 | Line 169 | EPNODE  *ep;
169
170		static double
171		enumber(ep)
172	<	EPNODE  *ep;
172	>	EPNODE  *ep;
173		{
174		return(ep->v.num);
175		}
176
177		static double
178		euminus(ep)
179	<	EPNODE  *ep;
179	>	EPNODE  *ep;
180		{
181		register EPNODE  *ep1 = ep->v.kid;
182
183		return(-evalue(ep1));
184		}
185
186	<	#ifdef  INCHAN
186	>	#ifdef  INCHAN
187		static double
188		echannel(ep)
189	<	EPNODE  *ep;
189	>	EPNODE  *ep;
190		{
191		return(chanvalue(ep->v.chan));
192		}
#	Line 192 | Line 194 | EPNODE  *ep;
194
195		static double
196		eadd(ep)
197	<	EPNODE  *ep;
197	>	EPNODE  *ep;
198		{
199		register EPNODE  *ep1 = ep->v.kid;
200
#	Line 201 | Line 203 | EPNODE  *ep;
203
204		static double
205		esubtr(ep)
206	<	EPNODE  *ep;
206	>	EPNODE  *ep;
207		{
208		register EPNODE  *ep1 = ep->v.kid;
209
#	Line 210 | Line 212 | EPNODE  *ep;
212
213		static double
214		emult(ep)
215	<	EPNODE  *ep;
215	>	EPNODE  *ep;
216		{
217		register EPNODE  *ep1 = ep->v.kid;
218
#	Line 219 | Line 221 | EPNODE  *ep;
221
222		static double
223		edivi(ep)
224	<	EPNODE  *ep;
224	>	EPNODE  *ep;
225		{
226		register EPNODE  *ep1 = ep->v.kid;
227		double  d;
#	Line 235 | Line 237 | EPNODE  *ep;
237
238		static double
239		epow(ep)
240	<	EPNODE  *ep;
240	>	EPNODE  *ep;
241		{
242		register EPNODE  *ep1 = ep->v.kid;
243		double  d;
244	<	int  lasterrno;
244	>	int  lasterrno;
245
246		lasterrno = errno;
247		errno = 0;
248		d = pow(evalue(ep1), evalue(ep1->sibling));
249	<	#ifdef  IEEE
249	>	#ifdef  IEEE
250		if (!finite(d))
251		errno = EDOM;
252		#endif
#	Line 258 | Line 260 | EPNODE  *ep;
260
261		static double
262		ebotch(ep)
263	<	EPNODE  *ep;
263	>	EPNODE  *ep;
264		{
265		eputs("Bad expression!\n");
266		quit(1);
#	Line 267 | Line 269 | EPNODE  *ep;
269
270		EPNODE *
271		ekid(ep, n)                     /* return pointer to a node's nth kid */
272	<	register EPNODE  *ep;
272	>	register EPNODE  *ep;
273		register int  n;
274		{
275
#	Line 281 | Line 283 | register int  n;
283
284		int
285		nekids(ep)                      /* return # of kids for node ep */
286	<	register EPNODE  *ep;
286	>	register EPNODE  *ep;
287		{
288		register int  n = 0;
289
#	Line 297 | Line 299 | FILE  *fp;
299		char  *fn;
300		int  ln;
301		{
302	<	static char  inpbuf[MAXLINE];
302	>	static char  inpbuf[MAXLINE];
303
304		infp = fp;
305		linbuf = inpbuf;
#	Line 372 | Line 374 | char *
374		ltoa(l)                         /* convert long to ascii */
375		long  l;
376		{
377	<	static char  buf[16];
377	>	static char  buf[16];
378		register char  *cp;
379	<	int  neg = 0;
379	>	int  neg = 0;
380
381		if (l == 0)
382		return("0");
#	Line 420 | Line 422 | char  *err;
422
423
424		addekid(ep, ekid)                       /* add a child to ep */
425	<	register EPNODE  *ep;
426	<	EPNODE  *ekid;
425	>	register EPNODE  *ep;
426	>	EPNODE  *ekid;
427		{
428		if (ep->v.kid == NULL)
429		ep->v.kid = ekid;
#	Line 434 | Line 436 | EPNODE  *ekid;
436		}
437
438
439	+	#if  defined(VARIABLE) || defined(FUNCTION)
440		char *
441		getname()                       /* scan an identifier */
442		{
443	<	static char  str[MAXWORD+1];
443	>	static char  str[MAXWORD+1];
444		register int  i, lnext;
445
446		lnext = nextc;
447		for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
448		str[i] = lnext;
449		str[i] = '\0';
450	+	while (isid(lnext))         /* skip rest of name */
451	+	lnext = scan();
452
453		return(str);
454		}
455	+	#endif
456
457
458		int
#	Line 477 | Line 483 | getnum()                       /* scan a positive float */
483		lnext = scan();
484		}
485		if (lnext == '.' && i < MAXWORD) {
486	<	str[i++] = lnext;
487	<	lnext = scan();
486	>	str[i++] = lnext;
487	>	lnext = scan();
488		while (isdigit(lnext) && i < MAXWORD) {
489		str[i++] = lnext;
490		lnext = scan();
491		}
492		}
493		if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
494	<	str[i++] = lnext;
495	<	lnext = scan();
494	>	str[i++] = lnext;
495	>	lnext = scan();
496		if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
497		str[i++] = lnext;
498		lnext = scan();
#	Line 504 | Line 510 | getnum()                       /* scan a positive float */
510
511		EPNODE *
512		getE1()                         /* E1 -> E1 ADDOP E2 */
513	<	/*       E2 */
513	>	/*       E2 */
514		{
515		register EPNODE  *ep1, *ep2;
516
#	Line 515 | Line 521 | getE1()                                /* E1 -> E1 ADDOP E2 */
521		scan();
522		addekid(ep2, ep1);
523		addekid(ep2, getE2());
524	<	#ifdef  RCONST
524	>	#ifdef  RCONST
525		if (ep1->type == NUM && ep1->sibling->type == NUM)
526		ep2 = rconst(ep2);
527		#endif
#	Line 527 | Line 533 | getE1()                                /* E1 -> E1 ADDOP E2 */
533
534		EPNODE *
535		getE2()                         /* E2 -> E2 MULOP E3 */
536	<	/*       E3 */
536	>	/*       E3 */
537		{
538		register EPNODE  *ep1, *ep2;
539
#	Line 538 | Line 544 | getE2()                                /* E2 -> E2 MULOP E3 */
544		scan();
545		addekid(ep2, ep1);
546		addekid(ep2, getE3());
547	<	#ifdef  RCONST
547	>	#ifdef  RCONST
548		if (ep1->type == NUM && ep1->sibling->type == NUM)
549		ep2 = rconst(ep2);
550		#endif
#	Line 550 | Line 556 | getE2()                                /* E2 -> E2 MULOP E3 */
556
557		EPNODE *
558		getE3()                         /* E3 -> E4 ^ E3 */
559	<	/*       E4 */
559	>	/*       E4 */
560		{
561		register EPNODE  *ep1, *ep2;
562
#	Line 561 | Line 567 | getE3()                                /* E3 -> E4 ^ E3 */
567		scan();
568		addekid(ep2, ep1);
569		addekid(ep2, getE3());
570	<	#ifdef  RCONST
570	>	#ifdef  RCONST
571		if (ep1->type == NUM && ep1->sibling->type == NUM)
572		ep2 = rconst(ep2);
573		#endif
#	Line 573 | Line 579 | getE3()                                /* E3 -> E4 ^ E3 */
579
580		EPNODE *
581		getE4()                         /* E4 -> ADDOP E5 */
582	<	/*       E5 */
582	>	/*       E5 */
583		{
584		register EPNODE  *ep1, *ep2;
585
#	Line 584 | Line 590 | getE4()                                /* E4 -> ADDOP E5 */
590		ep2->v.num = -ep2->v.num;
591		return(ep2);
592		}
593	+	if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
594	+	efree((char *)ep2);
595	+	return(ep2->v.kid);
596	+	}
597		ep1 = newnode();
598		ep1->type = UMINUS;
599		addekid(ep1, ep2);
#	Line 597 | Line 607 | getE4()                                /* E4 -> ADDOP E5 */
607
608		EPNODE *
609		getE5()                         /* E5 -> (E1) */
610	<	/*       VAR */
611	<	/*       NUM */
612	<	/*       $N */
613	<	/*       FUNC(E1,..) */
614	<	/*       ARG */
610	>	/*       VAR */
611	>	/*       NUM */
612	>	/*       $N */
613	>	/*       FUNC(E1,..) */
614	>	/*       ARG */
615		{
616	<	int  i;
616	>	int  i;
617	>	char  *nam;
618		register EPNODE  *ep1, *ep2;
619
620		if (nextc == '(') {
#	Line 615 | Line 626 | getE5()                                /* E5 -> (E1) */
626		return(ep1);
627		}
628
629	<	#ifdef  INCHAN
629	>	#ifdef  INCHAN
630		if (nextc == '$') {
631		scan();
632		ep1 = newnode();
#	Line 626 | Line 637 | getE5()                                /* E5 -> (E1) */
637		#endif
638
639		#if  defined(VARIABLE) || defined(FUNCTION)
640	<	if (isalpha(nextc)) {
641	<	ep1 = newnode();
631	<	ep1->type = VAR;
632	<	ep1->v.ln = varinsert(getname());
633	<
640	>	if (isalpha(nextc) || nextc == CNTXMARK) {
641	>	nam = getname();
642		#if  defined(VARIABLE) && defined(FUNCTION)
643	+	ep1 = NULL;
644		if (curfunc != NULL)
645		for (i = 1, ep2 = curfunc->v.kid->sibling;
646	<	ep2 != NULL; i++, ep2 = ep2->sibling)
647	<	if (!strcmp(ep2->v.name, ep1->v.ln->name)) {
639	<	epfree(ep1);
646	>	ep2 != NULL; i++, ep2 = ep2->sibling)
647	>	if (!strcmp(ep2->v.name, nam)) {
648		ep1 = newnode();
649		ep1->type = ARG;
650		ep1->v.chan = i;
651		break;
652		}
653	+	if (ep1 == NULL)
654		#endif
655	<	#ifdef  FUNCTION
655	>	{
656	>	ep1 = newnode();
657	>	ep1->type = VAR;
658	>	ep1->v.ln = varinsert(nam);
659	>	}
660	>	#ifdef  FUNCTION
661		if (nextc == '(') {
662		ep2 = newnode();
663		ep2->type = FUNC;
#	Line 657 | Line 671 | getE5()                                /* E5 -> (E1) */
671		syntax("')' expected");
672		scan();
673		}
674	<	#ifndef  VARIABLE
674	>	#ifndef  VARIABLE
675		else
676		syntax("'(' expected");
677		#endif
678		#endif
679	<	#ifdef  RCONST
679	>	#ifdef  RCONST
680		if (isconstvar(ep1))
681		ep1 = rconst(ep1);
682		#endif
#	Line 680 | Line 694 | getE5()                                /* E5 -> (E1) */
694		}
695
696
697	<	#ifdef  RCONST
697	>	#ifdef  RCONST
698		EPNODE *
699		rconst(epar)                    /* reduce a constant expression */
700	<	register EPNODE  *epar;
700	>	register EPNODE  *epar;
701		{
702		register EPNODE  *ep;
703
#	Line 692 | Line 706 | register EPNODE  *epar;
706		errno = 0;
707		ep->v.num = evalue(epar);
708		if (errno)
709	<	syntax("bad constant expression");
709	>	syntax("bad constant expression");
710		epfree(epar);
711
712		return(ep);
#	Line 700 | Line 714 | register EPNODE  *epar;
714
715
716		isconstvar(ep)                  /* is ep linked to a constant expression? */
717	<	register EPNODE  *ep;
717	>	register EPNODE  *ep;
718		{
719	<	#ifdef  VARIABLE
719	>	#ifdef  VARIABLE
720		register EPNODE  *ep1;
721	<	#ifdef  FUNCTION
721	>	#ifdef  FUNCTION
722
723		if (ep->type == FUNC) {
724		if (!isconstfun(ep->v.kid))
#	Line 720 | Line 734 | register EPNODE  *ep;
734		ep1 = ep->v.ln->def;
735		if (ep1 == NULL || ep1->type != ':')
736		return(0);
737	<	#ifdef  FUNCTION
737	>	#ifdef  FUNCTION
738		if (ep1->v.kid->type != SYM)
739		return(0);
740		#endif
#	Line 733 | Line 747 | register EPNODE  *ep;
747
748		#if  defined(FUNCTION) && defined(VARIABLE)
749		isconstfun(ep)                  /* is ep linked to a constant function? */
750	<	register EPNODE  *ep;
750	>	register EPNODE  *ep;
751		{
752		register EPNODE  *dp;
753		register LIBR  *lp;
754
755		if (ep->type != VAR)
756		return(0);
757	<	dp = ep->v.ln->def;
758	<	if (dp != NULL && dp->type != ':')
759	<	return(0);
760	<	if ((dp == NULL || dp->v.kid->type != FUNC)
761	<	&& ((lp = liblookup(ep->v.ln->name)) == NULL
748	<	|| lp->atyp != ':'))
749	<	return(0);
750	<	return(1);
757	>	if ((dp = ep->v.ln->def) != NULL && dp->v.kid->type == FUNC)
758	>	return(dp->type == ':');
759	>	if ((lp = ep->v.ln->lib) != NULL)
760	>	return(lp->atyp == ':');
761	>	return(0);
762		}
763		#endif
764		#endif

Diff Legend

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