src/common/loadvars.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  Routines for loading and checking variables from file.
 */

#include "copyright.h"

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "vars.h"

#define NOCHAR  127             /* constant for character to delete */

extern char  *fgetline();


void
loadvars(rfname)                /* load variables into vv from file */
char    *rfname;
{
        FILE    *fp;
        char    buf[512];
        register char   *cp;

        if (rfname == NULL)
                fp = stdin;
        else if ((fp = fopen(rfname, "r")) == NULL) {
                perror(rfname);
                quit(1);
        }
        while (fgetline(buf, sizeof(buf), fp) != NULL) {
                for (cp = buf; *cp; cp++) {
                        switch (*cp) {
                        case '\\':
                                *cp++ = NOCHAR;
                                continue;
                        case '#':
                                *cp = '\0';
                                break;
                        default:
                                continue;
                        }
                        break;
                }
                if (setvariable(buf, matchvar) < 0) {
                        fprintf(stderr, "%s: unknown variable: %s\n",
                                        rfname, buf);
                        quit(1);
                }
        }
        fclose(fp);
}


int
setvariable(ass, mv)            /* assign variable according to string */
register char   *ass;
VARIABLE        *(*mv)();
{
        char    varname[32];
        int     n;
        register char   *cp;
        register VARIABLE       *vp;
        register int    i;

        while (isspace(*ass))           /* skip leading space */
                ass++;
        cp = varname;                   /* extract name */
        while (cp < varname+sizeof(varname)-1
                        && *ass && !isspace(*ass) && *ass != '=')
                *cp++ = *ass++;
        *cp = '\0';
        if (!varname[0])
                return(0);      /* no variable name! */
                                        /* trim value */
        while (isspace(*ass) || *ass == '=')
                ass++;
        for (n = strlen(ass); n > 0; n--)
                if (!isspace(ass[n-1]))
                        break;
        if (!n)
                return(0);      /* no assignment */
                                        /* match variable from list */
        vp = (*mv)(varname);
        if (vp == NULL)
                return(-1);
                                        /* assign new value */
        if (i = vp->nass) {
                cp = vp->value;
                while (i--)
                        while (*cp++)
                                ;
                i = cp - vp->value;
                vp->value = (char *)realloc(vp->value, i+n+1);
        } else
                vp->value = (char *)malloc(n+1);
        if (vp->value == NULL) {
                perror(progname);
                quit(1);
        }
        cp = vp->value+i;               /* copy value, squeezing spaces */
        *cp = *ass;
        for (i = 1; i <= n; i++) {
                if (ass[i] == NOCHAR)
                        continue;
                if (isspace(*cp))
                        while (isspace(ass[i]))
                                i++;
                *++cp = ass[i];
        }
        if (isspace(*cp))               /* remove trailing space */
                *cp = '\0';
        return(++vp->nass);
}


VARIABLE *
matchvar(nam)                   /* match a variable by its name */
char    *nam;
{
        int     n = strlen(nam);
        register int    i;

        for (i = 0; i < NVARS; i++)
                if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
                        return(vv+i);
        return(NULL);
}


char *
nvalue(vn, n)                   /* return nth variable value */
register int    vn;
register int    n;
{
        register char   *cp;

        if (vval(vn) == NULL | n < 0 | n >= vdef(vn))
                return(NULL);
        cp = vval(vn);
        while (n--)
                while (*cp++)
                        ;
        return(cp);
}


void
checkvalues()                   /* check assignments */
{
        register int    i;

        for (i = 0; i < NVARS; i++)
                if (vv[i].fixval != NULL)
                        (*vv[i].fixval)(vv+i);
}


void
onevalue(vp)                    /* only one assignment for this variable */
register VARIABLE       *vp;
{
        if (vp->nass < 2)
                return;
        if (!nowarn)
                fprintf(stderr,
                "%s: warning - multiple assignment of variable '%s'\n",
                        progname, vp->name);
        do
                vp->value += strlen(vp->value)+1;
        while (--vp->nass > 1);
}


void
catvalues(vp)                   /* concatenate variable values */
register VARIABLE       *vp;
{
        register char   *cp;

        if (vp->nass < 2)
                return;
        for (cp = vp->value; vp->nass > 1; vp->nass--) {
                while (*cp)
                        cp++;
                *cp++ = ' ';
        }
}


