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.7 by schorsch, Mon Jul 21 22:30:19 2003 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 <
10 > #include  <ctype.h>
11 > #include  "rtio.h"
12   #include  "platform.h"
13 + #include  "rtprocess.h"
14 + #include  "resolu.h"
15  
16 + static char     fmt[MAXFMTLEN] = "*";
17  
18  
19 < int
20 < tabstr(s)                               /* put out line followed by tab */
21 < register char  *s;
19 > static int
20 > tabstr(                         /* put out line followed by tab */
21 >        char  *s,
22 >        void *p
23 > )
24   {
25          while (*s) {
26                  putchar(*s);
27                  s++;
28          }
29          if (*--s == '\n')
30 <                putchar('\t');
30 >                fputc('\t', stdout);
31          return(0);
32   }
33  
34  
35 < main(argc, argv)
36 < int  argc;
37 < char  **argv;
35 > static int
36 > adjheadline(                    /* check for lines to remove */
37 >        char  *s,
38 >        void *p
39 > )
40   {
41 <        int  dim = 0;
35 <        FILE  *fp;
36 <        int  i;
41 >        char    **av;
42  
43 <        if (argc > 1 && !strcmp(argv[1], "-d")) {
44 <                argc--; argv++;
45 <                dim = 1;
46 <                SET_DEFAULT_BINARY(); /* for output file */
47 <                SET_FILE_BINARY(stdin);
48 <        } else if (argc == 2 && !strcmp(argv[1], "-")) {
49 <                SET_FILE_BINARY(stdin);
50 <                SET_FILE_BINARY(stdout);
51 <                getheader(stdin, NULL, NULL);
52 <                copycat();
53 <                exit(0);
54 <        }
50 <        for (i = 1; i < argc; i++) {
51 <                fputs(argv[i], stdout);
52 <                if ((fp = fopen(argv[i], "r")) == NULL)
53 <                        fputs(": cannot open\n", stdout);
54 <                else {
55 <                        if (dim) {
56 <                                fputs(": ", stdout);
57 <                                getdim(fp);
58 <                        } else {
59 <                                tabstr(":\n");
60 <                                getheader(fp, tabstr, NULL);
61 <                                putchar('\n');
62 <                        }
63 <                        fclose(fp);
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 <        }
57 <        if (argc == 1) {
58 <                if (dim) {
59 <                        getdim(stdin);
60 <                } else {
61 <                        getheader(stdin, fputs, stdout);
71 <                        putchar('\n');
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 <        exit(0);
70 >        fputs(s, stdout);       /* copy if no match */
71 >        return(0);
72   }
73  
74  
75 < getdim(fp)                              /* get dimensions from file */
76 < register FILE  *fp;
75 > static void
76 > getdim(                         /* get dimensions from file */
77 >        FILE  *fp
78 > )
79   {
80          int  j;
81 <        register int  c;
81 >        int  c;
82  
84 –        getheader(fp, NULL, NULL);      /* skip header */
85 –
83          switch (c = getc(fp)) {
84          case '+':               /* picture */
85          case '-':
# Line 94 | Line 91 | register FILE  *fp;
91                  getc(fp);
92                  j = 0;
93                  while ((c = getc(fp)) != EOF)
94 <                        if (c == 0)
94 >                        if (c == 0) {
95                                  if (++j >= 4)
96                                          break;
97 <                                else
98 <                                        putchar(' ');
102 <                        else
97 >                                fputc(' ', stdout);
98 >                        } else {
99                                  putchar(c);
100 <                putchar('\n');
100 >                        }
101 >                fputc('\n', stdout);
102                  break;
103          default:                /* ??? */
104                  fputs("unknown file type\n", stdout);
# Line 110 | Line 107 | register FILE  *fp;
107   }
108  
109  
110 < copycat()                       /* copy input to output */
110 > static void
111 > copycat(void)                   /* copy input to output */
112   {
113 <        register int    c;
113 >        char    buf[8192];
114 >        int     n;
115  
116 <        while ((c = getchar()) != EOF)
117 <                putchar(c);
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,
126 >        char  **argv
127 > )
128 > {
129 >        int  dim = 0;
130 >        FILE  *fp;
131 >        int  i;
132 >
133 >        if (argc > 1 && (argv[1][0] == '-') | (argv[1][0] == '+') &&
134 >                        argv[1][1] == 'd') {
135 >                dim = 1 - 2*(argv[1][0] == '-');
136 >                argc--; argv++;
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 (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);
158 >                                return 1;
159 >                        }
160 >                        if (dim > 0)
161 >                                fputsresolu(&rs, stdout);
162 >                }
163 >                fflush(stdout);
164 >                execvp(argv[2], argv+2);
165 >                perror(argv[2]);
166 >                return 1;
167 >        }
168 >        if (argc > 2 && !strcmp(argv[1], "-a")) {
169 >                SET_FILE_BINARY(stdout);
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;
177 >                        fputs(argv[i], stdout);
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 >        }
187 >        if (argc > 2 && !strcmp(argv[1], "-r")) {
188 >                SET_FILE_BINARY(stdout);
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);
223 >                                return 1;
224 >                        }
225 >                }
226 >                copycat();
227 >                return 0;
228 >        }
229 >        for (i = 1; i < argc; i++) {
230 >                fputs(argv[i], stdout);
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);
240 >                                        continue;      
241 >                                }
242 >                                fputs(": ", stdout);
243 >                                getdim(fp);
244 >                        } else {
245 >                                tabstr(":\n", NULL);
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);
254 >                                        getdim(fp);
255 >                                }
256 >                        }
257 >                        fclose(fp);
258 >                }
259 >        }
260 >        if (argc == 1) {
261 >                if (dim < 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) {
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;
278   }

Diff Legend

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