src/common/loadvars.c

#ifndef lint
static const char       RCSid[] = "$Id: loadvars.c,v 2.13 2003/07/27 22:12:01 schorsch Exp $";
#endif
/*
 *  Routines for loading and checking variables from file.
 */

#include "copyright.h"

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

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