src/common/loadvars.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  Routines for loading and checking variables from file.
 */

/* ====================================================================
 * The Radiance Software License, Version 1.0
 *
 * Copyright (c) 1990 - 2002 The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory.   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *         notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *           if any, must include the following acknowledgment:
 *             "This product includes Radiance software
 *                 (http://radsite.lbl.gov/)
 *                 developed by the Lawrence Berkeley National Laboratory
 *               (http://www.lbl.gov/)."
 *       Alternately, this acknowledgment may appear in the software itself,
 *       if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
 *       and "The Regents of the University of California" must
 *       not be used to endorse or promote products derived from this
 *       software without prior written permission. For written
 *       permission, please contact [email protected].
 *
 * 5. Products derived from this software may not be called "Radiance",
 *       nor may "Radiance" appear in their name, without prior written
 *       permission of Lawrence Berkeley National Laboratory.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
 * information on Lawrence Berkeley National Laboratory, please see
 * <http://www.lbl.gov/>.
 */

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

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

extern char  *fgetline();


void
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);
                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(ass, mv)            /* assign variable according to string */
register char   *ass;
VARIABLE        *(*mv)();
{
        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(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(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(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);
}


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

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


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


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


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


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


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


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


void
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 : 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.9
Committed:	Sat Feb 22 02:07:22 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.8:	+70 -10 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id$";
3	greg	2.1	#endif
4			/*
5			* Routines for loading and checking variables from file.
6			*/
7
8	greg	2.9	/* ====================================================================
9			* The Radiance Software License, Version 1.0
10			*
11			* Copyright (c) 1990 - 2002 The Regents of the University of California,
12			* through Lawrence Berkeley National Laboratory. All rights reserved.
13			*
14			* Redistribution and use in source and binary forms, with or without
15			* modification, are permitted provided that the following conditions
16			* are met:
17			*
18			* 1. Redistributions of source code must retain the above copyright
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 2. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in
23			* the documentation and/or other materials provided with the
24			* distribution.
25			*
26			* 3. The end-user documentation included with the redistribution,
27			* if any, must include the following acknowledgment:
28			* "This product includes Radiance software
29			* (http://radsite.lbl.gov/)
30			* developed by the Lawrence Berkeley National Laboratory
31			* (http://www.lbl.gov/)."
32			* Alternately, this acknowledgment may appear in the software itself,
33			* if and wherever such third-party acknowledgments normally appear.
34			*
35			* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36			* and "The Regents of the University of California" must
37			* not be used to endorse or promote products derived from this
38			* software without prior written permission. For written
39			* permission, please contact [email protected].
40			*
41			* 5. Products derived from this software may not be called "Radiance",
42			* nor may "Radiance" appear in their name, without prior written
43			* permission of Lawrence Berkeley National Laboratory.
44			*
45			* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46			* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48			* DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49			* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51			* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52			* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53			* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54			* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55			* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56			* SUCH DAMAGE.
57			* ====================================================================
58			*
59			* This software consists of voluntary contributions made by many
60			* individuals on behalf of Lawrence Berkeley National Laboratory. For more
61			* information on Lawrence Berkeley National Laboratory, please see
62			* <http://www.lbl.gov/>.
63			*/
64
65	greg	2.1	#include <stdio.h>
66	greg	2.9	#include <stdlib.h>
67	greg	2.1	#include <ctype.h>
68			#include "vars.h"
69
70			#define NOCHAR 127 /* constant for character to delete */
71
72	greg	2.4	extern char *fgetline();
73
74	greg	2.1
75	greg	2.9	void
76	greg	2.1	loadvars(rfname) /* load variables into vv from file */
77			char *rfname;
78			{
79			FILE *fp;
80			char buf[512];
81			register char *cp;
82
83			if (rfname == NULL)
84			fp = stdin;
85			else if ((fp = fopen(rfname, "r")) == NULL) {
86			perror(rfname);
87	greg	2.5	quit(1);
88	greg	2.1	}
89			while (fgetline(buf, sizeof(buf), fp) != NULL) {
90			for (cp = buf; *cp; cp++) {
91			switch (*cp) {
92			case '\\':
93			*cp++ = NOCHAR;
94			continue;
95			case '#':
96			*cp = '\0';
97			break;
98			default:
99			continue;
100			}
101			break;
102			}
103	greg	2.6	if (setvariable(buf, matchvar) < 0) {
104			fprintf(stderr, "%s: unknown variable: %s\n",
105			rfname, buf);
106			quit(1);
107			}
108	greg	2.1	}
109			fclose(fp);
110			}
111
112
113	greg	2.6	int
114			setvariable(ass, mv) /* assign variable according to string */
115	greg	2.1	register char *ass;
116	greg	2.6	VARIABLE (mv)();
117	greg	2.1	{
118			char varname[32];
119			int n;
120			register char *cp;
121			register VARIABLE *vp;
122			register int i;
123
124			while (isspace(ass)) / skip leading space */
125			ass++;
126			cp = varname; /* extract name */
127			while (cp < varname+sizeof(varname)-1
128			&& ass && !isspace(ass) && *ass != '=')
129			cp++ = ass++;
130			*cp = '\0';
131			if (!varname[0])
132	greg	2.6	return(0); /* no variable name! */
133	greg	2.1	/* trim value */
134			while (isspace(ass) \|\| ass == '=')
135			ass++;
136			for (n = strlen(ass); n > 0; n--)
137			if (!isspace(ass[n-1]))
138			break;
139	greg	2.6	if (!n)
140			return(0); /* no assignment */
141	greg	2.1	/* match variable from list */
142	greg	2.6	vp = (*mv)(varname);
143			if (vp == NULL)
144			return(-1);
145	greg	2.1	/* assign new value */
146			if (i = vp->nass) {
147			cp = vp->value;
148			while (i--)
149			while (*cp++)
150			;
151			i = cp - vp->value;
152	greg	2.9	vp->value = (char *)realloc(vp->value, i+n+1);
153	greg	2.1	} else
154	greg	2.9	vp->value = (char *)malloc(n+1);
155	greg	2.1	if (vp->value == NULL) {
156			perror(progname);
157	greg	2.5	quit(1);
158	greg	2.1	}
159			cp = vp->value+i; /* copy value, squeezing spaces */
160			cp = ass;
161			for (i = 1; i <= n; i++) {
162			if (ass[i] == NOCHAR)
163			continue;
164			if (isspace(*cp))
165			while (isspace(ass[i]))
166			i++;
167			*++cp = ass[i];
168			}
169			if (isspace(cp)) / remove trailing space */
170			*cp = '\0';
171	greg	2.6	return(++vp->nass);
172	greg	2.1	}
173
174
175			VARIABLE *
176			matchvar(nam) /* match a variable by its name */
177			char *nam;
178			{
179			int n = strlen(nam);
180			register int i;
181
182			for (i = 0; i < NVARS; i++)
183			if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
184			return(vv+i);
185			return(NULL);
186			}
187
188
189			char *
190	greg	2.2	nvalue(vn, n) /* return nth variable value */
191			register int vn;
192	greg	2.1	register int n;
193			{
194			register char *cp;
195
196	greg	2.2	if (vval(vn) == NULL \| n < 0 \| n >= vdef(vn))
197	greg	2.1	return(NULL);
198	greg	2.2	cp = vval(vn);
199	greg	2.1	while (n--)
200			while (*cp++)
201			;
202			return(cp);
203			}
204
205
206	greg	2.9	void
207	greg	2.1	checkvalues() /* check assignments */
208			{
209			register int i;
210
211			for (i = 0; i < NVARS; i++)
212			if (vv[i].fixval != NULL)
213			(*vv[i].fixval)(vv+i);
214			}
215
216
217	greg	2.9	void
218	greg	2.1	onevalue(vp) /* only one assignment for this variable */
219			register VARIABLE *vp;
220			{
221			if (vp->nass < 2)
222			return;
223			if (!nowarn)
224			fprintf(stderr,
225			"%s: warning - multiple assignment of variable '%s'\n",
226			progname, vp->name);
227			do
228			vp->value += strlen(vp->value)+1;
229			while (--vp->nass > 1);
230			}
231
232
233	greg	2.9	void
234	greg	2.1	catvalues(vp) /* concatenate variable values */
235			register VARIABLE *vp;
236			{
237			register char *cp;
238
239			if (vp->nass < 2)
240			return;
241			for (cp = vp->value; vp->nass > 1; vp->nass--) {
242			while (*cp)
243			cp++;
244			*cp++ = ' ';
245			}
246			}
247
248
249			int
250			badmatch(tv, cv) /* case insensitive truncated comparison */
251			register char tv, cv;
252			{
253			if (!tv) return(1); / null string cannot match */
254			do
255			if (UPPER(tv) != cv++)
256			return(1);
257			while (*++tv);
258			return(0); /* OK */
259			}
260
261
262	greg	2.9	void
263	greg	2.1	boolvalue(vp) /* check boolean for legal values */
264			register VARIABLE *vp;
265			{
266			if (!vp->nass) return;
267			onevalue(vp);
268			switch (UPPER(vp->value[0])) {
269			case 'T':
270			if (badmatch(vp->value, "TRUE")) break;
271			return;
272			case 'F':
273			if (badmatch(vp->value, "FALSE")) break;
274			return;
275			}
276			fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
277			progname, vp->name);
278	greg	2.5	quit(1);
279	greg	2.1	}
280
281
282	greg	2.9	void
283	greg	2.1	qualvalue(vp) /* check qualitative var. for legal values */
284			register VARIABLE *vp;
285			{
286			if (!vp->nass) return;
287			onevalue(vp);
288			switch (UPPER(vp->value[0])) {
289			case 'L':
290			if (badmatch(vp->value, "LOW")) break;
291			return;
292			case 'M':
293			if (badmatch(vp->value, "MEDIUM")) break;
294			return;
295			case 'H':
296			if (badmatch(vp->value, "HIGH")) break;
297			return;
298			}
299			fprintf(stderr, "%s: illegal value for qualitative variable '%s'\n",
300			progname, vp->name);
301	greg	2.5	quit(1);
302	greg	2.1	}
303
304
305	greg	2.9	void
306	greg	2.1	intvalue(vp) /* check integer variable for legal values */
307			register VARIABLE *vp;
308			{
309			if (!vp->nass) return;
310			onevalue(vp);
311			if (isint(vp->value)) return;
312			fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
313			progname, vp->name);
314	greg	2.5	quit(1);
315	greg	2.1	}
316
317
318	greg	2.9	void
319	greg	2.1	fltvalue(vp) /* check float variable for legal values */
320			register VARIABLE *vp;
321			{
322			if (!vp->nass) return;
323			onevalue(vp);
324			if (isflt(vp->value)) return;
325			fprintf(stderr, "%s: illegal value for real variable '%s'\n",
326			progname, vp->name);
327	greg	2.5	quit(1);
328	greg	2.1	}
329
330
331	greg	2.9	void
332	greg	2.1	printvars(fp) /* print variable values */
333			register FILE *fp;
334			{
335			int i, j, k, clipline;
336			register char *cp;
337
338			for (i = 0; i < NVARS; i++) /* print each variable */
339			for (j = 0; j < vdef(i); j++) { /* print each assignment */
340			fputs(vnam(i), fp);
341			fputs("= ", fp);
342	gwlarson	2.8	k = clipline = ( vv[i].fixval == catvalues ? 64 : 236 )
343	greg	2.1	- strlen(vnam(i)) ;
344	greg	2.2	cp = nvalue(i, j);
345	greg	2.1	while (*cp) {
346			putc(*cp++, fp);
347			if (--k <= 0) { /* line too long */
348			while (cp && !isspace(cp))
349	gwlarson	2.7	fputc(cp++, fp); / finish this word */
350	greg	2.1	if (cp) { / start new line */
351	gwlarson	2.7	if (vv[i].fixval == catvalues) {
352			fputc('\n', fp);
353			fputs(vnam(i), fp);
354			fputc('=', fp);
355			} else
356			fputs(" \\\n", fp);
357	greg	2.1	k = clipline;
358			}
359			}
360			}
361	gwlarson	2.7	fputc('\n', fp);
362	greg	2.1	}
363			fflush(fp);
364			}