![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cut.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / cut|
Return to cut.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / cut |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Adam S. Moskowitz of Menlo Consulting and Marciano Pitargue.
7: *
8: * Redistribution and use in source and binary forms are permitted provided
9: * that: (1) source distributions retain this entire copyright notice and
10: * comment, and (2) distributions including binaries display the following
11: * acknowledgement: ``This product includes software developed by the
12: * University of California, Berkeley and its contributors'' in the
13: * documentation or other materials provided with the distribution and in
14: * all advertising materials mentioning features or use of this software.
15: * Neither the name of the University nor the names of its contributors may
16: * be used to endorse or promote products derived from this software without
17: * specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: char copyright[] =
25: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\
26: All rights reserved.\n";
27: #endif /* not lint */
28:
29: #ifndef lint
30: static char sccsid[] = "@(#)cut.c 5.3 (Berkeley) 6/24/90";
31: #endif /* not lint */
32:
33: #include <limits.h>
34: #include <stdio.h>
35: #include <ctype.h>
36:
37: int cflag;
38: char dchar;
39: int dflag;
40: int fflag;
41: int sflag;
42:
43: main(argc, argv)
44: int argc;
45: char **argv;
46: {
47: extern char *optarg;
48: extern int errno, optind;
49: FILE *fp;
50: int ch, (*fcn)(), c_cut(), f_cut();
51: char *strerror();
52:
53: dchar = '\t'; /* default delimiter is \t */
54:
55: while ((ch = getopt(argc, argv, "c:d:f:s")) != EOF)
56: switch(ch) {
57: case 'c':
58: fcn = c_cut;
59: get_list(optarg);
60: cflag = 1;
61: break;
62: case 'd':
63: dchar = *optarg;
64: dflag = 1;
65: break;
66: case 'f':
67: get_list(optarg);
68: fcn = f_cut;
69: fflag = 1;
70: break;
71: case 's':
72: sflag = 1;
73: break;
74: case '?':
75: default:
76: usage();
77: }
78: argc -= optind;
79: argv += optind;
80:
81: if (fflag) {
82: if (cflag)
83: usage();
84: } else if (!cflag || dflag || sflag)
85: usage();
86:
87: if (*argv)
88: for (; *argv; ++argv) {
89: if (!(fp = fopen(*argv, "r"))) {
90: (void)fprintf(stderr,
91: "cut: %s: %s\n", *argv, strerror(errno));
92: exit(1);
93: }
94: fcn(fp, *argv);
95: }
96: else
97: fcn(stdin, "stdin");
98: exit(0);
99: }
100:
101: int autostart, autostop, maxval;
102:
103: char positions[_BSD_LINE_MAX + 1];
104:
105: get_list(list)
106: char *list;
107: {
108: register char *pos;
109: register int setautostart, start, stop;
110: char *p, *strtok();
111:
112: /*
113: * set a byte in the positions array to indicate if a field or
114: * column is to be selected; use +1, it's 1-based, not 0-based.
115: * This parser is less restrictive than the Draft 9 POSIX spec.
116: * POSIX doesn't allow lists that aren't in increasing order or
117: * overlapping lists. We also handle "-3-5" although there's no
118: * real reason too.
119: */
120: for (; p = strtok(list, ", \t"); list = NULL) {
121: setautostart = start = stop = 0;
122: if (*p == '-') {
123: ++p;
124: setautostart = 1;
125: }
126: if (isdigit(*p)) {
127: start = stop = strtol(p, &p, 10);
128: if (setautostart && start > autostart)
129: autostart = start;
130: }
131: if (*p == '-') {
132: if (isdigit(p[1]))
133: stop = strtol(p + 1, &p, 10);
134: if (*p == '-') {
135: ++p;
136: if (!autostop || autostop > stop)
137: autostop = stop;
138: }
139: }
140: if (*p)
141: badlist("illegal list value");
142: if (!stop || !start)
143: badlist("values may not include zero");
144: if (stop > _BSD_LINE_MAX) {
145: /* positions used rather than allocate a new buffer */
146: (void)sprintf(positions, "%d too large (max %d)",
147: stop, _BSD_LINE_MAX);
148: badlist(positions);
149: }
150: if (maxval < stop)
151: maxval = stop;
152: for (pos = positions + start; start++ <= stop; *pos++ = 1);
153: }
154:
155: /* overlapping ranges */
156: if (autostop && maxval > autostop)
157: maxval = autostop;
158:
159: /* set autostart */
160: if (autostart)
161: memset(positions + 1, '1', autostart);
162: }
163:
164: /* ARGSUSED */
165: c_cut(fp, fname)
166: FILE *fp;
167: char *fname;
168: {
169: register int ch, col;
170: register char *pos;
171:
172: for (;;) {
173: pos = positions + 1;
174: for (col = maxval; col; --col) {
175: if ((ch = getc(fp)) == EOF)
176: return;
177: if (ch == '\n')
178: break;
179: if (*pos++)
180: putchar(ch);
181: }
182: if (ch != '\n')
183: if (autostop)
184: while ((ch = getc(fp)) != EOF && ch != '\n')
185: putchar(ch);
186: else
187: while ((ch = getc(fp)) != EOF && ch != '\n');
188: putchar('\n');
189: }
190: }
191:
192: f_cut(fp, fname)
193: FILE *fp;
194: char *fname;
195: {
196: register int ch, field, isdelim;
197: register char *pos, *p, sep;
198: int output;
199: char lbuf[_BSD_LINE_MAX + 1];
200:
201: for (sep = dchar, output = 0; fgets(lbuf, sizeof(lbuf), fp);) {
202: for (isdelim = 0, p = lbuf;; ++p) {
203: if (!(ch = *p)) {
204: (void)fprintf(stderr,
205: "cut: %s: line too long.\n", fname);
206: exit(1);
207: }
208: /* this should work if newline is delimiter */
209: if (ch == sep)
210: isdelim = 1;
211: if (ch == '\n') {
212: if (!isdelim && !sflag)
213: (void)printf("%s", lbuf);
214: break;
215: }
216: }
217: if (!isdelim)
218: continue;
219:
220: pos = positions + 1;
221: for (field = maxval, p = lbuf; field; --field, ++pos) {
222: if (*pos) {
223: if (output++)
224: putchar(sep);
225: while ((ch = *p++) != '\n' && ch != sep)
226: putchar(ch);
227: } else
228: while ((ch = *p++) != '\n' && ch != sep);
229: if (ch == '\n')
230: break;
231: }
232: if (ch != '\n')
233: if (autostop) {
234: if (output)
235: putchar(sep);
236: for (; (ch = *p) != '\n'; ++p)
237: putchar(ch);
238: } else
239: for (; (ch = *p) != '\n'; ++p);
240: putchar('\n');
241: }
242: }
243:
244: badlist(msg)
245: char *msg;
246: {
247: (void)fprintf(stderr, "cut: [-cf] list: %s.\n", msg);
248: exit(1);
249: }
250:
251: usage()
252: {
253: (void)fprintf(stderr,
254: "usage:\tcut -c list [file1 ...]\n\tcut -f list [-s] [-d delim] [file ...]\n");
255: exit(1);
256: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.