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.36 by greg, Sat Aug 1 23:27:04 2015 UTC vs.
Revision 2.38 by greg, Sat Dec 7 16:38:08 2019 UTC

# Line 105 | Line 105 | eval(                  /* evaluate an expression string */
105      char  *expr
106   )
107   {
108 <    register EPNODE  *ep;
108 >    int  prev_support = esupport;
109 >    EPNODE  *ep;
110      double  rval;
111  
112 +    esupport &= ~E_RCONST;      /* don't bother reducing constant expr */
113      ep = eparse(expr);
114 +    esupport = prev_support;    /* as you were */
115      rval = evalue(ep);
116      epfree(ep);
117      return(rval);
# Line 117 | Line 120 | eval(                  /* evaluate an expression string */
120  
121   int
122   epcmp(                  /* compare two expressions for equivalence */
123 <    register EPNODE  *ep1,
124 <    register EPNODE  *ep2
123 >    EPNODE  *ep1,
124 >    EPNODE  *ep2
125   )
126   {
127          double  d;
# Line 167 | Line 170 | epcmp(                 /* compare two expressions for equivalence */
170  
171   void
172   epfree(                 /* free a parse tree */
173 <    register EPNODE      *epar
173 >    EPNODE       *epar
174   )
175   {
176 <    register EPNODE  *ep;
176 >    EPNODE  *ep;
177  
178      switch (epar->type) {
179  
# Line 222 | Line 225 | euminus(
225      EPNODE      *ep
226   )
227   {
228 <    register EPNODE  *ep1 = ep->v.kid;
228 >    EPNODE  *ep1 = ep->v.kid;
229  
230      return(-evalue(ep1));
231   }
# Line 240 | Line 243 | eadd(
243      EPNODE      *ep
244   )
245   {
246 <    register EPNODE  *ep1 = ep->v.kid;
246 >    EPNODE  *ep1 = ep->v.kid;
247  
248      return(evalue(ep1) + evalue(ep1->sibling));
249   }
# Line 250 | Line 253 | esubtr(
253      EPNODE      *ep
254   )
255   {
256 <    register EPNODE  *ep1 = ep->v.kid;
256 >    EPNODE  *ep1 = ep->v.kid;
257  
258      return(evalue(ep1) - evalue(ep1->sibling));
259   }
# Line 260 | Line 263 | emult(
263      EPNODE      *ep
264   )
265   {
266 <    register EPNODE  *ep1 = ep->v.kid;
266 >    EPNODE  *ep1 = ep->v.kid;
267  
268      return(evalue(ep1) * evalue(ep1->sibling));
269   }
# Line 270 | Line 273 | edivi(
273      EPNODE      *ep
274   )
275   {
276 <    register EPNODE  *ep1 = ep->v.kid;
276 >    EPNODE  *ep1 = ep->v.kid;
277      double  d;
278  
279      d = evalue(ep1->sibling);
# Line 287 | Line 290 | epow(
290      EPNODE      *ep
291   )
292   {
293 <    register EPNODE  *ep1 = ep->v.kid;
293 >    EPNODE  *ep1 = ep->v.kid;
294      double  d;
295      int  lasterrno;
296  
# Line 323 | Line 326 | ebotch(
326  
327   EPNODE *
328   ekid(                   /* return pointer to a node's nth kid */
329 <    register EPNODE      *ep,
330 <    register int  n
329 >    EPNODE       *ep,
330 >    int  n
331   )
332   {
333  
# Line 338 | Line 341 | ekid(                  /* return pointer to a node's nth kid */
341  
342   int
343   nekids(                 /* return # of kids for node ep */
344 <    register EPNODE      *ep
344 >    EPNODE       *ep
345   )
346   {
347 <    register int  n = 0;
347 >    int  n = 0;
348  
349      for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
350          n++;
# Line 403 | Line 406 | getscanpos(    /* return current scan position */
406   int
407   scan(void)              /* scan next character, return literal next */
408   {
409 <    register int  lnext = 0;
409 >    int  lnext = 0;
410  
411      do {
412          if (linbuf[linepos] == '\0')
# Line 442 | Line 445 | long2ascii(                          /* convert long to ascii */
445   )
446   {
447      static char  buf[16];
448 <    register char  *cp;
448 >    char  *cp;
449      int  neg = 0;
450  
451      if (l == 0)
# Line 468 | Line 471 | syntax(                        /* report syntax error and quit */
471      char  *err
472   )
473   {
474 <    register int  i;
474 >    int  i;
475  
476      if (infile != NULL || lineno != 0) {
477          if (infile != NULL) eputs(infile);
# Line 492 | Line 495 | syntax(                        /* report syntax error and quit */
495  
496   void
497   addekid(                        /* add a child to ep */
498 <    register EPNODE      *ep,
498 >    EPNODE       *ep,
499      EPNODE      *ekid
500   )
501   {
# Line 511 | Line 514 | char *
514   getname(void)                   /* scan an identifier */
515   {
516      static char  str[RMAXWORD+1];
517 <    register int  i, lnext;
517 >    int  i, lnext;
518  
519      lnext = nextc;
520      for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
# Line 527 | Line 530 | getname(void)                  /* scan an identifier */
530   int
531   getinum(void)                   /* scan a positive integer */
532   {
533 <    register int  n, lnext;
533 >    int  n, lnext;
534  
535      n = 0;
536      lnext = nextc;
# Line 542 | Line 545 | getinum(void)                  /* scan a positive integer */
545   double
546   getnum(void)                    /* scan a positive float */
547   {
548 <    register int  i, lnext;
548 >    int  i, lnext;
549      char  str[RMAXWORD+1];
550  
551      i = 0;
# Line 585 | Line 588 | EPNODE *
588   getE1(void)                     /* E1 -> E1 ADDOP E2 */
589                                  /*       E2 */
590   {
591 <    register EPNODE  *ep1, *ep2;
591 >    EPNODE  *ep1, *ep2;
592  
593      ep1 = getE2();
594      while (nextc == '+' || nextc == '-') {
# Line 607 | Line 610 | EPNODE *
610   getE2(void)                     /* E2 -> E2 MULOP E3 */
611                                  /*       E3 */
612   {
613 <    register EPNODE  *ep1, *ep2;
613 >    EPNODE  *ep1, *ep2;
614  
615      ep1 = getE3();
616      while (nextc == '*' || nextc == '/') {
# Line 648 | Line 651 | EPNODE *
651   getE3(void)                     /* E3 -> E4 ^ E3 */
652                                  /*       E4 */
653   {
654 <        register EPNODE  *ep1, *ep2;
654 >        EPNODE  *ep1, *ep2;
655  
656          ep1 = getE4();
657          if (nextc != '^')
# Line 683 | Line 686 | EPNODE *
686   getE4(void)                     /* E4 -> ADDOP E5 */
687                                  /*       E5 */
688   {
689 <    register EPNODE  *ep1, *ep2;
689 >    EPNODE  *ep1, *ep2;
690  
691      if (nextc == '-') {
692          scan();
# Line 718 | Line 721 | getE5(void)                    /* E5 -> (E1) */
721   {
722          int      i;
723          char  *nam;
724 <        register EPNODE  *ep1, *ep2;
724 >        EPNODE  *ep1, *ep2;
725  
726          if (nextc == '(') {
727                  scan();
# Line 788 | Line 791 | getE5(void)                    /* E5 -> (E1) */
791  
792   EPNODE *
793   rconst(                 /* reduce a constant expression */
794 <    register EPNODE      *epar
794 >    EPNODE       *epar
795   )
796   {
797 <    register EPNODE  *ep;
797 >    EPNODE  *ep;
798  
799      ep = newnode();
800      ep->type = NUM;
# Line 807 | Line 810 | rconst(                        /* reduce a constant expression */
810  
811   int
812   isconstvar(                     /* is ep linked to a constant expression? */
813 <    register EPNODE      *ep
813 >    EPNODE       *ep
814   )
815   {
816 <    register EPNODE  *ep1;
816 >    EPNODE  *ep1;
817  
818      if (esupport&E_FUNCTION && ep->type == FUNC) {
819          if (!isconstfun(ep->v.kid))
# Line 833 | Line 836 | isconstvar(                    /* is ep linked to a constant expression
836  
837   int
838   isconstfun(                     /* is ep linked to a constant function? */
839 <    register EPNODE      *ep
839 >    EPNODE       *ep
840   )
841   {
842 <    register EPNODE  *dp;
843 <    register LIBR  *lp;
842 >    EPNODE  *dp;
843 >    LIBR  *lp;
844  
845      if (ep->type != VAR)
846          return(0);

Diff Legend

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