cut.c

   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 */
  32 extern int optind;
  33 extern char *optarg;
  34
  35
  36 /* option vars */
  37 static char part = 0; /* (b)yte, (c)har, (f)ields */
  38 static unsigned int supress_non_delimited_lines = 0;
  39 static char delim = '\t'; /* delimiter, default is tab */
  40
  41 struct cut_list {
  42         int startpos;
  43         int endpos;
  44 };
  45
  46 static const int BOL = 0;
  47 static const int EOL = INT_MAX;
  48 static const int NON_RANGE = -1;
  49
  50 static struct cut_list *cut_lists = NULL; /* growable array holding a series of lists */
  51 static unsigned int nlists = 0; /* number of elements in above list */
  52
  53
  54 static 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  */
  72 static 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
 143 static 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
 167 static 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
 223 static 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  */
 264 static 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                 /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
 274                 if (part == 'c' || part == 'b')
 275                         cut_line_by_chars(line);
 276
 277                 /* cut based on fields */
 278                 else if (part == 'f') {
 279                         if (delim == '\n')
 280                                 cut_file_by_lines(line, linenum);
 281                         else
 282                                 cut_line_by_fields(line);
 283                 }
 284
 285                 linenum++;
 286                 free(line);
 287         }
 288 }
 289
 290
 291 extern int cut_main(int argc, char **argv)
 292 {
 293         int opt;
 294
 295         while ((opt = getopt(argc, argv, "b:c:d:f:ns")) > 0) {
 296                 switch (opt) {
 297                         case 'b':
 298                         case 'c':
 299                         case 'f':
 300                                 /* make sure they didn't ask for two types of lists */
 301                                 if (part != 0) {
 302                                         error_msg_and_die("only one type of list may be specified");
 303                                 }
 304                                 part = (char)opt;
 305                                 parse_lists(optarg);
 306                                 break;
 307                         case 'd':
 308                                 if (strlen(optarg) > 1) {
 309                                         error_msg_and_die("the delimiter must be a single character");
 310                                 }
 311                                 delim = optarg[0];
 312                                 break;
 313                         case 'n':
 314                                 /* no-op */
 315                                 break;
 316                         case 's':
 317                                 supress_non_delimited_lines++;
 318                                 break;
 319                 }
 320         }
 321
 322         if (part == 0) {
 323                 error_msg_and_die("you must specify a list of bytes, characters, or fields");
 324         }
 325
 326         /*  non-field (char or byte) cutting has some special handling */
 327         if (part != 'f') {
 328                 if (supress_non_delimited_lines) {
 329                         error_msg_and_die("suppressing non-delimited lines makes sense"
 330                                         " only when operating on fields");
 331                 }
 332                 if (delim != '\t' && part != 'f') {
 333                         error_msg_and_die("a delimiter may be specified only when operating on fields");
 334                 }
 335         }
 336
 337         /* argv[(optind)..(argc-1)] should be names of file to process. If no
 338          * files were specified or '-' was specified, take input from stdin.
 339          * Otherwise, we process all the files specified. */
 340         if (argv[optind] == NULL || (strcmp(argv[optind], "-") == 0)) {
 341                 cut_file(stdin);
 342         }
 343         else {
 344                 int i;
 345                 FILE *file;
 346                 for (i = optind; i < argc; i++) {
 347                         file = fopen(argv[i], "r");
 348                         if (file == NULL) {
 349                                 perror_msg("%s", argv[i]);
 350                         } else {
 351                                 cut_file(file);
 352                                 fclose(file);
 353                         }
 354                 }
 355         }
 356
 357         return EXIT_SUCCESS;
 358 }