src/common/loadvars.c

#ifndef lint
static const char       RCSid[] = "$Id: loadvars.c,v 2.17 2023/06/05 16:09:55 greg 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 */
        const 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);
                }
        }
        if (fp != stdin)
                fclose(fp);
}


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