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.5 by greg, Tue May 19 20:21:58 1992 UTC vs.
Revision 2.6 by greg, Mon Sep 21 12:01:54 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1991 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   #ifndef atof
36   extern double  atof();
# Line 43 | 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();
46 – 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 126 | 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 159 | 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 170 | 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 195 | 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 204 | 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 213 | 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 222 | 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 238 | 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 261 | 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 270 | 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 284 | 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 300 | 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 375 | 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 423 | 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 441 | Line 440 | EPNODE  *ekid;
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;
# Line 484 | 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 511 | 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 522 | 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 534 | 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 545 | 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 557 | 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 568 | 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 580 | 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 608 | 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  
# Line 627 | 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 644 | Line 643 | getE5()                                /* E5 -> (E1) */
643          ep1 = NULL;
644          if (curfunc != NULL)
645              for (i = 1, ep2 = curfunc->v.kid->sibling;
646 <                                ep2 != NULL; i++, ep2 = ep2->sibling)
646 >                                ep2 != NULL; i++, ep2 = ep2->sibling)
647                  if (!strcmp(ep2->v.name, nam)) {
648                      ep1 = newnode();
649                      ep1->type = ARG;
# Line 658 | Line 657 | getE5()                                /* E5 -> (E1) */
657              ep1->type = VAR;
658              ep1->v.ln = varinsert(nam);
659          }
660 < #ifdef  FUNCTION
660 > #ifdef  FUNCTION
661          if (nextc == '(') {
662              ep2 = newnode();
663              ep2->type = FUNC;
# Line 672 | 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 695 | 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 707 | 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 715 | 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 735 | 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 748 | 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;

Diff Legend

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