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

Comparing ray/src/util/eplus_idf.c (file contents):
Revision 2.7 by greg, Tue Feb 11 23:30:11 2014 UTC vs.
Revision 2.8 by greg, Wed Feb 12 17:40:07 2014 UTC

# Line 20 | Line 20 | static const char RCSid[] = "$Id$";
20   #define getc    getc_unlocked
21   #endif
22  
23 < /* Create a new parameter with empty field list (comment optional) */
24 < IDF_PARAMETER *
25 < idf_newparam(IDF_LOADED *idf, const char *pname, const char *comm,
26 <                        IDF_PARAMETER *prev)
23 > /* Create a new object with empty field list (comment optional) */
24 > IDF_OBJECT *
25 > idf_newobject(IDF_LOADED *idf, const char *pname, const char *comm,
26 >                        IDF_OBJECT *prev)
27   {
28          LUENT           *pent;
29 <        IDF_PARAMETER   *pnew;
29 >        IDF_OBJECT      *pnew;
30  
31          if ((idf == NULL) | (pname == NULL))
32                  return(NULL);
# Line 34 | Line 34 | idf_newparam(IDF_LOADED *idf, const char *pname, const
34          pent = lu_find(&idf->ptab, pname);
35          if (pent == NULL)
36                  return(NULL);
37 <        if (pent->key == NULL) {        /* new parameter name/type? */
37 >        if (pent->key == NULL) {        /* new object name/type? */
38                  pent->key = (char *)malloc(strlen(pname)+1);
39                  if (pent->key == NULL)
40                          return(NULL);
41                  strcpy(pent->key, pname);
42          }
43 <        pnew = (IDF_PARAMETER *)malloc(sizeof(IDF_PARAMETER)+strlen(comm));
43 >        pnew = (IDF_OBJECT *)malloc(sizeof(IDF_OBJECT)+strlen(comm));
44          if (pnew == NULL)
45                  return(NULL);
46          strcpy(pnew->rem, comm);
47          pnew->nfield = 0;
48          pnew->flist = NULL;
49          pnew->pname = pent->key;        /* add to table */
50 <        pnew->pnext = (IDF_PARAMETER *)pent->data;
50 >        pnew->pnext = (IDF_OBJECT *)pent->data;
51          pent->data = (char *)pnew;
52          pnew->dnext = NULL;             /* add to file list */
53          if (prev != NULL || (prev = idf->plast) != NULL) {
# Line 62 | Line 62 | idf_newparam(IDF_LOADED *idf, const char *pname, const
62          return(pnew);
63   }
64  
65 < /* Add a field to the given parameter and follow with the given text */
65 > /* Add a field to the given object and follow with the given text */
66   int
67 < idf_addfield(IDF_PARAMETER *param, const char *fval, const char *comm)
67 > idf_addfield(IDF_OBJECT *param, const char *fval, const char *comm)
68   {
69          int             fnum = 1;       /* returned argument number */
70          IDF_FIELD       *fnew, *flast;
# Line 83 | Line 83 | idf_addfield(IDF_PARAMETER *param, const char *fval, c
83          fnew->rem = cp;
84          while ((*cp++ = *comm++))
85                  ;
86 <                                        /* add to parameter's field list */
86 >                                        /* add to object's field list */
87          if ((flast = param->flist) != NULL) {
88                  ++fnum;
89                  while (flast->next != NULL) {
# Line 99 | Line 99 | idf_addfield(IDF_PARAMETER *param, const char *fval, c
99          return(fnum);
100   }
101  
102 < /* Retrieve the indexed field from parameter (first field index is 1) */
102 > /* Retrieve the indexed field from object (first field index is 1) */
103   IDF_FIELD *
104 < idf_getfield(IDF_PARAMETER *param, int fn)
104 > idf_getfield(IDF_OBJECT *param, int fn)
105   {
106          IDF_FIELD       *fld;
107  
# Line 113 | Line 113 | idf_getfield(IDF_PARAMETER *param, int fn)
113          return(fld);
114   }
115  
116 < /* Delete the specified parameter from loaded IDF */
116 > /* Delete the specified object from loaded IDF */
117   int
118 < idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
118 > idf_delobject(IDF_LOADED *idf, IDF_OBJECT *param)
119   {
120          LUENT           *pent;
121 <        IDF_PARAMETER   *pptr, *plast;
121 >        IDF_OBJECT      *pptr, *plast;
122  
123          if ((idf == NULL) | (param == NULL))
124                  return(0);
125 <                                        /* remove from parameter table */
125 >                                        /* remove from object table */
126          pent = lu_find(&idf->ptab, param->pname);
127 <        for (plast = NULL, pptr = (IDF_PARAMETER *)pent->data;
127 >        for (plast = NULL, pptr = (IDF_OBJECT *)pent->data;
128                                  pptr != NULL; plast = pptr, pptr = pptr->pnext)
129                  if (pptr == param)
130                          break;
# Line 151 | Line 151 | idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
151                  param->flist = fdel->next;
152                  free(fdel);
153          }
154 <        free(param);                    /* free parameter struct */
154 >        free(param);                    /* free object struct */
155          return(1);
156   }
157  
158 < /* Move the specified parameter to the given position in the IDF */
158 > /* Move the specified object to the given position in the IDF */
159   int
160 < idf_movparam(IDF_LOADED *idf, IDF_PARAMETER *param, IDF_PARAMETER *prev)
160 > idf_movobject(IDF_LOADED *idf, IDF_OBJECT *param, IDF_OBJECT *prev)
161   {
162 <        IDF_PARAMETER   *pptr, *plast;
162 >        IDF_OBJECT      *pptr, *plast;
163  
164          if ((idf == NULL) | (param == NULL))
165                  return(0);
# Line 187 | Line 187 | idf_movparam(IDF_LOADED *idf, IDF_PARAMETER *param, ID
187          return(1);
188   }
189  
190 < /* Get a named parameter list */
191 < IDF_PARAMETER *
192 < idf_getparam(IDF_LOADED *idf, const char *pname)
190 > /* Get a named object list */
191 > IDF_OBJECT *
192 > idf_getobject(IDF_LOADED *idf, const char *pname)
193   {
194          if ((idf == NULL) | (pname == NULL))
195                  return(NULL);
196  
197 <        return((IDF_PARAMETER *)lu_find(&idf->ptab,pname)->data);
197 >        return((IDF_OBJECT *)lu_find(&idf->ptab,pname)->data);
198   }
199  
200   /* Read an argument including terminating ',' or ';' -- return which */
# Line 244 | Line 244 | idf_read_comment(char *buf, int len, FILE *fp)
244                  ungetc(c, fp);
245   }
246  
247 < /* Read a parameter and fields from an open file and add to end of list */
248 < IDF_PARAMETER *
249 < idf_readparam(IDF_LOADED *idf, FILE *fp)
247 > /* Read a object and fields from an open file and add to end of list */
248 > IDF_OBJECT *
249 > idf_readobject(IDF_LOADED *idf, FILE *fp)
250   {
251          char            abuf[IDF_MAXARGL], cbuf[IDF_MAXLINE];
252          int             delim;
253 <        IDF_PARAMETER   *pnew;
253 >        IDF_OBJECT      *pnew;
254          
255          if ((delim = idf_read_argument(abuf, fp, 1)) == EOF)
256                  return(NULL);
257          idf_read_comment(cbuf, IDF_MAXLINE, fp);
258 <        pnew = idf_newparam(idf, abuf, cbuf, NULL);
258 >        pnew = idf_newobject(idf, abuf, cbuf, NULL);
259          while (delim == ',')
260                  if ((delim = idf_read_argument(abuf, fp, 1)) != EOF) {
261                          idf_read_comment(cbuf, IDF_MAXLINE, fp);
262                          idf_addfield(pnew, abuf, cbuf);
263                  }
264          if (delim != ';')
265 <                fputs("Expected ';' at end of parameter list!\n", stderr);
265 >                fputs("Expected ';' at end of object list!\n", stderr);
266          return(pnew);
267   }
268  
# Line 343 | Line 343 | idf_load(const char *fname)
343          idf = idf_create(hdrcomm);      /* create IDF struct */
344          if (idf == NULL)
345                  return(NULL);
346 <                                        /* read each parameter */
347 <        while (idf_readparam(idf, fp) != NULL)
346 >                                        /* read each object */
347 >        while (idf_readobject(idf, fp) != NULL)
348                  ;
349          if (fp != stdin)                /* close file if not stdin */
350                  fclose(fp);
351          return(idf);                    /* success! */
352   }
353  
354 < /* Write a parameter and fields to an open file */
354 > /* Write a object and fields to an open file */
355   int
356 < idf_writeparam(IDF_PARAMETER *param, FILE *fp, int incl_comm)
356 > idf_writeparam(IDF_OBJECT *param, FILE *fp, int incl_comm)
357   {
358          IDF_FIELD       *fptr;
359  
# Line 381 | Line 381 | int
381   idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
382   {
383          FILE            *fp;
384 <        IDF_PARAMETER   *pptr;
384 >        IDF_OBJECT      *pptr;
385  
386          if (idf == NULL)
387                  return(0);
# Line 410 | Line 410 | idf_free(IDF_LOADED *idf)
410          if (idf->hrem != NULL)
411                  free(idf->hrem);
412          while (idf->pfirst != NULL)
413 <                idf_delparam(idf, idf->pfirst);
413 >                idf_delobject(idf, idf->pfirst);
414          lu_done(&idf->ptab);
415   }

Diff Legend

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