← Back to branch summary

~mmach/netext73/busybox

« back to all changes in this revision

Viewing changes to coreutils/cut.c

  • Committer: mmach
  • Date: 2021-04-14 13:54:24 UTC
  • Revision ID: netbit73@gmail.com-20210414135424-8x3fxf716zs4wflb
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
coreutils/cut.c
 
1
/* vi: set sw=4 ts=4: */
 
2
/*
 
3
 * cut.c - minimalist version of cut
 
4
 *
 
5
 * Copyright (C) 1999,2000,2001 by Lineo, inc.
 
6
 * Written by Mark Whitley <markw@codepoet.org>
 
7
 * debloated by Bernhard Reutner-Fischer
 
8
 *
 
9
 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
 
10
 */
 
11
//config:config CUT
 
12
//config:       bool "cut (5.8 kb)"
 
13
//config:       default y
 
14
//config:       help
 
15
//config:       cut is used to print selected parts of lines from
 
16
//config:       each file to stdout.
 
17
 
 
18
//applet:IF_CUT(APPLET_NOEXEC(cut, cut, BB_DIR_USR_BIN, BB_SUID_DROP, cut))
 
19
 
 
20
//kbuild:lib-$(CONFIG_CUT) += cut.o
 
21
 
 
22
//usage:#define cut_trivial_usage
 
23
//usage:       "[OPTIONS] [FILE]..."
 
24
//usage:#define cut_full_usage "\n\n"
 
25
//usage:       "Print selected fields from each input FILE to stdout\n"
 
26
//usage:     "\n        -b LIST Output only bytes from LIST"
 
27
//usage:     "\n        -c LIST Output only characters from LIST"
 
28
//usage:     "\n        -d CHAR Use CHAR instead of tab as the field delimiter"
 
29
//usage:     "\n        -s      Output only the lines containing delimiter"
 
30
//usage:     "\n        -f N    Print only these fields"
 
31
//usage:     "\n        -n      Ignored"
 
32
//usage:
 
33
//usage:#define cut_example_usage
 
34
//usage:       "$ echo \"Hello world\" | cut -f 1 -d ' '\n"
 
35
//usage:       "Hello\n"
 
36
//usage:       "$ echo \"Hello world\" | cut -f 2 -d ' '\n"
 
37
//usage:       "world\n"
 
38
 
 
39
#include "libbb.h"
 
40
 
 
41
/* This is a NOEXEC applet. Be very careful! */
 
42
 
 
43
 
 
44
/* option vars */
 
45
#define OPT_STR "b:c:f:d:sn"
 
46
#define CUT_OPT_BYTE_FLGS     (1 << 0)
 
47
#define CUT_OPT_CHAR_FLGS     (1 << 1)
 
48
#define CUT_OPT_FIELDS_FLGS   (1 << 2)
 
49
#define CUT_OPT_DELIM_FLGS    (1 << 3)
 
50
#define CUT_OPT_SUPPRESS_FLGS (1 << 4)
 
51
 
 
52
struct cut_list {
 
53
        int startpos;
 
54
        int endpos;
 
55
};
 
56
 
 
57
enum {
 
58
        BOL = 0,
 
59
        EOL = INT_MAX,
 
60
        NON_RANGE = -1
 
61
};
 
62
 
 
63
static int cmpfunc(const void *a, const void *b)
 
64
{
 
65
        return (((struct cut_list *) a)->startpos -
 
66
                        ((struct cut_list *) b)->startpos);
 
67
}
 
68
 
 
69
static void cut_file(FILE *file, char delim, const struct cut_list *cut_lists, unsigned nlists)
 
