src/unexpand.c

   1 /* unexpand - convert blanks to tabs
   2    Copyright (C) 1989-2013 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 <http://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 "error.h"
  43 #include "fadvise.h"
  44 #include "quote.h"
  45 #include "xstrndup.h"
  46
  47 /* The official name of this program (e.g., no 'g' prefix).  */
  48 #define PROGRAM_NAME "unexpand"
  49
  50 #define AUTHORS proper_name ("David MacKenzie")
  51
  52 /* If true, convert blanks even after nonblank characters have been
  53    read on the line.  */
  54 static bool convert_entire_line;
  55
  56 /* If nonzero, the size of all tab stops.  If zero, use 'tab_list' instead.  */
  57 static size_t tab_size;
  58
  59 /* The maximum distance between tab stops.  */
  60 static size_t max_column_width;
  61
  62 /* Array of the explicit column numbers of the tab stops;
  63    after 'tab_list' is exhausted, the rest of the line is printed
  64    unchanged.  The first column is column 0.  */
  65 static uintmax_t *tab_list;
  66
  67 /* The number of allocated entries in 'tab_list'.  */
  68 static size_t n_tabs_allocated;
  69
  70 /* The index of the first invalid element of 'tab_list',
  71    where the next element can be added.  */
  72 static size_t first_free_tab;
  73
  74 /* Null-terminated array of input filenames.  */
  75 static char **file_list;
  76
  77 /* Default for 'file_list' if no files are given on the command line.  */
  78 static char *stdin_argv[] =
  79 {
  80   (char *) "-", NULL
  81 };
  82
  83 /* True if we have ever read standard input.  */
  84 static bool have_read_stdin;
  85
  86 /* The desired exit status.  */
  87 static int exit_status;
  88
  89 /* For long options that have no equivalent short option, use a
  90    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  91 enum
  92 {
  93   CONVERT_FIRST_ONLY_OPTION = CHAR_MAX + 1
  94 };
  95
  96 static struct option const longopts[] =
  97 {
  98   {"tabs", required_argument, NULL, 't'},
  99   {"all", no_argument, NULL, 'a'},
 100   {"first-only", no_argument, NULL, CONVERT_FIRST_ONLY_OPTION},
 101   {GETOPT_HELP_OPTION_DECL},
 102   {GETOPT_VERSION_OPTION_DECL},
 103   {NULL, 0, NULL, 0}
 104 };
 105
 106 void
 107 usage (int status)
 108 {
 109   if (status != EXIT_SUCCESS)
 110     emit_try_help ();
 111   else
 112     {
 113       printf (_("\
 114 Usage: %s [OPTION]... [FILE]...\n\
 115 "),
 116               program_name);
 117       fputs (_("\
 118 Convert blanks in each FILE to tabs, writing to standard output.\n\
 119 With no FILE, or when FILE is -, read standard input.\n\
 120 "), stdout);
 121
 122       emit_mandatory_arg_note ();
 123
 124       fputs (_("\
 125   -a, --all        convert all blanks, instead of just initial blanks\n\
 126       --first-only  convert only leading sequences of blanks (overrides -a)\n\
 127   -t, --tabs=N     have tabs N characters apart instead of 8 (enables -a)\n\
 128   -t, --tabs=LIST  use comma separated LIST of tab positions (enables -a)\n\
 129 "), stdout);
 130       fputs (HELP_OPTION_DESCRIPTION, stdout);
 131       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 132       emit_ancillary_info ();
 133     }
 134   exit (status);
 135 }
 136
 137 /* Add tab stop TABVAL to the end of 'tab_list'.  */
 138
 139 static void
 140 add_tab_stop (uintmax_t tabval)
 141 {
 142   uintmax_t prev_column = first_free_tab ? tab_list[first_free_tab - 1] : 0;
 143   uintmax_t column_width = prev_column <= tabval ? tabval - prev_column : 0;
 144
 145   if (first_free_tab == n_tabs_allocated)
 146     tab_list = X2NREALLOC (tab_list, &n_tabs_allocated);
 147   tab_list[first_free_tab++] = tabval;
 148
 149   if (max_column_width < column_width)
 150     {
 151       if (SIZE_MAX < column_width)
 152         error (EXIT_FAILURE, 0, _("tabs are too far apart"));
 153       max_column_width = column_width;
 154     }
 155 }
 156
 157 /* Add the comma or blank separated list of tab stops STOPS
 158    to the list of tab stops.  */
 159
 160 static void
 161 parse_tab_stops (char const *stops)
 162 {
 163   bool have_tabval = false;
 164   uintmax_t tabval IF_LINT ( = 0);
 165   char const *num_start IF_LINT ( = NULL);
 166   bool ok = true;
 167
 168   for (; *stops; stops++)
 169     {
 170       if (*stops == ',' || isblank (to_uchar (*stops)))
 171         {
 172           if (have_tabval)
 173             add_tab_stop (tabval);
 174           have_tabval = false;
 175         }
 176       else if (ISDIGIT (*stops))
 177         {
 178           if (!have_tabval)
 179             {
 180               tabval = 0;
 181               have_tabval = true;
 182               num_start = stops;
 183             }
 184
 185           /* Detect overflow.  */
 186           if (!DECIMAL_DIGIT_ACCUMULATE (tabval, *stops - '0', uintmax_t))
 187             {
 188               size_t len = strspn (num_start, "0123456789");
 189               char *bad_num = xstrndup (num_start, len);
 190               error (0, 0, _("tab stop is too large %s"), quote (bad_num));
 191               free (bad_num);
 192               ok = false;
 193               stops = num_start + len - 1;
 194             }
 195         }
 196       else
 197         {
 198           error (0, 0, _("tab size contains invalid character(s): %s"),
 199                  quote (stops));
 200           ok = false;
 201           break;
 202         }
 203     }
 204
 205   if (!ok)
 206     exit (EXIT_FAILURE);
 207
 208   if (have_tabval)
 209     add_tab_stop (tabval);
 210 }
 211
 212 /* Check that the list of tab stops TABS, with ENTRIES entries,
 213    contains only nonzero, ascending values.  */
 214
 215 static void
 216 validate_tab_stops (uintmax_t const *tabs, size_t entries)
 217 {
 218   uintmax_t prev_tab = 0;
 219   size_t i;
 220
 221   for (i = 0; i < entries; i++)
 222     {
 223       if (tabs[i] == 0)
 224         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 225       if (tabs[i] <= prev_tab)
 226         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 227       prev_tab = tabs[i];
 228     }
 229 }
 230
 231 /* Close the old stream pointer FP if it is non-NULL,
 232    and return a new one opened to read the next input file.
 233    Open a filename of '-' as the standard input.
 234    Return NULL if there are no more input files.  */
 235
 236 static FILE *
 237 next_file (FILE *fp)
 238 {
 239   static char *prev_file;
 240   char *file;
 241
 242   if (fp)
 243     {
 244       if (ferror (fp))
 245         {
 246           error (0, errno, "%s", prev_file);
 247           exit_status = EXIT_FAILURE;
 248         }
 249       if (STREQ (prev_file, "-"))
 250         clearerr (fp);          /* Also clear EOF.  */
 251       else if (fclose (fp) != 0)
 252         {
 253           error (0, errno, "%s", prev_file);
 254           exit_status = EXIT_FAILURE;
 255         }
 256     }
 257
 258   while ((file = *file_list++) != NULL)
 259     {
 260       if (STREQ (file, "-"))
 261         {
 262           have_read_stdin = true;
 263           fp = stdin;
 264         }
 265       else
 266         fp = fopen (file, "r");
 267       if (fp)
 268         {
 269           prev_file = file;
 270           fadvise (fp, FADVISE_SEQUENTIAL);
 271           return fp;
 272         }
 273       error (0, errno, "%s", file);
 274       exit_status = EXIT_FAILURE;
 275     }
 276   return NULL;
 277 }
 278
 279 /* Change blanks to tabs, writing to stdout.
 280    Read each file in 'file_list', in order.  */
 281
 282 static void
 283 unexpand (void)
 284 {
 285   /* Input stream.  */
 286   FILE *fp = next_file (NULL);
 287
 288   /* The array of pending blanks.  In non-POSIX locales, blanks can
 289      include characters other than spaces, so the blanks must be
 290      stored, not merely counted.  */
 291   char *pending_blank;
 292
 293   if (!fp)
 294     return;
 295
 296   /* The worst case is a non-blank character, then one blank, then a
 297      tab stop, then MAX_COLUMN_WIDTH - 1 blanks, then a non-blank; so
 298      allocate MAX_COLUMN_WIDTH bytes to store the blanks.  */
 299   pending_blank = xmalloc (max_column_width);
 300
 301   while (true)
 302     {
 303       /* Input character, or EOF.  */
 304       int c;
 305
 306       /* If true, perform translations.  */
 307       bool convert = true;
 308
 309
 310       /* The following variables have valid values only when CONVERT
 311          is true:  */
 312
 313       /* Column of next input character.  */
 314       uintmax_t column = 0;
 315
 316       /* Column the next input tab stop is on.  */
 317       uintmax_t next_tab_column = 0;
 318
 319       /* Index in TAB_LIST of next tab stop to examine.  */
 320       size_t tab_index = 0;
 321
 322       /* If true, the first pending blank came just before a tab stop.  */
 323       bool one_blank_before_tab_stop = false;
 324
 325       /* If true, the previous input character was a blank.  This is
 326          initially true, since initial strings of blanks are treated
 327          as if the line was preceded by a blank.  */
 328       bool prev_blank = true;
 329
 330       /* Number of pending columns of blanks.  */
 331       size_t pending = 0;
 332
 333
 334       /* Convert a line of text.  */
 335
 336       do
 337         {
 338           while ((c = getc (fp)) < 0 && (fp = next_file (fp)))
 339             continue;
 340
 341           if (convert)
 342             {
 343               bool blank = !! isblank (c);
 344
 345               if (blank)
 346                 {
 347                   if (next_tab_column <= column)
 348                     {
 349                       if (tab_size)
 350                         next_tab_column =
 351                           column + (tab_size - column % tab_size);
 352                       else
 353                         while (true)
 354                           if (tab_index == first_free_tab)
 355                             {
 356                               convert = false;
 357                               break;
 358                             }
 359                           else
 360                             {
 361                               uintmax_t tab = tab_list[tab_index++];
 362                               if (column < tab)
 363                                 {
 364                                   next_tab_column = tab;
 365                                   break;
 366                                 }
 367                             }
 368                     }
 369
 370                   if (convert)
 371                     {
 372                       if (next_tab_column < column)
 373                         error (EXIT_FAILURE, 0, _("input line is too long"));
 374
 375                       if (c == '\t')
 376                         {
 377                           column = next_tab_column;
 378
 379                           if (pending)
 380                             pending_blank[0] = '\t';
 381                         }
 382                       else
 383                         {
 384                           column++;
 385
 386                           if (! (prev_blank && column == next_tab_column))
 387                             {
 388                               /* It is not yet known whether the pending blanks
 389                                  will be replaced by tabs.  */
 390                               if (column == next_tab_column)
 391                                 one_blank_before_tab_stop = true;
 392                               pending_blank[pending++] = c;
 393                               prev_blank = true;
 394                               continue;
 395                             }
 396
 397                           /* Replace the pending blanks by a tab or two.  */
 398                           pending_blank[0] = c = '\t';
 399                         }
 400
 401                       /* Discard pending blanks, unless it was a single
 402                          blank just before the previous tab stop.  */
 403                       pending = one_blank_before_tab_stop;
 404                     }
 405                 }
 406               else if (c == '\b')
 407                 {
 408                   /* Go back one column, and force recalculation of the
 409                      next tab stop.  */
 410                   column -= !!column;
 411                   next_tab_column = column;
 412                   tab_index -= !!tab_index;
 413                 }
 414               else
 415                 {
 416                   column++;
 417                   if (!column)
 418                     error (EXIT_FAILURE, 0, _("input line is too long"));
 419                 }
 420
 421               if (pending)
 422                 {
 423                   if (pending > 1 && one_blank_before_tab_stop)
 424                     pending_blank[0] = '\t';
 425                   if (fwrite (pending_blank, 1, pending, stdout) != pending)
 426                     error (EXIT_FAILURE, errno, _("write error"));
 427                   pending = 0;
 428                   one_blank_before_tab_stop = false;
 429                 }
 430
 431               prev_blank = blank;
 432               convert &= convert_entire_line || blank;
 433             }
 434
 435           if (c < 0)
 436             {
 437               free (pending_blank);
 438               return;
 439             }
 440
 441           if (putchar (c) < 0)
 442             error (EXIT_FAILURE, errno, _("write error"));
 443         }
 444       while (c != '\n');
 445     }
 446 }
 447
 448 int
 449 main (int argc, char **argv)
 450 {
 451   bool have_tabval = false;
 452   uintmax_t tabval IF_LINT ( = 0);
 453   int c;
 454
 455   /* If true, cancel the effect of any -a (explicit or implicit in -t),
 456      so that only leading blanks will be considered.  */
 457   bool convert_first_only = false;
 458
 459   initialize_main (&argc, &argv);
 460   set_program_name (argv[0]);
 461   setlocale (LC_ALL, "");
 462   bindtextdomain (PACKAGE, LOCALEDIR);
 463   textdomain (PACKAGE);
 464
 465   atexit (close_stdout);
 466
 467   have_read_stdin = false;
 468   exit_status = EXIT_SUCCESS;
 469   convert_entire_line = false;
 470   tab_list = NULL;
 471   first_free_tab = 0;
 472
 473   while ((c = getopt_long (argc, argv, ",0123456789at:", longopts, NULL))
 474          != -1)
 475     {
 476       switch (c)
 477         {
 478         case '?':
 479           usage (EXIT_FAILURE);
 480         case 'a':
 481           convert_entire_line = true;
 482           break;
 483         case 't':
 484           convert_entire_line = true;
 485           parse_tab_stops (optarg);
 486           break;
 487         case CONVERT_FIRST_ONLY_OPTION:
 488           convert_first_only = true;
 489           break;
 490         case ',':
 491           if (have_tabval)
 492             add_tab_stop (tabval);
 493           have_tabval = false;
 494           break;
 495         case_GETOPT_HELP_CHAR;
 496         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 497         default:
 498           if (!have_tabval)
 499             {
 500               tabval = 0;
 501               have_tabval = true;
 502             }
 503           if (!DECIMAL_DIGIT_ACCUMULATE (tabval, c - '0', uintmax_t))
 504             error (EXIT_FAILURE, 0, _("tab stop value is too large"));
 505           break;
 506         }
 507     }
 508
 509   if (convert_first_only)
 510     convert_entire_line = false;
 511
 512   if (have_tabval)
 513     add_tab_stop (tabval);
 514
 515   validate_tab_stops (tab_list, first_free_tab);
 516
 517   if (first_free_tab == 0)
 518     tab_size = max_column_width = 8;
 519   else if (first_free_tab == 1)
 520     tab_size = tab_list[0];
 521   else
 522     tab_size = 0;
 523
 524   file_list = (optind < argc ? &argv[optind] : stdin_argv);
 525
 526   unexpand ();
 527
 528   if (have_read_stdin && fclose (stdin) != 0)
 529     error (EXIT_FAILURE, errno, "-");
 530
 531   exit (exit_status);
 532 }