int
badmatch(tv, cv)                /* case insensitive truncated comparison */
register char   *tv, *cv;
{
        if (!*tv) return(1);            /* null string cannot match */
        do
                if (UPPER(*tv) != *cv++)
                        return(1);
        while (*++tv);
        return(0);              /* OK */
}


void
boolvalue(vp)                   /* check boolean for legal values */
register VARIABLE       *vp;
{
        if (!vp->nass) return;
        onevalue(vp);
        switch (UPPER(vp->value[0])) {
        case 'T':
                if (badmatch(vp->value, "TRUE")) break;
                return;
        case 'F':
                if (badmatch(vp->value, "FALSE")) break;
                return;
        }
        fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
                        progname, vp->name);
        quit(1);
}


void
qualvalue(vp)                   /* check qualitative var. for legal values */
register VARIABLE       *vp;
{
        if (!vp->nass) return;
        onevalue(vp);
        switch (UPPER(vp->value[0])) {
        case 'L':
                if (badmatch(vp->value, "LOW")) break;
                return;
        case 'M':
                if (badmatch(vp->value, "MEDIUM")) break;
                return;
        case 'H':
                if (badmatch(vp->value, "HIGH")) break;
                return;
        }
        fprintf(stderr, "%s: illegal value for qualitative variable '%s'\n",
                        progname, vp->name);
        quit(1);
}


void
intvalue(vp)                    /* check integer variable for legal values */
register VARIABLE       *vp;
{
        if (!vp->nass) return;
        onevalue(vp);
        if (isint(vp->value)) return;
        fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
                        progname, vp->name);
        quit(1);
}


void
fltvalue(vp)                    /* check float variable for legal values */
register VARIABLE       *vp;
{
        if (!vp->nass) return;
        onevalue(vp);
        if (isflt(vp->value)) return;
        fprintf(stderr, "%s: illegal value for real variable '%s'\n",
                        progname, vp->name);
        quit(1);
}