70
{
 
71
        char *line;
 
72
        unsigned linenum = 0;   /* keep these zero-based to be consistent */
 
73
 
 
74
        /* go through every line in the file */
 
75
        while ((line = xmalloc_fgetline(file)) != NULL) {
 
76
 
 
77
                /* set up a list so we can keep track of what's been printed */
 
78
                int linelen = strlen(line);
 
79
                char *printed = xzalloc(linelen + 1);
 
80
                char *orig_line = line;
 
81
                unsigned cl_pos = 0;
 
82
                int spos;
 
83
 
 
84
                /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
 
85
                if (option_mask32 & (CUT_OPT_CHAR_FLGS | CUT_OPT_BYTE_FLGS)) {
 
86
                        /* print the chars specified in each cut list */
 
87
                        for (; cl_pos < nlists; cl_pos++) {
 
88
                                spos = cut_lists[cl_pos].startpos;
 
89
                                while (spos < linelen) {
 
90
                                        if (!printed[spos]) {
 
91
                                                printed[spos] = 'X';
 
92
                                                putchar(line[spos]);
 
93
                                        }
 
94
                                        spos++;
 
95
                                        if (spos > cut_lists[cl_pos].endpos
 
96
                                        /* NON_RANGE is -1, so if below is true,
 
97
                                         * the above was true too (spos is >= 0) */
 
98
                                        /* || cut_lists[cl_pos].endpos == NON_RANGE */
 
99
                                        ) {
 
100
                                                break;
 
101
                                        }
 
102
                                }
 
103
                        }
 
104
                } else if (delim == '\n') {     /* cut by lines */
 
105
                        spos = cut_lists[cl_pos].startpos;
 
106
 
 
107
                        /* get out if we have no more lists to process or if the lines
 
108
                         * are lower than what we're interested in */
 
109
                        if (((int)linenum < spos) || (cl_pos >= nlists))
 
110
                                goto next_line;
 
111
 
 
112
                        /* if the line we're looking for is lower than the one we were
 
113
                         * passed, it means we displayed it already, so move on */
 
114
                        while (spos < (int)linenum) {
 
115
                                spos++;
 
116
                                /* go to the next list if we're at the end of this one */
 
117
                                if (spos > cut_lists[cl_pos].endpos
 
118
                                 || cut_lists[cl_pos].endpos == NON_RANGE
 
119
                                ) {
 
120
                                        cl_pos++;
 
121
                                        /* get out if there's no more lists to process */
 
122
                                        if (cl_pos >= nlists)
 
123
                                                goto next_line;
 
124
                                        spos = cut_lists[cl_pos].startpos;
 
125
                                        /* get out if the current line is lower than the one
 
126
                                         * we just became interested in */
 
127
                                        if ((int)linenum < spos)
 
128
                                                goto next_line;
 
129
                                }
 
130
                        }
 
131
 
 
132
                        /* If we made it here, it means we've found the line we're
 
133
                         * looking for, so print it */
 
134
                        puts(line);
 
135
                        goto next_line;
 
136
                } else {                /* cut by fields */
 
137
                        int ndelim = -1;        /* zero-based / one-based problem */
 
138
                        int nfields_printed = 0;
 
139
                        char *field = NULL;
 
140
                        char delimiter[2];
 
141
 
 
142
                        delimiter[0] = delim;
 
143
                        delimiter[1] = 0;
 
144
 
 
145
                        /* does this line contain any delimiters? */
 
146
                        if (strchr(line, delim) == NULL) {
 
147
                                if (!(option_mask32 & CUT_OPT_SUPPRESS_FLGS))
 
148
                                        puts(line);
 
149
                                goto next_line;
 
150
                        }
 
151
 
 
152
                        /* process each list on this line, for as long as we've got
 
153
                         * a line to process */
 
154
                        for (; cl_pos < nlists && line; cl_pos++) {
 
155
                                spos = cut_lists[cl_pos].startpos;
 
156
                                do {
 
157
                                        /* find the field we're looking for */
 
158
                                        while (line && ndelim < spos) {
 
159
                                                field = strsep(&line, delimiter);
 
160
                                                ndelim++;
 
161
                                        }
 
162
 
 
163
                                        /* we found it, and it hasn't been printed yet */
 
164
                                        if (field && ndelim == spos && !printed[ndelim]) {
 
165
                                                /* if this isn't our first time through, we need to
 
166
                                                 * print the delimiter after the last field that was
 
167
                                                 * printed */
 
168
                                                if (nfields_printed > 0)
 
169
                                                        putchar(delim);
 
170
                                                fputs(field, stdout);
 
171
                                                printed[ndelim] = 'X';
 
172
                                                nfields_printed++;      /* shouldn't overflow.. */
 
173
                                        }
 
174
 
 
175
                                        spos++;
 
176
 
 
177
                                        /* keep going as long as we have a line to work with,
 
178
                                         * this is a list, and we're not at the end of that
 
179
                                         * list */
 
180
                                } while (spos <= cut_lists[cl_pos].endpos && line
 
181
                                                && cut_lists[cl_pos].endpos != NON_RANGE);
 
182
                        }
 
183
                }
 
184
                /* if we printed anything at all, we need to finish it with a
 
185
                 * newline cuz we were handed a chomped line */
 
186
                putchar('\n');
 
187
 next_line:
 
188
                linenum++;
 
189
                free(printed);
 
190
                free(orig_line);
 
191
        }
 
192
}
 
193
 
 
194
int cut_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 
195
int cut_main(int argc UNUSED_PARAM, char **argv)
 
196
{
 
197
        /* growable array holding a series of lists */
 
198
        struct cut_list *cut_lists = NULL;
 
199
        unsigned nlists = 0;    /* number of elements in above list */
 
200
        char delim = '\t';      /* delimiter, default is tab */
 
201
        char *sopt, *ltok;
 
202
        unsigned opt;
 
203
 
 
204
        opt = getopt32(argv, "^"
 
205
                        OPT_STR
 
206
                        "\0" "b--bcf:c--bcf:f--bcf",
 
207
                        &sopt, &sopt, &sopt, &ltok
 
208
        );
 
209
//      argc -= optind;
 
210
        argv += optind;
 
211
        if (!(opt & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS)))
 
