src/unexpand.c

   1 /* unexpand - convert blanks to tabs
   2    Copyright (C) 1989-2023 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* By default, convert only maximal strings of initial blanks and tabs
  18    into tabs.
  19    Preserves backspace characters in the output; they decrement the
  20    column count for tab calculations.
  21    The default action is equivalent to -8.
  22
  23    Options:
  24    --tabs=tab1[,tab2[,...]]
  25    -t tab1[,tab2[,...]]
  26    -tab1[,tab2[,...]]   If only one tab stop is given, set the tabs tab1
  27                         columns apart instead of the default 8.  Otherwise,
  28                         set the tabs at columns tab1, tab2, etc. (numbered from
  29                         0); preserve any blanks beyond the tab stops given.
  30    --all
  31    -a                   Use tabs wherever they would replace 2 or more blanks,
  32                         not just at the beginnings of lines.
  33
  34    David MacKenzie <djm@gnu.ai.mit.edu> */
  35
  36 #include <config.h>
  37
  38 #include <stdio.h>
  39 #include <getopt.h>
  40 #include <sys/types.h>
  41 #include "system.h"
  42 #include "expand-common.h"
  43
  44 /* The official name of this program (e.g., no 'g' prefix).  */
  45 #define PROGRAM_NAME "unexpand"
  46
  47 #define AUTHORS proper_name ("David MacKenzie")
  48
  49
  50
  51 /* For long options that have no equivalent short option, use a
  52    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  53 enum
  54 {
  55   CONVERT_FIRST_ONLY_OPTION = CHAR_MAX + 1
  56 };
  57
  58 static struct option const longopts[] =
  59 {
  60   {"tabs", required_argument, nullptr, 't'},
  61   {"all", no_argument, nullptr, 'a'},
  62   {"first-only", no_argument, nullptr, CONVERT_FIRST_ONLY_OPTION},
  63   {GETOPT_HELP_OPTION_DECL},
  64   {GETOPT_VERSION_OPTION_DECL},
  65   {nullptr, 0, nullptr, 0}
  66 };
  67
  68 void
  69 usage (int status)
  70 {
  71   if (status != EXIT_SUCCESS)
  72     emit_try_help ();
  73   else
  74     {
  75       printf (_("\
  76 Usage: %s [OPTION]... [FILE]...\n\
  77 "),
  78               program_name);
  79       fputs (_("\
  80 Convert blanks in each FILE to tabs, writing to standard output.\n\
  81 "), stdout);
  82
  83       emit_stdin_note ();
  84       emit_mandatory_arg_note ();
  85
  86       fputs (_("\
  87   -a, --all        convert all blanks, instead of just initial blanks\n\
  88       --first-only  convert only leading sequences of blanks (overrides -a)\n\
  89   -t, --tabs=N     have tabs N characters apart instead of 8 (enables -a)\n\
  90 "), stdout);
  91       emit_tab_list_info ();
  92       fputs (HELP_OPTION_DESCRIPTION, stdout);
  93       fputs (VERSION_OPTION_DESCRIPTION, stdout);
  94       emit_ancillary_info (PROGRAM_NAME);
  95     }
  96   exit (status);
  97 }
  98
  99 /* Change blanks to tabs, writing to stdout.
 100    Read each file in 'file_list', in order.  */
 101
 102 static void
 103 unexpand (void)
 104 {
 105   /* Input stream.  */
 106   FILE *fp = next_file (nullptr);
 107
 108   /* The array of pending blanks.  In non-POSIX locales, blanks can
 109      include characters other than spaces, so the blanks must be
 110      stored, not merely counted.  */
 111   char *pending_blank;
 112
 113   if (!fp)
 114     return;
 115
 116   /* The worst case is a non-blank character, then one blank, then a
 117      tab stop, then MAX_COLUMN_WIDTH - 1 blanks, then a non-blank; so
 118      allocate MAX_COLUMN_WIDTH bytes to store the blanks.  */
 119   pending_blank = xmalloc (max_column_width);
 120
 121   while (true)
 122     {
 123       /* Input character, or EOF.  */
 124       int c;
 125
 126       /* If true, perform translations.  */
 127       bool convert = true;
 128
 129
 130       /* The following variables have valid values only when CONVERT
 131          is true:  */
 132
 133       /* Column of next input character.  */
 134       uintmax_t column = 0;
 135
 136       /* Column the next input tab stop is on.  */
 137       uintmax_t next_tab_column = 0;
 138
 139       /* Index in TAB_LIST of next tab stop to examine.  */
 140       size_t tab_index = 0;
 141
 142       /* If true, the first pending blank came just before a tab stop.  */
 143       bool one_blank_before_tab_stop = false;
 144
 145       /* If true, the previous input character was a blank.  This is
 146          initially true, since initial strings of blanks are treated
 147          as if the line was preceded by a blank.  */
 148       bool prev_blank = true;
 149
 150       /* Number of pending columns of blanks.  */
 151       size_t pending = 0;
 152
 153
 154       /* Convert a line of text.  */
 155
 156       do
 157         {
 158           while ((c = getc (fp)) < 0 && (fp = next_file (fp)))
 159             continue;
 160
 161           if (convert)
 162             {
 163               bool blank = !! isblank (c);
 164
 165               if (blank)
 166                 {
 167                   bool last_tab;
 168
 169                   next_tab_column = get_next_tab_column (column, &tab_index,
 170                                                          &last_tab);
 171
 172                   if (last_tab)
 173                     convert = false;
 174
 175                   if (convert)
 176                     {
 177                       if (next_tab_column < column)
 178                         error (EXIT_FAILURE, 0, _("input line is too long"));
 179
 180                       if (c == '\t')
 181                         {
 182                           column = next_tab_column;
 183
 184                           if (pending)
 185                             pending_blank[0] = '\t';
 186                         }
 187                       else
 188                         {
 189                           column++;
 190
 191                           if (! (prev_blank && column == next_tab_column))
 192                             {
 193                               /* It is not yet known whether the pending blanks
 194                                  will be replaced by tabs.  */
 195                               if (column == next_tab_column)
 196                                 one_blank_before_tab_stop = true;
 197                               pending_blank[pending++] = c;
 198                               prev_blank = true;
 199                               continue;
 200                             }
 201
 202                           /* Replace the pending blanks by a tab or two.  */
 203                           pending_blank[0] = c = '\t';
 204                         }
 205
 206                       /* Discard pending blanks, unless it was a single
 207                          blank just before the previous tab stop.  */
 208                       pending = one_blank_before_tab_stop;
 209                     }
 210                 }
 211               else if (c == '\b')
 212                 {
 213                   /* Go back one column, and force recalculation of the
 214                      next tab stop.  */
 215                   column -= !!column;
 216                   next_tab_column = column;
 217                   tab_index -= !!tab_index;
 218                 }
 219               else
 220                 {
 221                   column++;
 222                   if (!column)
 223                     error (EXIT_FAILURE, 0, _("input line is too long"));
 224                 }
 225
 226               if (pending)
 227                 {
 228                   if (pending > 1 && one_blank_before_tab_stop)
 229                     pending_blank[0] = '\t';
 230                   if (fwrite (pending_blank, 1, pending, stdout) != pending)
 231                     write_error ();
 232                   pending = 0;
 233                   one_blank_before_tab_stop = false;
 234                 }
 235
 236               prev_blank = blank;
 237               convert &= convert_entire_line || blank;
 238             }
 239
 240           if (c < 0)
 241             {
 242               free (pending_blank);
 243               return;
 244             }
 245
 246           if (putchar (c) < 0)
 247             write_error ();
 248         }
 249       while (c != '\n');
 250     }
 251 }
 252
 253 int
 254 main (int argc, char **argv)
 255 {
 256   bool have_tabval = false;
 257   uintmax_t tabval IF_LINT ( = 0);
 258   int c;
 259
 260   /* If true, cancel the effect of any -a (explicit or implicit in -t),
 261      so that only leading blanks will be considered.  */
 262   bool convert_first_only = false;
 263
 264   initialize_main (&argc, &argv);
 265   set_program_name (argv[0]);
 266   setlocale (LC_ALL, "");
 267   bindtextdomain (PACKAGE, LOCALEDIR);
 268   textdomain (PACKAGE);
 269
 270   atexit (close_stdout);
 271
 272   while ((c = getopt_long (argc, argv, ",0123456789at:", longopts, nullptr))
 273          != -1)
 274     {
 275       switch (c)
 276         {
 277         case '?':
 278           usage (EXIT_FAILURE);
 279         case 'a':
 280           convert_entire_line = true;
 281           break;
 282         case 't':
 283           convert_entire_line = true;
 284           parse_tab_stops (optarg);
 285           break;
 286         case CONVERT_FIRST_ONLY_OPTION:
 287           convert_first_only = true;
 288           break;
 289         case ',':
 290           if (have_tabval)
 291             add_tab_stop (tabval);
 292           have_tabval = false;
 293           break;
 294         case_GETOPT_HELP_CHAR;
 295         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 296         default:
 297           if (!have_tabval)
 298             {
 299               tabval = 0;
 300               have_tabval = true;
 301             }
 302           if (!DECIMAL_DIGIT_ACCUMULATE (tabval, c - '0', uintmax_t))
 303             error (EXIT_FAILURE, 0, _("tab stop value is too large"));
 304           break;
 305         }
 306     }
 307
 308   if (convert_first_only)
 309     convert_entire_line = false;
 310
 311   if (have_tabval)
 312     add_tab_stop (tabval);
 313
 314   finalize_tab_stops ();
 315
 316   set_file_list ((optind < argc) ? &argv[optind] : nullptr);
 317
 318   unexpand ();
 319
 320   cleanup_file_list_stdin ();
 321
 322   return exit_status;
 323 }