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 && !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.2
Committed:	Wed Jan 17 15:45:16 1996 UTC (29 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.1:	+5 -5 lines
Log Message:	changed parameter to nvalue()
#	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			if (!n && !nowarn) {
80			fprintf(stderr, "%s: warning - missing value for variable '%s'\n",
81			progname, varname);
82			return;
83			}
84			/* match variable from list */
85			vp = matchvar(varname);
86			if (vp == NULL) {
87			fprintf(stderr, "%s: unknown variable '%s'\n",
88			progname, varname);
89			exit(1);
90			}
91			/* assign new value */
92			if (i = vp->nass) {
93			cp = vp->value;
94			while (i--)
95			while (*cp++)
96			;
97			i = cp - vp->value;
98			vp->value = realloc(vp->value, i+n+1);
99			} else
100			vp->value = malloc(n+1);
101			if (vp->value == NULL) {
102			perror(progname);
103			exit(1);
104			}
105			cp = vp->value+i; /* copy value, squeezing spaces */
106			cp = ass;
107			for (i = 1; i <= n; i++) {
108			if (ass[i] == NOCHAR)
109			continue;
110			if (isspace(*cp))
111			while (isspace(ass[i]))
112			i++;
113			*++cp = ass[i];
114			}
115			if (isspace(cp)) / remove trailing space */
116			*cp = '\0';
117			vp->nass++;
118			}
119
120
121			VARIABLE *
122			matchvar(nam) /* match a variable by its name */
123			char *nam;
124			{
125			int n = strlen(nam);
126			register int i;
127
128			for (i = 0; i < NVARS; i++)
129			if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
130			return(vv+i);
131			return(NULL);
132			}
133
134
135			char *
136	greg	2.2	nvalue(vn, n) /* return nth variable value */
137			register int vn;
138	greg	2.1	register int n;
139			{
140			register char *cp;
141
142	greg	2.2	if (vval(vn) == NULL \| n < 0 \| n >= vdef(vn))
143	greg	2.1	return(NULL);
144	greg	2.2	cp = vval(vn);
145	greg	2.1	while (n--)
146			while (*cp++)
147			;
148			return(cp);
149			}
150
151
152			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			onevalue(vp) /* only one assignment for this variable */
163			register VARIABLE *vp;
164			{
165			if (vp->nass < 2)
166			return;
167			if (!nowarn)
168			fprintf(stderr,
169			"%s: warning - multiple assignment of variable '%s'\n",
170			progname, vp->name);
171			do
172			vp->value += strlen(vp->value)+1;
173			while (--vp->nass > 1);
174			}
175
176
177			catvalues(vp) /* concatenate variable values */
178			register VARIABLE *vp;
179			{
180			register char *cp;
181
182			if (vp->nass < 2)
183			return;
184			for (cp = vp->value; vp->nass > 1; vp->nass--) {
185			while (*cp)
186			cp++;
187			*cp++ = ' ';
188			}
189			}
190
191
192			int
193			badmatch(tv, cv) /* case insensitive truncated comparison */
194			register char tv, cv;
195			{
196			if (!tv) return(1); / null string cannot match */
197			do
198			if (UPPER(tv) != cv++)
199			return(1);
200			while (*++tv);
201			return(0); /* OK */
202			}
203
204
205			boolvalue(vp) /* check boolean for legal values */
206			register VARIABLE *vp;
207			{
208			if (!vp->nass) return;
209			onevalue(vp);
210			switch (UPPER(vp->value[0])) {
211			case 'T':
212			if (badmatch(vp->value, "TRUE")) break;
213			return;
214			case 'F':
215			if (badmatch(vp->value, "FALSE")) break;
216			return;
217			}
218			fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
219			progname, vp->name);
220			exit(1);
221			}
222
223
224			qualvalue(vp) /* check qualitative var. for legal values */
225			register VARIABLE *vp;
226			{
227			if (!vp->nass) return;
228			onevalue(vp);
229			switch (UPPER(vp->value[0])) {
230			case 'L':
231			if (badmatch(vp->value, "LOW")) break;
232			return;
233			case 'M':
234			if (badmatch(vp->value, "MEDIUM")) break;
235			return;
236			case 'H':
237			if (badmatch(vp->value, "HIGH")) break;
238			return;
239			}
240			fprintf(stderr, "%s: illegal value for qualitative variable '%s'\n",
241			progname, vp->name);
242			exit(1);
243			}
244
245
246			intvalue(vp) /* check integer variable for legal values */
247			register VARIABLE *vp;
248			{
249			if (!vp->nass) return;
250			onevalue(vp);
251			if (isint(vp->value)) return;
252			fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
253			progname, vp->name);
254			exit(1);
255			}
256
257
258			fltvalue(vp) /* check float variable for legal values */
259			register VARIABLE *vp;
260			{
261			if (!vp->nass) return;
262			onevalue(vp);
263			if (isflt(vp->value)) return;
264			fprintf(stderr, "%s: illegal value for real variable '%s'\n",
265			progname, vp->name);
266			exit(1);
267			}
268
269
270			printvars(fp) /* print variable values */
271			register FILE *fp;
272			{
273			int i, j, k, clipline;
274			register char *cp;
275
276			for (i = 0; i < NVARS; i++) /* print each variable */
277			for (j = 0; j < vdef(i); j++) { /* print each assignment */
278			fputs(vnam(i), fp);
279			fputs("= ", fp);
280			k = clipline = ( vv[i].fixval == catvalues ? 64 : 320 )
281			- strlen(vnam(i)) ;
282	greg	2.2	cp = nvalue(i, j);
283	greg	2.1	while (*cp) {
284			putc(*cp++, fp);
285			if (--k <= 0) { /* line too long */
286			while (cp && !isspace(cp))
287			putc(cp++, fp); / finish this word */
288			if (cp) { / start new line */
289			putc('\n', fp);
290			fputs(vnam(i), fp);
291			putc('=', fp);
292			k = clipline;
293			}
294			}
295			}
296			putc('\n', fp);
297			}
298			fflush(fp);
299			}