src/util/getinfo.c

#ifndef lint
static const char       RCSid[] = "$Id: getinfo.c,v 2.23 2022/03/21 00:21:13 greg Exp $";
#endif
/*
 *  getinfo.c - program to read info. header from file.
 *
 *     1/3/86
 */

#include  <ctype.h>
#include  "rtio.h"
#include  "platform.h"
#include  "rtprocess.h"
#include  "resolu.h"

static char     fmt[MAXFMTLEN] = "*";


static int
tabstr(                         /* put out line followed by tab */
        char  *s,
        void *p
)
{
        while (*s) {
                putchar(*s);
                s++;
        }
        if (*--s == '\n')
                fputc('\t', stdout);
        return(0);
}


static int
adjheadline(                    /* check for lines to remove */
        char  *s,
        void *p
)
{
        char    **av;

        if (formatval(fmt, s))
                return(0);      /* don't echo format */

                                /* check for match to skip */
        for (av = (char **)p; *av; av++) {
                char    *s1 = s;
                char    *s2 = *av;
                if (isspace(*s2)) {
                        if (!isspace(*s1))
                                continue;
                        while (isspace(*++s1)) ;
                        while (isspace(*++s2)) ;
                }
                while (*s2 && *s1 == *s2) {
                        if ((*s1 == '=') & (s1 > s))
                                return(0);
                        if (isspace(*s2))
                                break;
                        s1++; s2++;
                }
                if (s1 == s)
                        continue;
                if (isspace(*s1) && !*s2 | isspace(*s2))
                        return(0);      /* skip */
        }
        fputs(s, stdout);       /* copy if no match */
        return(0);
}


static void
getdim(                         /* get dimensions from file */
        FILE  *fp
)
{
        int  j;
        int  c;

        switch (c = getc(fp)) {
        case '+':               /* picture */
        case '-':
                do
                        putchar(c);
                while (c != '\n' && (c = getc(fp)) != EOF);
                break;
        case 1:                 /* octree */
                getc(fp);
                j = 0;
                while ((c = getc(fp)) != EOF)
                        if (c == 0) {
                                if (++j >= 4)
                                        break;
                                fputc(' ', stdout);
                        } else {
                                putchar(c);
                        }
                fputc('\n', stdout);
                break;
        default:                /* ??? */
                fputs("unknown file type\n", stdout);
                break;
        }
}


static void
copycat(void)                   /* copy input to output */
{
        char    buf[8192];
        int     n;

        fflush(stdout);
        while ((n = fread(buf, 1, sizeof(buf), stdin)) > 0)
                if (writebuf(fileno(stdout), buf, n) != n)
                        break;
}


