ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/caldefn.c
(Generate patch)

Comparing ray/src/common/caldefn.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:34:26 1989 UTC vs.
Revision 1.8 by greg, Tue Apr 23 12:59:33 1991 UTC

# Line 16 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16   *  1/15/88  Added clock for caching of variable values.
17   *
18   *  11/16/88  Added VARDEF structure for hard linking.
19 + *
20 + *  5/31/90  Added conditional compile (REDEFW) for redefinition warning.
21 + *
22 + *  4/23/91  Added ':' defines for constant expressions (RCONST)
23   */
24  
25   #include  <stdio.h>
# Line 32 | Line 36 | static char SCCSid[] = "$SunId$ LBL";
36  
37   extern char  *ecalloc(), *savestr();
38  
39 < extern double  dvalue();
39 > static double  dvalue();
40  
41   long  eclock = -1;                      /* value storage timer */
42  
# Line 66 | Line 70 | char  *fname;
70          eputs(": cannot open\n");
71          quit(1);
72      }
73 <    initfile(fname, fp);
73 >    initfile(fp, fname, 0);
74      while (nextc != EOF)
75          loaddefn();
76      if (fname != NULL)
# Line 74 | Line 78 | char  *fname;
78   }
79  
80  
81 < scompile(file, str)             /* get definitions from a string */
78 < char  *file;
81 > scompile(str, fn, ln)           /* get definitions from a string */
82   char  *str;
83 + char  *fn;
84 + int  ln;
85   {
86 <    initstr(file, str);
86 >    initstr(str, fn, ln);
87      while (nextc != EOF)
88          loaddefn();
89   }
# Line 102 | Line 107 | EPNODE  *ep;
107   }
108  
109  
110 < varset(vname, val)              /* set a variable's value */
110 > varset(vname, assign, val)      /* set a variable's value */
111   char  *vname;
112 + int  assign;
113   double  val;
114   {
115      register EPNODE  *ep1, *ep2;
# Line 112 | Line 118 | double  val;
118          ep2 = ep1->v.kid->sibling;
119          if (ep2->type == NUM) {
120              ep2->v.num = val;
121 <            ep2->sibling->v.tick = -1;
121 >            ep1->type = assign;
122              return;
123          }
124      }
125                                          /* hand build definition */
126      ep1 = newnode();
127 <    ep1->type = '=';
127 >    ep1->type = assign;
128      ep2 = newnode();
129      ep2->type = SYM;
130      ep2->v.name = savestr(vname);
# Line 127 | Line 133 | double  val;
133      ep2->type = NUM;
134      ep2->v.num = val;
135      addekid(ep1, ep2);
136 <    ep2 = newnode();
131 <    ep2->type = TICK;
132 <    ep2->v.tick = -1;
133 <    addekid(ep1, ep2);
134 <    ep2 = newnode();
135 <    ep2->type = NUM;
136 <    addekid(ep1, ep2);
137 <    dclear(vname);
136 >    dremove(vname);
137      dpush(ep1);
138   }
139  
140  
141 < dclear(name)                    /* delete all definitions of name */
141 > dclear(name)                    /* delete variable definitions of name */
142   char  *name;
143   {
144      register EPNODE  *ep;
145  
146 +    while ((ep = dpop(name)) != NULL) {
147 +        if (ep->type == ':') {
148 +            dpush(ep);          /* don't clear constants */
149 +            return;
150 +        }
151 +        epfree(ep);
152 +    }
153 + }
154 +
155 +
156 + dremove(name)                   /* delete all definitions of name */
157 + char  *name;
158 + {
159 +    register EPNODE  *ep;
160 +
161      while ((ep = dpop(name)) != NULL)
162          epfree(ep);
163   }
# Line 159 | Line 173 | char  *name;
173  
174  
175   #ifdef  OUTCHAN
176 < chanout()                       /* set output channels */
176 > chanout(cs)                     /* set output channels */
177 > int  (*cs)();
178   {
179      register EPNODE  *ep;
180  
181      for (ep = outchan; ep != NULL; ep = ep->sibling)
182 <        chanset(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
182 >        (*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
183  
184   }
185   #endif
# Line 178 | Line 193 | dclearall()                    /* clear all definitions */
193  
194      for (i = 0; i < NHASH; i++)
195          for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
196 <            dclear(vp->name);
196 >            dremove(vp->name);
197   #ifdef  OUTCHAN
198      for (ep = outchan; ep != NULL; ep = ep->sibling)
199          epfree(ep);
# Line 370 | Line 385 | loaddefn()                     /* load next definition */
385   #endif
386      {                           /* ordinary definition */
387          ep = getdefn();
388 + #ifdef  REDEFW
389 +        if (dlookup(dname(ep)) != NULL) {
390 +            dclear(dname(ep));
391 +            wputs(dname(ep));
392 +            if (dlookup(dname(ep)) == NULL)
393 +                wputs(": redefined\n");
394 +            else
395 +                wputs(": redefined constant expression\n");
396 +        }
397 + #ifdef  FUNCTION
398 +        else if (ep->v.kid->type == FUNC &&
399 +                        liblookup(ep->v.kid->v.kid->v.name) != NULL) {
400 +            wputs(ep->v.kid->v.kid->v.name);
401 +            wputs(": redefined library function\n");
402 +        }
403 + #endif
404 + #else
405          dclear(dname(ep));
406 + #endif
407          dpush(ep);
408      }
409      if (nextc != EOF) {
# Line 383 | Line 416 | loaddefn()                     /* load next definition */
416  
417   EPNODE *
418   getdefn()                       /* A -> SYM = E1 */
419 +                                /*      SYM : E1 */
420                                  /*      FUNC(SYM,..) = E1 */
421 +                                /*      FUNC(SYM,..) : E1 */
422   {
423      register EPNODE  *ep1, *ep2;
424  
# Line 417 | Line 452 | getdefn()                      /* A -> SYM = E1 */
452          curfunc = NULL;
453   #endif
454  
455 <    if (nextc != '=')
456 <        syntax("'=' expected");
422 <    scan();
455 >    if (nextc != '=' && nextc != ':')
456 >        syntax("'=' or ':' expected");
457  
458      ep2 = newnode();
459 <    ep2->type = '=';
459 >    ep2->type = nextc;
460 >    scan();
461      addekid(ep2, ep1);
462 + #ifdef  RCONST
463 +    if (
464 + #ifdef  FUNCTION
465 +            ep1->type == SYM &&
466 + #endif
467 +            ep2->type == ':')
468 +        addekid(ep2, rconst(getE1()));
469 +    else
470 + #endif
471      addekid(ep2, getE1());
472  
473 +    if (
474   #ifdef  FUNCTION
475 <    if (ep1->type == SYM)
475 >            ep1->type == SYM &&
476   #endif
477 <    {
477 >            ep1->sibling->type != NUM) {
478          ep1 = newnode();
479          ep1->type = TICK;
480          ep1->v.tick = -1;
# Line 490 | Line 535 | EPNODE  *d;
535          quit(1);
536      }
537      ep1 = d->v.kid->sibling;                    /* get expression */
538 +    if (ep1->type == NUM)
539 +        return(ep1->v.num);                     /* return if number */
540      ep2 = ep1->sibling;                         /* check time */
541      if (ep2->v.tick < 0 || ep2->v.tick < eclock) {
542 <        ep2->v.tick = eclock;
542 >        ep2->v.tick = d->type == ':' ? 1L<<30 : eclock;
543          ep2 = ep2->sibling;
544 <        ep2->v.num = evalue(ep1);               /* compute new value */
544 >        ep2->v.num = evalue(ep1);               /* needs new value */
545      } else
546 <        ep2 = ep2->sibling;                     /* reuse old value */
546 >        ep2 = ep2->sibling;                     /* else reuse old value */
547  
548      return(ep2->v.num);
549   }

Diff Legend

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