ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/Development/ray/src/common/loadvars.c
(Generate patch)

Comparing ray/src/common/loadvars.c (file contents):
Revision 2.8 by gwlarson, Thu Jul 9 10:47:59 1998 UTC vs.
Revision 2.24 by greg, Sat Jun 7 05:09:45 2025 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1995 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  Routines for loading and checking variables from file.
6   */
7  
8 < #include <stdio.h>
8 > #include "copyright.h"
9 >
10   #include <ctype.h>
11 +
12 + #include "standard.h"
13 + #include "paths.h"
14   #include "vars.h"
15  
16   #define NOCHAR  127             /* constant for character to delete */
17  
17 – #ifndef malloc
18 – extern char  *malloc(), *realloc();
19 – #endif
20 –
18   extern char  *fgetline();
19  
20  
21 < loadvars(rfname)                /* load variables into vv from file */
22 < char    *rfname;
21 > void
22 > loadvars(                       /* load variables into vv from file */
23 >        const char      *rfname
24 > )
25   {
26          FILE    *fp;
27          char    buf[512];
28 <        register char   *cp;
28 >        char    *cp;
29  
30          if (rfname == NULL)
31                  fp = stdin;
# Line 54 | Line 53 | char   *rfname;
53                          quit(1);
54                  }
55          }
56 <        fclose(fp);
56 >        if (fp != stdin)
57 >                fclose(fp);
58   }
59  
60  
61   int
62 < setvariable(ass, mv)            /* assign variable according to string */
63 < register char   *ass;
64 < VARIABLE        *(*mv)();
62 > setvariable(                    /* assign variable according to string */
63 >        const char      *ass,
64 >        VARIABLE        *(*mv)(const char*)
65 > )
66   {
67 +        int     quote = '\0';
68          char    varname[32];
69          int     n;
70 <        register char   *cp;
71 <        register VARIABLE       *vp;
72 <        register int    i;
70 >        char    *cp;
71 >        VARIABLE        *vp;
72 >        int     i;
73  
74          while (isspace(*ass))           /* skip leading space */
75                  ass++;
# Line 91 | Line 93 | VARIABLE       *(*mv)();
93          if (vp == NULL)
94                  return(-1);
95                                          /* assign new value */
96 <        if (i = vp->nass) {
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);
102 >                vp->value = (char *)realloc((void *)vp->value, i+n+1);
103          } else
104 <                vp->value = malloc(n+1);
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 */
109 >        cp = vp->value+i;               /* copy value */
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++;
114 >                if (quote) {            /* don't change quoted parts */
115 >                        quote *= (ass[i] != quote);
116 >                } else {                /* otherwise, squeeze spaces */
117 >                        if (isspace(*cp))
118 >                                while (isspace(ass[i])|(ass[i]==NOCHAR))
119 >                                        i++;
120 >                        if ((ass[i] == '"') | (ass[i] == '\''))
121 >                                quote = ass[i];
122 >                }
123                  *++cp = ass[i];
124          }
125          if (isspace(*cp))               /* remove trailing space */
# Line 121 | Line 129 | VARIABLE       *(*mv)();
129  
130  
131   VARIABLE *
132 < matchvar(nam)                   /* match a variable by its name */
133 < char    *nam;
132 > matchvar(                       /* match a variable by its name */
133 >        const char      *nam
134 > )
135   {
136          int     n = strlen(nam);
137 <        register int    i;
137 >        int     i;
138  
139          for (i = 0; i < NVARS; i++)
140                  if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
# Line 135 | Line 144 | char   *nam;
144  
145  
146   char *
147 < nvalue(vn, n)                   /* return nth variable value */
148 < register int    vn;
149 < register int    n;
147 > nvalue(                         /* return nth variable value */
148 >        int     vn,
149 >        int     n
150 > )
151   {
152 <        register char   *cp;
152 >        char    *cp;
153  
154 <        if (vval(vn) == NULL | n < 0 | n >= vdef(vn))
154 >        if ((vval(vn) == NULL) | (n < 0) | (n >= vdef(vn)))
155                  return(NULL);
156          cp = vval(vn);
157          while (n--)
# Line 151 | Line 161 | register int   n;
161   }
162  
163  
164 < checkvalues()                   /* check assignments */
164 > void
165 > checkvalues(void)               /* check assignments */
166   {
167 <        register int    i;
167 >        int     i;
168  
169          for (i = 0; i < NVARS; i++)
170                  if (vv[i].fixval != NULL)
# Line 161 | Line 172 | checkvalues()                  /* check assignments */
172   }
173  
174  
175 < onevalue(vp)                    /* only one assignment for this variable */
176 < register VARIABLE       *vp;
175 > void
176 > onevalue(                       /* only one assignment for this variable */
177 >        VARIABLE        *vp
178 > )
179   {
180          if (vp->nass < 2)
181                  return;
# Line 176 | Line 189 | register VARIABLE      *vp;
189   }
190  
191  
192 < catvalues(vp)                   /* concatenate variable values */
193 < register VARIABLE       *vp;
192 > void
193 > catvalues(                      /* concatenate variable values */
194 >        VARIABLE        *vp
195 > )
196   {
197 <        register char   *cp;
197 >        char    *cp;
198  
199          if (vp->nass < 2)
200                  return;
# Line 192 | Line 207 | register VARIABLE      *vp;
207  
208  
209   int
210 < badmatch(tv, cv)                /* case insensitive truncated comparison */
211 < register char   *tv, *cv;
210 > badmatch(                       /* case insensitive truncated comparison */
211 >        char    *tv,
212 >        char    *cv
213 > )
214   {
215          if (!*tv) return(1);            /* null string cannot match */
216          do
# Line 204 | Line 221 | register char  *tv, *cv;
221   }
222  
223  
224 < boolvalue(vp)                   /* check boolean for legal values */
225 < register VARIABLE       *vp;
224 > void
225 > boolvalue(                      /* check boolean for legal values */
226 >        VARIABLE        *vp
227 > )
228   {
229          if (!vp->nass) return;
230          onevalue(vp);
# Line 223 | Line 242 | register VARIABLE      *vp;
242   }
243  
244  
245 < qualvalue(vp)                   /* check qualitative var. for legal values */
246 < register VARIABLE       *vp;
245 > void
246 > qualvalue(                      /* check qualitative var. for legal values */
247 >        VARIABLE        *vp
248 > )
249   {
250          if (!vp->nass) return;
251          onevalue(vp);
# Line 244 | Line 265 | register VARIABLE      *vp;
265          quit(1);
266   }
267  
268 + void
269 + strvalue(                               /* check for single (quoted) string value */
270 +        VARIABLE        *vp
271 + )
272 + {
273 +        if (!vp->nass) return;
274 +        onevalue(vp);
275 +        if ((vp->value[0] == '"') | (vp->value[0] == '\'')) {
276 +                char    *cp = vp->value + strlen(vp->value+1);
277 +                if ((cp != vp->value) & (*cp == vp->value[0])) {
278 +                        vp->value++;    /* elide quotation marks */
279 +                        *cp = '\0';
280 +                }
281 +        }
282 + }
283  
284 < intvalue(vp)                    /* check integer variable for legal values */
285 < register VARIABLE       *vp;
284 >
285 > void
286 > intvalue(                               /* check integer variable for legal values */
287 >        VARIABLE        *vp
288 > )
289   {
290          if (!vp->nass) return;
291          onevalue(vp);
# Line 257 | Line 296 | register VARIABLE      *vp;
296   }
297  
298  
299 < fltvalue(vp)                    /* check float variable for legal values */
300 < register VARIABLE       *vp;
299 > void
300 > fltvalue(                               /* check float variable for legal values */
301 >        VARIABLE        *vp
302 > )
303   {
304          if (!vp->nass) return;
305          onevalue(vp);
# Line 269 | Line 310 | register VARIABLE      *vp;
310   }
311  
312  
313 < printvars(fp)                   /* print variable values */
314 < register FILE   *fp;
313 > int
314 > singlevar(                              /* assigned single value? */
315 >        VARIABLE *vp
316 > )
317   {
318 +        if (vp->fixval == catvalues)
319 +                return(0);
320 +
321 +        return((vp->fixval == strvalue) |
322 +                        (vp->fixval == fltvalue) |
323 +                        (vp->fixval == intvalue) |
324 +                        (vp->fixval == qualvalue) |
325 +                        (vp->fixval == boolvalue));
326 + }
327 +
328 + void
329 + printvars(                              /* print variable values */
330 +        FILE    *fp
331 + )
332 + {
333          int     i, j, k, clipline;
334 <        register char   *cp;
334 >        char    *cp;
335  
336          for (i = 0; i < NVARS; i++)             /* print each variable */
337              for (j = 0; j < vdef(i); j++) {     /* print each assignment */
338                  fputs(vnam(i), fp);
339 <                fputs("= ", fp);
339 >                fputc('=', fp);
340 >                if (!singlevar(&vv[i]))
341 >                        fputc(' ', fp);
342                  k = clipline = ( vv[i].fixval == catvalues ? 64 : 236 )
343                                  - strlen(vnam(i)) ;
344                  cp = nvalue(i, j);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines