![[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 [MW Coherent from dump] / coherent / d / usr / bin / cutpaste|
Return to cut.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / cutpaste |
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: static char sccsid[] = "@(#)cut.c 5.3 (Berkeley) 6/24/90";
28: #endif /* not lint */
29:
30: #include <stdio.h>
31: #include <ctype.h>
32: #if COHERENT
33: #include <string.h>
34: #define _BSD_LINE_MAX BUFSIZ /* compatibility */
35: #else
36: #include <limits.h>
37: #endif
38:
39: int cflag;
40: char dchar;
41: int dflag;
42: int fflag;
43: int sflag;
44: long strtol();
45:
46: main(argc, argv)
47: int argc;
48: char **argv;
49: {
50: extern char *optarg;
51: extern int errno, optind;
52: FILE *fp;
53: int ch, (*fcn)(), c_cut(), f_cut();
54: char *strerror();
55:
56: dchar = '\t'; /* default delimiter is \t */
57:
58: while ((ch = getopt(argc, argv, "c:d:f:s")) != EOF)
59: switch(ch) {
60: case 'c':
61: fcn = c_cut;
62: get_list(optarg);
63: cflag = 1;
64: break;
65: case 'd':
66: dchar = *optarg;
67: dflag = 1;
68: break;
69: case 'f':
70: get_list(optarg);
71: fcn = f_cut;
72: fflag = 1;
73: break;
74: case 's':
75: sflag = 1;
76: break;
77: case '?':
78: default:
79: usage();
80: }
81: argc -= optind;
82: argv += optind;
83:
84: if (fflag) {
85: if (cflag)
86: usage();
87: } else if (!cflag || dflag || sflag)
88: usage();
89:
90: if (*argv)
91: for (; *argv; ++argv) {
92: if (!(fp = fopen(*argv, "r"))) {
93: (void)fprintf(stderr,
94: "cut: %s: %s\n", *argv, strerror(errno));
95: exit(1);
96: }
97: (*fcn)(fp, *argv);
98: }
99: else
100: (*fcn)(stdin, "stdin");
101: exit(0);
102: }
103:
104: int autostart, autostop, maxval;
105:
106: char positions[_BSD_LINE_MAX + 1];
107:
108: get_list(list)
109: char *list;
110: {
111: register char *pos;
112: register int setautostart, start, stop;
113: char *p, *strtok();
114:
115: /*
116: * set a byte in the positions array to indicate if a field or
117: * column is to be selected; use +1, it's 1-based, not 0-based.
118: * This parser is less restrictive than the Draft 9 POSIX spec.
119: * POSIX doesn't allow lists that aren't in increasing order or
120: * overlapping lists. We also handle "-3-5" although there's no
121: * real reason too.
122: */
123: for (; p = strtok(list, ", \t"); list = NULL) {
124: setautostart = start = stop = 0;
125: if (*p == '-') {
126: ++p;
127: setautostart = 1;
128: }
129: if (isdigit(*p)) {
130: start = stop = strtol(p, &p, 10);
131: if (setautostart && start > autostart)
132: autostart = start;
133: }
134: if (*p == '-') {
135: if (isdigit(p[1]))
136: stop = strtol(p + 1, &p, 10);
137: if (*p == '-') {
138: ++p;
139: if (!autostop || autostop > stop)
140: autostop = stop;
141: }
142: }
143: if (*p)
144: badlist("illegal list value");
145: if (!stop || !start)
146: badlist("values may not include zero");
147: if (stop > _BSD_LINE_MAX) {
148: /* positions used rather than allocate a new buffer */
149: (void)sprintf(positions, "%d too large (max %d)",
150: stop, _BSD_LINE_MAX);
151: badlist(positions);
152: }
153: if (maxval < stop)
154: maxval = stop;
155: for (pos = positions + start; start++ <= stop; *pos++ = 1);
156: }
157:
158: /* overlapping ranges */
159: if (autostop && maxval > autostop)
160: maxval = autostop;
161:
162: /* set autostart */
163: if (autostart)
164: memset(positions + 1, '1', autostart);
165: }
166:
167: /* ARGSUSED */
168: c_cut(fp, fname)
169: FILE *fp;
170: char *fname;
171: {
172: register int ch, col;
173: register char *pos;
174:
175: for (;;) {
176: pos = positions + 1;
177: for (col = maxval; col; --col) {
178: if ((ch = getc(fp)) == EOF)
179: return;
180: if (ch == '\n')
181: break;
182: if (*pos++)
183: putchar(ch);
184: }
185: if (ch != '\n')
186: if (autostop)
187: while ((ch = getc(fp)) != EOF && ch != '\n')
188: putchar(ch);
189: else
190: while ((ch = getc(fp)) != EOF && ch != '\n');
191: putchar('\n');
192: }
193: }
194:
195: f_cut(fp, fname)
196: FILE *fp;
197: char *fname;
198: {
199: register int ch, field, isdelim;
200: register char *pos, *p, sep;
201: int output;
202: char lbuf[_BSD_LINE_MAX + 1];
203:
204: for (sep = dchar, output = 0; fgets(lbuf, sizeof(lbuf), fp);) {
205: for (isdelim = 0, p = lbuf;; ++p) {
206: if (!(ch = *p)) {
207: (void)fprintf(stderr,
208: "cut: %s: line too long.\n", fname);
209: exit(1);
210: }
211: /* this should work if newline is delimiter */
212: if (ch == sep)
213: isdelim = 1;
214: if (ch == '\n') {
215: if (!isdelim && !sflag)
216: (void)printf("%s", lbuf);
217: break;
218: }
219: }
220: if (!isdelim)
221: continue;
222:
223: pos = positions + 1;
224: for (field = maxval, p = lbuf; field; --field, ++pos) {
225: if (*pos) {
226: if (output++)
227: putchar(sep);
228: while ((ch = *p++) != '\n' && ch != sep)
229: putchar(ch);
230: } else
231: while ((ch = *p++) != '\n' && ch != sep);
232: if (ch == '\n')
233: break;
234: }
235: if (ch != '\n')
236: if (autostop) {
237: if (output)
238: putchar(sep);
239: for (; (ch = *p) != '\n'; ++p)
240: putchar(ch);
241: } else
242: for (; (ch = *p) != '\n'; ++p);
243: putchar('\n');
244: }
245: }
246:
247: badlist(msg)
248: char *msg;
249: {
250: (void)fprintf(stderr, "cut: [-cf] list: %s.\n", msg);
251: exit(1);
252: }
253:
254: usage()
255: {
256: (void)fprintf(stderr,
257: "usage:\tcut -c list [file1 ...]\n\tcut -f list [-s] [-d delim] [file ...]\n");
258: exit(1);
259: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.