ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/eplus_idf.c
Revision: 2.9
Committed: Thu Feb 13 17:33:37 2014 UTC (10 years, 1 month ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.8: +4 -4 lines
Log Message:
Increased allowed comment length and corrected name of view factors object

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: eplus_idf.c,v 2.8 2014/02/12 17:40:07 greg Exp $";
3 #endif
4 /*
5 * eplus_idf.c
6 *
7 * EnergyPlus Input Data File i/o routines
8 *
9 * Created by Greg Ward on 1/31/14.
10 */
11
12 #include <stdio.h>
13 #include <string.h>
14 #include <ctype.h>
15 #include <stdlib.h>
16 #include "eplus_idf.h"
17
18 #ifdef getc_unlocked /* avoid horrendous overhead of flockfile */
19 #undef getc
20 #define getc getc_unlocked
21 #endif
22
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_OBJECT *pnew;
30
31 if ((idf == NULL) | (pname == NULL))
32 return(NULL);
33 if (comm == NULL) comm = "";
34 pent = lu_find(&idf->ptab, pname);
35 if (pent == NULL)
36 return(NULL);
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_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_OBJECT *)pent->data;
51 pent->data = (char *)pnew;
52 pnew->dnext = NULL; /* add to file list */
53 if (prev != NULL || (prev = idf->plast) != NULL) {
54 pnew->dnext = prev->dnext;
55 if (prev == idf->plast)
56 idf->plast = pnew;
57 }
58 if (idf->pfirst == NULL)
59 idf->pfirst = idf->plast = pnew;
60 else
61 prev->dnext = pnew;
62 return(pnew);
63 }
64
65 /* Add a field to the given object and follow with the given text */
66 int
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;
71 char *cp;
72
73 if ((param == NULL) | (fval == NULL))
74 return(0);
75 if (comm == NULL) comm = "";
76 fnew = (IDF_FIELD *)malloc(sizeof(IDF_FIELD)+strlen(fval)+strlen(comm));
77 if (fnew == NULL)
78 return(0);
79 fnew->next = NULL;
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 object's field list */
87 if ((flast = param->flist) != NULL) {
88 ++fnum;
89 while (flast->next != NULL) {
90 flast = flast->next;
91 ++fnum;
92 }
93 }
94 if (flast == NULL)
95 param->flist = fnew;
96 else
97 flast->next = fnew;
98 param->nfield++;
99 return(fnum);
100 }
101
102 /* Retrieve the indexed field from object (first field index is 1) */
103 IDF_FIELD *
104 idf_getfield(IDF_OBJECT *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 object from loaded IDF */
117 int
118 idf_delobject(IDF_LOADED *idf, IDF_OBJECT *param)
119 {
120 LUENT *pent;
121 IDF_OBJECT *pptr, *plast;
122
123 if ((idf == NULL) | (param == NULL))
124 return(0);
125 /* remove from object table */
126 pent = lu_find(&idf->ptab, param->pname);
127 for (plast = NULL, pptr = (IDF_OBJECT *)pent->data;
128 pptr != NULL; plast = pptr, pptr = pptr->pnext)
129 if (pptr == param)
130 break;
131 if (pptr == NULL)
132 return(0);
133 if (plast == NULL)
134 pent->data = (char *)param->pnext;
135 else
136 plast->pnext = param->pnext;
137 /* remove from global list */
138 for (plast = NULL, pptr = idf->pfirst;
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
145 plast->dnext = param->dnext;
146 if (idf->plast == param)
147 idf->plast = plast;
148 /* free field list */
149 while (param->flist != NULL) {
150 IDF_FIELD *fdel = param->flist;
151 param->flist = fdel->next;
152 free(fdel);
153 }
154 free(param); /* free object struct */
155 return(1);
156 }
157
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_OBJECT *)lu_find(&idf->ptab,pname)->data);
198 }
199
200 /* Read an argument including terminating ',' or ';' -- return which */
201 static int
202 idf_read_argument(char *buf, FILE *fp, int trim)
203 {
204 int skipwhite = trim;
205 char *cp = buf;
206 int c;
207
208 while ((c = getc(fp)) != EOF && (c != ',') & (c != ';')) {
209 if (skipwhite && isspace(c))
210 continue;
211 skipwhite = 0;
212 if (cp-buf < IDF_MAXARGL-1)
213 *cp++ = c;
214 }
215 if (trim)
216 while (cp > buf && isspace(cp[-1]))
217 --cp;
218 *cp = '\0';
219 return(c);
220 }
221
222 /* Read a comment, including all white space up to next alpha character */
223 static void
224 idf_read_comment(char *buf, int len, FILE *fp)
225 {
226 int incomm = 0;
227 char *cp = buf;
228 char dummyc;
229 int c;
230
231 if ((buf == NULL) | (len <= 0)) {
232 buf = &dummyc;
233 len = 1;
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)
240 *cp++ = c;
241 }
242 *cp = '\0';
243 if (c != EOF)
244 ungetc(c, fp);
245 }
246
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[100*IDF_MAXLINE];
252 int delim;
253 IDF_OBJECT *pnew;
254
255 if ((delim = idf_read_argument(abuf, fp, 1)) == EOF)
256 return(NULL);
257 idf_read_comment(cbuf, sizeof(cbuf), fp);
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, sizeof(cbuf), fp);
262 idf_addfield(pnew, abuf, cbuf);
263 }
264 if (delim != ';')
265 fputs("Expected ';' at end of object list!\n", stderr);
266 return(pnew);
267 }
268
269 /* Upper-case string hashing function */
270 static unsigned long
271 strcasehash(const char *s)
272 {
273 char strup[IDF_MAXARGL];
274 char *cdst = strup;
275
276 while ((*cdst++ = toupper(*s++)))
277 if (cdst >= strup+(sizeof(strup)-1)) {
278 *cdst = '\0';
279 break;
280 }
281 return(lu_shash(strup));
282 }
283
284 /* Initialize an IDF struct */
285 IDF_LOADED *
286 idf_create(const char *hdrcomm)
287 {
288 IDF_LOADED *idf = (IDF_LOADED *)calloc(1, sizeof(IDF_LOADED));
289
290 if (idf == NULL)
291 return(NULL);
292 idf->ptab.hashf = &strcasehash;
293 idf->ptab.keycmp = &strcasecmp;
294 idf->ptab.freek = &free;
295 lu_init(&idf->ptab, 200);
296 if (hdrcomm != NULL && *hdrcomm) {
297 idf->hrem = (char *)malloc(strlen(hdrcomm)+1);
298 if (idf->hrem != NULL)
299 strcpy(idf->hrem, hdrcomm);
300 }
301 return(idf);
302 }
303
304 /* Add comment(s) to header */
305 int
306 idf_add2hdr(IDF_LOADED *idf, const char *hdrcomm)
307 {
308 int olen, len;
309
310 if ((idf == NULL) | (hdrcomm == NULL))
311 return(0);
312 len = strlen(hdrcomm);
313 if (!len)
314 return(0);
315 if (idf->hrem == NULL)
316 olen = 0;
317 else
318 olen = strlen(idf->hrem);
319 if (olen)
320 idf->hrem = (char *)realloc(idf->hrem, olen+len+1);
321 else
322 idf->hrem = (char *)malloc(len+1);
323 if (idf->hrem == NULL)
324 return(0);
325 strcpy(idf->hrem+olen, hdrcomm);
326 return(1);
327 }
328
329 /* Load an Input Data File */
330 IDF_LOADED *
331 idf_load(const char *fname)
332 {
333 char hdrcomm[256*IDF_MAXLINE];
334 FILE *fp;
335 IDF_LOADED *idf;
336
337 if (fname == NULL)
338 fp = stdin; /* open file if not stdin */
339 else if ((fp = fopen(fname, "r")) == NULL)
340 return(NULL);
341 /* read header comments */
342 idf_read_comment(hdrcomm, sizeof(hdrcomm), fp);
343 idf = idf_create(hdrcomm); /* create IDF struct */
344 if (idf == NULL)
345 return(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 object and fields to an open file */
355 int
356 idf_writeparam(IDF_OBJECT *param, FILE *fp, int incl_comm)
357 {
358 IDF_FIELD *fptr;
359
360 if ((param == NULL) | (fp == NULL))
361 return(0);
362 fputs(param->pname, fp);
363 fputc(',', fp);
364 if (incl_comm)
365 fputs(param->rem, fp);
366 for (fptr = param->flist; fptr != NULL; fptr = fptr->next) {
367 if (!incl_comm)
368 fputs("\n ", fp);
369 fputs(fptr->val, fp);
370 fputc((fptr->next==NULL ? ';' : ','), fp);
371 if (incl_comm)
372 fputs(fptr->rem, fp);
373 }
374 if (!incl_comm)
375 fputs("\n\n", fp);
376 return(!ferror(fp));
377 }
378
379 /* Write out an Input Data File */
380 int
381 idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
382 {
383 FILE *fp;
384 IDF_OBJECT *pptr;
385
386 if (idf == NULL)
387 return(0);
388 if (fname == NULL)
389 fp = stdout; /* open file if not stdout */
390 else if ((fp = fopen(fname, "w")) == NULL)
391 return(0);
392 if (incl_comm)
393 fputs(idf->hrem, fp); /* write header then parameters */
394 for (pptr = idf->pfirst; pptr != NULL; pptr = pptr->dnext)
395 if (!idf_writeparam(pptr, fp, incl_comm>0)) {
396 fclose(fp);
397 return(0);
398 }
399 if (fp == stdout) /* flush/close file & check status */
400 return(fflush(fp) == 0);
401 return(fclose(fp) == 0);
402 }
403
404 /* Free a loaded IDF */
405 void
406 idf_free(IDF_LOADED *idf)
407 {
408 if (idf == NULL)
409 return;
410 if (idf->hrem != NULL)
411 free(idf->hrem);
412 while (idf->pfirst != NULL)
413 idf_delobject(idf, idf->pfirst);
414 lu_done(&idf->ptab);
415 }