home *** CD-ROM | disk | FTP | other *** search
/ PC-Online 1996 May / PCOnline_05_1996.bin / linux / source / a / txtutils / textutil.9 / textutil / textutils-1.9 / src / cut.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-06  |  15.6 KB  |  645 lines
  1. /* cut - remove parts of lines of files
  2.    Copyright (C) 1984 by David M. Ihnat
  3.  
  4.    This program is a total rewrite of the Bell Laboratories Unix(Tm)
  5.    command of the same name, as of System V.  It contains no proprietary
  6.    code, and therefore may be used without violation of any proprietary
  7.    agreements whatsoever.  However, you will notice that the program is
  8.    copyrighted by me.  This is to assure the program does *not* fall
  9.    into the public domain.  Thus, I may specify just what I am now:
  10.    This program may be freely copied and distributed, provided this notice
  11.    remains; it may not be sold for profit without express written consent of
  12.    the author.
  13.    Please note that I recreated the behavior of the Unix(Tm) 'cut' command
  14.    as faithfully as possible; however, I haven't run a full set of regression
  15.    tests.  Thus, the user of this program accepts full responsibility for any
  16.    effects or loss; in particular, the author is not responsible for any losses,
  17.    explicit or incidental, that may be incurred through use of this program.
  18.  
  19.    I ask that any bugs (and, if possible, fixes) be reported to me when
  20.    possible.  -David Ihnat (312) 784-4544 ignatz@homebru.chi.il.us
  21.  
  22.    POSIX changes, bug fixes, long-named options, and cleanup
  23.    by David MacKenzie <djm@gnu.ai.mit.edu>.
  24.  
  25.    Options:
  26.    --bytes=byte-list
  27.    -b byte-list            Print only the bytes in positions listed
  28.                 in BYTE-LIST.
  29.                 Tabs and backspaces are treated like any
  30.                 other character; they take up 1 byte.
  31.  
  32.    --characters=character-list
  33.    -c character-list        Print only characters in positions listed
  34.                 in CHARACTER-LIST.
  35.                 The same as -b for now, but
  36.                 internationalization will change that.
  37.                 Tabs and backspaces are treated like any
  38.                 other character; they take up 1 character.
  39.  
  40.    --fields=field-list
  41.    -f field-list        Print only the fields listed in FIELD-LIST.
  42.                 Fields are separated by a TAB by default.
  43.  
  44.    --delimiter=delim
  45.    -d delim            For -f, fields are separated by the first
  46.                 character in DELIM instead of TAB.
  47.  
  48.    -n                Do not split multibyte chars (no-op for now).
  49.  
  50.    --only-delimited
  51.    -s                For -f, do not print lines that do not contain
  52.                 the field separator character.
  53.  
  54.    The BYTE-LIST, CHARACTER-LIST, and FIELD-LIST are one or more numbers
  55.    or ranges separated by commas.  The first byte, character, and field
  56.    are numbered 1.
  57.  
  58.    A FILE of `-' means standard input. */
  59.  
  60. #ifdef HAVE_CONFIG_H
  61. #if defined (CONFIG_BROKETS)
  62. /* We use <config.h> instead of "config.h" so that a compilation
  63.    using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
  64.    (which it would do because it found this file in $srcdir).  */
  65. #include <config.h>
  66. #else
  67. #include "config.h"
  68. #endif
  69. #endif
  70.  
  71. /* Get isblank from GNU libc.  */
  72. #define _GNU_SOURCE
  73.  
  74. #include <stdio.h>
  75. #include <getopt.h>
  76. #include <sys/types.h>
  77. #include "system.h"
  78. #include "version.h"
  79.  
  80. char *xmalloc ();
  81. char *xrealloc ();
  82. void error ();
  83.  
  84. static int set_fields ();
  85. static int cut_file ();
  86. static void cut_stream ();
  87. static void cut_bytes ();
  88. static void cut_fields ();
  89. static void enlarge_line ();
  90. static void invalid_list ();
  91. static void usage ();
  92.  
  93. /* The number of elements allocated for the input line
  94.    and the byte or field number.
  95.    Enlarged as necessary. */
  96. static int line_size;
  97.  
  98. /* Processed output buffer. */
  99. static char *outbuf;
  100.  
  101. /* Where to save next char to output. */
  102. static char *outbufptr;
  103.  
  104. /* Raw line buffer for field mode. */
  105. static char *inbuf;
  106.  
  107. /* Where to save next input char. */
  108. static char *inbufptr;
  109.  
  110. /* What can be done about a byte or field. */
  111. enum field_action
  112. {
  113.   field_omit,
  114.   field_output
  115. };
  116.  
  117. /* In byte mode, which bytes to output.
  118.    In field mode, which `delim'-separated fields to output.
  119.    Both bytes and fields are numbered starting with 1,
  120.    so the first element of `fields' is unused. */
  121. static enum field_action *fields;
  122.  
  123. enum operating_mode
  124. {
  125.   undefined_mode,
  126.  
  127.   /* Output characters that are in the given bytes. */
  128.   byte_mode,
  129.  
  130.   /* Output the given delimeter-separated fields. */
  131.   field_mode
  132. };
  133.  
  134. /* The name this program was run with. */
  135. char *program_name;
  136.  
  137. static enum operating_mode operating_mode;
  138.  
  139. /* If nonzero,
  140.    for field mode, do not output lines containing no delimeter characters. */
  141. static int delimited_lines_only;
  142.  
  143. /* The delimeter character for field mode. */
  144. static unsigned char delim;
  145.  
  146. /* Nonzero if we have ever read standard input. */
  147. static int have_read_stdin;
  148.  
  149. /* If nonzero, this is the index of the first field in a range that goes
  150.    to end of line. */
  151. static int eol_range_start;
  152.  
  153. /* If non-zero, display usage information and exit.  */
  154. static int show_help;
  155.  
  156. /* If non-zero, print the version on standard output then exit.  */
  157. static int show_version;
  158.  
  159. static struct option const longopts[] =
  160. {
  161.   {"bytes", required_argument, 0, 'b'},
  162.   {"characters", required_argument, 0, 'c'},
  163.   {"fields", required_argument, 0, 'f'},
  164.   {"delimiter", required_argument, 0, 'd'},
  165.   {"only-delimited", no_argument, 0, 's'},
  166.   {"help", no_argument, &show_help, 1},
  167.   {"version", no_argument, &show_version, 1},
  168.   {0, 0, 0, 0}
  169. };
  170.  
  171. void
  172. main (argc, argv)
  173.      int argc;
  174.      char **argv;
  175. {
  176.   int optc, exit_status = 0;
  177.  
  178.   program_name = argv[0];
  179.  
  180.   line_size = 512;
  181.   operating_mode = undefined_mode;
  182.   delimited_lines_only = 0;
  183.   delim = '\0';
  184.   have_read_stdin = 0;
  185.  
  186.   fields = (enum field_action *)
  187.     xmalloc (line_size * sizeof (enum field_action));
  188.   outbuf = (char *) xmalloc (line_size);
  189.   inbuf = (char *) xmalloc (line_size);
  190.  
  191.   for (optc = 0; optc < line_size; optc++)
  192.     fields[optc] = field_omit;
  193.  
  194.   while ((optc = getopt_long (argc, argv, "b:c:d:f:ns", longopts, (int *) 0))
  195.      != EOF)
  196.     {
  197.       switch (optc)
  198.     {
  199.     case 0:
  200.       break;
  201.  
  202.     case 'b':
  203.     case 'c':
  204.       /* Build the byte list. */
  205.       if (operating_mode != undefined_mode)
  206.         usage (2);
  207.       operating_mode = byte_mode;
  208.       if (set_fields (optarg) == 0)
  209.         error (2, 0, "no fields given");
  210.       break;
  211.  
  212.     case 'f':
  213.       /* Build the field list. */
  214.       if (operating_mode != undefined_mode)
  215.         usage (2);
  216.       operating_mode = field_mode;
  217.       if (set_fields (optarg) == 0)
  218.         error (2, 0, "no fields given");
  219.       break;
  220.  
  221.     case 'd':
  222.       /* New delimiter. */
  223.       if (optarg[0] == '\0')
  224.         error (2, 0, "no delimiter given");
  225.       if (optarg[1] != '\0')
  226.         error (2, 0, "delimiter must be a single character");
  227.       delim = optarg[0];
  228.       break;
  229.  
  230.     case 'n':
  231.       break;
  232.  
  233.     case 's':
  234.       delimited_lines_only++;
  235.       break;
  236.  
  237.     default:
  238.       usage (2);
  239.     }
  240.     }
  241.  
  242.   if (show_version)
  243.     {
  244.       printf ("%s\n", version_string);
  245.       exit (0);
  246.     }
  247.  
  248.   if (show_help)
  249.     usage (0);
  250.  
  251.   if (operating_mode == undefined_mode)
  252.     usage (2);
  253.  
  254.   if ((delimited_lines_only || delim != '\0') && operating_mode != field_mode)
  255.     usage (2);
  256.  
  257.   if (delim == '\0')
  258.     delim = '\t';
  259.  
  260.   if (optind == argc)
  261.     exit_status |= cut_file ("-");
  262.   else
  263.     for (; optind < argc; optind++)
  264.       exit_status |= cut_file (argv[optind]);
  265.  
  266.   if (have_read_stdin && fclose (stdin) == EOF)
  267.     {
  268.       error (0, errno, "-");
  269.       exit_status = 1;
  270.     }
  271.   if (ferror (stdout) || fclose (stdout) == EOF)
  272.     error (1, errno, "write error");
  273.  
  274.   exit (exit_status);
  275. }
  276.  
  277. /* Select for printing the positions in `fields' that are listed in
  278.    byte or field specification FIELDSTR.  FIELDSTR should be
  279.    composed of one or more numbers or ranges of numbers, separated by
  280.    blanks or commas.  Incomplete ranges may be given: `-m' means
  281.    `1-m'; `n-' means `n' through end of line or last field.
  282.  
  283.    Return the number of fields selected. */
  284.  
  285. static int
  286. set_fields (fieldstr)
  287.      char *fieldstr;
  288. {
  289.   int initial = 1;        /* Value of first number in a range. */
  290.   int dash_found = 0;        /* Nonzero if a '-' is found in this field. */
  291.   int value = 0;        /* If nonzero, a number being accumulated. */
  292.   int fields_selected = 0;    /* Number of fields selected so far. */
  293.  
  294.   for (;;)
  295.     {
  296.       if (*fieldstr == '-')
  297.     {
  298.       /* Starting a range. */
  299.       if (dash_found)
  300.         invalid_list ();
  301.       dash_found++;
  302.       fieldstr++;
  303.  
  304.       if (value)
  305.         {
  306.           if (value >= line_size)
  307.         enlarge_line (value);
  308.           initial = value;
  309.           value = 0;
  310.         }
  311.       else
  312.         initial = 1;
  313.     }
  314.       else if (*fieldstr == ',' || ISBLANK (*fieldstr) || *fieldstr == '\0')
  315.     {
  316.       /* Ending the string, or this field/byte sublist. */
  317.       if (dash_found)
  318.         {
  319.           dash_found = 0;
  320.  
  321.           /* A range.  Possibilites: -n, m-n, n-.
  322.          In any case, `initial' contains the start of the range. */
  323.           if (value == 0)
  324.         {
  325.           /* `n-'.  From `initial' to end of line. */
  326.           eol_range_start = initial;
  327.           fields_selected++;
  328.         }
  329.           else
  330.         {
  331.           /* `m-n' or `-n' (1-n). */
  332.           if (value < initial)
  333.             invalid_list ();
  334.  
  335.           if (value >= line_size)
  336.             enlarge_line (value);
  337.  
  338.           /* Is there already a range going to end of line? */
  339.           if (eol_range_start != 0)
  340.             {
  341.               /* Yes.  Is the new sequence already contained
  342.              in the old one?  If so, no processing is
  343.              necessary. */
  344.               if (initial < eol_range_start)
  345.             {
  346.               /* No, the new sequence starts before the
  347.                  old.  Does the old range going to end of line
  348.                  extend into the new range?  */
  349.               if (eol_range_start < value)
  350.                 /* Yes.  Simply move the end of line marker. */
  351.                 eol_range_start = initial;
  352.               else
  353.                 {
  354.                   /* No.  A simple range, before and disjoint from
  355.                  the range going to end of line.  Fill it. */
  356.                   for (; initial <= value; initial++)
  357.                 fields[initial] = field_output;
  358.                 }
  359.  
  360.               /* In any case, some fields were selected. */
  361.               fields_selected++;
  362.             }
  363.             }
  364.           else
  365.             {
  366.               /* There is no range going to end of line. */
  367.               for (; initial <= value; initial++)
  368.             fields[initial] = field_output;
  369.               fields_selected++;
  370.             }
  371.           value = 0;
  372.         }
  373.         }
  374.       else if (value != 0)
  375.         {
  376.           /* A simple field number, not a range. */
  377.           if (value >= line_size)
  378.         enlarge_line (value);
  379.  
  380.           fields[value] = field_output;
  381.           value = 0;
  382.           fields_selected++;
  383.         }
  384.  
  385.       if (*fieldstr == '\0')
  386.         {
  387.           /* If there was a range going to end of line, fill the
  388.          array from the end of line point.  */
  389.           if (eol_range_start)
  390.         for (initial = eol_range_start; initial < line_size; initial++)
  391.           fields[initial] = field_output;
  392.  
  393.           return fields_selected;
  394.         }
  395.  
  396.       fieldstr++;
  397.     }
  398.       else if (ISDIGIT (*fieldstr))
  399.     {
  400.       value = 10 * value + *fieldstr - '0';
  401.       fieldstr++;
  402.     }
  403.       else
  404.     invalid_list ();
  405.     }
  406. }
  407.  
  408. /* Process file FILE to standard output.
  409.    Return 0 if successful, 1 if not. */
  410.  
  411. static int
  412. cut_file (file)
  413.      char *file;
  414. {
  415.   FILE *stream;
  416.  
  417.   if (!strcmp (file, "-"))
  418.     {
  419.       have_read_stdin = 1;
  420.       stream = stdin;
  421.     }
  422.   else
  423.     {
  424.       stream = fopen (file, "r");
  425.       if (stream == NULL)
  426.     {
  427.       error (0, errno, "%s", file);
  428.       return 1;
  429.     }
  430.     }
  431.  
  432.   cut_stream (stream);
  433.  
  434.   if (ferror (stream))
  435.     {
  436.       error (0, errno, "%s", file);
  437.       return 1;
  438.     }
  439.   if (!strcmp (file, "-"))
  440.     clearerr (stream);        /* Also clear EOF. */
  441.   else if (fclose (stream) == EOF)
  442.     {
  443.       error (0, errno, "%s", file);
  444.       return 1;
  445.     }
  446.   return 0;
  447. }
  448.  
  449. static void
  450. cut_stream (stream)
  451.      FILE *stream;
  452. {
  453.   if (operating_mode == byte_mode)
  454.     cut_bytes (stream);
  455.   else
  456.     cut_fields (stream);
  457. }
  458.  
  459. /* Print the file open for reading on stream STREAM
  460.    with the bytes marked `field_omit' in `fields' removed from each line. */
  461.  
  462. static void
  463. cut_bytes (stream)
  464.      FILE *stream;
  465. {
  466.   register int c;        /* Each character from the file. */
  467.   int doneflag = 0;        /* Nonzero if EOF reached. */
  468.   int char_count;        /* Number of chars in the line so far. */
  469.  
  470.   while (doneflag == 0)
  471.     {
  472.       /* Start processing a line. */
  473.       outbufptr = outbuf;
  474.       char_count = 0;
  475.  
  476.       do
  477.     {
  478.       c = getc (stream);
  479.       if (c == EOF)
  480.         {
  481.           doneflag++;
  482.           break;
  483.         }
  484.  
  485.       /* If this character is to be sent, stow it in the outbuffer. */
  486.  
  487.       if (++char_count == line_size - 1)
  488.         enlarge_line (char_count);
  489.  
  490.       if (fields[char_count] == field_output || c == '\n')
  491.         *outbufptr++ = c;
  492.     }
  493.       while (c != '\n');
  494.  
  495.       if (char_count)
  496.     fwrite (outbuf, sizeof (char), outbufptr - outbuf, stdout);
  497.     }
  498. }
  499.  
  500. /* Print the file open for reading on stream STREAM
  501.    with the fields marked `field_omit' in `fields' removed from each line.
  502.    All characters are initially stowed in the raw input buffer, until
  503.    at least one field has been found. */
  504.  
  505. static void
  506. cut_fields (stream)
  507.      FILE *stream;
  508. {
  509.   register int c;        /* Each character from the file. */
  510.   int doneflag = 0;        /* Nonzero if EOF reached. */
  511.   int char_count;        /* Number of chars in line before any delim. */
  512.   int fieldfound;        /* Nonzero if any fields to print found. */
  513.   int curr_field;        /* Current index in `fields'. */
  514.  
  515.   while (doneflag == 0)
  516.     {
  517.       char_count = 0;
  518.       fieldfound = 0;
  519.       curr_field = 1;
  520.       outbufptr = outbuf;
  521.       inbufptr = inbuf;
  522.  
  523.       do
  524.     {
  525.       c = getc (stream);
  526.       if (c == EOF)
  527.         {
  528.           doneflag++;
  529.           break;
  530.         }
  531.  
  532.       if (fields[curr_field] == field_output && c != '\n')
  533.         {
  534.           /* Working on a field.  It, and its terminating
  535.          delimiter, go only into the processed buffer. */
  536.           fieldfound = 1;
  537.           if (outbufptr - outbuf == line_size - 2)
  538.         enlarge_line (outbufptr - outbuf);
  539.           *outbufptr++ = c;
  540.         }
  541.       else if (fieldfound == 0)
  542.         {
  543.           if (++char_count == line_size - 1)
  544.         enlarge_line (char_count);
  545.           *inbufptr++ = c;
  546.         }
  547.  
  548.       if (c == delim && ++curr_field == line_size - 1)
  549.         enlarge_line (curr_field);
  550.     }
  551.       while (c != '\n');
  552.  
  553.       if (fieldfound)
  554.     {
  555.       /* Something was found. Print it. */
  556.  
  557.       if ((unsigned char) outbufptr[-1] == delim && eol_range_start == 0)
  558.         {
  559.           /* Suppress the trailing delimiter unless there is a range
  560.          extending to end of line. */
  561.           --outbufptr;
  562.         }
  563.  
  564.       fwrite (outbuf, sizeof (char), outbufptr - outbuf, stdout);
  565.       if (c == '\n')
  566.         putc (c, stdout);
  567.     }
  568.       else if (!delimited_lines_only && char_count)
  569.     /* A line with some characters, no delimiters, and no
  570.        suppression.  Print it. */
  571.     fwrite (inbuf, sizeof (char), inbufptr - inbuf, stdout);
  572.     }
  573. }
  574.  
  575. /* Extend the buffers to accomodate at least NEW_SIZE characters. */
  576.  
  577. static void
  578. enlarge_line (new_size)
  579.      int new_size;
  580. {
  581.   char *newp;
  582.   int i;
  583.  
  584.   new_size += 256;        /* Leave some room to grow. */
  585.  
  586.   fields = (enum field_action *)
  587.     xrealloc (fields, new_size * sizeof (enum field_action));
  588.  
  589.   newp = (char *) xrealloc (outbuf, new_size);
  590.   outbufptr += newp - outbuf;
  591.   outbuf = newp;
  592.  
  593.   newp = (char *) xrealloc (inbuf, new_size);
  594.   inbufptr += newp - inbuf;
  595.   inbuf = newp;
  596.  
  597.   for (i = line_size; i < new_size; i++)
  598.     fields[i] = field_omit;
  599.   line_size = new_size;
  600. }
  601.  
  602. static void
  603. invalid_list ()
  604. {
  605.   error (2, 0, "invalid byte or field list");
  606. }
  607.  
  608. static void
  609. usage (status)
  610.      int status;
  611. {
  612.   if (status != 0)
  613.     fprintf (stderr, "Try `%s --help' for more information.\n",
  614.          program_name);
  615.   else
  616.     {
  617.       printf ("\
  618. Usage: %s [OPTION]... [FILE]...\n\
  619. ",
  620.           program_name);
  621.       printf ("\
  622. \n\
  623.   -b, --bytes=LIST        output only these bytes\n\
  624.   -c, --characters=LIST   output only these characters\n\
  625.   -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter\n\
  626.   -f, --fields=LIST       output only these fields\n\
  627.   -n                      (ignored)\n\
  628.   -s, --only-delimited    do not print lines not containing delimiters\n\
  629.       --help              display this help and exit\n\
  630.       --version           output version information and exit\n\
  631. \n\
  632. Use one, and only one of -b, -c or -f.  Each LIST is made up of one\n\
  633. range, or many ranges separated by commas.  Each range is one of:\n\
  634. \n\
  635.   N     N'th byte, character or field, counted from 1\n\
  636.   N-    from N'th byte, character or field, to end of line\n\
  637.   N-M   from N'th to M'th (included) byte, character or field\n\
  638.   -M    from first to M'th (included) byte, character or field\n\
  639. \n\
  640. With no FILE, or when FILE is -, read standard input.\n\
  641. ");
  642.     }
  643.   exit (status);
  644. }
  645.