212
                bb_error_msg_and_die("expected a list of bytes, characters, or fields");
 
213
 
 
214
        if (opt & CUT_OPT_DELIM_FLGS) {
 
215
                if (ltok[0] && ltok[1]) { /* more than 1 char? */
 
216
                        bb_error_msg_and_die("the delimiter must be a single character");
 
217
                }
 
218
                delim = ltok[0];
 
219
        }
 
220
 
 
221
        /*  non-field (char or byte) cutting has some special handling */
 
222
        if (!(opt & CUT_OPT_FIELDS_FLGS)) {
 
223
                static const char _op_on_field[] ALIGN1 = " only when operating on fields";
 
224
 
 
225
                if (opt & CUT_OPT_SUPPRESS_FLGS) {
 
226
                        bb_error_msg_and_die
 
227
                                ("suppressing non-delimited lines makes sense%s",
 
228
                                _op_on_field);
 
229
                }
 
230
                if (delim != '\t') {
 
231
                        bb_error_msg_and_die
 
232
                                ("a delimiter may be specified%s", _op_on_field);
 
233
                }
 
234
        }
 
235
 
 
236
        /*
 
237
         * parse list and put values into startpos and endpos.
 
238
         * valid list formats: N, N-, N-M, -M
 
239
         * more than one list can be separated by commas
 
240
         */
 
241
        {
 
242
                char *ntok;
 
243
                int s = 0, e = 0;
 
244
 
 
245
                /* take apart the lists, one by one (they are separated with commas) */
 
246
                while ((ltok = strsep(&sopt, ",")) != NULL) {
 
247
 
 
248
                        /* it's actually legal to pass an empty list */
 
249
                        if (!ltok[0])
 
250
                                continue;
 
251
 
 
252
                        /* get the start pos */
 
253
                        ntok = strsep(&ltok, "-");
 
254
                        if (!ntok[0]) {
 
255
                                s = BOL;
 
256
                        } else {
 
257
                                s = xatoi_positive(ntok);
 
258
                                /* account for the fact that arrays are zero based, while
 
259
                                 * the user expects the first char on the line to be char #1 */
 
260
                                if (s != 0)
 
261
                                        s--;
 
262
                        }
 
263
 
 
264
                        /* get the end pos */
 
265
                        if (ltok == NULL) {
 
266
                                e = NON_RANGE;
 
267
                        } else if (!ltok[0]) {
 
268
                                e = EOL;
 
269
                        } else {
 
270
                                e = xatoi_positive(ltok);
 
271
                                /* if the user specified and end position of 0,
 
272
                                 * that means "til the end of the line" */
 
273
                                if (e == 0)
 
274
                                        e = EOL;
 
275
                                e--;    /* again, arrays are zero based, lines are 1 based */
 
276
                                if (e == s)
 
277
                                        e = NON_RANGE;
 
278
                        }
 
279
 
 
280
                        /* add the new list */
 
281
                        cut_lists = xrealloc_vector(cut_lists, 4, nlists);
 
282
                        /* NB: startpos is always >= 0,
 
283
                         * while endpos may be = NON_RANGE (-1) */
 
284
                        cut_lists[nlists].startpos = s;
 
285
                        cut_lists[nlists].endpos = e;
 
286
                        nlists++;
 
287
                }
 
288
 
 
289
                /* make sure we got some cut positions out of all that */
 
290
                if (nlists == 0)
 
291
                        bb_error_msg_and_die("missing list of positions");
 
292
 
 
293
                /* now that the lists are parsed, we need to sort them to make life
 
294
                 * easier on us when it comes time to print the chars / fields / lines
 
295
                 */
 
296
                qsort(cut_lists, nlists, sizeof(cut_lists[0]), cmpfunc);
 
297
        }
 
298
 
 
299
        {
 
300
                int retval = EXIT_SUCCESS;
 
301
 
 
302
                if (!*argv)
 
303
                        *--argv = (char *)"-";
 
304
 
 
305
                do {
 
306
                        FILE *file = fopen_or_warn_stdin(*argv);
 
307
                        if (!file) {
 
308
                                retval = EXIT_FAILURE;
 
309
                                continue;
 
310
                        }
 
311
                        cut_file(file, delim, cut_lists, nlists);
 
312
                        fclose_if_not_stdin(file);
 
313
                } while (*++argv);
 
314
 
 
315
                if (ENABLE_FEATURE_CLEAN_UP)
 
316
                        free(cut_lists);
 
317
                fflush_stdout_and_exit(retval);
 
318
        }
 
319
}