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.1 by greg, Sat Feb 1 01:28:43 2014 UTC vs.
Revision 2.6 by greg, Mon Feb 10 04:51:26 2014 UTC

# Line 44 | Line 44 | idf_newparam(IDF_LOADED *idf, const char *pname, const
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;
# 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;
# 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) */
103 + IDF_FIELD *
104 + idf_getfield(IDF_PARAMETER *param, int fn)
105 + {
106 +        IDF_FIELD       *fld;
107 +
108 +        if ((param == NULL) | (fn <= 0))
109 +                return(NULL);
110 +        fld = param->flist;
111 +        while ((--fn > 0) & (fld != NULL))
112 +                fld = fld->next;
113 +        return(fld);
114 + }
115 +
116   /* Delete the specified parameter from loaded IDF */
117   int
118   idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
# Line 120 | 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;
126 <        if (pptr == NULL)
127 <                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 141 | Line 155 | idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
155          return(1);
156   }
157  
158 + /* Move the specified parameter to the given position in the IDF */
159 + int
160 + idf_movparam(IDF_LOADED *idf, IDF_PARAMETER *param, IDF_PARAMETER *prev)
161 + {
162 +        IDF_PARAMETER   *pptr, *plast;
163 +
164 +        if ((idf == NULL) | (param == NULL))
165 +                return(0);
166 +                                        /* find in IDF list, first*/
167 +        for (plast = NULL, pptr = idf->pfirst;
168 +                                pptr != param; plast = pptr, pptr = pptr->dnext)
169 +                if (pptr == NULL)
170 +                        return(0);
171 +        if (plast == NULL) {
172 +                if (prev == NULL)
173 +                        return(1);      /* already in place */
174 +                idf->pfirst = param->dnext;
175 +        } else {
176 +                if (prev == plast)
177 +                        return(1);      /* already in place */
178 +                plast->dnext = param->dnext;
179 +        }
180 +        if (idf->plast == param)
181 +                idf->plast = plast;
182 +        if (prev == NULL) {             /* means they want it at beginning */
183 +                param->dnext = idf->pfirst;
184 +                idf->pfirst = param;
185 +        } else {
186 +                param->dnext = prev->dnext;
187 +                prev->dnext = param;
188 +        }
189 +        return(1);
190 + }
191 +
192   /* Get a named parameter list */
193   IDF_PARAMETER *
194   idf_getparam(IDF_LOADED *idf, const char *pname)
# Line 163 | Line 211 | idf_read_argument(char *buf, FILE *fp, int trim)
211                  if (skipwhite && isspace(c))
212                          continue;
213                  skipwhite = 0;
214 <                if (cp-buf < IDF_MAXLINE-1)
214 >                if (cp-buf < IDF_MAXARGL-1)
215                          *cp++ = c;
216          }
217          if (trim)
# Line 186 | Line 234 | idf_read_comment(char *buf, int len, FILE *fp)
234                  buf = &dummyc;
235                  len = 1;
236          }
237 <        while ((c = getc(fp)) != EOF && isspace(c) | incomm) {
238 <                if (c == '!')
239 <                        ++incomm;
192 <                else if (c == '\n')
237 >        while ((c = getc(fp)) != EOF &&
238 >                        (isspace(c) || (incomm += (c == '!')))) {
239 >                if (c == '\n')
240                          incomm = 0;
241                  if (cp-buf < len-1)
242                          *cp++ = c;
# Line 203 | Line 250 | idf_read_comment(char *buf, int len, FILE *fp)
250   IDF_PARAMETER *
251   idf_readparam(IDF_LOADED *idf, FILE *fp)
252   {
253 <        char            abuf[IDF_MAXLINE], cbuf[IDF_MAXLINE];
253 >        char            abuf[IDF_MAXARGL], cbuf[IDF_MAXLINE];
254          int             delim;
255          IDF_PARAMETER   *pnew;
256          
# Line 217 | Line 264 | idf_readparam(IDF_LOADED *idf, FILE *fp)
264                          idf_addfield(pnew, abuf, cbuf);
265                  }
266          if (delim != ';')
267 <                fprintf(stderr, "Expected ';' at end of parameter list\n");
267 >                fputs("Expected ';' at end of parameter list!\n", stderr);
268          return(pnew);
269   }
270  
271 + /* Upper-case string hashing function */
272 + static unsigned long
273 + strcasehash(const char *s)
274 + {
275 +        char            strup[IDF_MAXARGL];
276 +        char            *cdst = strup;
277 +
278 +        while ((*cdst++ = toupper(*s++)))
279 +                if (cdst >= strup+(sizeof(strup)-1)) {
280 +                        *cdst = '\0';
281 +                        break;
282 +                }
283 +        return(lu_shash(strup));
284 + }
285 +
286   /* Initialize an IDF struct */
287   IDF_LOADED *
288   idf_create(const char *hdrcomm)
# Line 229 | Line 291 | idf_create(const char *hdrcomm)
291  
292          if (idf == NULL)
293                  return(NULL);
294 <        idf->ptab.hashf = &lu_shash;
295 <        idf->ptab.keycmp = &strcmp;
294 >        idf->ptab.hashf = &strcasehash;
295 >        idf->ptab.keycmp = &strcasecmp;
296          idf->ptab.freek = &free;
297          lu_init(&idf->ptab, 200);
298          if (hdrcomm != NULL && *hdrcomm) {
# Line 241 | 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;
335 >        char            hdrcomm[256*IDF_MAXLINE];
336          FILE            *fp;
337          IDF_LOADED      *idf;
338  
# Line 254 | Line 341 | idf_load(const char *fname)
341          else if ((fp = fopen(fname, "r")) == NULL)
342                  return(NULL);
343                                          /* read header comments */
344 <        hdrcomm = (char *)malloc(100*IDF_MAXLINE);
258 <        idf_read_comment(hdrcomm, 100*IDF_MAXLINE, fp);
344 >        idf_read_comment(hdrcomm, sizeof(hdrcomm), fp);
345          idf = idf_create(hdrcomm);      /* create IDF struct */
260 –        free(hdrcomm);
346          if (idf == NULL)
347                  return(NULL);
348                                          /* read each parameter */
# Line 270 | Line 355 | idf_load(const char *fname)
355  
356   /* Write a parameter and fields to an open file */
357   int
358 < idf_writeparam(IDF_PARAMETER *param, FILE *fp)
358 > idf_writeparam(IDF_PARAMETER *param, FILE *fp, int incl_comm)
359   {
360          IDF_FIELD       *fptr;
361  
# Line 278 | Line 363 | idf_writeparam(IDF_PARAMETER *param, FILE *fp)
363                  return(0);
364          fputs(param->pname, fp);
365          fputc(',', fp);
366 <        fputs(param->rem, fp);
366 >        if (incl_comm)
367 >                fputs(param->rem, fp);
368          for (fptr = param->flist; fptr != NULL; fptr = fptr->next) {
369 <                fputs(fptr->arg, fp);
369 >                if (!incl_comm)
370 >                        fputs("\n    ", fp);
371 >                fputs(fptr->val, fp);
372                  fputc((fptr->next==NULL ? ';' : ','), fp);
373 <                fputs(fptr->rem, fp);
373 >                if (incl_comm)
374 >                        fputs(fptr->rem, fp);
375          }
376 +        if (!incl_comm)
377 +                fputs("\n\n", fp);
378          return(!ferror(fp));
379   }
380  
381   /* Write out an Input Data File */
382   int
383 < idf_write(IDF_LOADED *idf, const char *fname)
383 > idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
384   {
385          FILE            *fp;
386          IDF_PARAMETER   *pptr;
# Line 300 | Line 391 | idf_write(IDF_LOADED *idf, const char *fname)
391                  fp = stdout;            /* open file if not stdout */
392          else if ((fp = fopen(fname, "w")) == NULL)
393                  return(0);
394 <        fputs(idf->hrem, fp);           /* write header then parameters */
394 >        if (incl_comm)
395 >                fputs(idf->hrem, fp);   /* write header then parameters */
396          for (pptr = idf->pfirst; pptr != NULL; pptr = pptr->dnext)
397 <                if (!idf_writeparam(pptr, fp)) {
397 >                if (!idf_writeparam(pptr, fp, incl_comm>0)) {
398                          fclose(fp);
399                          return(0);
400                  }

Diff Legend

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