src/common/loadvars.c

/* Copyright (c) 1995 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  Routines for loading and checking variables from file.
 */

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

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

#ifndef malloc
extern char  *malloc(), *realloc();
#endif


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);
                exit(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;
                }
                setvariable(buf);
        }
        fclose(fp);
}


setvariable(ass)                /* assign variable according to string */
register char   *ass;
{
        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;         /* 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) {
                if (!nowarn)
                        fprintf(stderr,
                        "%s: warning - missing value for variable '%s'\n",
                                        progname, varname);
                return;
        }
                                        /* match variable from list */
        vp = matchvar(varname);
        if (vp == NULL) {
                fprintf(stderr, "%s: unknown variable '%s'\n",
                                progname, varname);
                exit(1);
        }
                                        /* assign new value */
        if (i = vp->nass) {
                cp = vp->value;
                while (i--)
                        while (*cp++)
                                ;
                i = cp - vp->value;
                vp->value = realloc(vp->value, i+n+1);
        } else
                vp->value = malloc(n+1);
        if (vp->value == NULL) {
                perror(progname);
                exit(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';
        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);
}


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

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


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);
}


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 */
}


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);
        exit(1);
}


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);
        exit(1);
}


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);
        exit(1);
}


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);
        exit(1);
}


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