cut.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * cut implementation for busybox
   4  *
   5  * Copyright (c) Michael J. Holme
   6  *
   7  * This version of cut is adapted from Minix cut and was modified
   8  * by Erik Andersen <andersee@debian.org> to be used in busybox.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  *
  24  * Original copyright notice is retained at the end of this file.
  25  */
  26
  27 #include "internal.h"
  28 #include <sys/types.h>
  29 #include <ctype.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #define BB_DECLARE_EXTERN
  35 #define bb_need_help
  36 #include "messages.c"
  37
  38 #define MAX_FIELD       80                      /* Pointers to the beginning of each field
  39                                                                    * are stored in columns[], if a line holds
  40                                                                    * more than MAX_FIELD columns the array
  41                                                                    * boundary is exceed. But unlikely at 80 */
  42
  43 #define MAX_ARGS        32                      /* Maximum number of fields following -f or
  44                                                                    * -c switches                                                      */
  45 int args[MAX_ARGS * 2];
  46 int num_args;
  47
  48 /* Lots of new defines, should easen maintainance...                    */
  49 #define DUMP_STDIN      0                       /* define for mode: no options   */
  50 #define OPTIONF         1                       /* define for mode: option -f    */
  51 #define OPTIONC         2                       /* define for mode: option -c    */
  52 #define OPTIONB         3                       /* define for mode: option -b    */
  53 #define NOTSET          0                       /* option not selected       */
  54 #define SET                     1                       /* option selected       */
  55 #define OPTIONS         1                       /*define option -s */
  56 /* Defines for the warnings                                             */
  57 #define DELIMITER_NOT_APPLICABLE        0
  58 #define OVERRIDING_PREVIOUS_MODE        1
  59 #define OPTION_NOT_APPLICABLE           2
  60 #define UNKNOWN_OPTION                  3
  61 #define FILE_NOT_READABLE               4
  62 /* Defines for the fatal errors                                         */
  63 #define SYNTAX_ERROR                            101
  64 #define POSITION_ERROR                          102
  65 #define LINE_TO_LONG_ERROR                      103
  66 #define RANGE_ERROR                                     104
  67 #define MAX_FIELDS_EXEEDED_ERROR        105
  68 #define MAX_ARGS_EXEEDED_ERROR          106
  69
  70
  71 int mode;                                               /* 0 = dump stdin to stdout, 1=-f, 2=-c   */
  72 char delim = '\t';                              /* default delimiting character   */
  73 FILE *fd;
  74 char line[BUFSIZ];
  75 int exit_status;
  76 int option = 0;                                     /* for -s option */
  77
  78 int cut_main(int argc, char **argv);
  79 void warn(int warn_number, char *option);
  80 void cuterror(int err);
  81 void get_args(void);
  82 void cut(void);
  83
  84 void warn(int warn_number, char *option)
  85 {
  86         static char *warn_msg[] = {
  87                 "Option -%s allowed only with -f\n",
  88                 "-%s overrides earlier option\n",
  89                 "-%s not allowed in current mode\n",
  90                 "Cannot open %s\n"
  91         };
  92
  93         errorMsg(warn_msg[warn_number], option);
  94         exit_status = warn_number + 1;
  95
  96 }
  97
  98 void cuterror(int err)
  99 {
 100         static char *err_mes[] = {
 101                 "syntax error\n",
 102                 "position must be >0\n",
 103                 "line longer than BUFSIZ\n",
 104                 "range must not decrease from left to right\n",
 105                 "MAX_FIELD exceeded\n",
 106                 "MAX_ARGS exceeded\n"
 107         };
 108
 109         errorMsg(err_mes[err - 101]);
 110         exit(err);
 111 }
 112
 113
 114 void get_args()
 115 {
 116         int i = 0;
 117         int arg_ptr = 0;
 118         int flag;
 119
 120         num_args = 0;
 121         do {
 122                 if (num_args == MAX_ARGS)
 123                         cuterror(MAX_ARGS_EXEEDED_ERROR);
 124                 if (!isdigit(line[i]) && line[i] != '-')
 125                         cuterror(SYNTAX_ERROR);
 126
 127                 args[arg_ptr] = 1;
 128                 args[arg_ptr + 1] = BUFSIZ;
 129                 flag = 1;
 130
 131                 while (line[i] != ',' && line[i] != 0) {
 132                         if (isdigit(line[i])) {
 133                                 args[arg_ptr] = 0;
 134                                 while (isdigit(line[i]))
 135                                         args[arg_ptr] = 10 * args[arg_ptr] + line[i++] - '0';
 136                                 if (!args[arg_ptr])
 137                                         cuterror(POSITION_ERROR);
 138                                 arg_ptr++;
 139                         }
 140                         if (line[i] == '-') {
 141                                 arg_ptr |= 1;
 142                                 i++;
 143                                 flag = 0;
 144                         }
 145                 }
 146                 if (flag && arg_ptr & 1)
 147                         args[arg_ptr] = args[arg_ptr - 1];
 148                 if (args[num_args * 2] > args[num_args * 2 + 1])
 149                         cuterror(RANGE_ERROR);
 150                 num_args++;
 151                 arg_ptr = num_args * 2;
 152         }
 153         while (line[i++]);
 154 }
 155
 156
 157 void cut()
 158 {
 159         int i, j, length, maxcol=0;
 160         char *columns[MAX_FIELD];
 161
 162         while (fgets(line, BUFSIZ, fd)) {
 163                 maxcol=0;
 164                 length = strlen(line) - 1;
 165                 *(line + length) = 0;
 166                 switch (mode) {
 167                 case DUMP_STDIN:
 168                         printf("%s", line);
 169                         break;
 170                 case OPTIONF:
 171                         columns[maxcol++] = line;
 172                         for (i = 0; i < length; i++) {
 173                                 if (*(line + i) == delim) {
 174                                         *(line + i) = 0;
 175                                         if (maxcol == MAX_FIELD)
 176                                                 cuterror(MAX_FIELDS_EXEEDED_ERROR);
 177                                         columns[maxcol] = line + i + 1;
 178                                         maxcol++;
 179                                 }
 180                         }
 181                         if (maxcol != 1) {
 182                                 for (i = 0; i < num_args; i++) {
 183                                         for (j = args[i * 2]; j <= args[i * 2 + 1]; j++)
 184                                                 if (j <= maxcol) {
 185
 186                                                         printf("%s", columns[j - 1]);
 187
 188                                                         if (i != num_args - 1 || j != args[i * 2 + 1])
 189                                                                 putchar(delim);
 190                                                 }
 191                                 }
 192                         } else if (option != OPTIONS) {
 193                           printf("%s",line);
 194                         }
 195                         break;
 196                 case OPTIONC:
 197                         for (i = 0; i < num_args; i++) {
 198                                 for (j = args[i * 2];
 199                                          j <= (args[i * 2 + 1] >
 200                                                    length ? length : args[i * 2 + 1]); j++)
 201                                         putchar(*(line + j - 1));
 202                         }
 203                 }
 204                 if (maxcol != 1)
 205                         putchar('\n');
 206         }
 207 }
 208
 209
 210 int cut_main(int argc, char **argv)
 211 {
 212         int i = 1;
 213         int numberFilenames = 0;
 214
 215         if (argc == 1 || strcmp(argv[1], dash_dash_help)==0)
 216                 usage( "cut [OPTION]... [FILE]...\n"
 217 #ifndef BB_FEATURE_TRIVIAL_HELP
 218                                 "\nPrints selected fields from each input FILE to standard output.\n\n"
 219                                 "Options:\n"
 220                                 "\t-b LIST\tOutput only bytes from LIST\n"
 221                                 "\t-c LIST\tOutput only characters from LIST\n"
 222                                 "\t-d CHAR\tUse CHAR instead of tab as the field delimiter\n"
 223                                 "\t-s\tOnly output Lines if the include DELIM\n"
 224                                 "\t-f N\tPrint only these fields\n"
 225                                 "\t-n\tIgnored\n"
 226 #endif
 227                                 );
 228
 229         while (i < argc) {
 230                 if (argv[i][0] == '-') {
 231                         switch (argv[i++][1]) {
 232                         case 'd':
 233                                 if (mode == OPTIONC || mode == OPTIONB)
 234                                         warn(DELIMITER_NOT_APPLICABLE, "d");
 235                                 if (argc > i)
 236                                         delim = argv[i++][0];
 237                                 else
 238                                         cuterror(SYNTAX_ERROR);
 239                                 break;
 240                         case 'f':
 241                                 sprintf(line, "%s", argv[i++]);
 242                                 if (mode == OPTIONC || mode == OPTIONB)
 243                                         warn(OVERRIDING_PREVIOUS_MODE, "f");
 244                                 mode = OPTIONF;
 245                                 break;
 246                         case 'b':
 247                                 sprintf(line, "%s", argv[i++]);
 248                                 if (mode == OPTIONF || mode == OPTIONC)
 249                                         warn(OVERRIDING_PREVIOUS_MODE, "b");
 250                                 mode = OPTIONB;
 251                                 break;
 252                         case 'c':
 253                                 sprintf(line, "%s", argv[i++]);
 254                                 if (mode == OPTIONF || mode == OPTIONB)
 255                                         warn(OVERRIDING_PREVIOUS_MODE, "c");
 256                                 mode = OPTIONC;
 257                                 break;
 258                         case 's':
 259                                 option = OPTIONS;
 260
 261                                 break;
 262                         case '\0':                      /* - means: read from stdin      */
 263                                 numberFilenames++;
 264                                 break;
 265                         case 'n':                       /* needed for Posix, but no effect here  */
 266                                 if (mode != OPTIONB)
 267                                         warn(OPTION_NOT_APPLICABLE, "n");
 268                                 break;
 269                         default:
 270                                 warn(UNKNOWN_OPTION, &(argv[i - 1][1]));
 271                         }
 272                 } else {
 273                         i++;
 274                         numberFilenames++;
 275                 }
 276         }
 277
 278 /* Here follow the checks, if the selected options are reasonable.      */
 279         if (mode == OPTIONB)            /* since in Minix char := byte       */
 280                 mode = OPTIONC;
 281
 282         if (mode != OPTIONF && option == OPTIONS)
 283                 warn(DELIMITER_NOT_APPLICABLE,"s");
 284         get_args();
 285         if (numberFilenames != 0) {
 286                 i = 1;
 287                 while (i < argc) {
 288                         if (argv[i][0] == '-') {
 289                                 switch (argv[i][1]) {
 290                                 case 'f':
 291                                 case 'c':
 292                                 case 'b':
 293                                 case 'd':
 294                                         i += 2;
 295                                         break;
 296                                 case 'n':
 297                                 case 'i':
 298                                 case 's':
 299                                         i++;
 300                                         break;
 301                                 case '\0':
 302                                         fd = stdin;
 303                                         i++;
 304                                         cut();
 305                                         break;
 306                                 default:
 307                                         i++;
 308                                 }
 309                         } else {
 310                                 if ((fd = fopen(argv[i++], "r")) == NULL) {
 311                                         warn(FILE_NOT_READABLE, argv[i - 1]);
 312                                 } else {
 313                                         cut();
 314                                         fclose(fd);
 315                                 }
 316                         }
 317                 }
 318         } else {
 319                 fd = stdin;
 320                 cut();
 321         }
 322
 323         return(exit_status);
 324 }
 325
 326 /* cut - extract columns from a file or stdin.  Author: Michael J. Holme
 327  *
 328  *      Copyright 1989, Michael John Holme, All rights reserved.
 329  *      This code may be freely distributed, provided that this notice
 330  *      remains intact.
 331  *
 332  *      V1.1: 6th September 1989
 333  *
 334  *      Bugs, criticisms, etc,
 335  *      c/o Mark Powell
 336  *          JANET sq79@uk.ac.liv
 337  *          ARPA  sq79%liv.ac.uk@nsfnet-relay.ac.uk
 338  *          UUCP  ...!mcvax!ukc!liv.ac.uk!sq79
 339  *-------------------------------------------------------------------------
 340  *      Changed for POSIX1003.2/Draft10 conformance
 341  *      Thomas Brupbacher (tobr@mw.lpc.ethz.ch), September 1990.
 342  *      Changes:
 343  *          - separation of error messages ( stderr) and output (stdout).
 344  *          - support for -b and -n (no effect, -b acts as -c)
 345  *          - support for -s
 346  *-------------------------------------------------------------------------
 347  */
 348
 349 /*
 350  * Copyright (c) 1987,1997, Prentice Hall
 351  * All rights reserved.
 352  *
 353  * Redistribution and use of the MINIX operating system in source and
 354  * binary forms, with or without modification, are permitted provided
 355  * that the following conditions are met:
 356  *
 357  * Redistributions of source code must retain the above copyright
 358  * notice, this list of conditions and the following disclaimer.
 359  *
 360  * Redistributions in binary form must reproduce the above
 361  * copyright notice, this list of conditions and the following
 362  * disclaimer in the documentation and/or other materials provided
 363  * with the distribution.
 364  *
 365  * Neither the name of Prentice Hall nor the names of the software
 366  * authors or contributors may be used to endorse or promote
 367  * products derived from this software without specific prior
 368  * written permission.
 369  *
 370  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
 371  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 372  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 373  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 374  * IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
 375  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 376  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 377  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 378  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 379  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 380  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 381  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 382  *
 383  */
 384
 385