src/common/loadvars.c

#ifndef lint
static const char       RCSid[] = "$Id: loadvars.c,v 2.14 2003/07/30 10:11:06 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(                       /* load variables into vv from file */
        char    *rfname
)
{
        FILE    *fp;
        char    buf[512];
        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(                    /* assign variable according to string */
        char    *ass,
        VARIABLE        *(*mv)(char*)
)
{
        char    varname[32];
        int     n;
        char    *cp;
        VARIABLE        *vp;
        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(                       /* match a variable by its name */
        char    *nam
)
{
        int     n = strlen(nam);
        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(                         /* return nth variable value */
        int     vn,
        int     n
)
{
        char    *cp;

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


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

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


void
onevalue(                       /* only one assignment for this variable */
        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(                      /* concatenate variable values */
        VARIABLE        *vp
)
{
        char    *cp;

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


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


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