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.37 by greg, Mon Mar 4 18:16:18 2019 UTC

# Line 105 | Line 105 | eval(                  /* evaluate an expression string */
105      char  *expr
106   )
107   {
108 <    register EPNODE  *ep;
108 >    EPNODE  *ep;
109      double  rval;
110  
111      ep = eparse(expr);
# Line 117 | Line 117 | eval(                  /* evaluate an expression string */
117  
118   int
119   epcmp(                  /* compare two expressions for equivalence */
120 <    register EPNODE  *ep1,
121 <    register EPNODE  *ep2
120 >    EPNODE  *ep1,
121 >    EPNODE  *ep2
122   )
123   {
124          double  d;
# Line 167 | Line 167 | epcmp(                 /* compare two expressions for equivalence */
167  
168   void
169   epfree(                 /* free a parse tree */
170 <    register EPNODE      *epar
170 >    EPNODE       *epar
171   )
172   {
173 <    register EPNODE  *ep;
173 >    EPNODE  *ep;
174  
175      switch (epar->type) {
176  
# Line 222 | Line 222 | euminus(
222      EPNODE      *ep
223   )
224   {
225 <    register EPNODE  *ep1 = ep->v.kid;
225 >    EPNODE  *ep1 = ep->v.kid;
226  
227      return(-evalue(ep1));
228   }
# Line 240 | Line 240 | eadd(
240      EPNODE      *ep
241   )
242   {
243 <    register EPNODE  *ep1 = ep->v.kid;
243 >    EPNODE  *ep1 = ep->v.kid;
244  
245      return(evalue(ep1) + evalue(ep1->sibling));
246   }
# Line 250 | Line 250 | esubtr(
250      EPNODE      *ep
251   )
252   {
253 <    register EPNODE  *ep1 = ep->v.kid;
253 >    EPNODE  *ep1 = ep->v.kid;
254  
255      return(evalue(ep1) - evalue(ep1->sibling));
256   }
# Line 260 | Line 260 | emult(
260      EPNODE      *ep
261   )
262   {
263 <    register EPNODE  *ep1 = ep->v.kid;
263 >    EPNODE  *ep1 = ep->v.kid;
264  
265      return(evalue(ep1) * evalue(ep1->sibling));
266   }
# Line 270 | Line 270 | edivi(
270      EPNODE      *ep
271   )
272   {
273 <    register EPNODE  *ep1 = ep->v.kid;
273 >    EPNODE  *ep1 = ep->v.kid;
274      double  d;
275  
276      d = evalue(ep1->sibling);
# Line 287 | Line 287 | epow(
287      EPNODE      *ep
288   )
289   {
290 <    register EPNODE  *ep1 = ep->v.kid;
290 >    EPNODE  *ep1 = ep->v.kid;
291      double  d;
292      int  lasterrno;
293  
# Line 323 | Line 323 | ebotch(
323  
324   EPNODE *
325   ekid(                   /* return pointer to a node's nth kid */
326 <    register EPNODE      *ep,
327 <    register int  n
326 >    EPNODE       *ep,
327 >    int  n
328   )
329   {
330  
# Line 338 | Line 338 | ekid(                  /* return pointer to a node's nth kid */
338  
339   int
340   nekids(                 /* return # of kids for node ep */
341 <    register EPNODE      *ep
341 >    EPNODE       *ep
342   )
343   {
344 <    register int  n = 0;
344 >    int  n = 0;
345  
346      for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
347          n++;
# Line 403 | Line 403 | getscanpos(    /* return current scan position */
403   int
404   scan(void)              /* scan next character, return literal next */
405   {
406 <    register int  lnext = 0;
406 >    int  lnext = 0;
407  
408      do {
409          if (linbuf[linepos] == '\0')
# Line 442 | Line 442 | long2ascii(                          /* convert long to ascii */
442   )
443   {
444      static char  buf[16];
445 <    register char  *cp;
445 >    char  *cp;
446      int  neg = 0;
447  
448      if (l == 0)
# Line 468 | Line 468 | syntax(                        /* report syntax error and quit */
468      char  *err
469   )
470   {
471 <    register int  i;
471 >    int  i;
472  
473      if (infile != NULL || lineno != 0) {
474          if (infile != NULL) eputs(infile);
# Line 492 | Line 492 | syntax(                        /* report syntax error and quit */
492  
493   void
494   addekid(                        /* add a child to ep */
495 <    register EPNODE      *ep,
495 >    EPNODE       *ep,
496      EPNODE      *ekid
497   )
498   {
# Line 511 | Line 511 | char *
511   getname(void)                   /* scan an identifier */
512   {
513      static char  str[RMAXWORD+1];
514 <    register int  i, lnext;
514 >    int  i, lnext;
515  
516      lnext = nextc;
517      for (i = 0; i < RMAXWORD && isid(lnext); i++, lnext = scan())
# Line 527 | Line 527 | getname(void)                  /* scan an identifier */
527   int
528   getinum(void)                   /* scan a positive integer */
529   {
530 <    register int  n, lnext;
530 >    int  n, lnext;
531  
532      n = 0;
533      lnext = nextc;
# Line 542 | Line 542 | getinum(void)                  /* scan a positive integer */
542   double
543   getnum(void)                    /* scan a positive float */
544   {
545 <    register int  i, lnext;
545 >    int  i, lnext;
546      char  str[RMAXWORD+1];
547  
548      i = 0;
# Line 585 | Line 585 | EPNODE *
585   getE1(void)                     /* E1 -> E1 ADDOP E2 */
586                                  /*       E2 */
587   {
588 <    register EPNODE  *ep1, *ep2;
588 >    EPNODE  *ep1, *ep2;
589  
590      ep1 = getE2();
591      while (nextc == '+' || nextc == '-') {
# Line 607 | Line 607 | EPNODE *
607   getE2(void)                     /* E2 -> E2 MULOP E3 */
608                                  /*       E3 */
609   {
610 <    register EPNODE  *ep1, *ep2;
610 >    EPNODE  *ep1, *ep2;
611  
612      ep1 = getE3();
613      while (nextc == '*' || nextc == '/') {
# Line 648 | Line 648 | EPNODE *
648   getE3(void)                     /* E3 -> E4 ^ E3 */
649                                  /*       E4 */
650   {
651 <        register EPNODE  *ep1, *ep2;
651 >        EPNODE  *ep1, *ep2;
652  
653          ep1 = getE4();
654          if (nextc != '^')
# Line 683 | Line 683 | EPNODE *
683   getE4(void)                     /* E4 -> ADDOP E5 */
684                                  /*       E5 */
685   {
686 <    register EPNODE  *ep1, *ep2;
686 >    EPNODE  *ep1, *ep2;
687  
688      if (nextc == '-') {
689          scan();
# Line 718 | Line 718 | getE5(void)                    /* E5 -> (E1) */
718   {
719          int      i;
720          char  *nam;
721 <        register EPNODE  *ep1, *ep2;
721 >        EPNODE  *ep1, *ep2;
722  
723          if (nextc == '(') {
724                  scan();
# Line 788 | Line 788 | getE5(void)                    /* E5 -> (E1) */
788  
789   EPNODE *
790   rconst(                 /* reduce a constant expression */
791 <    register EPNODE      *epar
791 >    EPNODE       *epar
792   )
793   {
794 <    register EPNODE  *ep;
794 >    EPNODE  *ep;
795  
796      ep = newnode();
797      ep->type = NUM;
# Line 807 | Line 807 | rconst(                        /* reduce a constant expression */
807  
808   int
809   isconstvar(                     /* is ep linked to a constant expression? */
810 <    register EPNODE      *ep
810 >    EPNODE       *ep
811   )
812   {
813 <    register EPNODE  *ep1;
813 >    EPNODE  *ep1;
814  
815      if (esupport&E_FUNCTION && ep->type == FUNC) {
816          if (!isconstfun(ep->v.kid))
# Line 833 | Line 833 | isconstvar(                    /* is ep linked to a constant expression
833  
834   int
835   isconstfun(                     /* is ep linked to a constant function? */
836 <    register EPNODE      *ep
836 >    EPNODE       *ep
837   )
838   {
839 <    register EPNODE  *dp;
840 <    register LIBR  *lp;
839 >    EPNODE  *dp;
840 >    LIBR  *lp;
841  
842      if (ep->type != VAR)
843          return(0);

Diff Legend

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