1/*
2 * cut.c - minimalist version of cut
3 *
4 * Copyright (C) 1999,2000,2001 by Lineo, inc.
5 * Written by Mark Whitley <markw@lineo.com>, <markw@codepoet.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <unistd.h> /* getopt */
26#include <string.h>
27#include <limits.h>
28#include "busybox.h"
29
30
31/* globals from other files */
32extern int optind;
33extern char *optarg;
34
35
36/* option vars */
37static char part = 0; /* (b)yte, (c)har, (f)ields */
38static unsigned int supress_non_delimited_lines = 0;
39static char delim = '\t'; /* delimiter, default is tab */
40
41struct cut_list {
42	int startpos;
43	int endpos;
44};
45
46static const int BOL = 0;
47static const int EOL = INT_MAX;
48static const int NON_RANGE = -1;
49
50static struct cut_list *cut_lists = NULL; /* growable array holding a series of lists */
51static unsigned int nlists = 0; /* number of elements in above list */
52
53
54static int cmpfunc(const void *a, const void *b)
55{
56	struct cut_list *la = (struct cut_list *)a;
57	struct cut_list *lb = (struct cut_list *)b;
58
59	if (la->startpos > lb->startpos)
60		return 1;
61	if (la->startpos < lb->startpos)
62		return -1;
63	return 0;
64}
65
66
67/*
68 * parse_lists() - parses a list and puts values into startpos and endpos.
69 * valid list formats: N, N-, N-M, -M
70 * more than one list can be seperated by commas
71 */
72static void parse_lists(char *lists)
73{
74	char *ltok = NULL;
75	char *ntok = NULL;
76	char *junk;
77	int s = 0, e = 0;
78
79	/* take apart the lists, one by one (they are seperated with commas */
80	while ((ltok = strsep(&lists, ",")) != NULL) {
81
82		/* it's actually legal to pass an empty list */
83		if (strlen(ltok) == 0)
84			continue;
85
86		/* get the start pos */
87		ntok = strsep(&ltok, "-");
88		if (ntok == NULL) {
89			fprintf(stderr, "Help ntok is null for starting position! What do I do?\n");
90		} else if (strlen(ntok) == 0) {
91			s = BOL;
92		} else {
93			s = strtoul(ntok, &junk, 10);
94			if(*junk != '\0' || s < 0)
95				error_msg_and_die("invalid byte or field list");
96
97			/* account for the fact that arrays are zero based, while the user
98			 * expects the first char on the line to be char # 1 */
99			if (s != 0)
100				s--;
101		}
102
103		/* get the end pos */
104		ntok = strsep(&ltok, "-");
105		if (ntok == NULL) {
106			e = NON_RANGE;
107		} else if (strlen(ntok) == 0) {
108			e = EOL;
109		} else {
110			e = strtoul(ntok, &junk, 10);
111			if(*junk != '\0' || e < 0)
112				error_msg_and_die("invalid byte or field list");
113			/* if the user specified and end position of 0, that means "til the
114			 * end of the line */
115			if (e == 0)
116				e = INT_MAX;
117			e--; /* again, arrays are zero based, lines are 1 based */
118			if (e == s)
119				e = NON_RANGE;
120		}
121
122		/* if there's something left to tokenize, the user past an invalid list */
123		if (ltok)
124			error_msg_and_die("invalid byte or field list");
125
126		/* add the new list */
127		cut_lists = xrealloc(cut_lists, sizeof(struct cut_list) * (++nlists));
128		cut_lists[nlists-1].startpos = s;
129		cut_lists[nlists-1].endpos = e;
130	}
131
132	/* make sure we got some cut positions out of all that */
133	if (nlists == 0)
134		error_msg_and_die("missing list of positions");
135
136	/* now that the lists are parsed, we need to sort them to make life easier
137	 * on us when it comes time to print the chars / fields / lines */
138	qsort(cut_lists, nlists, sizeof(struct cut_list), cmpfunc);
139
140}
141
142
143static void cut_line_by_chars(const char *line)
144{
145	int c, l;
146	/* set up a list so we can keep track of what's been printed */
147	char *printed = xcalloc(strlen(line), sizeof(char));
148
149	/* print the chars specified in each cut list */
150	for (c = 0; c < nlists; c++) {
151		l = cut_lists[c].startpos;
152		while (l < strlen(line)) {
153			if (!printed[l]) {
154				putchar(line[l]);
155				printed[l] = 'X';
156			}
157			l++;
158			if (cut_lists[c].endpos == NON_RANGE || l > cut_lists[c].endpos)
159				break;
160		}
161	}
162	putchar('\n'); /* cuz we were handed a chomped line */
163	free(printed);
164}
165
166
167static void cut_line_by_fields(char *line)
168{
169	int c, f;
170	int ndelim = -1; /* zero-based / one-based problem */
171	int nfields_printed = 0;
172	char *field = NULL;
173	char d[2] = { delim, 0 };
174	char *printed;
175
176	/* test the easy case first: does this line contain any delimiters? */
177	if (strchr(line, delim) == NULL) {
178		if (!supress_non_delimited_lines)
179			puts(line);
180		return;
181	}
182
183	/* set up a list so we can keep track of what's been printed */
184	printed = xcalloc(strlen(line), sizeof(char));
185
186	/* process each list on this line, for as long as we've got a line to process */
187	for (c = 0; c < nlists && line; c++) {
188		f = cut_lists[c].startpos;
189		do {
190
191			/* find the field we're looking for */
192			while (line && ndelim < f) {
193				field = strsep(&line, d);
194				ndelim++;
195			}
196
197			/* we found it, and it hasn't been printed yet */
198			if (field && ndelim == f && !printed[ndelim]) {
199				/* if this isn't our first time through, we need to print the
200				 * delimiter after the last field that was printed */
201				if (nfields_printed > 0)
202					putchar(delim);
203				fputs(field, stdout);
204				printed[ndelim] = 'X';
205				nfields_printed++;
206			}
207
208			f++;
209
210			/* keep going as long as we have a line to work with, this is a
211			 * list, and we're not at the end of that list */
212		} while (line && cut_lists[c].endpos != NON_RANGE && f <= cut_lists[c].endpos);
213	}
214
215	/* if we printed anything at all, we need to finish it with a newline cuz
216	 * we were handed a chomped line */
217	putchar('\n');
218
219	free(printed);
220}
221
222
223static void cut_file_by_lines(const char *line, unsigned int linenum)
224{
225	static int c = 0;
226	static int l = -1;
227
228	/* I can't initialize this above cuz the "initializer isn't
229	 * constant" *sigh* */
230	if (l == -1)
231		l = cut_lists[c].startpos;
232
233	/* get out if we have no more lists to process or if the lines are lower
234	 * than what we're interested in */
235	if (c >= nlists || linenum < l)
236		return;
237
238	/* if the line we're looking for is lower than the one we were passed, it
239	 * means we displayed it already, so move on */
240	while (l < linenum) {
241		l++;
242		/* move on to the next list if we're at the end of this one */
243		if (cut_lists[c].endpos == NON_RANGE || l > cut_lists[c].endpos) {
244			c++;
245			/* get out if there's no more lists to process */
246			if (c >= nlists)
247				return;
248			l = cut_lists[c].startpos;
249			/* get out if the current line is lower than the one we just became
250			 * interested in */
251			if (linenum < l)
252				return;
253		}
254	}
255
256	/* If we made it here, it means we've found the line we're looking for, so print it */
257	puts(line);
258}
259
260
261/*
262 * snippy-snip
263 */
264static void cut_file(FILE *file)
265{
266	char *line = NULL;
267	unsigned int linenum = 0; /* keep these zero-based to be consistent */
268
269	/* go through every line in the file */
270	while ((line = get_line_from_file(file)) != NULL) {
271		chomp(line);
272
273		if (part == 'c' || part == 'b')
274			cut_line_by_chars(line);
275
276		/* cut based on fields */
277		else if (part == 'f') {
278			if (delim == '\n')
279				cut_file_by_lines(line, linenum);
280			else
281				cut_line_by_fields(line);
282		}
283
284		linenum++;
285		free(line);
286	}
287}
288
289
290extern int cut_main(int argc, char **argv)
291{
292	int opt;
293
294	while ((opt = getopt(argc, argv, "b:c:d:f:ns")) > 0) {
295		switch (opt) {
296			case 'b':
297			case 'c':
298			case 'f':
299				/* make sure they didn't ask for two types of lists */
300				if (part != 0) {
301					error_msg_and_die("only one type of list may be specified");
302				}
303				part = (char)opt;
304				parse_lists(optarg);
305				break;
306			case 'd':
307				if (strlen(optarg) > 1) {
308					error_msg_and_die("the delimiter must be a single character");
309				}
310				delim = optarg[0];
311				break;
312			case 'n':
313				/* no-op */
314				break;
315			case 's':
316				supress_non_delimited_lines++;
317				break;
318		}
319	}
320
321	if (part == 0) {
322		error_msg_and_die("you must specify a list of bytes, characters, or fields");
323	}
324
325	/*  non-field (char or byte) cutting has some special handling */
326	if (part != 'f') {
327		if (supress_non_delimited_lines) {
328			error_msg_and_die("suppressing non-delimited lines makes sense"
329					" only when operating on fields");
330		}
331		if (delim != '\t' && part != 'f') {
332			error_msg_and_die("a delimiter may be specified only when operating on fields");
333		}
334	}
335
336	/* argv[(optind)..(argc-1)] should be names of file to process. If no
337	 * files were specified or '-' was specified, take input from stdin.
338	 * Otherwise, we process all the files specified. */
339	if (argv[optind] == NULL || (strcmp(argv[optind], "-") == 0)) {
340		cut_file(stdin);
341	}
342	else {
343		int i;
344		FILE *file;
345		for (i = optind; i < argc; i++) {
346			file = wfopen(argv[i], "r");
347			if(file) {
348				cut_file(file);
349				fclose(file);
350			}
351		}
352	}
353
354	return EXIT_SUCCESS;
355}
356