src/cal/lam.c

#ifndef lint
static const char       RCSid[] = "$Id: lam.c,v 1.14 2014/03/09 20:07:27 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 "rtprocess.h"

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

#define MAXLINE         65536           /* maximum input line */

long    incnt = 0;                      /* limit number of records? */

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

char    buf[MAXLINE];

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

        curtab = "\t";
        curbytes = 0;
        nfiles = 0;
        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);
                                if (abs(curbytes) > MAXLINE) {
                                        fputs(argv[0], stderr);
                                        fputs(": input size too big\n", stderr);
                                        exit(1);
                                }
                                if (curbytes) {
                                        curtab = "";
                                        ++binout;
                                }
                                break;
                        case '\0':
                                tabc[nfiles] = curtab;
                                input[nfiles] = stdin;
                                if (curbytes > 0)
                                        SET_FILE_BINARY(input[nfiles]);
                                else
                                        curbytes = -curbytes;
                                bytsiz[nfiles++] = curbytes;
                                break;
                        badopt:;
                        default:
                                fputs(argv[0], stderr);
                                fputs(": bad option\n", stderr);
                                exit(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);
                                exit(1);
                        }
                        if (curbytes > 0)
                                SET_FILE_BINARY(input[nfiles]);
                        else
                                curbytes = -curbytes;
                        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);
                                exit(1);
                        }
                        if (curbytes > 0)
                                SET_FILE_BINARY(input[nfiles]);
                        else
                                curbytes = -curbytes;
                        bytsiz[nfiles++] = curbytes;
                }
                if (nfiles >= MAXFILE) {
                        fputs(argv[0], stderr);
                        fputs(": too many input streams\n", stderr);
                        exit(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--; )
                if (!bytsiz[i] || isprint(tabc[i][0]) || tabc[i][0] == '\t') {
                        puteol++;
                        break;
                }
        while (--incnt) {                       /* main loop */
                for (i = 0; i < nfiles; i++) {
                        if (bytsiz[i]) {                /* binary file */
                                if (fread(buf, bytsiz[i], 1, input[i]) < 1)
                                        break;
                                if (i)
                                        fputs(tabc[i], stdout);
                                fwrite(buf, bytsiz[i], 1, stdout);
                        } else {
                                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);
        }
        return(0);
}
Revision:	1.15
Committed:	Thu Mar 24 18:48:28 2016 UTC (8 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.14:	+8 -3 lines
Log Message:	Added -in options to commands for manual EOF specification
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	1.15	static const char RCSid[] = "$Id: lam.c,v 1.14 2014/03/09 20:07:27 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	schorsch	1.3	#include "rtprocess.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	greg	1.15	long incnt = 0; /* limit number of records? */
23
24	greg	1.1	FILE *input[MAXFILE];
25	greg	1.7	int bytsiz[MAXFILE];
26	greg	1.6	char *tabc[MAXFILE];
27	greg	1.1	int nfiles;
28
29			char buf[MAXLINE];
30
31	schorsch	1.4	int
32	greg	1.1	main(argc, argv)
33			int argc;
34			char *argv[];
35			{
36	greg	1.11	int unbuff = 0;
37	greg	1.14	int binout = 0;
38	greg	1.11	int i;
39	greg	1.6	char *curtab;
40	greg	1.7	int curbytes;
41	greg	1.11	int puteol;
42	greg	1.1
43	greg	1.6	curtab = "\t";
44	greg	1.7	curbytes = 0;
45	greg	1.1	nfiles = 0;
46			for (i = 1; i < argc; i++) {
47			if (argv[i][0] == '-') {
48			switch (argv[i][1]) {
49			case 't':
50	greg	1.6	curtab = argv[i]+2;
51	greg	1.1	break;
52	greg	1.11	case 'u':
53			unbuff = !unbuff;
54			break;
55	greg	1.7	case 'i':
56			switch (argv[i][2]) {
57	greg	1.15	case 'n':
58			incnt = atol(argv[++i]);
59			break;
60	greg	1.7	case 'f':
61			curbytes = sizeof(float);
62			break;
63			case 'd':
64			curbytes = sizeof(double);
65			break;
66	greg	1.10	case 'i':
67			curbytes = sizeof(int);
68			break;
69	greg	1.7	case 'w':
70	greg	1.10	curbytes = 2;
71			break;
72			case 'b':
73			curbytes = 1;
74	greg	1.7	break;
75			case 'a':
76	greg	1.12	curbytes = argv[i][3] ? -1 : 0;
77	greg	1.7	break;
78			default:
79			goto badopt;
80			}
81			if (isdigit(argv[i][3]))
82			curbytes *= atoi(argv[i]+3);
83	greg	1.12	if (abs(curbytes) > MAXLINE) {
84	greg	1.7	fputs(argv[0], stderr);
85	greg	1.12	fputs(": input size too big\n", stderr);
86	greg	1.7	exit(1);
87			}
88	greg	1.14	if (curbytes) {
89	greg	1.8	curtab = "";
90	greg	1.14	++binout;
91			}
92	greg	1.7	break;
93	greg	1.1	case '\0':
94			tabc[nfiles] = curtab;
95	greg	1.12	input[nfiles] = stdin;
96			if (curbytes > 0)
97			SET_FILE_BINARY(input[nfiles]);
98			else
99			curbytes = -curbytes;
100			bytsiz[nfiles++] = curbytes;
101	greg	1.1	break;
102	greg	1.7	badopt:;
103	greg	1.1	default:
104			fputs(argv[0], stderr);
105			fputs(": bad option\n", stderr);
106			exit(1);
107			}
108			} else if (argv[i][0] == '!') {
109			tabc[nfiles] = curtab;
110	greg	1.9	if ((input[nfiles] = popen(argv[i]+1, "r")) == NULL) {
111	greg	1.1	fputs(argv[i], stderr);
112			fputs(": cannot start command\n", stderr);
113			exit(1);
114			}
115	greg	1.12	if (curbytes > 0)
116	greg	1.9	SET_FILE_BINARY(input[nfiles]);
117	greg	1.12	else
118			curbytes = -curbytes;
119			bytsiz[nfiles++] = curbytes;
120	greg	1.1	} else {
121			tabc[nfiles] = curtab;
122	greg	1.9	if ((input[nfiles] = fopen(argv[i], "r")) == NULL) {
123	greg	1.1	fputs(argv[i], stderr);
124			fputs(": cannot open file\n", stderr);
125			exit(1);
126			}
127	greg	1.12	if (curbytes > 0)
128	greg	1.9	SET_FILE_BINARY(input[nfiles]);
129	greg	1.12	else
130			curbytes = -curbytes;
131			bytsiz[nfiles++] = curbytes;
132	greg	1.1	}
133			if (nfiles >= MAXFILE) {
134			fputs(argv[0], stderr);
135			fputs(": too many input streams\n", stderr);
136			exit(1);
137			}
138			}
139	greg	1.14	if (binout) /* binary output? */
140			SET_FILE_BINARY(stdout);
141			#ifdef getc_unlocked /* avoid lock/unlock overhead */
142			for (i = nfiles; i--; )
143			flockfile(input[i]);
144			flockfile(stdout);
145			#endif
146	greg	1.15	puteol = 0; /* any ASCII output at all? */
147	greg	1.7	for (i = nfiles; i--; )
148	greg	1.11	if (!bytsiz[i] \|\| isprint(tabc[i][0]) \|\| tabc[i][0] == '\t') {
149	greg	1.7	puteol++;
150			break;
151			}
152	greg	1.15	while (--incnt) { /* main loop */
153	greg	1.1	for (i = 0; i < nfiles; i++) {
154	greg	1.7	if (bytsiz[i]) { /* binary file */
155	greg	1.11	if (fread(buf, bytsiz[i], 1, input[i]) < 1)
156			break;
157			if (i)
158			fputs(tabc[i], stdout);
159			fwrite(buf, bytsiz[i], 1, stdout);
160			} else {
161			if (fgets(buf, MAXLINE, input[i]) == NULL)
162			break;
163	greg	1.1	if (i)
164	greg	1.6	fputs(tabc[i], stdout);
165	greg	1.1	buf[strlen(buf)-1] = '\0';
166			fputs(buf, stdout);
167			}
168			}
169	greg	1.11	if (i < nfiles)
170			break;
171			if (puteol)
172	greg	1.1	putchar('\n');
173	greg	1.11	if (unbuff)
174			fflush(stdout);
175			}
176			return(0);
177	greg	1.1	}