src/unexpand.c

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