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.8 by greg, Fri Oct 2 15:57:29 1992 UTC vs.
Revision 2.27 by greg, Mon Aug 4 19:20:26 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 < #include  <stdio.h>
20 > #include "copyright.h"
21  
22 + #include  <stdio.h>
23 + #include  <string.h>
24   #include  <ctype.h>
24 –
25   #include  <errno.h>
26 –
26   #include  <math.h>
27 + #include  <stdlib.h>
28  
29 + #include  "rterror.h"
30   #include  "calcomp.h"
31  
32   #define  MAXLINE        256             /* maximum line length */
# Line 34 | Line 35 | static char SCCSid[] = "$SunId$ LBL";
35  
36   #define  isdecimal(c)   (isdigit(c) || (c) == '.')
37  
38 < #ifndef atof
39 < extern double  atof();
40 < #endif
41 < extern char  *fgets(), *savestr();
42 < extern char  *emalloc(), *ecalloc();
43 < extern EPNODE  *curfunc;
43 < extern double  efunc(), evariable();
44 < static double  euminus(), echannel(), eargument(), enumber();
45 < static double  eadd(), esubtr(), emult(), edivi(), epow();
46 < static double  ebotch();
38 > static double  euminus(EPNODE *), eargument(EPNODE *), enumber(EPNODE *);
39 > static double  echannel(EPNODE *);
40 > static double  eadd(EPNODE *), esubtr(EPNODE *),
41 >               emult(EPNODE *), edivi(EPNODE *),
42 >               epow(EPNODE *);
43 > static double  ebotch(EPNODE *);
44  
45 + unsigned int  esupport =                /* what to support */
46 +                E_VARIABLE | E_FUNCTION ;
47 +
48   int  nextc;                             /* lookahead character */
49  
50 < double  (*eoper[])() = {                /* expression operations */
50 > double  (*eoper[])(EPNODE *) = {        /* expression operations */
51          ebotch,
52 – #ifdef  VARIABLE
52          evariable,
54 – #else
55 –        ebotch,
56 – #endif
53          enumber,
54          euminus,
59 – #ifdef  INCHAN
55          echannel,
61 – #else
62 –        ebotch,
63 – #endif
64 – #ifdef  FUNCTION
56          efunc,
57          eargument,
67 – #else
58          ebotch,
59          ebotch,
70 – #endif
71 –        ebotch,
72 –        ebotch,
60          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
61          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
62          emult,
# Line 101 | Line 88 | char  *expr;
88      EPNODE  *ep;
89  
90      initstr(expr, NULL, 0);
104 – #if  defined(VARIABLE) && defined(FUNCTION)
91      curfunc = NULL;
106 – #endif
92      ep = getE1();
93      if (nextc != EOF)
94          syntax("unexpected character");
# Line 125 | Line 110 | char  *expr;
110   }
111  
112  
113 + int
114 + epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
115 + register EPNODE  *ep1, *ep2;
116 + {
117 +        double  d;
118 +
119 +        if (ep1->type != ep2->type)
120 +                return(1);
121 +
122 +        switch (ep1->type) {
123 +
124 +        case VAR:
125 +                return(ep1->v.ln != ep2->v.ln);
126 +
127 +        case NUM:
128 +                if (ep2->v.num == 0)
129 +                        return(ep1->v.num != 0);
130 +                d = ep1->v.num / ep2->v.num;
131 +                return((d > 1.000000000001) | (d < 0.999999999999));
132 +
133 +        case CHAN:
134 +        case ARG:
135 +                return(ep1->v.chan != ep2->v.chan);
136 +
137 +        case '=':
138 +        case ':':
139 +                return(epcmp(ep1->v.kid->sibling, ep2->v.kid->sibling));
140 +
141 +        case TICK:
142 +        case SYM:                       /* should never get this one */
143 +                return(0);
144 +
145 +        default:
146 +                ep1 = ep1->v.kid;
147 +                ep2 = ep2->v.kid;
148 +                while (ep1 != NULL) {
149 +                        if (ep2 == NULL)
150 +                                return(1);
151 +                        if (epcmp(ep1, ep2))
152 +                                return(1);
153 +                        ep1 = ep1->sibling;
154 +                        ep2 = ep2->sibling;
155 +                }
156 +                return(ep2 != NULL);
157 +        }
158 + }
159 +
160 +
161 + void
162   epfree(epar)                    /* free a parse tree */
163   register EPNODE  *epar;
164   {
# Line 132 | Line 166 | register EPNODE         *epar;
166  
167      switch (epar->type) {
168  
135 – #if  defined(VARIABLE) || defined(FUNCTION)
169          case VAR:
170              varfree(epar->v.ln);
171              break;
# Line 140 | Line 173 | register EPNODE         *epar;
173          case SYM:
174              freestr(epar->v.name);
175              break;
143 – #endif
176  
177          case NUM:
178          case CHAN:
# Line 149 | Line 181 | register EPNODE         *epar;
181              break;
182  
183          default:
184 <            for (ep = epar->v.kid; ep != NULL; ep = ep->sibling)
184 >            while ((ep = epar->v.kid) != NULL) {
185 >                epar->v.kid = ep->sibling;
186                  epfree(ep);
187 +            }
188              break;
189  
190      }
# Line 159 | Line 193 | register EPNODE         *epar;
193   }
194  
195                                  /* the following used to be a switch */
162 – #ifdef  FUNCTION
196   static double
197   eargument(ep)
198   EPNODE  *ep;
199   {
200      return(argument(ep->v.chan));
201   }
169 – #endif
202  
203   static double
204   enumber(ep)
# Line 184 | Line 216 | EPNODE *ep;
216      return(-evalue(ep1));
217   }
218  
187 – #ifdef  INCHAN
219   static double
220   echannel(ep)
221   EPNODE  *ep;
222   {
223      return(chanvalue(ep->v.chan));
224   }
194 – #endif
225  
226   static double
227   eadd(ep)
# Line 251 | Line 281 | EPNODE *ep;
281      if (!finite(d))
282          errno = EDOM;
283   #endif
284 <    if (errno) {
284 >    if (errno == EDOM || errno == ERANGE) {
285          wputs("Illegal power\n");
286          return(0.0);
287      }
# Line 265 | Line 295 | EPNODE *ep;
295   {
296      eputs("Bad expression!\n");
297      quit(1);
298 +        return 0.0; /* pro forma return */
299   }
300  
301  
# Line 295 | Line 326 | register EPNODE         *ep;
326   }
327  
328  
329 + void
330   initfile(fp, fn, ln)            /* prepare input file */
331   FILE  *fp;
332   char  *fn;
# Line 312 | Line 344 | int  ln;
344   }
345  
346  
347 + void
348   initstr(s, fn, ln)              /* prepare input string */
349   char  *s;
350   char  *fn;
# Line 326 | Line 359 | int  ln;
359   }
360  
361  
362 + void
363   getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
364   char  **fnp;
365   int  *lnp;
# Line 372 | Line 406 | scan()                         /* scan next character, return literal next
406  
407  
408   char *
409 < ltoa(l)                         /* convert long to ascii */
409 > long2ascii(l)                         /* convert long to ascii */
410   long  l;
411   {
412      static char  buf[16];
# Line 397 | Line 431 | long  l;
431   }
432  
433  
434 + void
435   syntax(err)                     /* report syntax error and quit */
436   char  *err;
437   {
# Line 406 | Line 441 | char  *err;
441          if (infile != NULL) eputs(infile);
442          if (lineno != 0) {
443              eputs(infile != NULL ? ", line " : "line ");
444 <            eputs(ltoa((long)lineno));
444 >            eputs(long2ascii((long)lineno));
445          }
446          eputs(":\n");
447      }
# Line 422 | Line 457 | char  *err;
457   }
458  
459  
460 + void
461   addekid(ep, ekid)                       /* add a child to ep */
462   register EPNODE  *ep;
463   EPNODE  *ekid;
# Line 437 | Line 473 | EPNODE *ekid;
473   }
474  
475  
440 – #if  defined(VARIABLE) || defined(FUNCTION)
476   char *
477   getname()                       /* scan an identifier */
478   {
479 <    static char  str[MAXWORD+1];
479 >    static char  str[RMAXWORD+1];
480      register int  i, lnext;
481  
482      lnext = nextc;
483 <    for (i = 0; i < MAXWORD && isid(lnext); i++, lnext = scan())
483 >    for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
484          str[i] = lnext;
485      str[i] = '\0';
486      while (isid(lnext))         /* skip rest of name */
# Line 453 | Line 488 | getname()                      /* scan an identifier */
488  
489      return(str);
490   }
456 – #endif
491  
492  
493   int
# Line 475 | Line 509 | double
509   getnum()                        /* scan a positive float */
510   {
511      register int  i, lnext;
512 <    char  str[MAXWORD+1];
512 >    char  str[RMAXWORD+1];
513  
514      i = 0;
515      lnext = nextc;
516 <    while (isdigit(lnext) && i < MAXWORD) {
516 >    while (isdigit(lnext) && i < RMAXWORD) {
517          str[i++] = lnext;
518          lnext = scan();
519      }
520 <    if (lnext == '.' && i < MAXWORD) {
520 >    if (lnext == '.' && i < RMAXWORD) {
521          str[i++] = lnext;
522          lnext = scan();
523 <        while (isdigit(lnext) && i < MAXWORD) {
523 >        if (i == 1 && !isdigit(lnext))
524 >            syntax("badly formed number");
525 >        while (isdigit(lnext) && i < RMAXWORD) {
526              str[i++] = lnext;
527              lnext = scan();
528          }
529      }
530 <    if ((lnext == 'e' || lnext == 'E') && i < MAXWORD) {
530 >    if ((lnext == 'e') | (lnext == 'E') && i < RMAXWORD) {
531          str[i++] = lnext;
532          lnext = scan();
533 <        if ((lnext == '-' || lnext == '+') && i < MAXWORD) {
533 >        if ((lnext == '-') | (lnext == '+') && i < RMAXWORD) {
534              str[i++] = lnext;
535              lnext = scan();
536          }
537 <        while (isdigit(lnext) && i < MAXWORD) {
537 >        if (!isdigit(lnext))
538 >            syntax("missing exponent");
539 >        while (isdigit(lnext) && i < RMAXWORD) {
540              str[i++] = lnext;
541              lnext = scan();
542          }
# Line 522 | Line 560 | getE1()                                /* E1 -> E1 ADDOP E2 */
560          scan();
561          addekid(ep2, ep1);
562          addekid(ep2, getE2());
563 < #ifdef  RCONST
564 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
563 >        if (esupport&E_RCONST &&
564 >                        ep1->type == NUM && ep1->sibling->type == NUM)
565                  ep2 = rconst(ep2);
528 – #endif
566          ep1 = ep2;
567      }
568      return(ep1);
# Line 545 | Line 582 | getE2()                                /* E2 -> E2 MULOP E3 */
582          scan();
583          addekid(ep2, ep1);
584          addekid(ep2, getE3());
585 < #ifdef  RCONST
586 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
585 >        if (esupport&E_RCONST &&
586 >                        ep1->type == NUM && ep1->sibling->type == NUM)
587                  ep2 = rconst(ep2);
551 – #endif
588          ep1 = ep2;
589      }
590      return(ep1);
# Line 568 | Line 604 | getE3()                                /* E3 -> E4 ^ E3 */
604          scan();
605          addekid(ep2, ep1);
606          addekid(ep2, getE3());
607 < #ifdef  RCONST
608 <        if (ep1->type == NUM && ep1->sibling->type == NUM)
607 >        if (esupport&E_RCONST &&
608 >                        ep1->type == NUM && ep1->sibling->type == NUM)
609                  ep2 = rconst(ep2);
574 – #endif
610          return(ep2);
611      }
612      return(ep1);
# Line 614 | Line 649 | getE5()                                /* E5 -> (E1) */
649                                  /*       FUNC(E1,..) */
650                                  /*       ARG */
651   {
652 <    int  i;
653 <    char  *nam;
654 <    register EPNODE  *ep1, *ep2;
652 >        int      i;
653 >        char  *nam;
654 >        register EPNODE  *ep1, *ep2;
655  
656 <    if (nextc == '(') {
657 <        scan();
658 <        ep1 = getE1();
659 <        if (nextc != ')')
660 <            syntax("')' expected");
661 <        scan();
662 <        return(ep1);
663 <    }
656 >        if (nextc == '(') {
657 >                scan();
658 >                ep1 = getE1();
659 >                if (nextc != ')')
660 >                        syntax("')' expected");
661 >                scan();
662 >                return(ep1);
663 >        }
664  
665 < #ifdef  INCHAN
666 <    if (nextc == '$') {
667 <        scan();
668 <        ep1 = newnode();
669 <        ep1->type = CHAN;
670 <        ep1->v.chan = getinum();
671 <        return(ep1);
637 <    }
638 < #endif
665 >        if (esupport&E_INCHAN && nextc == '$') {
666 >                scan();
667 >                ep1 = newnode();
668 >                ep1->type = CHAN;
669 >                ep1->v.chan = getinum();
670 >                return(ep1);
671 >        }
672  
673 < #if  defined(VARIABLE) || defined(FUNCTION)
674 <    if (isalpha(nextc) || nextc == CNTXMARK) {
675 <        nam = getname();
676 < #if  defined(VARIABLE) && defined(FUNCTION)
677 <        ep1 = NULL;
678 <        if (curfunc != NULL)
679 <            for (i = 1, ep2 = curfunc->v.kid->sibling;
680 <                                ep2 != NULL; i++, ep2 = ep2->sibling)
681 <                if (!strcmp(ep2->v.name, nam)) {
682 <                    ep1 = newnode();
683 <                    ep1->type = ARG;
684 <                    ep1->v.chan = i;
685 <                    break;
673 >        if (esupport&(E_VARIABLE|E_FUNCTION) &&
674 >                        (isalpha(nextc) || nextc == CNTXMARK)) {
675 >                nam = getname();
676 >                ep1 = NULL;
677 >                if ((esupport&(E_VARIABLE|E_FUNCTION)) == (E_VARIABLE|E_FUNCTION)
678 >                                && curfunc != NULL)
679 >                        for (i = 1, ep2 = curfunc->v.kid->sibling;
680 >                                        ep2 != NULL; i++, ep2 = ep2->sibling)
681 >                                if (!strcmp(ep2->v.name, nam)) {
682 >                                        ep1 = newnode();
683 >                                        ep1->type = ARG;
684 >                                        ep1->v.chan = i;
685 >                                        break;
686 >                                }
687 >                if (ep1 == NULL) {
688 >                        ep1 = newnode();
689 >                        ep1->type = VAR;
690 >                        ep1->v.ln = varinsert(nam);
691                  }
692 <        if (ep1 == NULL)
693 < #endif
694 <        {
695 <            ep1 = newnode();
696 <            ep1->type = VAR;
697 <            ep1->v.ln = varinsert(nam);
692 >                if (esupport&E_FUNCTION && nextc == '(') {
693 >                        ep2 = newnode();
694 >                        ep2->type = FUNC;
695 >                        addekid(ep2, ep1);
696 >                        ep1 = ep2;
697 >                        do {
698 >                                scan();
699 >                                addekid(ep1, getE1());
700 >                        } while (nextc == ',');
701 >                        if (nextc != ')')
702 >                                syntax("')' expected");
703 >                        scan();
704 >                } else if (!(esupport&E_VARIABLE))
705 >                        syntax("'(' expected");
706 >                if (esupport&E_RCONST && isconstvar(ep1))
707 >                        ep1 = rconst(ep1);
708 >                return(ep1);
709          }
661 – #ifdef  FUNCTION
662 –        if (nextc == '(') {
663 –            ep2 = newnode();
664 –            ep2->type = FUNC;
665 –            addekid(ep2, ep1);
666 –            ep1 = ep2;
667 –            do {
668 –                scan();
669 –                addekid(ep1, getE1());
670 –            } while (nextc == ',');
671 –            if (nextc != ')')
672 –                syntax("')' expected");
673 –            scan();
674 –        }
675 – #ifndef  VARIABLE
676 –        else
677 –            syntax("'(' expected");
678 – #endif
679 – #endif
680 – #ifdef  RCONST
681 –        if (isconstvar(ep1))
682 –            ep1 = rconst(ep1);
683 – #endif
684 –        return(ep1);
685 –    }
686 – #endif
710  
711 <    if (isdecimal(nextc)) {
712 <        ep1 = newnode();
713 <        ep1->type = NUM;
714 <        ep1->v.num = getnum();
715 <        return(ep1);
716 <    }
717 <    syntax("unexpected character");
711 >        if (isdecimal(nextc)) {
712 >                ep1 = newnode();
713 >                ep1->type = NUM;
714 >                ep1->v.num = getnum();
715 >                return(ep1);
716 >        }
717 >        syntax("unexpected character");
718 >        return NULL; /* pro forma return */
719   }
720  
721  
698 – #ifdef  RCONST
722   EPNODE *
723   rconst(epar)                    /* reduce a constant expression */
724   register EPNODE  *epar;
# Line 706 | Line 729 | register EPNODE         *epar;
729      ep->type = NUM;
730      errno = 0;
731      ep->v.num = evalue(epar);
732 <    if (errno)
732 >    if (errno == EDOM || errno == ERANGE)
733          syntax("bad constant expression");
734      epfree(epar);
735  
# Line 714 | Line 737 | register EPNODE         *epar;
737   }
738  
739  
740 + int
741   isconstvar(ep)                  /* is ep linked to a constant expression? */
742   register EPNODE  *ep;
743   {
720 – #ifdef  VARIABLE
744      register EPNODE  *ep1;
722 – #ifdef  FUNCTION
745  
746 <    if (ep->type == FUNC) {
746 >    if (esupport&E_FUNCTION && ep->type == FUNC) {
747          if (!isconstfun(ep->v.kid))
748                  return(0);
749          for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling)
# Line 729 | Line 751 | register EPNODE         *ep;
751                  return(0);
752          return(1);
753      }
732 – #endif
754      if (ep->type != VAR)
755          return(0);
756      ep1 = ep->v.ln->def;
757      if (ep1 == NULL || ep1->type != ':')
758          return(0);
759 < #ifdef  FUNCTION
739 <    if (ep1->v.kid->type != SYM)
759 >    if (esupport&E_FUNCTION && ep1->v.kid->type != SYM)
760          return(0);
741 – #endif
761      return(1);
743 – #else
744 –    return(ep->type == FUNC);
745 – #endif
762   }
763  
764  
765 < #if  defined(FUNCTION) && defined(VARIABLE)
765 > int
766   isconstfun(ep)                  /* is ep linked to a constant function? */
767   register EPNODE  *ep;
768   {
# Line 755 | Line 771 | register EPNODE         *ep;
771  
772      if (ep->type != VAR)
773          return(0);
774 <    if ((dp = ep->v.ln->def) != NULL && dp->v.kid->type == FUNC)
775 <        return(dp->type == ':');
774 >    if ((dp = ep->v.ln->def) != NULL) {
775 >        if (dp->v.kid->type == FUNC)
776 >            return(dp->type == ':');
777 >        else
778 >            return(0);          /* don't identify masked library functions */
779 >    }
780      if ((lp = ep->v.ln->lib) != NULL)
781          return(lp->atyp == ':');
782      return(0);
783   }
764 – #endif
765 – #endif

Diff Legend

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