src/util/getinfo.c

#ifndef lint
static const char       RCSid[] = "$Id: getinfo.c,v 2.26 2023/03/16 17:16:05 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 ((*s1 == '=') & !*s2)
                        return(0);
                if (isspace(*s1) & isspace(*s2))
                        return(0);
        }
        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(1, 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.27
Committed:	Wed Jun 5 21:56:53 2024 UTC (8 months, 1 week ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.26:	+2 -2 lines
Log Message:	perf(getinfo,rcollate): Removed unnecessary call to fileno() that used semaphore
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.27	static const char RCSid[] = "$Id: getinfo.c,v 2.26 2023/03/16 17:16:05 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	greg	2.25	if ((s1 == '=') & !s2)
66			return(0);
67			if (isspace(s1) & isspace(s2))
68			return(0);
69	greg	2.23	}
70			fputs(s, stdout); /* copy if no match */
71	gwlarson	2.4	return(0);
72	greg	1.1	}
73
74
75	greg	2.23	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	greg	2.27	if (writebuf(1, buf, n) != n)
119	greg	2.23	break;
120			}
121
122
123	schorsch	2.8	int
124			main(
125			int argc,
126			char **argv
127			)
128	greg	1.1	{
129			int dim = 0;
130			FILE *fp;
131			int i;
132
133	greg	2.19	if (argc > 1 && (argv[1][0] == '-') \| (argv[1][0] == '+') &&
134			argv[1][1] == 'd') {
135			dim = 1 - 2*(argv[1][0] == '-');
136	greg	1.1	argc--; argv++;
137	greg	2.18	}
138			#ifdef getc_unlocked /* avoid lock/unlock overhead */
139			flockfile(stdin);
140	greg	2.24	flockfile(stdout);
141	greg	2.18	#endif
142			SET_FILE_BINARY(stdin);
143			if (argc > 2 && !strcmp(argv[1], "-c")) {
144	greg	2.10	SET_FILE_BINARY(stdout);
145	greg	2.12	setvbuf(stdin, NULL, _IONBF, 2);
146	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
147	greg	2.21	fputs("Bad header!\n", stderr);
148	greg	2.17	return 1;
149	greg	2.21	}
150	greg	2.10	printargs(argc-2, argv+2, stdout);
151	greg	2.22	if (fmt[0] != '') / better be the same! */
152			fputformat(fmt, stdout);
153	greg	2.10	fputc('\n', stdout);
154	greg	2.18	if (dim) { /* copy resolution string? */
155			RESOLU rs;
156			if (!fgetsresolu(&rs, stdin)) {
157	greg	2.21	fputs("No resolution string!\n", stderr);
158	greg	2.18	return 1;
159			}
160	greg	2.19	if (dim > 0)
161			fputsresolu(&rs, stdout);
162	greg	2.18	}
163	greg	2.10	fflush(stdout);
164			execvp(argv[2], argv+2);
165			perror(argv[2]);
166			return 1;
167	greg	2.23	}
168			if (argc > 2 && !strcmp(argv[1], "-a")) {
169	greg	2.14	SET_FILE_BINARY(stdout);
170	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
171	greg	2.21	fputs("Bad header!\n", stderr);
172	greg	2.17	return 1;
173	greg	2.21	}
174	greg	2.14	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	greg	2.22	if (fmt[0] != '*')
182			fputformat(fmt, stdout);
183	greg	2.14	fputc('\n', stdout);
184			copycat();
185			return 0;
186	greg	2.23	}
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	schorsch	2.6	SET_FILE_BINARY(stdout);
215	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
216			fputs("Bad header!\n", stderr);
217	greg	2.17	return 1;
218	greg	2.21	}
219	greg	2.19	if (dim < 0) { /* skip resolution string? */
220	greg	2.18	RESOLU rs;
221			if (!fgetsresolu(&rs, stdin)) {
222	greg	2.21	fputs("No resolution string!\n", stderr);
223	greg	2.18	return 1;
224			}
225			}
226	greg	1.2	copycat();
227	schorsch	2.8	return 0;
228	greg	1.1	}
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	greg	2.24	#ifdef getc_unlocked /* avoid lock/unlock overhead */
235			flockfile(fp);
236			#endif
237	greg	2.19	if (dim < 0) { /* dimensions only */
238			if (getheader(fp, NULL, NULL) < 0) {
239	greg	2.26	fputs(": bad header!\n", stdout);
240	greg	2.19	continue;
241			}
242	greg	1.1	fputs(": ", stdout);
243			getdim(fp);
244			} else {
245	schorsch	2.8	tabstr(":\n", NULL);
246	greg	2.21	if (getheader(fp, tabstr, NULL) < 0) {
247			fputs(argv[i], stderr);
248			fputs(": bad header!\n", stderr);
249	greg	2.19	return 1;
250	greg	2.21	}
251	greg	2.10	fputc('\n', stdout);
252	greg	2.19	if (dim > 0) {
253			fputc('\t', stdout);
254			getdim(fp);
255			}
256	greg	1.1	}
257			fclose(fp);
258			}
259			}
260	schorsch	2.7	if (argc == 1) {
261	greg	2.19	if (dim < 0) {
262	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
263			fputs("Bad header!\n", stderr);
264	greg	2.19	return 1;
265	greg	2.21	}
266	greg	1.1	getdim(stdin);
267			} else {
268	greg	2.21	if (getheader(stdin, (gethfunc *)fputs, stdout) < 0) {
269			fputs("Bad header!\n", stderr);
270	greg	2.17	return 1;
271	greg	2.21	}
272	greg	2.10	fputc('\n', stdout);
273	greg	2.19	if (dim > 0)
274			getdim(stdin);
275	greg	1.1	}
276	schorsch	2.7	}
277	schorsch	2.8	return 0;
278	greg	1.1	}