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.29 by schorsch, Sun Mar 28 20:33:12 2004 UTC vs.
Revision 2.36 by greg, Sat Aug 1 23:27:04 2015 UTC

#	Line 47 | 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 144 | Line 145 | epcmp(                 /* compare two expressions for equivalence */
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 184 | Line 185 | epfree(                        /* free a parse tree */
185		case NUM:
186		case CHAN:
187		case ARG:
188	<	case TICK:
188	>	case CLKT:
189		break;
190
191		default:
#	Line 293 | Line 294 | epow(
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	>	}
304		#endif
305		if (errno == EDOM || errno == ERANGE) {
306		wputs("Illegal power\n");
#	Line 413 | Line 418 | scan(void)             /* scan next character, return literal nex
418		nextc = linbuf[linepos++];
419		if (!lnext)
420		lnext = nextc;
421	+	if (nextc == eofc) {
422	+	nextc = EOF;
423	+	break;
424	+	}
425		if (nextc == '{') {
426		scan();
427		while (nextc != '}')
#	Line 573 | Line 582 | getnum(void)                   /* scan a positive float */
582
583
584		EPNODE *
585	<	getE1(void)                             /* E1 -> E1 ADDOP E2 */
585	>	getE1(void)                     /* E1 -> E1 ADDOP E2 */
586		/*       E2 */
587		{
588		register EPNODE  *ep1, *ep2;
#	Line 595 | Line 604 | getE1(void)                            /* E1 -> E1 ADDOP E2 */
604
605
606		EPNODE *
607	<	getE2(void)                             /* E2 -> E2 MULOP E3 */
607	>	getE2(void)                     /* E2 -> E2 MULOP E3 */
608		/*       E3 */
609		{
610		register EPNODE  *ep1, *ep2;
#	Line 607 | Line 616 | getE2(void)                            /* E2 -> E2 MULOP E3 */
616		scan();
617		addekid(ep2, ep1);
618		addekid(ep2, getE3());
619	<	if (esupport&E_RCONST &&
620	<	ep1->type == NUM && ep1->sibling->type == NUM)
621	<	ep2 = rconst(ep2);
619	>	if (esupport&E_RCONST) {
620	>	EPNODE  *ep3 = ep1->sibling;
621	>	if (ep1->type == NUM && ep3->type == NUM) {
622	>	ep2 = rconst(ep2);
623	>	} else if (ep3->type == NUM) {
624	>	if (ep2->type == '/') {
625	>	if (ep3->v.num == 0)
626	>	syntax("divide by zero constant");
627	>	ep2->type = '*';        /* for speed */
628	>	ep3->v.num = 1./ep3->v.num;
629	>	} else if (ep3->v.num == 0) {
630	>	ep1->sibling = NULL;    /* (E2 * 0) */
631	>	epfree(ep2);
632	>	ep2 = ep3;
633	>	}
634	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
635	>	epfree(ep3);            /* (0 * E3) or (0 / E3) */
636	>	ep1->sibling = NULL;
637	>	efree((char *)ep2);
638	>	ep2 = ep1;
639	>	}
640	>	}
641		ep1 = ep2;
642		}
643		return(ep1);
#	Line 617 | Line 645 | getE2(void)                            /* E2 -> E2 MULOP E3 */
645
646
647		EPNODE *
648	<	getE3(void)                             /* E3 -> E4 ^ E3 */
648	>	getE3(void)                     /* E3 -> E4 ^ E3 */
649		/*       E4 */
650		{
651	<	register EPNODE  *ep1, *ep2;
651	>	register EPNODE  *ep1, *ep2;
652
653	<	ep1 = getE4();
654	<	if (nextc == '^') {
653	>	ep1 = getE4();
654	>	if (nextc != '^')
655	>	return(ep1);
656		ep2 = newnode();
657		ep2->type = nextc;
658		scan();
659		addekid(ep2, ep1);
660		addekid(ep2, getE3());
661	<	if (esupport&E_RCONST &&
662	<	ep1->type == NUM && ep1->sibling->type == NUM)
663	<	ep2 = rconst(ep2);
661	>	if (esupport&E_RCONST) {
662	>	EPNODE  *ep3 = ep1->sibling;
663	>	if (ep1->type == NUM && ep3->type == NUM) {
664	>	ep2 = rconst(ep2);
665	>	} else if (ep1->type == NUM && ep1->v.num == 0) {
666	>	epfree(ep3);            /* (0 ^ E3) */
667	>	ep1->sibling = NULL;
668	>	efree((char *)ep2);
669	>	ep2 = ep1;
670	>	} else if ((ep3->type == NUM && ep3->v.num == 0) ||
671	>	(ep1->type == NUM && ep1->v.num == 1)) {
672	>	epfree(ep2);            /* (E4 ^ 0) or (1 ^ E3) */
673	>	ep2 = newnode();
674	>	ep2->type = NUM;
675	>	ep2->v.num = 1;
676	>	}
677	>	}
678		return(ep2);
636	–	}
637	–	return(ep1);
679		}
680
681
682		EPNODE *
683	<	getE4(void)                             /* E4 -> ADDOP E5 */
683	>	getE4(void)                     /* E4 -> ADDOP E5 */
684		/*       E5 */
685		{
686		register EPNODE  *ep1, *ep2;
#	Line 652 | Line 693 | getE4(void)                            /* E4 -> ADDOP E5 */
693		return(ep2);
694		}
695		if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
696	+	ep1 = ep2->v.kid;
697		efree((char *)ep2);
698	<	return(ep2->v.kid);
698	>	return(ep1);
699		}
700		ep1 = newnode();
701		ep1->type = UMINUS;

Diff Legend

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