src/cal/lam.c

#ifndef lint
static const char       RCSid[] = "$Id: lam.c,v 1.19 2019/07/04 17:36:04 greg Exp $";
#endif
/*
 *  lam.c - simple program to laminate files.
 *
 *      7/14/88         Greg Ward
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>

#include "platform.h"
#include "rtio.h"

#define MAXFILE         512             /* maximum number of files */

#define MAXLINE         65536           /* maximum input line */

FILE    *input[MAXFILE];
int     bytsiz[MAXFILE];
char    *tabc[MAXFILE];
int     nfiles = 0;

char    buf[MAXLINE];

int
main(int argc, char *argv[])
{
        long    incnt = 0;
        int     unbuff = 0;
        int     binout = 0;
        char    *curtab = "\t";
        int     curbytes = 0;
        int     puteol;
        int     i;

        for (i = 1; i < argc; i++) {
                if (argv[i][0] == '-') {
                        switch (argv[i][1]) {
                        case 't':
                                curtab = argv[i]+2;
                                break;
                        case 'u':
                                unbuff = !unbuff;
                                break;
                        case 'i':
                                switch (argv[i][2]) {
                                case 'n':
                                        incnt = atol(argv[++i]);
                                        break;
                                case 'f':
                                        curbytes = sizeof(float);
                                        break;
                                case 'd':
                                        curbytes = sizeof(double);
                                        break;
                                case 'i':
                                        curbytes = sizeof(int);
                                        break;
                                case 'w':
                                        curbytes = 2;
                                        break;
                                case 'b':
                                        curbytes = 1;
                                        break;
                                case 'a':
                                        curbytes = argv[i][3] ? -1 : 0;
                                        break;
                                default:
                                        goto badopt;
                                }
                                if (isdigit(argv[i][3]))
                                        curbytes *= atoi(argv[i]+3);
                                curbytes += (curbytes == -1);
                                if (curbytes > MAXLINE) {
                                        fputs(argv[0], stderr);
                                        fputs(": input size too big\n", stderr);
                                        return(1);
                                }
                                if (curbytes > 0) {
                                        curtab = "";
                                        ++binout;
                                }
                                break;
                        case '\0':
                                tabc[nfiles] = curtab;
                                input[nfiles] = stdin;
                                if (curbytes > 0)
                                        SET_FILE_BINARY(input[nfiles]);
                                bytsiz[nfiles++] = curbytes;
                                break;
                        badopt:;
                        default:
                                fputs(argv[0], stderr);
                                fputs(": bad option\n", stderr);
                                return(1);
                        }
                } else if (argv[i][0] == '!') {
                        tabc[nfiles] = curtab;
                        if ((input[nfiles] = popen(argv[i]+1, "r")) == NULL) {
                                fputs(argv[i], stderr);
                                fputs(": cannot start command\n", stderr);
                                return(1);
                        }
                        if (curbytes > 0)
                                SET_FILE_BINARY(input[nfiles]);
                        bytsiz[nfiles++] = curbytes;
                } else {
                        tabc[nfiles] = curtab;
                        if ((input[nfiles] = fopen(argv[i], "r")) == NULL) {
                                fputs(argv[i], stderr);
                                fputs(": cannot open file\n", stderr);
                                return(1);
                        }
                        if (curbytes > 0)
                                SET_FILE_BINARY(input[nfiles]);
                        bytsiz[nfiles++] = curbytes;
                }
                if (nfiles >= MAXFILE) {
                        fputs(argv[0], stderr);
                        fputs(": too many input streams\n", stderr);
                        return(1);
                }
        }
        if (!nfiles) {
                fputs(argv[0], stderr);
                fputs(": no input streams\n", stderr);
                return(1);
        }
        if (binout)                             /* binary output? */
                SET_FILE_BINARY(stdout);
#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
        for (i = nfiles; i--; )
                flockfile(input[i]);
        flockfile(stdout);
#endif
        puteol = 0;                             /* any ASCII output at all? */
        for (i = nfiles; i--; )
                puteol += (bytsiz[i] <= 0);
        do {                                    /* main loop */
                for (i = 0; i < nfiles; i++) {
                        if (bytsiz[i] > 0) {            /* binary input */
                                if (getbinary(buf, bytsiz[i], 1, input[i]) < 1)
                                        break;
                                putbinary(buf, bytsiz[i], 1, stdout);
                        } else if (bytsiz[i] < 0) {     /* multi-line input */
                                int     n = -bytsiz[i];
                                while (n--) {
                                        if (fgets(buf, MAXLINE, input[i]) == NULL)
                                                break;
                                        if ((i > 0) | (n < -bytsiz[i]-1))
                                                fputs(tabc[i], stdout);
                                        buf[strlen(buf)-1] = '\0';
                                        fputs(buf, stdout);
                                }
                                if (n >= 0)             /* fell short? */
                                        break;
                        } else {                        /* single-line input */
                                if (fgets(buf, MAXLINE, input[i]) == NULL)
                                        break;
                                if (i)
                                        fputs(tabc[i], stdout);
                                buf[strlen(buf)-1] = '\0';
                                fputs(buf, stdout);
                        }
                }
                if (i < nfiles)
                        break;
                if (puteol)
                        putchar('\n');
                if (unbuff)
                        fflush(stdout);
        } while (--incnt);
        return(0);
}
Revision:	1.20
Committed:	Fri Jul 5 00:20:57 2019 UTC (4 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.19:	+3 -9 lines
Log Message:	Added rsplit tool to divide input to multiple output streams
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	1.20	static const char RCSid[] = "$Id: lam.c,v 1.19 2019/07/04 17:36:04 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* lam.c - simple program to laminate files.
6			*
7			* 7/14/88 Greg Ward
8			*/
9
10	schorsch	1.2	#include <stdlib.h>
11			#include <string.h>
12	greg	1.1	#include <stdio.h>
13	greg	1.7	#include <ctype.h>
14	schorsch	1.2
15			#include "platform.h"
16	greg	1.17	#include "rtio.h"
17	greg	1.1
18	greg	1.7	#define MAXFILE 512 /* maximum number of files */
19	greg	1.1
20	greg	1.13	#define MAXLINE 65536 /* maximum input line */
21	greg	1.1
22			FILE *input[MAXFILE];
23	greg	1.7	int bytsiz[MAXFILE];
24	greg	1.6	char *tabc[MAXFILE];
25	greg	1.20	int nfiles = 0;
26	greg	1.1
27			char buf[MAXLINE];
28
29	schorsch	1.4	int
30	greg	1.20	main(int argc, char *argv[])
31	greg	1.1	{
32	greg	1.18	long incnt = 0;
33	greg	1.11	int unbuff = 0;
34	greg	1.14	int binout = 0;
35	greg	1.18	char *curtab = "\t";
36			int curbytes = 0;
37			int puteol;
38	greg	1.11	int i;
39	greg	1.1
40			for (i = 1; i < argc; i++) {
41			if (argv[i][0] == '-') {
42			switch (argv[i][1]) {
43			case 't':
44	greg	1.6	curtab = argv[i]+2;
45	greg	1.1	break;
46	greg	1.11	case 'u':
47			unbuff = !unbuff;
48			break;
49	greg	1.7	case 'i':
50			switch (argv[i][2]) {
51	greg	1.15	case 'n':
52			incnt = atol(argv[++i]);
53			break;
54	greg	1.7	case 'f':
55			curbytes = sizeof(float);
56			break;
57			case 'd':
58			curbytes = sizeof(double);
59			break;
60	greg	1.10	case 'i':
61			curbytes = sizeof(int);
62			break;
63	greg	1.7	case 'w':
64	greg	1.10	curbytes = 2;
65			break;
66			case 'b':
67			curbytes = 1;
68	greg	1.7	break;
69			case 'a':
70	greg	1.12	curbytes = argv[i][3] ? -1 : 0;
71	greg	1.7	break;
72			default:
73			goto badopt;
74			}
75			if (isdigit(argv[i][3]))
76			curbytes *= atoi(argv[i]+3);
77	greg	1.19	curbytes += (curbytes == -1);
78			if (curbytes > MAXLINE) {
79	greg	1.7	fputs(argv[0], stderr);
80	greg	1.12	fputs(": input size too big\n", stderr);
81	greg	1.19	return(1);
82	greg	1.7	}
83	greg	1.19	if (curbytes > 0) {
84	greg	1.8	curtab = "";
85	greg	1.19	++binout;
86	greg	1.14	}
87	greg	1.7	break;
88	greg	1.1	case '\0':
89			tabc[nfiles] = curtab;
90	greg	1.12	input[nfiles] = stdin;
91			if (curbytes > 0)
92			SET_FILE_BINARY(input[nfiles]);
93			bytsiz[nfiles++] = curbytes;
94	greg	1.1	break;
95	greg	1.7	badopt:;
96	greg	1.1	default:
97			fputs(argv[0], stderr);
98			fputs(": bad option\n", stderr);
99	greg	1.19	return(1);
100	greg	1.1	}
101			} else if (argv[i][0] == '!') {
102			tabc[nfiles] = curtab;
103	greg	1.9	if ((input[nfiles] = popen(argv[i]+1, "r")) == NULL) {
104	greg	1.1	fputs(argv[i], stderr);
105			fputs(": cannot start command\n", stderr);
106	greg	1.19	return(1);
107	greg	1.1	}
108	greg	1.12	if (curbytes > 0)
109	greg	1.9	SET_FILE_BINARY(input[nfiles]);
110	greg	1.12	bytsiz[nfiles++] = curbytes;
111	greg	1.1	} else {
112			tabc[nfiles] = curtab;
113	greg	1.9	if ((input[nfiles] = fopen(argv[i], "r")) == NULL) {
114	greg	1.1	fputs(argv[i], stderr);
115			fputs(": cannot open file\n", stderr);
116	greg	1.19	return(1);
117	greg	1.1	}
118	greg	1.12	if (curbytes > 0)
119	greg	1.9	SET_FILE_BINARY(input[nfiles]);
120	greg	1.12	bytsiz[nfiles++] = curbytes;
121	greg	1.1	}
122			if (nfiles >= MAXFILE) {
123			fputs(argv[0], stderr);
124			fputs(": too many input streams\n", stderr);
125	greg	1.19	return(1);
126	greg	1.1	}
127			}
128	greg	1.19	if (!nfiles) {
129			fputs(argv[0], stderr);
130			fputs(": no input streams\n", stderr);
131			return(1);
132			}
133	greg	1.14	if (binout) /* binary output? */
134			SET_FILE_BINARY(stdout);
135			#ifdef getc_unlocked /* avoid lock/unlock overhead */
136			for (i = nfiles; i--; )
137			flockfile(input[i]);
138			flockfile(stdout);
139			#endif
140	greg	1.15	puteol = 0; /* any ASCII output at all? */
141	greg	1.7	for (i = nfiles; i--; )
142	greg	1.19	puteol += (bytsiz[i] <= 0);
143	greg	1.16	do { /* main loop */
144	greg	1.1	for (i = 0; i < nfiles; i++) {
145	greg	1.19	if (bytsiz[i] > 0) { /* binary input */
146	greg	1.17	if (getbinary(buf, bytsiz[i], 1, input[i]) < 1)
147	greg	1.11	break;
148	greg	1.17	putbinary(buf, bytsiz[i], 1, stdout);
149	greg	1.19	} else if (bytsiz[i] < 0) { /* multi-line input */
150			int n = -bytsiz[i];
151			while (n--) {
152			if (fgets(buf, MAXLINE, input[i]) == NULL)
153			break;
154			if ((i > 0) \| (n < -bytsiz[i]-1))
155			fputs(tabc[i], stdout);
156			buf[strlen(buf)-1] = '\0';
157			fputs(buf, stdout);
158			}
159			if (n >= 0) /* fell short? */
160			break;
161			} else { /* single-line input */
162	greg	1.11	if (fgets(buf, MAXLINE, input[i]) == NULL)
163			break;
164	greg	1.1	if (i)
165	greg	1.6	fputs(tabc[i], stdout);
166	greg	1.1	buf[strlen(buf)-1] = '\0';
167			fputs(buf, stdout);
168			}
169			}
170	greg	1.11	if (i < nfiles)
171			break;
172			if (puteol)
173	greg	1.1	putchar('\n');
174	greg	1.11	if (unbuff)
175			fflush(stdout);
176	greg	1.16	} while (--incnt);
177	greg	1.11	return(0);
178	greg	1.1	}