src/expand.c

   1 /* expand - convert tabs to spaces
   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 all tabs to spaces.
  18    Preserves backspace characters in the output; they decrement the
  19    column count for tab calculations.
  20    The default action is equivalent to -8.
  21
  22    Options:
  23    --tabs=tab1[,tab2[,...]]
  24    -t tab1[,tab2[,...]]
  25    -tab1[,tab2[,...]]   If only one tab stop is given, set the tabs tab1
  26                         columns apart instead of the default 8.  Otherwise,
  27                         set the tabs at columns tab1, tab2, etc. (numbered from
  28                         0); replace any tabs beyond the tab stops given with
  29                         single spaces.
  30    --initial
  31    -i                   Only convert initial tabs on each line to spaces.
  32
  33    David MacKenzie <djm@gnu.ai.mit.edu> */
  34
  35 #include <config.h>
  36
  37 #include <stdio.h>
  38 #include <getopt.h>
  39 #include <sys/types.h>
  40 #include "system.h"
  41 #include "error.h"
  42 #include "fadvise.h"
  43 #include "quote.h"
  44 #include "xstrndup.h"
  45
  46 /* The official name of this program (e.g., no 'g' prefix).  */
  47 #define PROGRAM_NAME "expand"
  48
  49 #define AUTHORS proper_name ("David MacKenzie")
  50
  51 /* If true, convert blanks even after nonblank characters have been
  52    read on the line.  */
  53 static bool convert_entire_line;
  54
  55 /* If nonzero, the size of all tab stops.  If zero, use 'tab_list' instead.  */
  56 static uintmax_t tab_size;
  57
  58 /* Array of the explicit column numbers of the tab stops;
  59    after 'tab_list' is exhausted, each additional tab is replaced
  60    by a space.  The first column is column 0.  */
  61 static uintmax_t *tab_list;
  62
  63 /* The number of allocated entries in 'tab_list'.  */
  64 static size_t n_tabs_allocated;
  65
  66 /* The index of the first invalid element of 'tab_list',
  67    where the next element can be added.  */
  68 static size_t first_free_tab;
  69
  70 /* Null-terminated array of input filenames.  */
  71 static char **file_list;
  72
  73 /* Default for 'file_list' if no files are given on the command line.  */
  74 static char *stdin_argv[] =
  75 {
  76   (char *) "-", NULL
  77 };
  78
  79 /* True if we have ever read standard input.  */
  80 static bool have_read_stdin;
  81
  82 /* The desired exit status.  */
  83 static int exit_status;
  84
  85 static char const shortopts[] = "it:0::1::2::3::4::5::6::7::8::9::";
  86
  87 static struct option const longopts[] =
  88 {
  89   {"tabs", required_argument, NULL, 't'},
  90   {"initial", no_argument, NULL, 'i'},
  91   {GETOPT_HELP_OPTION_DECL},
  92   {GETOPT_VERSION_OPTION_DECL},
  93   {NULL, 0, NULL, 0}
  94 };
  95
  96 void
  97 usage (int status)
  98 {
  99   if (status != EXIT_SUCCESS)
 100     emit_try_help ();
 101   else
 102     {
 103       printf (_("\
 104 Usage: %s [OPTION]... [FILE]...\n\
 105 "),
 106               program_name);
 107       fputs (_("\
 108 Convert tabs in each FILE to spaces, writing to standard output.\n\
 109 With no FILE, or when FILE is -, read standard input.\n\
 110 "), stdout);
 111
 112       emit_mandatory_arg_note ();
 113
 114       fputs (_("\
 115   -i, --initial       do not convert tabs after non blanks\n\
 116   -t, --tabs=NUMBER   have tabs NUMBER characters apart, not 8\n\
 117 "), stdout);
 118       fputs (_("\
 119   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 120 "), stdout);
 121       fputs (HELP_OPTION_DESCRIPTION, stdout);
 122       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 123       emit_ancillary_info ();
 124     }
 125   exit (status);
 126 }
 127
 128 /* Add tab stop TABVAL to the end of 'tab_list'.  */
 129
 130 static void
 131 add_tab_stop (uintmax_t tabval)
 132 {
 133   if (first_free_tab == n_tabs_allocated)
 134     tab_list = X2NREALLOC (tab_list, &n_tabs_allocated);
 135   tab_list[first_free_tab++] = tabval;
 136 }
 137
 138 /* Add the comma or blank separated list of tab stops STOPS
 139    to the list of tab stops.  */
 140
 141 static void
 142 parse_tab_stops (char const *stops)
 143 {
 144   bool have_tabval = false;
 145   uintmax_t tabval IF_LINT ( = 0);
 146   char const *num_start IF_LINT ( = NULL);
 147   bool ok = true;
 148
 149   for (; *stops; stops++)
 150     {
 151       if (*stops == ',' || isblank (to_uchar (*stops)))
 152         {
 153           if (have_tabval)
 154             add_tab_stop (tabval);
 155           have_tabval = false;
 156         }
 157       else if (ISDIGIT (*stops))
 158         {
 159           if (!have_tabval)
 160             {
 161               tabval = 0;
 162               have_tabval = true;
 163               num_start = stops;
 164             }
 165
 166           /* Detect overflow.  */
 167           if (!DECIMAL_DIGIT_ACCUMULATE (tabval, *stops - '0', uintmax_t))
 168             {
 169               size_t len = strspn (num_start, "0123456789");
 170               char *bad_num = xstrndup (num_start, len);
 171               error (0, 0, _("tab stop is too large %s"), quote (bad_num));
 172               free (bad_num);
 173               ok = false;
 174               stops = num_start + len - 1;
 175             }
 176         }
 177       else
 178         {
 179           error (0, 0, _("tab size contains invalid character(s): %s"),
 180                  quote (stops));
 181           ok = false;
 182           break;
 183         }
 184     }
 185
 186   if (!ok)
 187     exit (EXIT_FAILURE);
 188
 189   if (have_tabval)
 190     add_tab_stop (tabval);
 191 }
 192
 193 /* Check that the list of tab stops TABS, with ENTRIES entries,
 194    contains only nonzero, ascending values.  */
 195
 196 static void
 197 validate_tab_stops (uintmax_t const *tabs, size_t entries)
 198 {
 199   uintmax_t prev_tab = 0;
 200   size_t i;
 201
 202   for (i = 0; i < entries; i++)
 203     {
 204       if (tabs[i] == 0)
 205         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 206       if (tabs[i] <= prev_tab)
 207         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 208       prev_tab = tabs[i];
 209     }
 210 }
 211
 212 /* Close the old stream pointer FP if it is non-NULL,
 213    and return a new one opened to read the next input file.
 214    Open a filename of '-' as the standard input.
 215    Return NULL if there are no more input files.  */
 216
 217 static FILE *
 218 next_file (FILE *fp)
 219 {
 220   static char *prev_file;
 221   char *file;
 222
 223   if (fp)
 224     {
 225       if (ferror (fp))
 226         {
 227           error (0, errno, "%s", prev_file);
 228           exit_status = EXIT_FAILURE;
 229         }
 230       if (STREQ (prev_file, "-"))
 231         clearerr (fp);          /* Also clear EOF.  */
 232       else if (fclose (fp) != 0)
 233         {
 234           error (0, errno, "%s", prev_file);
 235           exit_status = EXIT_FAILURE;
 236         }
 237     }
 238
 239   while ((file = *file_list++) != NULL)
 240     {
 241       if (STREQ (file, "-"))
 242         {
 243           have_read_stdin = true;
 244           fp = stdin;
 245         }
 246       else
 247         fp = fopen (file, "r");
 248       if (fp)
 249         {
 250           prev_file = file;
 251           fadvise (fp, FADVISE_SEQUENTIAL);
 252           return fp;
 253         }
 254       error (0, errno, "%s", file);
 255       exit_status = EXIT_FAILURE;
 256     }
 257   return NULL;
 258 }
 259
 260 /* Change tabs to spaces, writing to stdout.
 261    Read each file in 'file_list', in order.  */
 262
 263 static void
 264 expand (void)
 265 {
 266   /* Input stream.  */
 267   FILE *fp = next_file (NULL);
 268
 269   if (!fp)
 270     return;
 271
 272   while (true)
 273     {
 274       /* Input character, or EOF.  */
 275       int c;
 276
 277       /* If true, perform translations.  */
 278       bool convert = true;
 279
 280
 281       /* The following variables have valid values only when CONVERT
 282          is true:  */
 283
 284       /* Column of next input character.  */
 285       uintmax_t column = 0;
 286
 287       /* Index in TAB_LIST of next tab stop to examine.  */
 288       size_t tab_index = 0;
 289
 290
 291       /* Convert a line of text.  */
 292
 293       do
 294         {
 295           while ((c = getc (fp)) < 0 && (fp = next_file (fp)))
 296             continue;
 297
 298           if (convert)
 299             {
 300               if (c == '\t')
 301                 {
 302                   /* Column the next input tab stop is on.  */
 303                   uintmax_t next_tab_column;
 304
 305                   if (tab_size)
 306                     next_tab_column = column + (tab_size - column % tab_size);
 307                   else
 308                     while (true)
 309                       if (tab_index == first_free_tab)
 310                         {
 311                           next_tab_column = column + 1;
 312                           break;
 313                         }
 314                       else
 315                         {
 316                           uintmax_t tab = tab_list[tab_index++];
 317                           if (column < tab)
 318                             {
 319                               next_tab_column = tab;
 320                               break;
 321                             }
 322                         }
 323
 324                   if (next_tab_column < column)
 325                     error (EXIT_FAILURE, 0, _("input line is too long"));
 326
 327                   while (++column < next_tab_column)
 328                     if (putchar (' ') < 0)
 329                       error (EXIT_FAILURE, errno, _("write error"));
 330
 331                   c = ' ';
 332                 }
 333               else if (c == '\b')
 334                 {
 335                   /* Go back one column, and force recalculation of the
 336                      next tab stop.  */
 337                   column -= !!column;
 338                   tab_index -= !!tab_index;
 339                 }
 340               else
 341                 {
 342                   column++;
 343                   if (!column)
 344                     error (EXIT_FAILURE, 0, _("input line is too long"));
 345                 }
 346
 347               convert &= convert_entire_line || !! isblank (c);
 348             }
 349
 350           if (c < 0)
 351             return;
 352
 353           if (putchar (c) < 0)
 354             error (EXIT_FAILURE, errno, _("write error"));
 355         }
 356       while (c != '\n');
 357     }
 358 }
 359
 360 int
 361 main (int argc, char **argv)
 362 {
 363   int c;
 364
 365   initialize_main (&argc, &argv);
 366   set_program_name (argv[0]);
 367   setlocale (LC_ALL, "");
 368   bindtextdomain (PACKAGE, LOCALEDIR);
 369   textdomain (PACKAGE);
 370
 371   atexit (close_stdout);
 372
 373   have_read_stdin = false;
 374   exit_status = EXIT_SUCCESS;
 375   convert_entire_line = true;
 376   tab_list = NULL;
 377   first_free_tab = 0;
 378
 379   while ((c = getopt_long (argc, argv, shortopts, longopts, NULL)) != -1)
 380     {
 381       switch (c)
 382         {
 383         case 'i':
 384           convert_entire_line = false;
 385           break;
 386
 387         case 't':
 388           parse_tab_stops (optarg);
 389           break;
 390
 391         case '0': case '1': case '2': case '3': case '4':
 392         case '5': case '6': case '7': case '8': case '9':
 393           if (optarg)
 394             parse_tab_stops (optarg - 1);
 395           else
 396             {
 397               char tab_stop[2];
 398               tab_stop[0] = c;
 399               tab_stop[1] = '\0';
 400               parse_tab_stops (tab_stop);
 401             }
 402           break;
 403
 404         case_GETOPT_HELP_CHAR;
 405
 406         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 407
 408         default:
 409           usage (EXIT_FAILURE);
 410         }
 411     }
 412
 413   validate_tab_stops (tab_list, first_free_tab);
 414
 415   if (first_free_tab == 0)
 416     tab_size = 8;
 417   else if (first_free_tab == 1)
 418     tab_size = tab_list[0];
 419   else
 420     tab_size = 0;
 421
 422   file_list = (optind < argc ? &argv[optind] : stdin_argv);
 423
 424   expand ();
 425
 426   if (have_read_stdin && fclose (stdin) != 0)
 427     error (EXIT_FAILURE, errno, "-");
 428
 429   exit (exit_status);
 430 }