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.26 by schorsch, Sun Jul 27 22:12:01 2003 UTC vs.
Revision 2.29 by schorsch, Sun Mar 28 20:33:12 2004 UTC

# Line 26 | Line 26 | static const char      RCSid[] = "$Id$";
26   #include  <math.h>
27   #include  <stdlib.h>
28  
29 + #include  "rtmisc.h"
30 + #include  "rtio.h"
31   #include  "rterror.h"
32   #include  "calcomp.h"
33  
# Line 47 | Line 49 | unsigned int  esupport =               /* what to support */
49  
50   int  nextc;                             /* lookahead character */
51  
52 < double  (*eoper[])() = {                /* expression operations */
52 > double  (*eoper[])(EPNODE *) = {        /* expression operations */
53          ebotch,
54          evariable,
55          enumber,
# Line 82 | Line 84 | static int  linepos;                   /* position in buffer */
84  
85  
86   EPNODE *
87 < eparse(expr)                    /* parse an expression string */
88 < char  *expr;
87 > eparse(                 /* parse an expression string */
88 >    char  *expr
89 > )
90   {
91      EPNODE  *ep;
92  
# Line 97 | Line 100 | char  *expr;
100  
101  
102   double
103 < eval(expr)                      /* evaluate an expression string */
104 < char  *expr;
103 > eval(                   /* evaluate an expression string */
104 >    char  *expr
105 > )
106   {
107      register EPNODE  *ep;
108      double  rval;
# Line 111 | Line 115 | char  *expr;
115  
116  
117   int
118 < epcmp(ep1, ep2)                 /* compare two expressions for equivalence */
119 < register EPNODE  *ep1, *ep2;
118 > epcmp(                  /* compare two expressions for equivalence */
119 >    register EPNODE  *ep1,
120 >    register EPNODE  *ep2
121 > )
122   {
123          double  d;
124  
# Line 159 | Line 165 | register EPNODE  *ep1, *ep2;
165  
166  
167   void
168 < epfree(epar)                    /* free a parse tree */
169 < register EPNODE  *epar;
168 > epfree(                 /* free a parse tree */
169 >    register EPNODE      *epar
170 > )
171   {
172      register EPNODE  *ep;
173  
# Line 194 | Line 201 | register EPNODE         *epar;
201  
202                                  /* the following used to be a switch */
203   static double
204 < eargument(ep)
205 < EPNODE  *ep;
204 > eargument(
205 >    EPNODE      *ep
206 > )
207   {
208      return(argument(ep->v.chan));
209   }
210  
211   static double
212 < enumber(ep)
213 < EPNODE  *ep;
212 > enumber(
213 >    EPNODE      *ep
214 > )
215   {
216      return(ep->v.num);
217   }
218  
219   static double
220 < euminus(ep)
221 < EPNODE  *ep;
220 > euminus(
221 >    EPNODE      *ep
222 > )
223   {
224      register EPNODE  *ep1 = ep->v.kid;
225  
# Line 217 | Line 227 | EPNODE *ep;
227   }
228  
229   static double
230 < echannel(ep)
231 < EPNODE  *ep;
230 > echannel(
231 >    EPNODE      *ep
232 > )
233   {
234      return(chanvalue(ep->v.chan));
235   }
236  
237   static double
238 < eadd(ep)
239 < EPNODE  *ep;
238 > eadd(
239 >    EPNODE      *ep
240 > )
241   {
242      register EPNODE  *ep1 = ep->v.kid;
243  
# Line 233 | Line 245 | EPNODE *ep;
245   }
246  
247   static double
248 < esubtr(ep)
249 < EPNODE  *ep;
248 > esubtr(
249 >    EPNODE      *ep
250 > )
251   {
252      register EPNODE  *ep1 = ep->v.kid;
253  
# Line 242 | Line 255 | EPNODE *ep;
255   }
256  
257   static double
258 < emult(ep)
259 < EPNODE  *ep;
258 > emult(
259 >    EPNODE      *ep
260 > )
261   {
262      register EPNODE  *ep1 = ep->v.kid;
263  
# Line 251 | Line 265 | EPNODE *ep;
265   }
266  
267   static double
268 < edivi(ep)
269 < EPNODE  *ep;
268 > edivi(
269 >    EPNODE      *ep
270 > )
271   {
272      register EPNODE  *ep1 = ep->v.kid;
273      double  d;
# Line 267 | Line 282 | EPNODE *ep;
282   }
283  
284   static double
285 < epow(ep)
286 < EPNODE  *ep;
285 > epow(
286 >    EPNODE      *ep
287 > )
288   {
289      register EPNODE  *ep1 = ep->v.kid;
290      double  d;
# Line 290 | Line 306 | EPNODE *ep;
306   }
307  
308   static double
309 < ebotch(ep)
310 < EPNODE  *ep;
309 > ebotch(
310 >    EPNODE      *ep
311 > )
312   {
313      eputs("Bad expression!\n");
314      quit(1);
# Line 300 | Line 317 | EPNODE *ep;
317  
318  
319   EPNODE *
320 < ekid(ep, n)                     /* return pointer to a node's nth kid */
321 < register EPNODE  *ep;
322 < register int  n;
320 > ekid(                   /* return pointer to a node's nth kid */
321 >    register EPNODE      *ep,
322 >    register int  n
323 > )
324   {
325  
326      for (ep = ep->v.kid; ep != NULL; ep = ep->sibling)
# Line 314 | Line 332 | register int  n;
332  
333  
334   int
335 < nekids(ep)                      /* return # of kids for node ep */
336 < register EPNODE  *ep;
335 > nekids(                 /* return # of kids for node ep */
336 >    register EPNODE      *ep
337 > )
338   {
339      register int  n = 0;
340  
# Line 327 | Line 346 | register EPNODE         *ep;
346  
347  
348   void
349 < initfile(fp, fn, ln)            /* prepare input file */
350 < FILE  *fp;
351 < char  *fn;
352 < int  ln;
349 > initfile(               /* prepare input file */
350 >    FILE  *fp,
351 >    char  *fn,
352 >    int  ln
353 > )
354   {
355      static char  inpbuf[MAXLINE];
356  
# Line 345 | Line 365 | int  ln;
365  
366  
367   void
368 < initstr(s, fn, ln)              /* prepare input string */
369 < char  *s;
370 < char  *fn;
371 < int  ln;
368 > initstr(                /* prepare input string */
369 >    char  *s,
370 >    char  *fn,
371 >    int  ln
372 > )
373   {
374      infp = NULL;
375      infile = fn;
# Line 360 | Line 381 | int  ln;
381  
382  
383   void
384 < getscanpos(fnp, lnp, spp, fpp)  /* return current scan position */
385 < char  **fnp;
386 < int  *lnp;
387 < char  **spp;
388 < FILE  **fpp;
384 > getscanpos(     /* return current scan position */
385 >    char  **fnp,
386 >    int  *lnp,
387 >    char  **spp,
388 >    FILE  **fpp
389 > )
390   {
391      if (fnp != NULL) *fnp = infile;
392      if (lnp != NULL) *lnp = lineno;
# Line 374 | Line 396 | FILE  **fpp;
396  
397  
398   int
399 < scan()                          /* scan next character, return literal next */
399 > scan(void)              /* scan next character, return literal next */
400   {
401      register int  lnext = 0;
402  
# Line 406 | Line 428 | scan()                         /* scan next character, return literal next
428  
429  
430   char *
431 < long2ascii(l)                         /* convert long to ascii */
432 < long  l;
431 > long2ascii(                           /* convert long to ascii */
432 >    long  l
433 > )
434   {
435      static char  buf[16];
436      register char  *cp;
# Line 432 | Line 455 | long  l;
455  
456  
457   void
458 < syntax(err)                     /* report syntax error and quit */
459 < char  *err;
458 > syntax(                 /* report syntax error and quit */
459 >    char  *err
460 > )
461   {
462      register int  i;
463  
# Line 458 | Line 482 | char  *err;
482  
483  
484   void
485 < addekid(ep, ekid)                       /* add a child to ep */
486 < register EPNODE  *ep;
487 < EPNODE  *ekid;
485 > addekid(                        /* add a child to ep */
486 >    register EPNODE      *ep,
487 >    EPNODE      *ekid
488 > )
489   {
490      if (ep->v.kid == NULL)
491          ep->v.kid = ekid;
# Line 474 | Line 499 | EPNODE *ekid;
499  
500  
501   char *
502 < getname()                       /* scan an identifier */
502 > getname(void)                   /* scan an identifier */
503   {
504      static char  str[RMAXWORD+1];
505      register int  i, lnext;
# Line 491 | Line 516 | getname()                      /* scan an identifier */
516  
517  
518   int
519 < getinum()                       /* scan a positive integer */
519 > getinum(void)                   /* scan a positive integer */
520   {
521      register int  n, lnext;
522  
# Line 506 | Line 531 | getinum()                      /* scan a positive integer */
531  
532  
533   double
534 < getnum()                        /* scan a positive float */
534 > getnum(void)                    /* scan a positive float */
535   {
536      register int  i, lnext;
537      char  str[RMAXWORD+1];
# Line 548 | Line 573 | getnum()                       /* scan a positive float */
573  
574  
575   EPNODE *
576 < getE1()                         /* E1 -> E1 ADDOP E2 */
576 > getE1(void)                             /* E1 -> E1 ADDOP E2 */
577                                  /*       E2 */
578   {
579      register EPNODE  *ep1, *ep2;
# Line 570 | Line 595 | getE1()                                /* E1 -> E1 ADDOP E2 */
595  
596  
597   EPNODE *
598 < getE2()                         /* E2 -> E2 MULOP E3 */
598 > getE2(void)                             /* E2 -> E2 MULOP E3 */
599                                  /*       E3 */
600   {
601      register EPNODE  *ep1, *ep2;
# Line 592 | Line 617 | getE2()                                /* E2 -> E2 MULOP E3 */
617  
618  
619   EPNODE *
620 < getE3()                         /* E3 -> E4 ^ E3 */
620 > getE3(void)                             /* E3 -> E4 ^ E3 */
621                                  /*       E4 */
622   {
623      register EPNODE  *ep1, *ep2;
# Line 614 | Line 639 | getE3()                                /* E3 -> E4 ^ E3 */
639  
640  
641   EPNODE *
642 < getE4()                         /* E4 -> ADDOP E5 */
642 > getE4(void)                             /* E4 -> ADDOP E5 */
643                                  /*       E5 */
644   {
645      register EPNODE  *ep1, *ep2;
# Line 642 | Line 667 | getE4()                                /* E4 -> ADDOP E5 */
667  
668  
669   EPNODE *
670 < getE5()                         /* E5 -> (E1) */
670 > getE5(void)                     /* E5 -> (E1) */
671                                  /*       VAR */
672                                  /*       NUM */
673                                  /*       $N */
# Line 720 | Line 745 | getE5()                                /* E5 -> (E1) */
745  
746  
747   EPNODE *
748 < rconst(epar)                    /* reduce a constant expression */
749 < register EPNODE  *epar;
748 > rconst(                 /* reduce a constant expression */
749 >    register EPNODE      *epar
750 > )
751   {
752      register EPNODE  *ep;
753  
# Line 738 | Line 764 | register EPNODE         *epar;
764  
765  
766   int
767 < isconstvar(ep)                  /* is ep linked to a constant expression? */
768 < register EPNODE  *ep;
767 > isconstvar(                     /* is ep linked to a constant expression? */
768 >    register EPNODE      *ep
769 > )
770   {
771      register EPNODE  *ep1;
772  
# Line 763 | Line 790 | register EPNODE         *ep;
790  
791  
792   int
793 < isconstfun(ep)                  /* is ep linked to a constant function? */
794 < register EPNODE  *ep;
793 > isconstfun(                     /* is ep linked to a constant function? */
794 >    register EPNODE      *ep
795 > )
796   {
797      register EPNODE  *dp;
798      register LIBR  *lp;

Diff Legend

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