src/util/eplus_idf.c

#ifndef lint
static const char RCSid[] = "$Id: eplus_idf.c,v 2.6 2014/02/10 04:51:26 greg Exp $";
#endif
/*
 *  eplus_idf.c
 *
 *  EnergyPlus Input Data File i/o routines
 *
 *  Created by Greg Ward on 1/31/14.
 */

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include "eplus_idf.h"

#ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
#undef getc
#define getc    getc_unlocked
#endif

/* Create a new parameter with empty field list (comment optional) */
IDF_PARAMETER *
idf_newparam(IDF_LOADED *idf, const char *pname, const char *comm,
                        IDF_PARAMETER *prev)
{
        LUENT           *pent;
        IDF_PARAMETER   *pnew;

        if ((idf == NULL) | (pname == NULL))
                return(NULL);
        if (comm == NULL) comm = "";
        pent = lu_find(&idf->ptab, pname);
        if (pent == NULL)
                return(NULL);
        if (pent->key == NULL) {        /* new parameter name/type? */
                pent->key = (char *)malloc(strlen(pname)+1);
                if (pent->key == NULL)
                        return(NULL);
                strcpy(pent->key, pname);
        }
        pnew = (IDF_PARAMETER *)malloc(sizeof(IDF_PARAMETER)+strlen(comm));
        if (pnew == NULL)
                return(NULL);
        strcpy(pnew->rem, comm);
        pnew->nfield = 0;
        pnew->flist = NULL;
        pnew->pname = pent->key;        /* add to table */
        pnew->pnext = (IDF_PARAMETER *)pent->data;
        pent->data = (char *)pnew;
        pnew->dnext = NULL;             /* add to file list */
        if (prev != NULL || (prev = idf->plast) != NULL) {
                pnew->dnext = prev->dnext;
                if (prev == idf->plast)
                        idf->plast = pnew;
        }
        if (idf->pfirst == NULL)
                idf->pfirst = idf->plast = pnew;
        else
                prev->dnext = pnew;
        return(pnew);
}

/* Add a field to the given parameter and follow with the given text */
int
idf_addfield(IDF_PARAMETER *param, const char *fval, const char *comm)
{
        int             fnum = 1;       /* returned argument number */
        IDF_FIELD       *fnew, *flast;
        char            *cp;

        if ((param == NULL) | (fval == NULL))
                return(0);
        if (comm == NULL) comm = "";
        fnew = (IDF_FIELD *)malloc(sizeof(IDF_FIELD)+strlen(fval)+strlen(comm));
        if (fnew == NULL)
                return(0);
        fnew->next = NULL;
        cp = fnew->val;                 /* copy value and comments */
        while ((*cp++ = *fval++))
                ;
        fnew->rem = cp;
        while ((*cp++ = *comm++))
                ;
                                        /* add to parameter's field list */
        if ((flast = param->flist) != NULL) {
                ++fnum;
                while (flast->next != NULL) {
                        flast = flast->next;
                        ++fnum;
                }
        }
        if (flast == NULL)
                param->flist = fnew;
        else
                flast->next = fnew;
        param->nfield++;
        return(fnum);
}

/* Retrieve the indexed field from parameter (first field index is 1) */
IDF_FIELD *
idf_getfield(IDF_PARAMETER *param, int fn)
{
        IDF_FIELD       *fld;

        if ((param == NULL) | (fn <= 0))
                return(NULL);
        fld = param->flist;
        while ((--fn > 0) & (fld != NULL))
                fld = fld->next;
        return(fld);
}

/* Delete the specified parameter from loaded IDF */
int
idf_delparam(IDF_LOADED *idf, IDF_PARAMETER *param)
{
        LUENT           *pent;
        IDF_PARAMETER   *pptr, *plast;

        if ((idf == NULL) | (param == NULL))
                return(0);
                                        /* remove from parameter table */
        pent = lu_find(&idf->ptab, param->pname);
        for (plast = NULL, pptr = (IDF_PARAMETER *)pent->data;
                                pptr != NULL; plast = pptr, pptr = pptr->pnext)
                if (pptr == param)
                        break;
        if (pptr == NULL)
                return(0);
        if (plast == NULL)
                pent->data = (char *)param->pnext;
        else
                plast->pnext = param->pnext;
                                        /* remove from global list */
        for (plast = NULL, pptr = idf->pfirst;
                                pptr != param; plast = pptr, pptr = pptr->dnext)
                if (pptr == NULL)
                        return(0);
        if (plast == NULL)
                idf->pfirst = param->dnext;
        else
                plast->dnext = param->dnext;
        if (idf->plast == param)
                idf->plast = plast;
                                        /* free field list */
        while (param->flist != NULL) {
                IDF_FIELD       *fdel = param->flist;
                param->flist = fdel->next;
                free(fdel);
        }
        free(param);                    /* free parameter struct */
        return(1);
}

