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

extern char  *fgetline();


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.4
Committed:	Fri Apr 19 09:09:28 1996 UTC (28 years ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.3:	+2 -0 lines
Log Message:	added declaration of fgetline()
#	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	greg	2.4	extern char *fgetline();
22
23	greg	2.1
24			loadvars(rfname) /* load variables into vv from file */
25			char *rfname;
26			{
27			FILE *fp;
28			char buf[512];
29			register char *cp;
30
31			if (rfname == NULL)
32			fp = stdin;
33			else if ((fp = fopen(rfname, "r")) == NULL) {
34			perror(rfname);
35			exit(1);
36			}
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			setvariable(buf);
52			}
53			fclose(fp);
54			}
55
56
57			setvariable(ass) /* assign variable according to string */
58			register char *ass;
59			{
60			char varname[32];
61			int n;
62			register char *cp;
63			register VARIABLE *vp;
64			register int i;
65
66			while (isspace(ass)) / skip leading space */
67			ass++;
68			cp = varname; /* extract name */
69			while (cp < varname+sizeof(varname)-1
70			&& ass && !isspace(ass) && *ass != '=')
71			cp++ = ass++;
72			*cp = '\0';
73			if (!varname[0])
74			return; /* no variable name! */
75			/* trim value */
76			while (isspace(ass) \|\| ass == '=')
77			ass++;
78			for (n = strlen(ass); n > 0; n--)
79			if (!isspace(ass[n-1]))
80			break;
81	greg	2.3	if (!n) {
82			if (!nowarn)
83			fprintf(stderr,
84			"%s: warning - missing value for variable '%s'\n",
85			progname, varname);
86	greg	2.1	return;
87			}
88			/* match variable from list */
89			vp = matchvar(varname);
90			if (vp == NULL) {
91			fprintf(stderr, "%s: unknown variable '%s'\n",
92			progname, varname);
93			exit(1);
94			}
95			/* assign new value */
96			if (i = vp->nass) {
97			cp = vp->value;
98			while (i--)
99			while (*cp++)
100			;
101			i = cp - vp->value;
102			vp->value = realloc(vp->value, i+n+1);
103			} else
104			vp->value = malloc(n+1);
105			if (vp->value == NULL) {
106			perror(progname);
107			exit(1);
108			}
109			cp = vp->value+i; /* copy value, squeezing spaces */
110			cp = ass;
111			for (i = 1; i <= n; i++) {
112			if (ass[i] == NOCHAR)
113			continue;
114			if (isspace(*cp))
115			while (isspace(ass[i]))
116			i++;
117			*++cp = ass[i];
118			}
119			if (isspace(cp)) / remove trailing space */
120			*cp = '\0';
121			vp->nass++;
122			}
123
124
125			VARIABLE *
126			matchvar(nam) /* match a variable by its name */
127			char *nam;
128			{
129			int n = strlen(nam);
130			register int i;
131
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.2	nvalue(vn, n) /* return nth variable value */
141			register int vn;
142	greg	2.1	register int n;
143			{
144			register char *cp;
145
146	greg	2.2	if (vval(vn) == NULL \| n < 0 \| n >= vdef(vn))
147	greg	2.1	return(NULL);
148	greg	2.2	cp = vval(vn);
149	greg	2.1	while (n--)
150			while (*cp++)
151			;
152			return(cp);
153			}
154
155
156			checkvalues() /* check assignments */
157			{
158			register int i;
159
160			for (i = 0; i < NVARS; i++)
161			if (vv[i].fixval != NULL)
162			(*vv[i].fixval)(vv+i);
163			}
164
165
166			onevalue(vp) /* only one assignment for this variable */
167			register VARIABLE *vp;
168			{
169			if (vp->nass < 2)
170			return;
171			if (!nowarn)
172			fprintf(stderr,
173			"%s: warning - multiple assignment of variable '%s'\n",
174			progname, vp->name);
175			do
176			vp->value += strlen(vp->value)+1;
177			while (--vp->nass > 1);
178			}
179
180
181			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			boolvalue(vp) /* check boolean for legal values */
210			register VARIABLE *vp;
211			{
212			if (!vp->nass) return;
213			onevalue(vp);
214			switch (UPPER(vp->value[0])) {
215			case 'T':
216			if (badmatch(vp->value, "TRUE")) break;
217			return;
218			case 'F':
219			if (badmatch(vp->value, "FALSE")) break;
220			return;
221			}
222			fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
223			progname, vp->name);
224			exit(1);
225			}
226
227
228			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			exit(1);
247			}
248
249
250			intvalue(vp) /* check integer variable for legal values */
251			register VARIABLE *vp;
252			{
253			if (!vp->nass) return;
254			onevalue(vp);
255			if (isint(vp->value)) return;
256			fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
257			progname, vp->name);
258			exit(1);
259			}
260
261
262			fltvalue(vp) /* check float variable for legal values */
263			register VARIABLE *vp;
264			{
265			if (!vp->nass) return;
266			onevalue(vp);
267			if (isflt(vp->value)) return;
268			fprintf(stderr, "%s: illegal value for real variable '%s'\n",
269			progname, vp->name);
270			exit(1);
271			}
272
273
274			printvars(fp) /* print variable values */
275			register FILE *fp;
276			{
277			int i, j, k, clipline;
278			register char *cp;
279
280			for (i = 0; i < NVARS; i++) /* print each variable */
281			for (j = 0; j < vdef(i); j++) { /* print each assignment */
282			fputs(vnam(i), fp);
283			fputs("= ", fp);
284			k = clipline = ( vv[i].fixval == catvalues ? 64 : 320 )
285			- strlen(vnam(i)) ;
286	greg	2.2	cp = nvalue(i, j);
287	greg	2.1	while (*cp) {
288			putc(*cp++, fp);
289			if (--k <= 0) { /* line too long */
290			while (cp && !isspace(cp))
291			putc(cp++, fp); / finish this word */
292			if (cp) { / start new line */
293			putc('\n', fp);
294			fputs(vnam(i), fp);
295			putc('=', fp);
296			k = clipline;
297			}
298			}
299			}
300			putc('\n', fp);
301			}
302			fflush(fp);
303			}