void
printvars(fp)                   /* print variable values */
register FILE   *fp;
{
        int     i, j, k, clipline;
        register char   *cp;

        for (i = 0; i < NVARS; i++)             /* print each variable */
            for (j = 0; j < vdef(i); j++) {     /* print each assignment */
                fputs(vnam(i), fp);
                fputs("= ", fp);
                k = clipline = ( vv[i].fixval == catvalues ? 64 : 236 )
                                - strlen(vnam(i)) ;
                cp = nvalue(i, j);
                while (*cp) {
                    putc(*cp++, fp);
                    if (--k <= 0) {             /* line too long */
                        while (*cp && !isspace(*cp))
                            fputc(*cp++, fp);   /* finish this word */
                        if (*cp) {              /* start new line */
                            if (vv[i].fixval == catvalues) {
                                fputc('\n', fp);
                                fputs(vnam(i), fp);
                                fputc('=', fp);
                            } else
                                fputs(" \\\n", fp);
                            k = clipline;
                        }
                    }
                }
                fputc('\n', fp);
            }
        fflush(fp);
}
Revision:	2.10
Committed:	Tue Feb 25 02:47:21 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.9:	+1 -56 lines
Log Message:	Replaced inline copyright notice with #include "copyright.h"
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id$";
3	greg	2.1	#endif
4			/*
5			* Routines for loading and checking variables from file.
6			*/
7
8	greg	2.10	#include "copyright.h"
9	greg	2.9
10	greg	2.1	#include <stdio.h>
11	greg	2.9	#include <stdlib.h>
12	greg	2.1	#include <ctype.h>
13			#include "vars.h"
14
15			#define NOCHAR 127 /* constant for character to delete */
16
17	greg	2.4	extern char *fgetline();
18
19	greg	2.1
20	greg	2.9	void
21	greg	2.1	loadvars(rfname) /* load variables into vv from file */
22			char *rfname;
23			{
24			FILE *fp;
25			char buf[512];
26			register char *cp;
27
28			if (rfname == NULL)
29			fp = stdin;
30			else if ((fp = fopen(rfname, "r")) == NULL) {
31			perror(rfname);
32	greg	2.5	quit(1);
33	greg	2.1	}
34			while (fgetline(buf, sizeof(buf), fp) != NULL) {
35			for (cp = buf; *cp; cp++) {
36			switch (*cp) {
37			case '\\':
38			*cp++ = NOCHAR;
39			continue;
40			case '#':
41			*cp = '\0';
42			break;
43			default:
44			continue;
45			}
46			break;
47			}
48	greg	2.6	if (setvariable(buf, matchvar) < 0) {
49			fprintf(stderr, "%s: unknown variable: %s\n",
50			rfname, buf);
51			quit(1);
52			}
53	greg	2.1	}
54			fclose(fp);
55			}
56
57
58	greg	2.6	int
59			setvariable(ass, mv) /* assign variable according to string */
60	greg	2.1	register char *ass;
61	greg	2.6	VARIABLE (mv)();
62	greg	2.1	{
63			char varname[32];
64			int n;
65			register char *cp;
66			register VARIABLE *vp;
67			register int i;
68
69			while (isspace(ass)) / skip leading space */
70			ass++;
71			cp = varname; /* extract name */
72			while (cp < varname+sizeof(varname)-1
73			&& ass && !isspace(ass) && *ass != '=')
74			cp++ = ass++;
75			*cp = '\0';
76			if (!varname[0])
77	greg	2.6	return(0); /* no variable name! */
78	greg	2.1	/* trim value */
79			while (isspace(ass) \|\| ass == '=')
80			ass++;
81			for (n = strlen(ass); n > 0; n--)
82			if (!isspace(ass[n-1]))
83			break;
84	greg	2.6	if (!n)
85			return(0); /* no assignment */
86	greg	2.1	/* match variable from list */
87	greg	2.6	vp = (*mv)(varname);
88			if (vp == NULL)
89			return(-1);
90	greg	2.1	/* assign new value */
91			if (i = vp->nass) {
92			cp = vp->value;
93			while (i--)
94			while (*cp++)
95			;
96			i = cp - vp->value;
97	greg	2.9	vp->value = (char *)realloc(vp->value, i+n+1);
98	greg	2.1	} else
99	greg	2.9	vp->value = (char *)malloc(n+1);
100	greg	2.1	if (vp->value == NULL) {
101			perror(progname);
102	greg	2.5	quit(1);
103	greg	2.1	}
104			cp = vp->value+i; /* copy value, squeezing spaces */
105			cp = ass;
106			for (i = 1; i <= n; i++) {
107			if (ass[i] == NOCHAR)
108			continue;
109			if (isspace(*cp))
110			while (isspace(ass[i]))
111			i++;
112			*++cp = ass[i];
113			}
114			if (isspace(cp)) / remove trailing space */
115			*cp = '\0';
116	greg	2.6	return(++vp->nass);
117	greg	2.1	}
118
119
120			VARIABLE *
121			matchvar(nam) /* match a variable by its name */
122			char *nam;
123			{
124			int n = strlen(nam);
125			register int i;
126
127			for (i = 0; i < NVARS; i++)
128			if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
129			return(vv+i);
130			return(NULL);
131			}
132
133
134			char *
135	greg	2.2	nvalue(vn, n) /* return nth variable value */
136			register int vn;
137	greg	2.1	register int n;
138			{
139			register char *cp;
140
141	greg	2.2	if (vval(vn) == NULL \| n < 0 \| n >= vdef(vn))
142	greg	2.1	return(NULL);
143	greg	2.2	cp = vval(vn);
144	greg	2.1	while (n--)
145			while (*cp++)
146			;
147			return(cp);
148			}
149
150
151	greg	2.9	void
152	greg	2.1	checkvalues() /* check assignments */
153			{
154			register int i;
155
156			for (i = 0; i < NVARS; i++)
157			if (vv[i].fixval != NULL)
158			(*vv[i].fixval)(vv+i);
159			}
160
161
162	greg	2.9	void
163	greg	2.1	onevalue(vp) /* only one assignment for this variable */
164			register VARIABLE *vp;
165			{
166			if (vp->nass < 2)
167			return;
168			if (!nowarn)
169			fprintf(stderr,
170			"%s: warning - multiple assignment of variable '%s'\n",
171			progname, vp->name);
172			do
173			vp->value += strlen(vp->value)+1;
174			while (--vp->nass > 1);
175			}
176
177
178	greg	2.9	void
179	greg	2.1	catvalues(vp) /* concatenate variable values */
180			register VARIABLE *vp;
181			{
182			register char *cp;
183
184			if (vp->nass < 2)
185			return;
186			for (cp = vp->value; vp->nass > 1; vp->nass--) {
187			while (*cp)
188			cp++;
189			*cp++ = ' ';
190			}
191			}
192
193
194			int
195			badmatch(tv, cv) /* case insensitive truncated comparison */
196			register char tv, cv;
197			{
198			if (!tv) return(1); / null string cannot match */
199			do
200			if (UPPER(tv) != cv++)
201			return(1);
202			while (*++tv);
203			return(0); /* OK */
204			}
205
206
207	greg	2.9	void
208	greg	2.1	boolvalue(vp) /* check boolean for legal values */
209			register VARIABLE *vp;
210			{
211			if (!vp->nass) return;
212			onevalue(vp);
213			switch (UPPER(vp->value[0])) {
214			case 'T':
215			if (badmatch(vp->value, "TRUE")) break;
216			return;
217			case 'F':
218			if (badmatch(vp->value, "FALSE")) break;
219			return;
220			}
221			fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
222			progname, vp->name);
223	greg	2.5	quit(1);
224	greg	2.1	}
225
226
227	greg	2.9	void
228	greg	2.1	qualvalue(vp) /* check qualitative var. for legal values */
229			register VARIABLE *vp;
230			{
231			if (!vp->nass) return;
232			onevalue(vp);
233			switch (UPPER(vp->value[0])) {
234			case 'L':
235			if (badmatch(vp->value, "LOW")) break;
236			return;
237			case 'M':
238			if (badmatch(vp->value, "MEDIUM")) break;
239			return;
240			case 'H':
241			if (badmatch(vp->value, "HIGH")) break;
242			return;
243			}
244			fprintf(stderr, "%s: illegal value for qualitative variable '%s'\n",
245			progname, vp->name);
246	greg	2.5	quit(1);
247	greg	2.1	}
248
249
250	greg	2.9	void
251	greg	2.1	intvalue(vp) /* check integer variable for legal values */
252			register VARIABLE *vp;
253			{
254			if (!vp->nass) return;
255			onevalue(vp);
256			if (isint(vp->value)) return;
257			fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
258			progname, vp->name);
259	greg	2.5	quit(1);
260	greg	2.1	}
261
262
263	greg	2.9	void
264	greg	2.1	fltvalue(vp) /* check float variable for legal values */
265			register VARIABLE *vp;
266			{
267			if (!vp->nass) return;
268			onevalue(vp);
269			if (isflt(vp->value)) return;
270			fprintf(stderr, "%s: illegal value for real variable '%s'\n",
271			progname, vp->name);
272	greg	2.5	quit(1);
273	greg	2.1	}
274
275
276	greg	2.9	void
277	greg	2.1	printvars(fp) /* print variable values */
278			register FILE *fp;
279			{
280			int i, j, k, clipline;
281			register char *cp;
282
283			for (i = 0; i < NVARS; i++) /* print each variable */
284			for (j = 0; j < vdef(i); j++) { /* print each assignment */
285			fputs(vnam(i), fp);
286			fputs("= ", fp);
287	gwlarson	2.8	k = clipline = ( vv[i].fixval == catvalues ? 64 : 236 )
288	greg	2.1	- strlen(vnam(i)) ;
289	greg	2.2	cp = nvalue(i, j);
290	greg	2.1	while (*cp) {
291			putc(*cp++, fp);
292			if (--k <= 0) { /* line too long */
293			while (cp && !isspace(cp))
294	gwlarson	2.7	fputc(cp++, fp); / finish this word */
295	greg	2.1	if (cp) { / start new line */
296	gwlarson	2.7	if (vv[i].fixval == catvalues) {
297			fputc('\n', fp);
298			fputs(vnam(i), fp);
299			fputc('=', fp);
300			} else
301			fputs(" \\\n", fp);
302	greg	2.1	k = clipline;
303			}
304			}
305			}
306	gwlarson	2.7	fputc('\n', fp);
307	greg	2.1	}
308			fflush(fp);
309			}