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.6 by greg, Mon Feb 10 04:51:26 2014 UTC vs.
Revision 2.10 by greg, Thu Feb 13 17:39:39 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);
166 +                                        /* quick check if already there */
167 +        if (param == (prev==NULL ? idf->pfirst : prev->dnext))
168 +                return(1);
169                                          /* find in IDF list, first*/
170          for (plast = NULL, pptr = idf->pfirst;
171                                  pptr != param; plast = pptr, pptr = pptr->dnext)
172                  if (pptr == NULL)
173                          return(0);
174 <        if (plast == NULL) {
172 <                if (prev == NULL)
173 <                        return(1);      /* already in place */
174 >        if (plast == NULL)
175                  idf->pfirst = param->dnext;
176 <        } else {
176 <                if (prev == plast)
177 <                        return(1);      /* already in place */
176 >        else
177                  plast->dnext = param->dnext;
179 –        }
178          if (idf->plast == param)
179                  idf->plast = plast;
180          if (prev == NULL) {             /* means they want it at beginning */
# Line 189 | 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 227 | Line 225 | idf_read_comment(char *buf, int len, FILE *fp)
225   {
226          int     incomm = 0;
227          char    *cp = buf;
228 <        char    dummyc;
228 >        char    dummys[2];
229          int     c;
230  
231          if ((buf == NULL) | (len <= 0)) {
232 <                buf = &dummyc;
233 <                len = 1;
232 >                buf = dummys;
233 >                len = sizeof(dummys);
234          }
235          while ((c = getc(fp)) != EOF &&
236                          (isspace(c) || (incomm += (c == '!')))) {
237                  if (c == '\n')
238                          incomm = 0;
239 <                if (cp-buf < len-1)
239 >                if (cp-buf < len-2)
240                          *cp++ = c;
241 +                else if (cp-buf == len-2)
242 +                        *cp++ = '\n';
243          }
244          *cp = '\0';
245          if (c != EOF)
246                  ungetc(c, fp);
247   }
248  
249 < /* Read a parameter and fields from an open file and add to end of list */
250 < IDF_PARAMETER *
251 < idf_readparam(IDF_LOADED *idf, FILE *fp)
249 > /* Read a object and fields from an open file and add to end of list */
250 > IDF_OBJECT *
251 > idf_readobject(IDF_LOADED *idf, FILE *fp)
252   {
253 <        char            abuf[IDF_MAXARGL], cbuf[IDF_MAXLINE];
253 >        char            abuf[IDF_MAXARGL], cbuf[100*IDF_MAXLINE];
254          int             delim;
255 <        IDF_PARAMETER   *pnew;
255 >        IDF_OBJECT      *pnew;
256          
257          if ((delim = idf_read_argument(abuf, fp, 1)) == EOF)
258                  return(NULL);
259 <        idf_read_comment(cbuf, IDF_MAXLINE, fp);
260 <        pnew = idf_newparam(idf, abuf, cbuf, NULL);
259 >        idf_read_comment(cbuf, sizeof(cbuf), fp);
260 >        pnew = idf_newobject(idf, abuf, cbuf, NULL);
261          while (delim == ',')
262                  if ((delim = idf_read_argument(abuf, fp, 1)) != EOF) {
263 <                        idf_read_comment(cbuf, IDF_MAXLINE, fp);
263 >                        idf_read_comment(cbuf, sizeof(cbuf), fp);
264                          idf_addfield(pnew, abuf, cbuf);
265                  }
266          if (delim != ';')
267 <                fputs("Expected ';' at end of parameter list!\n", stderr);
267 >                fputs("Expected ';' at end of object list!\n", stderr);
268          return(pnew);
269   }
270  
# Line 345 | Line 345 | idf_load(const char *fname)
345          idf = idf_create(hdrcomm);      /* create IDF struct */
346          if (idf == NULL)
347                  return(NULL);
348 <                                        /* read each parameter */
349 <        while (idf_readparam(idf, fp) != NULL)
348 >                                        /* read each object */
349 >        while (idf_readobject(idf, fp) != NULL)
350                  ;
351          if (fp != stdin)                /* close file if not stdin */
352                  fclose(fp);
353          return(idf);                    /* success! */
354   }
355  
356 < /* Write a parameter and fields to an open file */
356 > /* Write a object and fields to an open file */
357   int
358 < idf_writeparam(IDF_PARAMETER *param, FILE *fp, int incl_comm)
358 > idf_writeparam(IDF_OBJECT *param, FILE *fp, int incl_comm)
359   {
360          IDF_FIELD       *fptr;
361  
# Line 383 | Line 383 | int
383   idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
384   {
385          FILE            *fp;
386 <        IDF_PARAMETER   *pptr;
386 >        IDF_OBJECT      *pptr;
387  
388          if (idf == NULL)
389                  return(0);
# Line 412 | Line 412 | idf_free(IDF_LOADED *idf)
412          if (idf->hrem != NULL)
413                  free(idf->hrem);
414          while (idf->pfirst != NULL)
415 <                idf_delparam(idf, idf->pfirst);
415 >                idf_delobject(idf, idf->pfirst);
416          lu_done(&idf->ptab);
417   }

Diff Legend

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