/* Move the specified parameter to the given position in the IDF */
int
idf_movparam(IDF_LOADED *idf, IDF_PARAMETER *param, IDF_PARAMETER *prev)
{
        IDF_PARAMETER   *pptr, *plast;

        if ((idf == NULL) | (param == NULL))
                return(0);
                                        /* quick check if already there */
        if (param == (prev==NULL ? idf->pfirst : prev->dnext))
                return(1);
                                        /* find in IDF list, first*/
        for (plast = NULL, pptr = idf->pfirst;
                                pptr != param; plast = pptr, pptr = pptr->dnext)
                if (pptr == NULL)
                        return(0);
        if (plast == NULL)
                idf->pfirst = param->dnext;
        else
                plast->dnext = param->dnext;
        if (idf->plast == param)
                idf->plast = plast;
        if (prev == NULL) {             /* means they want it at beginning */
                param->dnext = idf->pfirst;
                idf->pfirst = param;
        } else {
                param->dnext = prev->dnext;
                prev->dnext = param;
        }
        return(1);
}

/* Get a named parameter list */
IDF_PARAMETER *
idf_getparam(IDF_LOADED *idf, const char *pname)
{
        if ((idf == NULL) | (pname == NULL))
                return(NULL);

        return((IDF_PARAMETER *)lu_find(&idf->ptab,pname)->data);
}

/* Read an argument including terminating ',' or ';' -- return which */
static int
idf_read_argument(char *buf, FILE *fp, int trim)
{
        int     skipwhite = trim;
        char    *cp = buf;
        int     c;

        while ((c = getc(fp)) != EOF && (c != ',') & (c != ';')) {
                if (skipwhite && isspace(c))
                        continue;
                skipwhite = 0;
                if (cp-buf < IDF_MAXARGL-1)
                        *cp++ = c;
        }
        if (trim)
                while (cp > buf && isspace(cp[-1]))
                        --cp;
        *cp = '\0';
        return(c);
}

/* Read a comment, including all white space up to next alpha character */
static void
idf_read_comment(char *buf, int len, FILE *fp)
{
        int     incomm = 0;
        char    *cp = buf;
        char    dummyc;
        int     c;

        if ((buf == NULL) | (len <= 0)) {
                buf = &dummyc;
                len = 1;
        }
        while ((c = getc(fp)) != EOF &&
                        (isspace(c) || (incomm += (c == '!')))) {
                if (c == '\n')
                        incomm = 0;
                if (cp-buf < len-1)
                        *cp++ = c;
        }
        *cp = '\0';
        if (c != EOF)
                ungetc(c, fp);
}

/* Read a parameter and fields from an open file and add to end of list */
IDF_PARAMETER *
idf_readparam(IDF_LOADED *idf, FILE *fp)
{
        char            abuf[IDF_MAXARGL], cbuf[IDF_MAXLINE];
        int             delim;
        IDF_PARAMETER   *pnew;
        
        if ((delim = idf_read_argument(abuf, fp, 1)) == EOF)
                return(NULL);
        idf_read_comment(cbuf, IDF_MAXLINE, fp);
        pnew = idf_newparam(idf, abuf, cbuf, NULL);
        while (delim == ',')
                if ((delim = idf_read_argument(abuf, fp, 1)) != EOF) {
                        idf_read_comment(cbuf, IDF_MAXLINE, fp);
                        idf_addfield(pnew, abuf, cbuf);
                }
        if (delim != ';')
                fputs("Expected ';' at end of parameter list!\n", stderr);
        return(pnew);
}

/* Upper-case string hashing function */
static unsigned long
strcasehash(const char *s)
{
        char            strup[IDF_MAXARGL];
        char            *cdst = strup;

        while ((*cdst++ = toupper(*s++)))
                if (cdst >= strup+(sizeof(strup)-1)) {
                        *cdst = '\0';
                        break;
                }
        return(lu_shash(strup));
}

/* Initialize an IDF struct */
IDF_LOADED *
idf_create(const char *hdrcomm)
{
        IDF_LOADED      *idf = (IDF_LOADED *)calloc(1, sizeof(IDF_LOADED));

        if (idf == NULL)
                return(NULL);
        idf->ptab.hashf = &strcasehash;
        idf->ptab.keycmp = &strcasecmp;
        idf->ptab.freek = &free;
        lu_init(&idf->ptab, 200);
        if (hdrcomm != NULL && *hdrcomm) {
                idf->hrem = (char *)malloc(strlen(hdrcomm)+1);
                if (idf->hrem != NULL)
                        strcpy(idf->hrem, hdrcomm);
        }
        return(idf);
}

