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 2.24 by greg, Fri Mar 5 17:28:46 2010 UTC vs.
Revision 2.35 by greg, Tue Sep 26 00:14:02 2023 UTC

# Line 27 | Line 27 | static const char      RCSid[] = "$Id$";
27  
28   #include "copyright.h"
29  
30 – #include  <stdio.h>
31 – #include  <string.h>
30   #include  <ctype.h>
31  
32   #include  "rterror.h"
# Line 80 | Line 78 | fcompile(                      /* get definitions from a file */
78          eputs(": cannot open\n");
79          quit(1);
80      }
81 <    initfile(fp, fname, 0);
81 > #ifdef getc_unlocked                    /* avoid stupid semaphores */
82 >    flockfile(fp);
83 > #endif
84 >   initfile(fp, fname, 0);
85      while (nextc != EOF)
86          getstatement();
87      if (fname != NULL)
88          fclose(fp);
89 + #ifdef getc_unlocked
90 +    else
91 +        funlockfile(fp);
92 + #endif
93   }
94  
95  
# Line 115 | Line 120 | evariable(                     /* evaluate a variable */
120          EPNODE  *ep
121   )
122   {
123 <    register VARDEF  *dp = ep->v.ln;
123 >    VARDEF  *dp = ep->v.ln;
124  
125      return(dvalue(dp->name, dp->def));
126   }
# Line 129 | Line 134 | varset(                /* set a variable's value */
134   )
135   {
136      char  *qname;
137 <    register EPNODE  *ep1, *ep2;
137 >    EPNODE  *ep1, *ep2;
138                                          /* get qualified name */
139      qname = qualname(vname, 0);
140                                          /* check for quick set */
141 <    if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM) {
141 >    if ((ep1 = dlookup(qname)) != NULL && ep1->v.kid->type == SYM &&
142 >                (ep1->type == ':') <= (assign == ':')) {
143          ep2 = ep1->v.kid->sibling;
144          if (ep2->type == NUM) {
145              ep2->v.num = val;
# Line 141 | Line 147 | varset(                /* set a variable's value */
147              return;
148          }
149      }
150 +    if (ep1 != NULL && esupport&E_REDEFW) {
151 +        wputs(qname);
152 +        if (ep1->type == ':')
153 +            wputs(": reset constant expression\n");
154 +        else
155 +            wputs(": reset expression\n");
156 +    }
157                                          /* hand build definition */
158      ep1 = newnode();
159      ep1->type = assign;
# Line 152 | Line 165 | varset(                /* set a variable's value */
165      ep2->type = NUM;
166      ep2->v.num = val;
167      addekid(ep1, ep2);
168 <    dremove(qname);
168 >    if (assign == ':')
169 >        dremove(qname);
170 >    else
171 >        dclear(qname);
172      dpush(qname, ep1);
173   }
174  
# Line 162 | Line 178 | dclear(                        /* delete variable definitions of name */
178          char  *name
179   )
180   {
181 <    register EPNODE  *ep;
181 >    EPNODE  *ep;
182  
183      while ((ep = dpop(name)) != NULL) {
184          if (ep->type == ':') {
# Line 179 | Line 195 | dremove(                       /* delete all definitions of name */
195          char  *name
196   )
197   {
198 <    register EPNODE  *ep;
198 >    EPNODE  *ep;
199  
200      while ((ep = dpop(name)) != NULL)
201          epfree(ep);
# Line 187 | Line 203 | dremove(                       /* delete all definitions of name */
203  
204  
205   int
206 < vardefined(     /* return non-zero if variable defined */
206 > vardefined(     /* return '=' or ':' if variable/constant defined */
207          char  *name
208   )
209   {
210 <    register EPNODE  *dp;
210 >    EPNODE  *dp = dlookup(name);
211  
212 <    return((dp = dlookup(name)) != NULL && dp->v.kid->type == SYM);
212 >    if (dp == NULL || dp->v.kid->type != SYM)
213 >        return(0);
214 >
215 >    return(dp->type);
216   }
217  
218  
219   char *
220 < setcontext(                     /* set a new context path */
221 <        register char  *ctx
220 > calcontext(                     /* set a new context path */
221 >        char  *ctx
222   )
223   {
224 <    register char  *cpp;
224 >    char  *cpp;
225  
226      if (ctx == NULL)
227          return(context);                /* just asking */
# Line 236 | Line 255 | pushcontext(           /* push on another context */
255   )
256   {
257      char  oldcontext[MAXCNTX+1];
258 <    register int  n;
258 >    int  n;
259  
260      strcpy(oldcontext, context);        /* save old context */
261 <    setcontext(ctx);                    /* set new context */
261 >    calcontext(ctx);                    /* set new context */
262      n = strlen(context);                /* tack on old */
263      if (n+strlen(oldcontext) > MAXCNTX) {
264          strncpy(context+n, oldcontext, MAXCNTX-n);
# Line 253 | Line 272 | pushcontext(           /* push on another context */
272   char *
273   popcontext(void)                        /* pop off top context */
274   {
275 <    register char  *cp1, *cp2;
275 >    char  *cp1, *cp2;
276  
277      if (!context[0])                    /* nothing left to pop */
278          return(context);
# Line 269 | Line 288 | popcontext(void)                       /* pop off top context */
288  
289   char *
290   qualname(               /* get qualified name */
291 <        register char  *nam,
291 >        char  *nam,
292          int  lvl
293   )
294   {
295      static char  nambuf[RMAXWORD+1];
296 <    register char  *cp = nambuf, *cpp;
296 >    char  *cp = nambuf, *cpp;
297                                  /* check for explicit local */
298      if (*nam == CNTXMARK)
299          if (lvl > 0)            /* only action is to refuse search */
# Line 316 | Line 335 | toolong:
335  
336   int
337   incontext(                      /* is qualified name in current context? */
338 <        register char  *qn
338 >        char  *qn
339   )
340   {
341      if (!context[0])                    /* global context accepts all */
# Line 332 | Line 351 | chanout(                       /* set output channels */
351          void  (*cs)(int n, double v)
352   )
353   {
354 <    register EPNODE  *ep;
354 >    EPNODE  *ep;
355  
356      for (ep = outchan; ep != NULL; ep = ep->sibling)
357          (*cs)(ep->v.kid->v.chan, evalue(ep->v.kid->sibling));
# Line 345 | Line 364 | dcleanup(              /* clear definitions (0->vars,1->output,2->
364          int  lvl
365   )
366   {
367 <    register int  i;
368 <    register VARDEF  *vp;
369 <    register EPNODE  *ep;
367 >    int  i;
368 >    VARDEF  *vp;
369 >    EPNODE  *ep;
370                                  /* if context is global, clear all */
371      for (i = 0; i < NHASH; i++)
372          for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
# Line 357 | Line 376 | dcleanup(              /* clear definitions (0->vars,1->output,2->
376                  else
377                      dclear(vp->name);
378              }
379 <    if (lvl >= 1) {
380 <        for (ep = outchan; ep != NULL; ep = ep->sibling)
379 >    if (lvl >= 1)
380 >        while (outchan != NULL) {
381 >            ep = outchan;
382 >            outchan = ep->sibling;
383 >            ep->sibling = NULL;
384              epfree(ep);
385 <        outchan = NULL;
364 <    }
385 >        }
386   }
387  
388  
# Line 370 | Line 391 | dlookup(                       /* look up a definition */
391          char  *name
392   )
393   {
394 <    register VARDEF  *vp;
394 >    VARDEF  *vp;
395      
396      if ((vp = varlookup(name)) == NULL)
397          return(NULL);
# Line 384 | Line 405 | varlookup(                     /* look up a variable */
405   )
406   {
407      int  lvl = 0;
408 <    register char  *qname;
409 <    register VARDEF  *vp;
408 >    char  *qname;
409 >    VARDEF  *vp;
410                                  /* find most qualified match */
411      while ((qname = qualname(name, lvl++)) != NULL)
412          for (vp = hashtbl[hash(qname)]; vp != NULL; vp = vp->next)
# Line 400 | Line 421 | varinsert(                     /* get a link to a variable */
421          char  *name
422   )
423   {
424 <    register VARDEF  *vp;
424 >    VARDEF  *vp;
425      int  hv;
426      
427      if ((vp = varlookup(name)) != NULL) {
# Line 426 | Line 447 | libupdate(                     /* update library links */
447          char  *fn
448   )
449   {
450 <    register int  i;
451 <    register VARDEF  *vp;
450 >    int  i;
451 >    VARDEF  *vp;
452                                          /* if fn is NULL then relink all */
453      for (i = 0; i < NHASH; i++)
454          for (vp = hashtbl[i]; vp != NULL; vp = vp->next)
455 <            if (vp->lib != NULL || fn == NULL || !strcmp(fn, vp->name))
455 >            if ((vp->lib != NULL) | (fn == NULL) || !strcmp(fn, vp->name))
456                  vp->lib = liblookup(vp->name);
457   }
458  
459  
460   void
461   varfree(                                /* release link to variable */
462 <        register VARDEF  *ln
462 >        VARDEF   *ln
463   )
464   {
465 <    register VARDEF  *vp;
465 >    VARDEF  *vp;
466      int  hv;
467  
468      if (--ln->nlinks > 0)
# Line 457 | Line 478 | varfree(                               /* release link to variable */
478          vp->next = ln->next;
479      }
480      freestr(ln->name);
481 <    efree((char *)ln);
481 >    efree(ln);
482   }
483  
484  
# Line 474 | Line 495 | dfirst(void)                   /* return pointer to first definition *
495   EPNODE *
496   dnext(void)                             /* return pointer to next definition */
497   {
498 <    register EPNODE  *ep;
499 <    register char  *nm;
498 >    EPNODE  *ep;
499 >    char  *nm;
500  
501      while (htndx < NHASH) {
502          if (htpos == NULL)
# Line 499 | Line 520 | dpop(                  /* pop a definition */
520          char  *name
521   )
522   {
523 <    register VARDEF  *vp;
524 <    register EPNODE  *dp;
523 >    VARDEF  *vp;
524 >    EPNODE  *dp;
525      
526      if ((vp = varlookup(name)) == NULL || vp->def == NULL)
527          return(NULL);
# Line 514 | Line 535 | dpop(                  /* pop a definition */
535   void
536   dpush(                  /* push on a definition */
537          char  *nm,
538 <        register EPNODE  *ep
538 >        EPNODE   *ep
539   )
540   {
541 <    register VARDEF  *vp;
541 >    VARDEF  *vp;
542  
543      vp = varinsert(nm);
544      ep->sibling = vp->def;
# Line 531 | Line 552 | addchan(                       /* add an output channel assignment */
552   )
553   {
554      int  ch = sp->v.kid->v.chan;
555 <    register EPNODE  *ep, *epl;
555 >    EPNODE  *ep, *epl;
556  
557      for (epl = NULL, ep = outchan; ep != NULL; epl = ep, ep = ep->sibling)
558          if (ep->v.kid->v.chan >= ch) {
# Line 559 | Line 580 | addchan(                       /* add an output channel assignment */
580   void
581   getstatement(void)                      /* get next statement */
582   {
583 <    register EPNODE  *ep;
583 >    EPNODE  *ep;
584      char  *qname;
585 <    register VARDEF  *vdef;
585 >    VARDEF  *vdef;
586  
587      if (nextc == ';') {         /* empty statement */
588          scan();
# Line 607 | Line 628 | getdefn(void)
628          /*      FUNC(SYM,..) = E1 */
629          /*      FUNC(SYM,..) : E1 */
630   {
631 <    register EPNODE  *ep1, *ep2;
631 >    EPNODE  *ep1, *ep2;
632  
633 <    if (!isalpha(nextc) && nextc != CNTXMARK)
633 >    if (!isalpha(nextc) & (nextc != CNTXMARK))
634          syntax("illegal variable name");
635  
636      ep1 = newnode();
# Line 628 | Line 649 | getdefn(void)
649              ep2 = newnode();
650              ep2->type = SYM;
651              ep2->v.name = savestr(getname());
652 +            if (strchr(ep2->v.name, CNTXMARK) != NULL)
653 +                syntax("illegal parameter name");
654              addekid(ep1, ep2);
655          } while (nextc == ',');
656          if (nextc != ')')
# Line 636 | Line 659 | getdefn(void)
659          curfunc = ep1;
660      }
661  
662 <    if (nextc != '=' && nextc != ':')
662 >    if ((nextc != '=') & (nextc != ':'))
663          syntax("'=' or ':' expected");
664  
665      ep2 = newnode();
# Line 663 | Line 686 | getdefn(void)
686   EPNODE *
687   getchan(void)                   /* A -> $N = E1 */
688   {
689 <    register EPNODE  *ep1, *ep2;
689 >    EPNODE  *ep1, *ep2;
690  
691      if (nextc != '$')
692          syntax("missing '$'");
# Line 693 | Line 716 | getchan(void)                  /* A -> $N = E1 */
716  
717  
718   static double                   /* evaluate a variable */
719 < dvalue(char  *name, EPNODE      *d)
719 > dvalue(char *name, EPNODE *d)
720   {
721 <    register EPNODE  *ep1, *ep2;
721 >    EPNODE  *ep1, *ep2;
722      
723      if (d == NULL || d->v.kid->type != SYM) {
724          eputs(name);
# Line 705 | Line 728 | dvalue(char  *name, EPNODE     *d)
728      ep1 = d->v.kid->sibling;                    /* get expression */
729      if (ep1->type == NUM)
730          return(ep1->v.num);                     /* return if number */
731 +    if (esupport&E_RCONST && d->type == ':') {
732 +        wputs(name);
733 +        wputs(": assigned non-constant value\n");
734 +    }
735      ep2 = ep1->sibling;                         /* check time */
736      if (eclock >= MAXCLOCK)
737          eclock = 1;                             /* wrap clock counter */

Diff Legend

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