aboutsummaryrefslogtreecommitdiff
path: root/coreutils
diff options
context:
space:
mode:
authormarkw <markw@69ca8d6d-28ef-0310-b511-8ec308f3f277>2001-05-18 23:04:51 +0000
committermarkw <markw@69ca8d6d-28ef-0310-b511-8ec308f3f277>2001-05-18 23:04:51 +0000
commit7e85901690323ef4f6d6228fa5e736d26e9df72d (patch)
treec1d5f442fec6424e892066160758d985764b7ae6 /coreutils
parent5f1531b144988f02544891f96193cc785fc7c253 (diff)
downloadbusybox-w32-7e85901690323ef4f6d6228fa5e736d26e9df72d.tar.gz
busybox-w32-7e85901690323ef4f6d6228fa5e736d26e9df72d.tar.bz2
busybox-w32-7e85901690323ef4f6d6228fa5e736d26e9df72d.zip
(Almost) brand-new version of cut that supports muitiple lists of positions,
per feature request from Tom Oehser. git-svn-id: svn://busybox.net/trunk/busybox@2675 69ca8d6d-28ef-0310-b511-8ec308f3f277
Diffstat (limited to 'coreutils')
-rw-r--r--coreutils/cut.c340
1 files changed, 231 insertions, 109 deletions
diff --git a/coreutils/cut.c b/coreutils/cut.c
index 69f8010d2..abe05726b 100644
--- a/coreutils/cut.c
+++ b/coreutils/cut.c
@@ -24,8 +24,7 @@
24#include <stdlib.h> 24#include <stdlib.h>
25#include <unistd.h> /* getopt */ 25#include <unistd.h> /* getopt */
26#include <string.h> 26#include <string.h>
27#include <ctype.h> 27#include <limits.h>
28#include <errno.h>
29#include "busybox.h" 28#include "busybox.h"
30 29
31 30
@@ -34,65 +33,228 @@ extern int optind;
34extern char *optarg; 33extern char *optarg;
35 34
36 35
37/* globals in this file only */ 36/* option vars */
38static char part = 0; /* (b)yte, (c)har, (f)ields */ 37static char part = 0; /* (b)yte, (c)har, (f)ields */
39static int startpos = 1;
40static int endpos = -1;
41static char delim = '\t'; /* delimiter, default is tab */
42static unsigned int supress_non_delimited_lines = 0; 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}
43 65
44 66
45/* 67/*
46 * decompose_list() - parses a list and puts values into startpos and endpos. 68 * parse_lists() - parses a list and puts values into startpos and endpos.
47 * valid list formats: N, N-, N-M, -M 69 * valid list formats: N, N-, N-M, -M
70 * more than one list can be seperated by commas
48 */ 71 */
49static void decompose_list(const char *list) 72static void parse_lists(char *lists)
50{ 73{
51 unsigned int nminus = 0; 74 char *ltok = NULL;
52 char *ptr; 75 char *ntok = NULL;
76 char *junk;
77 int s = 0, e = 0;
53 78
54 /* the list must contain only digits and no more than one minus sign */ 79 /* take apart the lists, one by one (they are seperated with commas */
55 for (ptr = (char *)list; *ptr; ptr++) { 80 while ((ltok = strsep(&lists, ",")) != NULL) {
56 if (!isdigit(*ptr) && *ptr != '-') { 81
57 error_msg_and_die("invalid byte or field list"); 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--;
58 } 101 }
59 if (*ptr == '-') { 102
60 nminus++; 103 /* get the end pos */
61 if (nminus > 1) { 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)
62 error_msg_and_die("invalid byte or field list"); 112 error_msg_and_die("invalid byte or field list");
63 } 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;
64 } 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;
65 } 130 }
66 131
67 /* handle single value 'N' case */ 132 /* make sure we got some cut positions out of all that */
68 if (nminus == 0) { 133 if (nlists == 0)
69 startpos = strtol(list, &ptr, 10); 134 error_msg_and_die("missing list of positions");
70 if (startpos == 0) { 135
71 error_msg_and_die("missing list of fields"); 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;
72 } 160 }
73 endpos = startpos;
74 } 161 }
75 /* handle multi-value cases */ 162 putchar('\n'); /* cuz we were handed a chomped line */
76 else if (nminus == 1) { 163 free(printed);
77 /* handle 'N-' case */ 164}
78 if (last_char_is((char *)list,'-')) { 165
79 startpos = strtol(list, &ptr, 10); 166
80 } 167static void cut_line_by_fields(char *line)
81 /* handle '-M' case */ 168{
82 else if (list[0] == '-') { 169 int c, f;
83 endpos = strtol(&list[1], NULL, 10); 170 int ndelim = -1; /* zero-based / one-based problem */
84 } 171 int nfields_printed = 0;
85 /* handle 'N-M' case */ 172 char *field = NULL;
86 else { 173 char d[2] = { delim, 0 };
87 startpos = strtol(list, &ptr, 10); 174 char *printed;
88 endpos = strtol(ptr+1, &ptr, 10);
89 }
90 175
91 /* a sanity check */ 176 /* test the easy case first: does this line contain any delimiters? */
92 if (startpos == 0) { 177 if (strchr(line, delim) == NULL) {
93 startpos = 1; 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;
94 } 253 }
95 } 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);
96} 258}
97 259
98 260
@@ -101,72 +263,31 @@ static void decompose_list(const char *list)
101 */ 263 */
102static void cut_file(FILE *file) 264static void cut_file(FILE *file)
103{ 265{
104 char *line; 266 char *line = NULL;
105 unsigned int cr_hits = 0; 267 unsigned int linenum = 0; /* keep these zero-based to be consistent */
106 268
107 /* go through every line in the file */ 269 /* go through every line in the file */
108 for (line = NULL; (line = get_line_from_file(file)) != NULL; free(line)) { 270 while ((line = get_line_from_file(file)) != NULL) {
109 /* cut based on chars/bytes */ 271 chomp(line);
110 if (part == 'c' || part == 'b') { 272
111 chomp(line); 273 /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
112 if (0 < endpos && endpos < strlen(line)) 274 if (part == 'c' || part == 'b')
113 line[endpos] = '\0'; 275 cut_line_by_chars(line);
114 puts(line + startpos - 1); 276
115 }
116 /* cut based on fields */ 277 /* cut based on fields */
117 else if (part == 'f') { 278 else if (part == 'f') {
118 char *ptr; 279 if (delim == '\n')
119 char *start = line; 280 cut_file_by_lines(line, linenum);
120 unsigned int delims_hit = 0; 281 else
121 282 cut_line_by_fields(line);
122 if (delim == '\n') {
123 cr_hits++;
124 if (cr_hits >= startpos && cr_hits <= endpos) {
125 while (*start && *start != '\n') {
126 fputc(*start, stdout);
127 start++;
128 }
129 fputc('\n', stdout);
130 }
131 }
132 else {
133 for (ptr = line; (ptr = strchr(ptr, delim)) != NULL; ptr++) {
134 delims_hit++;
135 if (delims_hit == (startpos - 1)) {
136 start = ptr+1;
137 }
138 if (delims_hit == endpos) {
139 break;
140 }
141 }
142
143 /* we didn't hit any delimeters */
144 if (delims_hit == 0 && !supress_non_delimited_lines) {
145 fputs(line, stdout);
146 }
147 /* we =did= hit some delimiters */
148 else if (delims_hit > 0) {
149 /* we have a fixed end point */
150 if (ptr) {
151 while (start < ptr) {
152 fputc(*start, stdout);
153 start++;
154 }
155 fputc('\n', stdout);
156 }
157 /* or we're just going til the end of the line */
158 else {
159 while (*start) {
160 fputc(*start, stdout);
161 start++;
162 }
163 }
164 }
165 }
166 } 283 }
284
285 linenum++;
286 free(line);
167 } 287 }
168} 288}
169 289
290
170extern int cut_main(int argc, char **argv) 291extern int cut_main(int argc, char **argv)
171{ 292{
172 int opt; 293 int opt;
@@ -181,7 +302,7 @@ extern int cut_main(int argc, char **argv)
181 error_msg_and_die("only one type of list may be specified"); 302 error_msg_and_die("only one type of list may be specified");
182 } 303 }
183 part = (char)opt; 304 part = (char)opt;
184 decompose_list(optarg); 305 parse_lists(optarg);
185 break; 306 break;
186 case 'd': 307 case 'd':
187 if (strlen(optarg) > 1) { 308 if (strlen(optarg) > 1) {
@@ -202,14 +323,15 @@ extern int cut_main(int argc, char **argv)
202 error_msg_and_die("you must specify a list of bytes, characters, or fields"); 323 error_msg_and_die("you must specify a list of bytes, characters, or fields");
203 } 324 }
204 325
205 if (supress_non_delimited_lines && part != 'f') { 326 /* non-field (char or byte) cutting has some special handling */
206 error_msg_and_die("suppressing non-delimited lines makes sense" 327 if (part != 'f') {
207 " only when operating on fields"); 328 if (supress_non_delimited_lines) {
208 329 error_msg_and_die("suppressing non-delimited lines makes sense"
209 } 330 " only when operating on fields");
210 331 }
211 if (delim != '\t' && part != 'f') { 332 if (delim != '\t' && part != 'f') {
212 error_msg_and_die("a delimiter may be specified only when operating on fields"); 333 error_msg_and_die("a delimiter may be specified only when operating on fields");
334 }
213 } 335 }
214 336
215 /* argv[(optind)..(argc-1)] should be names of file to process. If no 337 /* argv[(optind)..(argc-1)] should be names of file to process. If no
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2026-02-13 21:19:49 +0000