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.3 by greg, Sun Feb 9 02:18:16 2014 UTC vs.
Revision 2.12 by greg, Wed Mar 5 19:49: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 61 | 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 76 | Line 77 | idf_addfield(IDF_PARAMETER *param, const char *fval, c
77          if (fnew == NULL)
78                  return(0);
79          fnew->next = NULL;
80 <        cp = fnew->arg;                 /* copy argument and comments */
80 >        cp = fnew->val;                 /* copy value and comments */
81          while ((*cp++ = *fval++))
82                  ;
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 94 | Line 95 | idf_addfield(IDF_PARAMETER *param, const char *fval, c
95                  param->flist = fnew;
96          else
97                  flast->next = fnew;
98 +        param->nfield++;
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 111 | 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 134 | Line 136 | idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
136                  plast->pnext = param->pnext;
137                                          /* remove from global list */
138          for (plast = NULL, pptr = idf->pfirst;
139 <                                pptr != NULL; plast = pptr, pptr = pptr->dnext)
140 <                if (pptr == param)
141 <                        break;
140 <        if (pptr == NULL)
141 <                return(0);
139 >                                pptr != param; plast = pptr, pptr = pptr->dnext)
140 >                if (pptr == NULL)
141 >                        return(0);
142          if (plast == NULL)
143                  idf->pfirst = param->dnext;
144          else
# 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 < /* Get a named parameter list */
159 < IDF_PARAMETER *
160 < idf_getparam(IDF_LOADED *idf, const char *pname)
158 > /* Move the specified object to the given position in the IDF */
159 > int
160 > idf_movobject(IDF_LOADED *idf, IDF_OBJECT *param, IDF_OBJECT *prev)
161   {
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)
175 +                idf->pfirst = param->dnext;
176 +        else
177 +                plast->dnext = param->dnext;
178 +        if (idf->plast == param)
179 +                idf->plast = plast;
180 +        if (prev == NULL) {             /* means they want it at beginning */
181 +                param->dnext = idf->pfirst;
182 +                idf->pfirst = param;
183 +        } else {
184 +                param->dnext = prev->dnext;
185 +                prev->dnext = param;
186 +        }
187 +        return(1);
188 + }
189 +
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 193 | 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 269 | Line 303 | idf_create(const char *hdrcomm)
303          return(idf);
304   }
305  
306 + /* Add comment(s) to header */
307 + int
308 + idf_add2hdr(IDF_LOADED *idf, const char *hdrcomm)
309 + {
310 +        int     olen, len;
311 +
312 +        if ((idf == NULL) | (hdrcomm == NULL))
313 +                return(0);
314 +        len = strlen(hdrcomm);
315 +        if (!len)
316 +                return(0);
317 +        if (idf->hrem == NULL)
318 +                olen = 0;
319 +        else
320 +                olen = strlen(idf->hrem);
321 +        if (olen)
322 +                idf->hrem = (char *)realloc(idf->hrem, olen+len+1);
323 +        else
324 +                idf->hrem = (char *)malloc(len+1);
325 +        if (idf->hrem == NULL)
326 +                return(0);
327 +        strcpy(idf->hrem+olen, hdrcomm);
328 +        return(1);
329 + }
330 +
331   /* Load an Input Data File */
332   IDF_LOADED *
333   idf_load(const char *fname)
334   {
335 <        char            hdrcomm[300*IF_MAXLINE];
335 >        char            hdrcomm[256*IDF_MAXLINE];
336          FILE            *fp;
337          IDF_LOADED      *idf;
338  
# Line 286 | 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 > /* Check string for end-of-line */
357 > static int
358 > idf_hasEOL(const char *s)
359 > {
360 >        while (*s)
361 >                if (*s++ == '\n')
362 >                        return(1);
363 >        return(0);
364 > }
365 >
366 > /* Write a object and fields to an open file */
367   int
368 < idf_writeparam(IDF_PARAMETER *param, FILE *fp)
368 > idf_writeparam(IDF_OBJECT *param, FILE *fp, int incl_comm)
369   {
370          IDF_FIELD       *fptr;
371  
# Line 304 | Line 373 | idf_writeparam(IDF_PARAMETER *param, FILE *fp)
373                  return(0);
374          fputs(param->pname, fp);
375          fputc(',', fp);
376 <        fputs(param->rem, fp);
376 >        if (incl_comm)
377 >                fputs(param->rem, fp);
378 >        else
379 >                fputc('\n', fp);
380          for (fptr = param->flist; fptr != NULL; fptr = fptr->next) {
381 <                fputs(fptr->arg, fp);
382 <                fputc((fptr->next==NULL ? ';' : ','), fp);
383 <                fputs(fptr->rem, fp);
381 >                if (!incl_comm)
382 >                        fputs("    ", fp);
383 >                fputs(fptr->val, fp);
384 >                if (fptr->next == NULL) {
385 >                        fputc(';', fp);
386 >                        if (incl_comm && !idf_hasEOL(fptr->rem))
387 >                                fputc('\n', fp);
388 >                } else
389 >                        fputc(',', fp);
390 >                if (incl_comm)
391 >                        fputs(fptr->rem, fp);
392 >                else
393 >                        fputc('\n', fp);
394          }
395 +        if (!incl_comm)
396 +                fputc('\n', fp);
397          return(!ferror(fp));
398   }
399  
400   /* Write out an Input Data File */
401   int
402 < idf_write(IDF_LOADED *idf, const char *fname)
402 > idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
403   {
404          FILE            *fp;
405 <        IDF_PARAMETER   *pptr;
405 >        IDF_OBJECT      *pptr;
406  
407          if (idf == NULL)
408                  return(0);
# Line 326 | Line 410 | idf_write(IDF_LOADED *idf, const char *fname)
410                  fp = stdout;            /* open file if not stdout */
411          else if ((fp = fopen(fname, "w")) == NULL)
412                  return(0);
413 <        fputs(idf->hrem, fp);           /* write header then parameters */
413 >        if (incl_comm)
414 >                fputs(idf->hrem, fp);   /* write header then parameters */
415          for (pptr = idf->pfirst; pptr != NULL; pptr = pptr->dnext)
416 <                if (!idf_writeparam(pptr, fp)) {
416 >                if (!idf_writeparam(pptr, fp, incl_comm>0)) {
417                          fclose(fp);
418                          return(0);
419                  }
# Line 343 | Line 428 | idf_free(IDF_LOADED *idf)
428   {
429          if (idf == NULL)
430                  return;
431 +        while (idf->pfirst != NULL) {
432 +                IDF_OBJECT      *pdel = idf->pfirst;
433 +                idf->pfirst = pdel->dnext;
434 +                while (pdel->flist != NULL) {
435 +                        IDF_FIELD       *fdel = pdel->flist;
436 +                        pdel->flist = fdel->next;
437 +                        free(fdel);
438 +                }
439 +                free(pdel);
440 +        }
441 +        lu_done(&idf->ptab);
442          if (idf->hrem != NULL)
443                  free(idf->hrem);
444 <        while (idf->pfirst != NULL)
349 <                idf_delparam(idf, idf->pfirst);
350 <        lu_done(&idf->ptab);
444 >        free(idf);
445   }

Diff Legend

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