/* Add comment(s) to header */
int
idf_add2hdr(IDF_LOADED *idf, const char *hdrcomm)
{
        int     olen, len;

        if ((idf == NULL) | (hdrcomm == NULL))
                return(0);
        len = strlen(hdrcomm);
        if (!len)
                return(0);
        if (idf->hrem == NULL)
                olen = 0;
        else
                olen = strlen(idf->hrem);
        if (olen)
                idf->hrem = (char *)realloc(idf->hrem, olen+len+1);
        else
                idf->hrem = (char *)malloc(len+1);
        if (idf->hrem == NULL)
                return(0);
        strcpy(idf->hrem+olen, hdrcomm);
        return(1);
}

/* Load an Input Data File */
IDF_LOADED *
idf_load(const char *fname)
{
        char            hdrcomm[256*IDF_MAXLINE];
        FILE            *fp;
        IDF_LOADED      *idf;

        if (fname == NULL)
                fp = stdin;             /* open file if not stdin */
        else if ((fp = fopen(fname, "r")) == NULL)
                return(NULL);
                                        /* read header comments */
        idf_read_comment(hdrcomm, sizeof(hdrcomm), fp);
        idf = idf_create(hdrcomm);      /* create IDF struct */
        if (idf == NULL)
                return(NULL);
                                        /* read each parameter */
        while (idf_readparam(idf, fp) != NULL)
                ;
        if (fp != stdin)                /* close file if not stdin */
                fclose(fp);
        return(idf);                    /* success! */
}

/* Write a parameter and fields to an open file */
int
idf_writeparam(IDF_PARAMETER *param, FILE *fp, int incl_comm)
{
        IDF_FIELD       *fptr;

        if ((param == NULL) | (fp == NULL))
                return(0);
        fputs(param->pname, fp);
        fputc(',', fp);
        if (incl_comm)
                fputs(param->rem, fp);
        for (fptr = param->flist; fptr != NULL; fptr = fptr->next) {
                if (!incl_comm)
                        fputs("\n    ", fp);
                fputs(fptr->val, fp);
                fputc((fptr->next==NULL ? ';' : ','), fp);
                if (incl_comm)
                        fputs(fptr->rem, fp);
        }
        if (!incl_comm)
                fputs("\n\n", fp);
        return(!ferror(fp));
}

/* Write out an Input Data File */
int
idf_write(IDF_LOADED *idf, const char *fname, int incl_comm)
{
        FILE            *fp;
        IDF_PARAMETER   *pptr;

        if (idf == NULL)
                return(0);
        if (fname == NULL)
                fp = stdout;            /* open file if not stdout */
        else if ((fp = fopen(fname, "w")) == NULL)
                return(0);
        if (incl_comm)
                fputs(idf->hrem, fp);   /* write header then parameters */
        for (pptr = idf->pfirst; pptr != NULL; pptr = pptr->dnext)
                if (!idf_writeparam(pptr, fp, incl_comm>0)) {
                        fclose(fp);
                        return(0);
                }
        if (fp == stdout)               /* flush/close file & check status */
                return(fflush(fp) == 0);
        return(fclose(fp) == 0);
}

