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.22 by schorsch, Sat Jun 7 12:50:20 2003 UTC vs.
Revision 2.35 by greg, Sat Sep 4 19:04:35 2010 UTC

#	Line 26 | Line 26 | static const char      RCSid[] = "$Id$";
26		#include  <math.h>
27		#include  <stdlib.h>
28
29	+	#include  "rtmisc.h"
30	+	#include  "rtio.h"
31	+	#include  "rterror.h"
32		#include  "calcomp.h"
33
34		#define  MAXLINE        256             /* maximum line length */
#	Line 34 | Line 37 | static const char      RCSid[] = "$Id$";
37
38		#define  isdecimal(c)   (isdigit(c) || (c) == '.')
39
40	<	static double  euminus(), eargument(), enumber();
41	<	static double  echannel();
42	<	static double  eadd(), esubtr(), emult(), edivi(), epow();
43	<	static double  ebotch();
40	>	static double  euminus(EPNODE *), eargument(EPNODE *), enumber(EPNODE *);
41	>	static double  echannel(EPNODE *);
42	>	static double  eadd(EPNODE *), esubtr(EPNODE *),
43	>	emult(EPNODE *), edivi(EPNODE *),
44	>	epow(EPNODE *);
45	>	static double  ebotch(EPNODE *);
46
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[])() = {                /* expression operations */
53	>	double  (*eoper[])(EPNODE *) = {        /* expression operations */
54		ebotch,
55		evariable,
56		enumber,
#	Line 79 | Line 85 | static int  linepos;                   /* position in buffer */
85
86
87		EPNODE *
88	<	eparse(expr)                    /* parse an expression string */
89	<	char  *expr;
88	>	eparse(                 /* parse an expression string */
89	>	char  *expr
90	>	)
91		{
92		EPNODE  *ep;
93
#	Line 94 | Line 101 | char  *expr;
101
102
103		double
104	<	eval(expr)                      /* evaluate an expression string */
105	<	char  *expr;
104	>	eval(                   /* evaluate an expression string */
105	>	char  *expr
106	>	)
107		{
108		register EPNODE  *ep;
109		double  rval;
#	Line 108 | Line 116 | char  *expr;
116
117
118		int
119	<	epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
120	<	register EPNODE  *ep1, *ep2;
119	>	epcmp(                  /* compare two expressions for equivalence */
120	>	register EPNODE  *ep1,
121	>	register EPNODE  *ep2
122	>	)
123		{
124		double  d;
125
#	Line 125 | Line 135 | register EPNODE  *ep1, *ep2;
135		if (ep2->v.num == 0)
136		return(ep1->v.num != 0);
137		d = ep1->v.num / ep2->v.num;
138	<	return(d > 1.000000000001 | d < 0.999999999999);
138	>	return((d > 1.000000000001) | (d < 0.999999999999));
139
140		case CHAN:
141		case ARG:
#	Line 135 | Line 145 | register EPNODE  *ep1, *ep2;
145		case ':':
146		return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
147
148	<	case TICK:
148	>	case CLKT:
149		case SYM:                       /* should never get this one */
150		return(0);
151
#	Line 156 | Line 166 | register EPNODE  *ep1, *ep2;
166
167
168		void
169	<	epfree(epar)                    /* free a parse tree */
170	<	register EPNODE  *epar;
169	>	epfree(                 /* free a parse tree */
170	>	register EPNODE      *epar
171	>	)
172		{
173		register EPNODE  *ep;
174
#	Line 174 | Line 185 | register EPNODE         *epar;
185		case NUM:
186		case CHAN:
187		case ARG:
188	<	case TICK:
188	>	case CLKT:
189		break;
190
191		default:
#	Line 191 | Line 202 | register EPNODE         *epar;
202
203		/* the following used to be a switch */
204		static double
205	<	eargument(ep)
206	<	EPNODE  *ep;
205	>	eargument(
206	>	EPNODE      *ep
207	>	)
208		{
209		return(argument(ep->v.chan));
210		}
211
212		static double
213	<	enumber(ep)
214	<	EPNODE  *ep;
213	>	enumber(
214	>	EPNODE      *ep
215	>	)
216		{
217		return(ep->v.num);
218		}
219
220		static double
221	<	euminus(ep)
222	<	EPNODE  *ep;
221	>	euminus(
222	>	EPNODE      *ep
223	>	)
224		{
225		register EPNODE  *ep1 = ep->v.kid;
226
#	Line 214 | Line 228 | EPNODE *ep;
228		}
229
230		static double
231	<	echannel(ep)
232	<	EPNODE  *ep;
231	>	echannel(
232	>	EPNODE      *ep
233	>	)
234		{
235		return(chanvalue(ep->v.chan));
236		}
237
238		static double
239	<	eadd(ep)
240	<	EPNODE  *ep;
239	>	eadd(
240	>	EPNODE      *ep
241	>	)
242		{
243		register EPNODE  *ep1 = ep->v.kid;
244
#	Line 230 | Line 246 | EPNODE *ep;
246		}
247
248		static double
249	<	esubtr(ep)
250	<	EPNODE  *ep;
249	>	esubtr(
250	>	EPNODE      *ep
251	>	)
252		{
253		register EPNODE  *ep1 = ep->v.kid;
254
#	Line 239 | Line 256 | EPNODE *ep;
256		}
257
258		static double
259	<	emult(ep)
260	<	EPNODE  *ep;
259	>	emult(
260	>	EPNODE      *ep
261	>	)
262		{
263		register EPNODE  *ep1 = ep->v.kid;
264
#	Line 248 | Line 266 | EPNODE *ep;
266		}
267
268		static double
269	<	edivi(ep)
270	<	EPNODE  *ep;
269	>	edivi(
270	>	EPNODE      *ep
271	>	)
272		{
273		register EPNODE  *ep1 = ep->v.kid;
274		double  d;
#	Line 264 | Line 283 | EPNODE *ep;
283		}
284
285		static double
286	<	epow(ep)
287	<	EPNODE  *ep;
286	>	epow(
287	>	EPNODE      *ep
288	>	)
289		{
290		register EPNODE  *ep1 = ep->v.kid;
291		double  d;
#	Line 274 | Line 294 | EPNODE *ep;
294		lasterrno = errno;
295		errno = 0;
296		d = pow(evalue(ep1), evalue(ep1->sibling));
297	<	#ifdef  IEEE
298	<	if (!finite(d))
299	<	errno = EDOM;
297	>	#ifdef  isnan
298	>	if (errno == 0)
299	>	if (isnan(d))
300	>	errno = EDOM;
301	>	else if (isinf(d))
302	>	errno = ERANGE;
303		#endif
304		if (errno == EDOM || errno == ERANGE) {
305		wputs("Illegal power\n");
#	Line 287 | Line 310 | EPNODE *ep;
310		}
311
312		static double
313	<	ebotch(ep)
314	<	EPNODE  *ep;
313	>	ebotch(
314	>	EPNODE      *ep
315	>	)
316		{
317		eputs("Bad expression!\n");
318		quit(1);
#	Line 297 | Line 321 | EPNODE *ep;
321
322
323		EPNODE *
324	<	ekid(ep, n)                     /* return pointer to a node's nth kid */
325	<	register EPNODE  *ep;
326	<	register int  n;
324	>	ekid(                   /* return pointer to a node's nth kid */
325	>	register EPNODE      *ep,
326	>	register int  n
327	>	)
328		{
329
330		for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
#	Line 311 | Line 336 | register int  n;
336
337
338		int
339	<	nekids(ep)                      /* return # of kids for node ep */
340	<	register EPNODE  *ep;
339	>	nekids(                 /* return # of kids for node ep */
340	>	register EPNODE      *ep
341	>	)
342		{
343		register int  n = 0;
344
#	Line 324 | Line 350 | register EPNODE         *ep;
350
351
352		void
353	<	initfile(fp, fn, ln)            /* prepare input file */
354	<	FILE  *fp;
355	<	char  *fn;
356	<	int  ln;
353	>	initfile(               /* prepare input file */
354	>	FILE  *fp,
355	>	char  *fn,
356	>	int  ln
357	>	)
358		{
359		static char  inpbuf[MAXLINE];
360
#	Line 342 | Line 369 | int  ln;
369
370
371		void
372	<	initstr(s, fn, ln)              /* prepare input string */
373	<	char  *s;
374	<	char  *fn;
375	<	int  ln;
372	>	initstr(                /* prepare input string */
373	>	char  *s,
374	>	char  *fn,
375	>	int  ln
376	>	)
377		{
378		infp = NULL;
379		infile = fn;
#	Line 357 | Line 385 | int  ln;
385
386
387		void
388	<	getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
389	<	char  **fnp;
390	<	int  *lnp;
391	<	char  **spp;
392	<	FILE  **fpp;
388	>	getscanpos(     /* return current scan position */
389	>	char  **fnp,
390	>	int  *lnp,
391	>	char  **spp,
392	>	FILE  **fpp
393	>	)
394		{
395		if (fnp != NULL) *fnp = infile;
396		if (lnp != NULL) *lnp = lineno;
#	Line 371 | Line 400 | FILE  **fpp;
400
401
402		int
403	<	scan()                          /* scan next character, return literal next */
403	>	scan(void)              /* scan next character, return literal next */
404		{
405		register int  lnext = 0;
406
#	Line 388 | Line 417 | scan()                         /* scan next character, return literal next
417		nextc = linbuf[linepos++];
418		if (!lnext)
419		lnext = nextc;
420	+	if (nextc == eofc) {
421	+	nextc = EOF;
422	+	break;
423	+	}
424		if (nextc == '{') {
425		scan();
426		while (nextc != '}')
#	Line 403 | Line 436 | scan()                         /* scan next character, return literal next
436
437
438		char *
439	<	long2ascii(l)                         /* convert long to ascii */
440	<	long  l;
439	>	long2ascii(                           /* convert long to ascii */
440	>	long  l
441	>	)
442		{
443		static char  buf[16];
444		register char  *cp;
#	Line 429 | Line 463 | long  l;
463
464
465		void
466	<	syntax(err)                     /* report syntax error and quit */
467	<	char  *err;
466	>	syntax(                 /* report syntax error and quit */
467	>	char  *err
468	>	)
469		{
470		register int  i;
471
#	Line 455 | Line 490 | char  *err;
490
491
492		void
493	<	addekid(ep, ekid)                       /* add a child to ep */
494	<	register EPNODE  *ep;
495	<	EPNODE  *ekid;
493	>	addekid(                        /* add a child to ep */
494	>	register EPNODE      *ep,
495	>	EPNODE      *ekid
496	>	)
497		{
498		if (ep->v.kid == NULL)
499		ep->v.kid = ekid;
#	Line 471 | Line 507 | EPNODE *ekid;
507
508
509		char *
510	<	getname()                       /* scan an identifier */
510	>	getname(void)                   /* scan an identifier */
511		{
512	<	static char  str[MAXWORD+1];
512	>	static char  str[RMAXWORD+1];
513		register int  i, lnext;
514
515		lnext = nextc;
516	<	for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
516	>	for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
517		str[i] = lnext;
518		str[i] = '\0';
519		while (isid(lnext))         /* skip rest of name */
#	Line 488 | Line 524 | getname()                      /* scan an identifier */
524
525
526		int
527	<	getinum()                       /* scan a positive integer */
527	>	getinum(void)                   /* scan a positive integer */
528		{
529		register int  n, lnext;
530
#	Line 503 | Line 539 | getinum()                      /* scan a positive integer */
539
540
541		double
542	<	getnum()                        /* scan a positive float */
542	>	getnum(void)                    /* scan a positive float */
543		{
544		register int  i, lnext;
545	<	char  str[MAXWORD+1];
545	>	char  str[RMAXWORD+1];
546
547		i = 0;
548		lnext = nextc;
549	<	while (isdigit(lnext) && i < MAXWORD) {
549	>	while (isdigit(lnext) && i < RMAXWORD) {
550		str[i++] = lnext;
551		lnext = scan();
552		}
553	<	if (lnext == '.' && i < MAXWORD) {
553	>	if (lnext == '.' && i < RMAXWORD) {
554		str[i++] = lnext;
555		lnext = scan();
556		if (i == 1 && !isdigit(lnext))
557		syntax("badly formed number");
558	<	while (isdigit(lnext) && i < MAXWORD) {
558	>	while (isdigit(lnext) && i < RMAXWORD) {
559		str[i++] = lnext;
560		lnext = scan();
561		}
562		}
563	<	if ((lnext == 'e' | lnext == 'E') && i < MAXWORD) {
563	>	if ((lnext == 'e') | (lnext == 'E') && i < RMAXWORD) {
564		str[i++] = lnext;
565		lnext = scan();
566	<	if ((lnext == '-' | lnext == '+') && i < MAXWORD) {
566	>	if ((lnext == '-') | (lnext == '+') && i < RMAXWORD) {
567		str[i++] = lnext;
568		lnext = scan();
569		}
570		if (!isdigit(lnext))
571		syntax("missing exponent");
572	<	while (isdigit(lnext) && i < MAXWORD) {
572	>	while (isdigit(lnext) && i < RMAXWORD) {
573		str[i++] = lnext;
574		lnext = scan();
575		}
#	Line 545 | Line 581 | getnum()                       /* scan a positive float */
581
582
583		EPNODE *
584	<	getE1()                         /* E1 -> E1 ADDOP E2 */
584	>	getE1(void)                     /* E1 -> E1 ADDOP E2 */
585		/*       E2 */
586		{
587		register EPNODE  *ep1, *ep2;
#	Line 567 | Line 603 | getE1()                                /* E1 -> E1 ADDOP E2 */
603
604
605		EPNODE *
606	<	getE2()                         /* E2 -> E2 MULOP E3 */
606	>	getE2(void)                     /* E2 -> E2 MULOP E3 */
607		/*       E3 */
608		{
609		register EPNODE  *ep1, *ep2;
#	Line 579 | Line 615 | getE2()                                /* E2 -> E2 MULOP E3 */
615		scan();
616		addekid(ep2, ep1);
617		addekid(ep2, getE3());
618	<	if (esupport&E_RCONST &&
619	<	ep1->type == NUM && ep1->sibling->type == NUM)
620	<	ep2 = rconst(ep2);
618	>	if (esupport&E_RCONST) {
619	>	EPNODE  *ep3 = ep1->sibling;
620	>	if (ep1->type == NUM && ep3->type == NUM) {
621	>	ep2 = rconst(ep2);
622	>	} else if (ep3->type == NUM) {
623	>	if (ep2->type == '/') {
624	>	if (ep3->v.num == 0)
625	>	syntax("divide by zero constant");
626	>	ep2->type = '*';        /* for speed */
627	>	ep3->v.num = 1./ep3->v.num;
628	>	} else if (ep3->v.num == 0) {
629	>	ep1->sibling = NULL;    /* (E2 * 0) */
630	>	epfree(ep2);
631	>	ep2 = ep3;
632	>	}
633	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
634	>	epfree(ep3);            /* (0 * E3) or (0 / E3) */
635	>	ep1->sibling = NULL;
636	>	efree((char *)ep2);
637	>	ep2 = ep1;
638	>	}
639	>	}
640		ep1 = ep2;
641		}
642		return(ep1);
#	Line 589 | Line 644 | getE2()                                /* E2 -> E2 MULOP E3 */
644
645
646		EPNODE *
647	<	getE3()                         /* E3 -> E4 ^ E3 */
647	>	getE3(void)                     /* E3 -> E4 ^ E3 */
648		/*       E4 */
649		{
650	<	register EPNODE  *ep1, *ep2;
650	>	register EPNODE  *ep1, *ep2;
651
652	<	ep1 = getE4();
653	<	if (nextc == '^') {
652	>	ep1 = getE4();
653	>	if (nextc != '^')
654	>	return(ep1);
655		ep2 = newnode();
656		ep2->type = nextc;
657		scan();
658		addekid(ep2, ep1);
659		addekid(ep2, getE3());
660	<	if (esupport&E_RCONST &&
661	<	ep1->type == NUM && ep1->sibling->type == NUM)
662	<	ep2 = rconst(ep2);
660	>	if (esupport&E_RCONST) {
661	>	EPNODE  *ep3 = ep1->sibling;
662	>	if (ep1->type == NUM && ep3->type == NUM) {
663	>	ep2 = rconst(ep2);
664	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
665	>	epfree(ep3);            /* (0 ^ E3) */
666	>	ep1->sibling = NULL;
667	>	efree((char *)ep2);
668	>	ep2 = ep1;
669	>	} else if ((ep3->type == NUM && ep3->v.num == 0) ||
670	>	(ep1->type == NUM && ep1->v.num == 1)) {
671	>	epfree(ep2);            /* (E4 ^ 0) or (1 ^ E3) */
672	>	ep2 = newnode();
673	>	ep2->type = NUM;
674	>	ep2->v.num = 1;
675	>	}
676	>	}
677		return(ep2);
608	–	}
609	–	return(ep1);
678		}
679
680
681		EPNODE *
682	<	getE4()                         /* E4 -> ADDOP E5 */
682	>	getE4(void)                     /* E4 -> ADDOP E5 */
683		/*       E5 */
684		{
685		register EPNODE  *ep1, *ep2;
#	Line 624 | Line 692 | getE4()                                /* E4 -> ADDOP E5 */
692		return(ep2);
693		}
694		if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
695	+	ep1 = ep2->v.kid;
696		efree((char *)ep2);
697	<	return(ep2->v.kid);
697	>	return(ep1);
698		}
699		ep1 = newnode();
700		ep1->type = UMINUS;
#	Line 639 | Line 708 | getE4()                                /* E4 -> ADDOP E5 */
708
709
710		EPNODE *
711	<	getE5()                         /* E5 -> (E1) */
711	>	getE5(void)                     /* E5 -> (E1) */
712		/*       VAR */
713		/*       NUM */
714		/*       $N */
#	Line 717 | Line 786 | getE5()                                /* E5 -> (E1) */
786
787
788		EPNODE *
789	<	rconst(epar)                    /* reduce a constant expression */
790	<	register EPNODE  *epar;
789	>	rconst(                 /* reduce a constant expression */
790	>	register EPNODE      *epar
791	>	)
792		{
793		register EPNODE  *ep;
794
#	Line 735 | Line 805 | register EPNODE         *epar;
805
806
807		int
808	<	isconstvar(ep)                  /* is ep linked to a constant expression? */
809	<	register EPNODE  *ep;
808	>	isconstvar(                     /* is ep linked to a constant expression? */
809	>	register EPNODE      *ep
810	>	)
811		{
812		register EPNODE  *ep1;
813
#	Line 760 | Line 831 | register EPNODE         *ep;
831
832
833		int
834	<	isconstfun(ep)                  /* is ep linked to a constant function? */
835	<	register EPNODE  *ep;
834	>	isconstfun(                     /* is ep linked to a constant function? */
835	>	register EPNODE      *ep
836	>	)
837		{
838		register EPNODE  *dp;
839		register LIBR  *lp;
840
841		if (ep->type != VAR)
842		return(0);
843	<	if ((dp = ep->v.ln->def) != NULL)
843	>	if ((dp = ep->v.ln->def) != NULL) {
844		if (dp->v.kid->type == FUNC)
845		return(dp->type == ':');
846		else
847		return(0);          /* don't identify masked library functions */
848	+	}
849		if ((lp = ep->v.ln->lib) != NULL)
850		return(lp->atyp == ':');
851		return(0);

Diff Legend

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