int
main(
        int  argc,
        char  **argv
)
{
        int  dim = 0;
        FILE  *fp;
        int  i;

        if (argc > 1 && (argv[1][0] == '-') | (argv[1][0] == '+') &&
                        argv[1][1] == 'd') {
                dim = 1 - 2*(argv[1][0] == '-');
                argc--; argv++;
        }
#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
        flockfile(stdin);
        flockfile(stdout);
#endif
        SET_FILE_BINARY(stdin);
        if (argc > 2 && !strcmp(argv[1], "-c")) {
                SET_FILE_BINARY(stdout);
                setvbuf(stdin, NULL, _IONBF, 2);
                if (checkheader(stdin, fmt, stdout) < 0) {
                        fputs("Bad header!\n", stderr);
                        return 1;
                }
                printargs(argc-2, argv+2, stdout);
                if (fmt[0] != '*')              /* better be the same! */
                        fputformat(fmt, stdout);
                fputc('\n', stdout);
                if (dim) {                      /* copy resolution string? */
                        RESOLU  rs;
                        if (!fgetsresolu(&rs, stdin)) {
                                fputs("No resolution string!\n", stderr);
                                return 1;
                        }
                        if (dim > 0)
                                fputsresolu(&rs, stdout);
                }
                fflush(stdout);
                execvp(argv[2], argv+2);
                perror(argv[2]);
                return 1;
        }
        if (argc > 2 && !strcmp(argv[1], "-a")) {
                SET_FILE_BINARY(stdout);
                if (checkheader(stdin, fmt, stdout) < 0) {
                        fputs("Bad header!\n", stderr);
                        return 1;
                }
                for (i = 2; i < argc; i++) {
                        int     len = strlen(argv[i]);
                        if (!len) continue;
                        fputs(argv[i], stdout);
                        if (argv[i][len-1] != '\n')
                                fputc('\n', stdout);
                }
                if (fmt[0] != '*')
                        fputformat(fmt, stdout);
                fputc('\n', stdout);
                copycat();
                return 0;
        }
        if (argc > 2 && !strcmp(argv[1], "-r")) {
                SET_FILE_BINARY(stdout);
                if (getheader(stdin, adjheadline, argv+2) < 0) {
                        fputs("Bad header!\n", stderr);
                        return 1;
                }
                for (i = 2; i < argc; i++) {    /* add lines w/ var[= ]value */
                        int     len = strlen(argv[i]);
                        int     strt = 0, j;
                        while(isspace(argv[i][strt])) strt++;
                        if (strt == len) continue;
                        while (isspace(argv[i][len-1])) len--;
                        for (j = strt+1; j < len-1; j++)
                                if (argv[i][j] == '=' || isspace(argv[i][j])) {
                                        for (j = 0; j < len; j++)
                                                putchar(argv[i][j]);
                                        fputc('\n', stdout);
                                        break;
                                }
                }
                if (fmt[0] != '*')
                        fputformat(fmt, stdout);
                fputc('\n', stdout);
                copycat();
                return 0;
        }
        if (argc == 2 && !strcmp(argv[1], "-")) {
                SET_FILE_BINARY(stdout);
                if (getheader(stdin, NULL, NULL) < 0) {
                        fputs("Bad header!\n", stderr);
                        return 1;
                }
                if (dim < 0) {                  /* skip resolution string? */
                        RESOLU  rs;
                        if (!fgetsresolu(&rs, stdin)) {
                                fputs("No resolution string!\n", stderr);
                                return 1;
                        }
                }
                copycat();
                return 0;
        }
        for (i = 1; i < argc; i++) {
                fputs(argv[i], stdout);
                if ((fp = fopen(argv[i], "r")) == NULL)
                        fputs(": cannot open\n", stdout);
                else {
#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
                        flockfile(fp);
#endif
                        if (dim < 0) {                  /* dimensions only */
                                if (getheader(fp, NULL, NULL) < 0) {
                                        fputs("bad header!\n", stdout);
                                        continue;       
                                }
                                fputs(": ", stdout);
                                getdim(fp);
                        } else {
                                tabstr(":\n", NULL);
                                if (getheader(fp, tabstr, NULL) < 0) {
                                        fputs(argv[i], stderr);
                                        fputs(": bad header!\n", stderr);
                                        return 1;
                                }
                                fputc('\n', stdout);
                                if (dim > 0) {
                                        fputc('\t', stdout);
                                        getdim(fp);
                                }
                        }
                        fclose(fp);
                }
        }
        if (argc == 1) {
                if (dim < 0) {
                        if (getheader(stdin, NULL, NULL) < 0) {
                                fputs("Bad header!\n", stderr);
                                return 1;       
                        }
                        getdim(stdin);
                } else {
                        if (getheader(stdin, (gethfunc *)fputs, stdout) < 0) {
                                fputs("Bad header!\n", stderr);
                                return 1;
                        }
                        fputc('\n', stdout);
                        if (dim > 0)
                                getdim(stdin);
                }
        }
        return 0;
}
Revision:	2.24
Committed:	Mon Mar 21 17:11:29 2022 UTC (2 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.23:	+5 -1 lines
Log Message:	perf(getinfo): Added a couple of missing calls to flockfile()
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.24	static const char RCSid[] = "$Id: getinfo.c,v 2.23 2022/03/21 00:21:13 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* getinfo.c - program to read info. header from file.
6			*
7			* 1/3/86
8			*/
9
10	greg	2.23	#include <ctype.h>
11	greg	2.20	#include "rtio.h"
12	schorsch	2.6	#include "platform.h"
13	greg	2.15	#include "rtprocess.h"
14	schorsch	2.8	#include "resolu.h"
15	greg	2.2
16	greg	2.23	static char fmt[MAXFMTLEN] = "*";
17	greg	1.1
18	greg	1.3
19	schorsch	2.8	static int
20			tabstr( /* put out line followed by tab */
21	greg	2.10	char *s,
22	schorsch	2.8	void *p
23			)
24	greg	1.1	{
25			while (*s) {
26			putchar(*s);
27			s++;
28			}
29			if (*--s == '\n')
30	greg	2.23	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 (isspace(s1) && !s2 \| isspace(*s2))
66			return(0); /* skip */
67			}
68			fputs(s, stdout); /* copy if no match */
69	gwlarson	2.4	return(0);
70	greg	1.1	}
71
72
73	greg	2.23	static void
74			getdim( /* get dimensions from file */
75			FILE *fp
76			)
77			{
78			int j;
79			int c;
80
81			switch (c = getc(fp)) {
82			case '+': /* picture */
83			case '-':
84			do
85			putchar(c);
86			while (c != '\n' && (c = getc(fp)) != EOF);
87			break;
88			case 1: /* octree */
89			getc(fp);
90			j = 0;
91			while ((c = getc(fp)) != EOF)
92			if (c == 0) {
93			if (++j >= 4)
94			break;
95			fputc(' ', stdout);
96			} else {
97			putchar(c);
98			}
99			fputc('\n', stdout);
100			break;
101			default: /* ??? */
102			fputs("unknown file type\n", stdout);
103			break;
104			}
105			}
106
107
108			static void
109			copycat(void) /* copy input to output */
110			{
111			char buf[8192];
112			int n;
113
114			fflush(stdout);
115			while ((n = fread(buf, 1, sizeof(buf), stdin)) > 0)
116			if (writebuf(fileno(stdout), buf, n) != n)
117			break;
118			}
119
120
121	schorsch	2.8	int
122			main(
123			int argc,
124			char **argv
125			)
126	greg	1.1	{
127			int dim = 0;
128			FILE *fp;
129			int i;
130
131	greg	2.19	if (argc > 1 && (argv[1][0] == '-') \| (argv[1][0] == '+') &&
132			argv[1][1] == 'd') {
133			dim = 1 - 2*(argv[1][0] == '-');
134	greg	1.1	argc--; argv++;
135	greg	2.18	}
136			#ifdef getc_unlocked /* avoid lock/unlock overhead */
137			flockfile(stdin);
138	greg	2.24	flockfile(stdout);
139	greg	2.18	#endif
140			SET_FILE_BINARY(stdin);
141			if (argc > 2 && !strcmp(argv[1], "-c")) {
142	greg	2.10	SET_FILE_BINARY(stdout);
143	greg	2.12	setvbuf(stdin, NULL, _IONBF, 2);
144	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
145	greg	2.21	fputs("Bad header!\n", stderr);
146	greg	2.17	return 1;
147	greg	2.21	}
148	greg	2.10	printargs(argc-2, argv+2, stdout);
149	greg	2.22	if (fmt[0] != '') / better be the same! */
150			fputformat(fmt, stdout);
151	greg	2.10	fputc('\n', stdout);
152	greg	2.18	if (dim) { /* copy resolution string? */
153			RESOLU rs;
154			if (!fgetsresolu(&rs, stdin)) {
155	greg	2.21	fputs("No resolution string!\n", stderr);
156	greg	2.18	return 1;
157			}
158	greg	2.19	if (dim > 0)
159			fputsresolu(&rs, stdout);
160	greg	2.18	}
161	greg	2.10	fflush(stdout);
162			execvp(argv[2], argv+2);
163			perror(argv[2]);
164			return 1;
165	greg	2.23	}
166			if (argc > 2 && !strcmp(argv[1], "-a")) {
167	greg	2.14	SET_FILE_BINARY(stdout);
168	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
169	greg	2.21	fputs("Bad header!\n", stderr);
170	greg	2.17	return 1;
171	greg	2.21	}
172	greg	2.14	for (i = 2; i < argc; i++) {
173			int len = strlen(argv[i]);
174			if (!len) continue;
175			fputs(argv[i], stdout);
176			if (argv[i][len-1] != '\n')
177			fputc('\n', stdout);
178			}
179	greg	2.22	if (fmt[0] != '*')
180			fputformat(fmt, stdout);
181	greg	2.14	fputc('\n', stdout);
182			copycat();
183			return 0;
184	greg	2.23	}
185			if (argc > 2 && !strcmp(argv[1], "-r")) {
186			SET_FILE_BINARY(stdout);
187			if (getheader(stdin, adjheadline, argv+2) < 0) {
188			fputs("Bad header!\n", stderr);
189			return 1;
190			}
191			for (i = 2; i < argc; i++) { /* add lines w/ var[= ]value */
192			int len = strlen(argv[i]);
193			int strt = 0, j;
194			while(isspace(argv[i][strt])) strt++;
195			if (strt == len) continue;
196			while (isspace(argv[i][len-1])) len--;
197			for (j = strt+1; j < len-1; j++)
198			if (argv[i][j] == '=' \|\| isspace(argv[i][j])) {
199			for (j = 0; j < len; j++)
200			putchar(argv[i][j]);
201			fputc('\n', stdout);
202			break;
203			}
204			}
205			if (fmt[0] != '*')
206			fputformat(fmt, stdout);
207			fputc('\n', stdout);
208			copycat();
209			return 0;
210			}
211			if (argc == 2 && !strcmp(argv[1], "-")) {
212	schorsch	2.6	SET_FILE_BINARY(stdout);
213	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
214			fputs("Bad header!\n", stderr);
215	greg	2.17	return 1;
216	greg	2.21	}
217	greg	2.19	if (dim < 0) { /* skip resolution string? */
218	greg	2.18	RESOLU rs;
219			if (!fgetsresolu(&rs, stdin)) {
220	greg	2.21	fputs("No resolution string!\n", stderr);
221	greg	2.18	return 1;
222			}
223			}
224	greg	1.2	copycat();
225	schorsch	2.8	return 0;
226	greg	1.1	}
227			for (i = 1; i < argc; i++) {
228			fputs(argv[i], stdout);
229			if ((fp = fopen(argv[i], "r")) == NULL)
230			fputs(": cannot open\n", stdout);
231			else {
232	greg	2.24	#ifdef getc_unlocked /* avoid lock/unlock overhead */
233			flockfile(fp);
234			#endif
235	greg	2.19	if (dim < 0) { /* dimensions only */
236			if (getheader(fp, NULL, NULL) < 0) {
237	greg	2.21	fputs("bad header!\n", stdout);
238	greg	2.19	continue;
239			}
240	greg	1.1	fputs(": ", stdout);
241			getdim(fp);
242			} else {
243	schorsch	2.8	tabstr(":\n", NULL);
244	greg	2.21	if (getheader(fp, tabstr, NULL) < 0) {
245			fputs(argv[i], stderr);
246			fputs(": bad header!\n", stderr);
247	greg	2.19	return 1;
248	greg	2.21	}
249	greg	2.10	fputc('\n', stdout);
250	greg	2.19	if (dim > 0) {
251			fputc('\t', stdout);
252			getdim(fp);
253			}
254	greg	1.1	}
255			fclose(fp);
256			}
257			}
258	schorsch	2.7	if (argc == 1) {
259	greg	2.19	if (dim < 0) {
260	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
261			fputs("Bad header!\n", stderr);
262	greg	2.19	return 1;
263	greg	2.21	}
264	greg	1.1	getdim(stdin);
265			} else {
266	greg	2.21	if (getheader(stdin, (gethfunc *)fputs, stdout) < 0) {
267			fputs("Bad header!\n", stderr);
268	greg	2.17	return 1;
269	greg	2.21	}
270	greg	2.10	fputc('\n', stdout);
271	greg	2.19	if (dim > 0)
272			getdim(stdin);
273	greg	1.1	}
274	schorsch	2.7	}
275	schorsch	2.8	return 0;
276	greg	1.1	}