src/util/getinfo.c

#ifndef lint
static const char       RCSid[] = "$Id: getinfo.c,v 2.22 2022/03/03 22:54:49 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);
#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 {
                        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.23
Committed:	Mon Mar 21 00:21:13 2022 UTC (2 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.22:	+120 -66 lines
Log Message:	feat(getinfo): Added getinfo -r option (similar to -a but with remove/replace)
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.23	static const char RCSid[] = "$Id: getinfo.c,v 2.22 2022/03/03 22:54:49 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			#endif
139			SET_FILE_BINARY(stdin);
140			if (argc > 2 && !strcmp(argv[1], "-c")) {
141	greg	2.10	SET_FILE_BINARY(stdout);
142	greg	2.12	setvbuf(stdin, NULL, _IONBF, 2);
143	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
144	greg	2.21	fputs("Bad header!\n", stderr);
145	greg	2.17	return 1;
146	greg	2.21	}
147	greg	2.10	printargs(argc-2, argv+2, stdout);
148	greg	2.22	if (fmt[0] != '') / better be the same! */
149			fputformat(fmt, stdout);
150	greg	2.10	fputc('\n', stdout);
151	greg	2.18	if (dim) { /* copy resolution string? */
152			RESOLU rs;
153			if (!fgetsresolu(&rs, stdin)) {
154	greg	2.21	fputs("No resolution string!\n", stderr);
155	greg	2.18	return 1;
156			}
157	greg	2.19	if (dim > 0)
158			fputsresolu(&rs, stdout);
159	greg	2.18	}
160	greg	2.10	fflush(stdout);
161			execvp(argv[2], argv+2);
162			perror(argv[2]);
163			return 1;
164	greg	2.23	}
165			if (argc > 2 && !strcmp(argv[1], "-a")) {
166	greg	2.14	SET_FILE_BINARY(stdout);
167	greg	2.22	if (checkheader(stdin, fmt, stdout) < 0) {
168	greg	2.21	fputs("Bad header!\n", stderr);
169	greg	2.17	return 1;
170	greg	2.21	}
171	greg	2.14	for (i = 2; i < argc; i++) {
172			int len = strlen(argv[i]);
173			if (!len) continue;
174			fputs(argv[i], stdout);
175			if (argv[i][len-1] != '\n')
176			fputc('\n', stdout);
177			}
178	greg	2.22	if (fmt[0] != '*')
179			fputformat(fmt, stdout);
180	greg	2.14	fputc('\n', stdout);
181			copycat();
182			return 0;
183	greg	2.23	}
184			if (argc > 2 && !strcmp(argv[1], "-r")) {
185			SET_FILE_BINARY(stdout);
186			if (getheader(stdin, adjheadline, argv+2) < 0) {
187			fputs("Bad header!\n", stderr);
188			return 1;
189			}
190			for (i = 2; i < argc; i++) { /* add lines w/ var[= ]value */
191			int len = strlen(argv[i]);
192			int strt = 0, j;
193			while(isspace(argv[i][strt])) strt++;
194			if (strt == len) continue;
195			while (isspace(argv[i][len-1])) len--;
196			for (j = strt+1; j < len-1; j++)
197			if (argv[i][j] == '=' \|\| isspace(argv[i][j])) {
198			for (j = 0; j < len; j++)
199			putchar(argv[i][j]);
200			fputc('\n', stdout);
201			break;
202			}
203			}
204			if (fmt[0] != '*')
205			fputformat(fmt, stdout);
206			fputc('\n', stdout);
207			copycat();
208			return 0;
209			}
210			if (argc == 2 && !strcmp(argv[1], "-")) {
211	schorsch	2.6	SET_FILE_BINARY(stdout);
212	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
213			fputs("Bad header!\n", stderr);
214	greg	2.17	return 1;
215	greg	2.21	}
216	greg	2.19	if (dim < 0) { /* skip resolution string? */
217	greg	2.18	RESOLU rs;
218			if (!fgetsresolu(&rs, stdin)) {
219	greg	2.21	fputs("No resolution string!\n", stderr);
220	greg	2.18	return 1;
221			}
222			}
223	greg	1.2	copycat();
224	schorsch	2.8	return 0;
225	greg	1.1	}
226			for (i = 1; i < argc; i++) {
227			fputs(argv[i], stdout);
228			if ((fp = fopen(argv[i], "r")) == NULL)
229			fputs(": cannot open\n", stdout);
230			else {
231	greg	2.19	if (dim < 0) { /* dimensions only */
232			if (getheader(fp, NULL, NULL) < 0) {
233	greg	2.21	fputs("bad header!\n", stdout);
234	greg	2.19	continue;
235			}
236	greg	1.1	fputs(": ", stdout);
237			getdim(fp);
238			} else {
239	schorsch	2.8	tabstr(":\n", NULL);
240	greg	2.21	if (getheader(fp, tabstr, NULL) < 0) {
241			fputs(argv[i], stderr);
242			fputs(": bad header!\n", stderr);
243	greg	2.19	return 1;
244	greg	2.21	}
245	greg	2.10	fputc('\n', stdout);
246	greg	2.19	if (dim > 0) {
247			fputc('\t', stdout);
248			getdim(fp);
249			}
250	greg	1.1	}
251			fclose(fp);
252			}
253			}
254	schorsch	2.7	if (argc == 1) {
255	greg	2.19	if (dim < 0) {
256	greg	2.21	if (getheader(stdin, NULL, NULL) < 0) {
257			fputs("Bad header!\n", stderr);
258	greg	2.19	return 1;
259	greg	2.21	}
260	greg	1.1	getdim(stdin);
261			} else {
262	greg	2.21	if (getheader(stdin, (gethfunc *)fputs, stdout) < 0) {
263			fputs("Bad header!\n", stderr);
264	greg	2.17	return 1;
265	greg	2.21	}
266	greg	2.10	fputc('\n', stdout);
267	greg	2.19	if (dim > 0)
268			getdim(stdin);
269	greg	1.1	}
270	schorsch	2.7	}
271	schorsch	2.8	return 0;
272	greg	1.1	}