ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/calexpr.c
(Generate patch)

Comparing ray/src/common/calexpr.c (file contents):
Revision 2.30 by greg, Tue May 17 17:51:51 2005 UTC vs.
Revision 2.34 by greg, Sun Jul 25 05:50:27 2010 UTC

# Line 145 | 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 185 | 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 294 | 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   #endif
304      if (errno == EDOM || errno == ERANGE) {
305          wputs("Illegal power\n");
# Line 578 | Line 581 | getnum(void)                   /* scan a positive float */
581  
582  
583   EPNODE *
584 < getE1(void)                             /* E1 -> E1 ADDOP E2 */
584 > getE1(void)                     /* E1 -> E1 ADDOP E2 */
585                                  /*       E2 */
586   {
587      register EPNODE  *ep1, *ep2;
# Line 600 | Line 603 | getE1(void)                            /* E1 -> E1 ADDOP E2 */
603  
604  
605   EPNODE *
606 < getE2(void)                             /* E2 -> E2 MULOP E3 */
606 > getE2(void)                     /* E2 -> E2 MULOP E3 */
607                                  /*       E3 */
608   {
609      register EPNODE  *ep1, *ep2;
# Line 612 | Line 615 | getE2(void)                            /* 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 && ep3->v.num == 0) {
623 >                        if (ep2->type == '/')
624 >                                syntax("divide by zero constant");
625 >                        ep1->sibling = NULL;    /* (E2 * 0) */
626 >                        epfree(ep2);
627 >                        ep2 = ep3;
628 >                } else if (ep1->type == NUM && ep1->v.num == 0) {
629 >                        epfree(ep3);            /* (0 * E3) or (0 / E3) */
630 >                        ep1->sibling = NULL;
631 >                        efree((char *)ep2);
632 >                        ep2 = ep1;
633 >                }
634 >        }
635          ep1 = ep2;
636      }
637      return(ep1);
# Line 622 | Line 639 | getE2(void)                            /* E2 -> E2 MULOP E3 */
639  
640  
641   EPNODE *
642 < getE3(void)                             /* E3 -> E4 ^ E3 */
642 > getE3(void)                     /* E3 -> E4 ^ E3 */
643                                  /*       E4 */
644   {
645 <    register EPNODE  *ep1, *ep2;
645 >        register EPNODE  *ep1, *ep2;
646  
647 <    ep1 = getE4();
648 <    if (nextc == '^') {
647 >        ep1 = getE4();
648 >        if (nextc != '^')
649 >                return(ep1);
650          ep2 = newnode();
651          ep2->type = nextc;
652          scan();
653          addekid(ep2, ep1);
654          addekid(ep2, getE3());
655 <        if (esupport&E_RCONST &&
656 <                        ep1->type == NUM && ep1->sibling->type == NUM)
657 <                ep2 = rconst(ep2);
655 >        if (esupport&E_RCONST) {
656 >                EPNODE  *ep3 = ep1->sibling;
657 >                if (ep1->type == NUM && ep3->type == NUM) {
658 >                        ep2 = rconst(ep2);
659 >                } else if (ep1->type == NUM && ep1->v.num == 0) {
660 >                        epfree(ep3);            /* (0 ^ E3) */
661 >                        ep1->sibling = NULL;
662 >                        efree((char *)ep2);
663 >                        ep2 = ep1;
664 >                } else if ((ep3->type == NUM && ep3->v.num == 0) ||
665 >                                (ep1->type == NUM && ep1->v.num == 1)) {
666 >                        epfree(ep2);            /* (E4 ^ 0) or (1 ^ E3) */
667 >                        ep2 = newnode();
668 >                        ep2->type = NUM;
669 >                        ep2->v.num = 1;
670 >                }
671 >        }
672          return(ep2);
641 –    }
642 –    return(ep1);
673   }
674  
675  
676   EPNODE *
677 < getE4(void)                             /* E4 -> ADDOP E5 */
677 > getE4(void)                     /* E4 -> ADDOP E5 */
678                                  /*       E5 */
679   {
680      register EPNODE  *ep1, *ep2;
# Line 657 | Line 687 | getE4(void)                            /* E4 -> ADDOP E5 */
687                  return(ep2);
688          }
689          if (ep2->type == UMINUS) {      /* don't generate -(-E5) */
690 +            ep1 = ep2->v.kid;
691              efree((char *)ep2);
692 <            return(ep2->v.kid);
692 >            return(ep1);
693          }
694          ep1 = newnode();
695          ep1->type = UMINUS;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines