ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/getinfo.c
(Generate patch)

Comparing ray/src/util/getinfo.c (file contents):
Revision 2.19 by greg, Tue Jul 16 17:07:35 2019 UTC vs.
Revision 2.27 by greg, Wed Jun 5 21:56:53 2024 UTC

# Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7   *     1/3/86
8   */
9  
10 < #include  <stdio.h>
11 < #include  <string.h>
12 <
10 > #include  <ctype.h>
11 > #include  "rtio.h"
12   #include  "platform.h"
13   #include  "rtprocess.h"
14   #include  "resolu.h"
15  
16 < #ifdef getc_unlocked            /* avoid nasty file-locking overhead */
18 < #undef getc
19 < #undef getchar
20 < #undef putchar
21 < #define getc            getc_unlocked
22 < #define getchar         getchar_unlocked
23 < #define putchar         putchar_unlocked
24 < #endif
16 > static char     fmt[MAXFMTLEN] = "*";
17  
26 – static gethfunc tabstr;
27 – static void getdim(FILE *fp);
28 – static void copycat(void);
18  
30 –
19   static int
20   tabstr(                         /* put out line followed by tab */
21          char  *s,
# Line 39 | Line 27 | tabstr(                                /* put out line followed by tab */
27                  s++;
28          }
29          if (*--s == '\n')
30 <                putchar('\t');
30 >                fputc('\t', stdout);
31          return(0);
32   }
33  
34  
35 + static int
36 + adjheadline(                    /* check for lines to remove */
37 +        char  *s,
38 +        void *p
39 + )
40 + {
41 +        char    **av;
42 +
43 +        if (formatval(fmt, s))
44 +                return(0);      /* don't echo format */
45 +
46 +                                /* check for match to skip */
47 +        for (av = (char **)p; *av; av++) {
48 +                char    *s1 = s;
49 +                char    *s2 = *av;
50 +                if (isspace(*s2)) {
51 +                        if (!isspace(*s1))
52 +                                continue;
53 +                        while (isspace(*++s1)) ;
54 +                        while (isspace(*++s2)) ;
55 +                }
56 +                while (*s2 && *s1 == *s2) {
57 +                        if ((*s1 == '=') & (s1 > s))
58 +                                return(0);
59 +                        if (isspace(*s2))
60 +                                break;
61 +                        s1++; s2++;
62 +                }
63 +                if (s1 == s)
64 +                        continue;
65 +                if ((*s1 == '=') & !*s2)
66 +                        return(0);
67 +                if (isspace(*s1) & isspace(*s2))
68 +                        return(0);
69 +        }
70 +        fputs(s, stdout);       /* copy if no match */
71 +        return(0);
72 + }
73 +
74 +
75 + static void
76 + getdim(                         /* get dimensions from file */
77 +        FILE  *fp
78 + )
79 + {
80 +        int  j;
81 +        int  c;
82 +
83 +        switch (c = getc(fp)) {
84 +        case '+':               /* picture */
85 +        case '-':
86 +                do
87 +                        putchar(c);
88 +                while (c != '\n' && (c = getc(fp)) != EOF);
89 +                break;
90 +        case 1:                 /* octree */
91 +                getc(fp);
92 +                j = 0;
93 +                while ((c = getc(fp)) != EOF)
94 +                        if (c == 0) {
95 +                                if (++j >= 4)
96 +                                        break;
97 +                                fputc(' ', stdout);
98 +                        } else {
99 +                                putchar(c);
100 +                        }
101 +                fputc('\n', stdout);
102 +                break;
103 +        default:                /* ??? */
104 +                fputs("unknown file type\n", stdout);
105 +                break;
106 +        }
107 + }
108 +
109 +
110 + static void
111 + copycat(void)                   /* copy input to output */
112 + {
113 +        char    buf[8192];
114 +        int     n;
115 +
116 +        fflush(stdout);
117 +        while ((n = fread(buf, 1, sizeof(buf), stdin)) > 0)
118 +                if (writebuf(1, buf, n) != n)
119 +                        break;
120 + }
121 +
122 +
123   int
124   main(
125          int  argc,
# Line 61 | Line 137 | main(
137          }
138   #ifdef getc_unlocked                            /* avoid lock/unlock overhead */
139          flockfile(stdin);
140 +        flockfile(stdout);
141   #endif
142          SET_FILE_BINARY(stdin);
143          if (argc > 2 && !strcmp(argv[1], "-c")) {
144                  SET_FILE_BINARY(stdout);
145                  setvbuf(stdin, NULL, _IONBF, 2);
146 <                if (getheader(stdin, (gethfunc *)fputs, stdout) < 0)
146 >                if (checkheader(stdin, fmt, stdout) < 0) {
147 >                        fputs("Bad header!\n", stderr);
148                          return 1;
149 +                }
150                  printargs(argc-2, argv+2, stdout);
151 +                if (fmt[0] != '*')              /* better be the same! */
152 +                        fputformat(fmt, stdout);
153                  fputc('\n', stdout);
154                  if (dim) {                      /* copy resolution string? */
155                          RESOLU  rs;
156                          if (!fgetsresolu(&rs, stdin)) {
157 <                                fputs("No resolution string\n", stderr);
157 >                                fputs("No resolution string!\n", stderr);
158                                  return 1;
159                          }
160                          if (dim > 0)
# Line 83 | Line 164 | main(
164                  execvp(argv[2], argv+2);
165                  perror(argv[2]);
166                  return 1;
167 <        } else if (argc > 2 && !strcmp(argv[1], "-a")) {
167 >        }
168 >        if (argc > 2 && !strcmp(argv[1], "-a")) {
169                  SET_FILE_BINARY(stdout);
170 <                if (getheader(stdin, (gethfunc *)fputs, stdout) < 0)
170 >                if (checkheader(stdin, fmt, stdout) < 0) {
171 >                        fputs("Bad header!\n", stderr);
172                          return 1;
173 +                }
174                  for (i = 2; i < argc; i++) {
175                          int     len = strlen(argv[i]);
176                          if (!len) continue;
# Line 94 | Line 178 | main(
178                          if (argv[i][len-1] != '\n')
179                                  fputc('\n', stdout);
180                  }
181 +                if (fmt[0] != '*')
182 +                        fputformat(fmt, stdout);
183                  fputc('\n', stdout);
184                  copycat();
185                  return 0;
186 <        } else if (argc == 2 && !strcmp(argv[1], "-")) {
186 >        }
187 >        if (argc > 2 && !strcmp(argv[1], "-r")) {
188                  SET_FILE_BINARY(stdout);
189 <                if (getheader(stdin, NULL, NULL) < 0)
189 >                if (getheader(stdin, adjheadline, argv+2) < 0) {
190 >                        fputs("Bad header!\n", stderr);
191                          return 1;
192 +                }
193 +                for (i = 2; i < argc; i++) {    /* add lines w/ var[= ]value */
194 +                        int     len = strlen(argv[i]);
195 +                        int     strt = 0, j;
196 +                        while(isspace(argv[i][strt])) strt++;
197 +                        if (strt == len) continue;
198 +                        while (isspace(argv[i][len-1])) len--;
199 +                        for (j = strt+1; j < len-1; j++)
200 +                                if (argv[i][j] == '=' || isspace(argv[i][j])) {
201 +                                        for (j = 0; j < len; j++)
202 +                                                putchar(argv[i][j]);
203 +                                        fputc('\n', stdout);
204 +                                        break;
205 +                                }
206 +                }
207 +                if (fmt[0] != '*')
208 +                        fputformat(fmt, stdout);
209 +                fputc('\n', stdout);
210 +                copycat();
211 +                return 0;
212 +        }
213 +        if (argc == 2 && !strcmp(argv[1], "-")) {
214 +                SET_FILE_BINARY(stdout);
215 +                if (getheader(stdin, NULL, NULL) < 0) {
216 +                        fputs("Bad header!\n", stderr);
217 +                        return 1;
218 +                }
219                  if (dim < 0) {                  /* skip resolution string? */
220                          RESOLU  rs;
221                          if (!fgetsresolu(&rs, stdin)) {
222 <                                fputs("No resolution string\n", stderr);
222 >                                fputs("No resolution string!\n", stderr);
223                                  return 1;
224                          }
225                  }
# Line 116 | Line 231 | main(
231                  if ((fp = fopen(argv[i], "r")) == NULL)
232                          fputs(": cannot open\n", stdout);
233                  else {
234 + #ifdef getc_unlocked                            /* avoid lock/unlock overhead */
235 +                        flockfile(fp);
236 + #endif
237                          if (dim < 0) {                  /* dimensions only */
238                                  if (getheader(fp, NULL, NULL) < 0) {
239 <                                        fputs("bad header\n", stdout);
239 >                                        fputs(": bad header!\n", stdout);
240                                          continue;      
241                                  }
242                                  fputs(": ", stdout);
243                                  getdim(fp);
244                          } else {
245                                  tabstr(":\n", NULL);
246 <                                if (getheader(fp, tabstr, NULL) < 0)
246 >                                if (getheader(fp, tabstr, NULL) < 0) {
247 >                                        fputs(argv[i], stderr);
248 >                                        fputs(": bad header!\n", stderr);
249                                          return 1;
250 +                                }
251                                  fputc('\n', stdout);
252                                  if (dim > 0) {
253                                          fputc('\t', stdout);
# Line 138 | Line 259 | main(
259          }
260          if (argc == 1) {
261                  if (dim < 0) {
262 <                        if (getheader(stdin, NULL, NULL) < 0)
262 >                        if (getheader(stdin, NULL, NULL) < 0) {
263 >                                fputs("Bad header!\n", stderr);
264                                  return 1;      
265 +                        }
266                          getdim(stdin);
267                  } else {
268 <                        if (getheader(stdin, (gethfunc *)fputs, stdout) < 0)
268 >                        if (getheader(stdin, (gethfunc *)fputs, stdout) < 0) {
269 >                                fputs("Bad header!\n", stderr);
270                                  return 1;
271 +                        }
272                          fputc('\n', stdout);
273                          if (dim > 0)
274                                  getdim(stdin);
275                  }
276          }
277          return 0;
153 – }
154 –
155 –
156 – static void
157 – getdim(                         /* get dimensions from file */
158 –        FILE  *fp
159 – )
160 – {
161 –        int  j;
162 –        int  c;
163 –
164 –        switch (c = getc(fp)) {
165 –        case '+':               /* picture */
166 –        case '-':
167 –                do
168 –                        putchar(c);
169 –                while (c != '\n' && (c = getc(fp)) != EOF);
170 –                break;
171 –        case 1:                 /* octree */
172 –                getc(fp);
173 –                j = 0;
174 –                while ((c = getc(fp)) != EOF)
175 –                        if (c == 0) {
176 –                                if (++j >= 4)
177 –                                        break;
178 –                                putchar(' ');
179 –                        } else {
180 –                                putchar(c);
181 –                        }
182 –                putchar('\n');
183 –                break;
184 –        default:                /* ??? */
185 –                fputs("unknown file type\n", stdout);
186 –                break;
187 –        }
188 – }
189 –
190 –
191 – static void
192 – copycat(void)                   /* copy input to output */
193 – {
194 –        char    buf[8192];
195 –        int     n;
196 –
197 –        fflush(stdout);
198 –        while ((n = fread(buf, 1, sizeof(buf), stdin)) > 0)
199 –                if (writebuf(fileno(stdout), buf, n) != n)
200 –                        break;
278   }

Diff Legend

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