/* Free a loaded IDF */
void
idf_free(IDF_LOADED *idf)
{
        if (idf == NULL)
                return;
        if (idf->hrem != NULL)
                free(idf->hrem);
        while (idf->pfirst != NULL)
                idf_delparam(idf, idf->pfirst);
        lu_done(&idf->ptab);
}
Revision:	2.7
Committed:	Tue Feb 11 23:30:11 2014 UTC (10 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.6:	+6 -8 lines
Log Message:	Slight logic simplification should not affect operation
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.7	static const char RCSid[] = "$Id: eplus_idf.c,v 2.6 2014/02/10 04:51:26 greg Exp $";
3	greg	2.1	#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 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)
27			{
28			LUENT *pent;
29			IDF_PARAMETER *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 parameter 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));
44			if (pnew == NULL)
45			return(NULL);
46			strcpy(pnew->rem, comm);
47	greg	2.5	pnew->nfield = 0;
48	greg	2.1	pnew->flist = NULL;
49			pnew->pname = pent->key; /* add to table */
50			pnew->pnext = (IDF_PARAMETER *)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 parameter and follow with the given text */
66			int
67			idf_addfield(IDF_PARAMETER 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	greg	2.6	cp = fnew->val; /* copy value and comments */
81	greg	2.1	while ((cp++ = fval++))
82			;
83			fnew->rem = cp;
84			while ((cp++ = comm++))
85			;
86			/* add to parameter'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	greg	2.5	param->nfield++;
99	greg	2.1	return(fnum);
100			}
101
102	greg	2.3	/* 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	greg	2.1	/* Delete the specified parameter from loaded IDF */
117			int
118			idf_delparam(IDF_LOADED idf, IDF_PARAMETER param)
119			{
120			LUENT *pent;
121			IDF_PARAMETER pptr, plast;
122
123			if ((idf == NULL) \| (param == NULL))
124			return(0);
125			/* remove from parameter table */
126			pent = lu_find(&idf->ptab, param->pname);
127			for (plast = NULL, pptr = (IDF_PARAMETER *)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	greg	2.4	pptr != param; plast = pptr, pptr = pptr->dnext)
140			if (pptr == NULL)
141			return(0);
142	greg	2.1	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 parameter struct */
155			return(1);
156			}
157
158	greg	2.4	/* 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	greg	2.7	/* quick check if already there */
167			if (param == (prev==NULL ? idf->pfirst : prev->dnext))
168			return(1);
169	greg	2.4	/* 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	greg	2.7	if (plast == NULL)
175	greg	2.4	idf->pfirst = param->dnext;
176	greg	2.7	else
177	greg	2.4	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	greg	2.1	/* Get a named parameter list */
191			IDF_PARAMETER *
192			idf_getparam(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);
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	greg	2.2	if (cp-buf < IDF_MAXARGL-1)
213	greg	2.1	*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	greg	2.3	while ((c = getc(fp)) != EOF &&
236			(isspace(c) \|\| (incomm += (c == '!')))) {
237			if (c == '\n')
238	greg	2.1	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 parameter and fields from an open file and add to end of list */
248			IDF_PARAMETER *
249			idf_readparam(IDF_LOADED idf, FILE fp)
250			{
251	greg	2.2	char abuf[IDF_MAXARGL], cbuf[IDF_MAXLINE];
252	greg	2.1	int delim;
253			IDF_PARAMETER *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);
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	greg	2.3	fputs("Expected ';' at end of parameter list!\n", stderr);
266	greg	2.1	return(pnew);
267			}
268
269	greg	2.2	/* 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	greg	2.1	/* 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	greg	2.2	idf->ptab.hashf = &strcasehash;
293			idf->ptab.keycmp = &strcasecmp;
294	greg	2.1	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	greg	2.4	/* 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	greg	2.1	/* Load an Input Data File */
330			IDF_LOADED *
331			idf_load(const char *fname)
332			{
333	greg	2.4	char hdrcomm[256*IDF_MAXLINE];
334	greg	2.1	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	greg	2.3	idf_read_comment(hdrcomm, sizeof(hdrcomm), fp);
343	greg	2.1	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)
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 */
355			int
356	greg	2.4	idf_writeparam(IDF_PARAMETER param, FILE fp, int incl_comm)
357	greg	2.1	{
358			IDF_FIELD *fptr;
359
360			if ((param == NULL) \| (fp == NULL))
361			return(0);
362			fputs(param->pname, fp);
363			fputc(',', fp);
364	greg	2.4	if (incl_comm)
365			fputs(param->rem, fp);
366	greg	2.1	for (fptr = param->flist; fptr != NULL; fptr = fptr->next) {
367	greg	2.4	if (!incl_comm)
368	greg	2.6	fputs("\n ", fp);
369			fputs(fptr->val, fp);
370	greg	2.1	fputc((fptr->next==NULL ? ';' : ','), fp);
371	greg	2.4	if (incl_comm)
372			fputs(fptr->rem, fp);
373	greg	2.1	}
374	greg	2.4	if (!incl_comm)
375			fputs("\n\n", fp);
376	greg	2.1	return(!ferror(fp));
377			}
378
379			/* Write out an Input Data File */
380			int
381	greg	2.4	idf_write(IDF_LOADED idf, const char fname, int incl_comm)
382	greg	2.1	{
383			FILE *fp;
384			IDF_PARAMETER *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	greg	2.4	if (incl_comm)
393			fputs(idf->hrem, fp); /* write header then parameters */
394	greg	2.1	for (pptr = idf->pfirst; pptr != NULL; pptr = pptr->dnext)
395	greg	2.4	if (!idf_writeparam(pptr, fp, incl_comm>0)) {
396	greg	2.1	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_delparam(idf, idf->pfirst);
414			lu_done(&idf->ptab);
415			}