src/expand.c

   1 /* expand - convert tabs to spaces
   2    Copyright (C) 89, 91, 1995-2002 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* By default, convert all tabs to spaces.
  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                         spaces apart instead of the default 8.  Otherwise,
  28                         set the tabs at columns tab1, tab2, etc. (numbered from
  29                         0); replace any tabs beyond the tabstops given with
  30                         single spaces.
  31    --initial
  32    -i                   Only convert initial tabs on each line to spaces.
  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 "closeout.h"
  43 #include "error.h"
  44
  45 /* The official name of this program (e.g., no `g' prefix).  */
  46 #define PROGRAM_NAME "expand"
  47
  48 #define AUTHORS "David MacKenzie"
  49
  50 /* The number of bytes added at a time to the amount of memory
  51    allocated for the output line. */
  52 #define OUTPUT_BLOCK 256
  53
  54 /* The number of bytes added at a time to the amount of memory
  55    allocated for the list of tabstops. */
  56 #define TABLIST_BLOCK 256
  57
  58 /* The name this program was run with. */
  59 char *program_name;
  60
  61 /* If nonzero, convert blanks even after nonblank characters have been
  62    read on the line. */
  63 static int convert_entire_line;
  64
  65 /* If nonzero, the size of all tab stops.  If zero, use `tab_list' instead. */
  66 static int tab_size;
  67
  68 /* Array of the explicit column numbers of the tab stops;
  69    after `tab_list' is exhausted, each additional tab is replaced
  70    by a space.  The first column is column 0. */
  71 static int *tab_list;
  72
  73 /* The index of the first invalid element of `tab_list',
  74    where the next element can be added. */
  75 static int first_free_tab;
  76
  77 /* Null-terminated array of input filenames. */
  78 static char **file_list;
  79
  80 /* Default for `file_list' if no files are given on the command line. */
  81 static char *stdin_argv[] =
  82 {
  83   "-", NULL
  84 };
  85
  86 /* Nonzero if we have ever read standard input. */
  87 static int have_read_stdin;
  88
  89 /* Status to return to the system. */
  90 static int exit_status;
  91
  92 static char const shortopts[] = "it:"
  93 #if POSIX2_VERSION < 200112
  94 ",0123456789"
  95 #endif
  96 ;
  97
  98 static struct option const longopts[] =
  99 {
 100   {"tabs", required_argument, NULL, 't'},
 101   {"initial", no_argument, NULL, 'i'},
 102   {GETOPT_HELP_OPTION_DECL},
 103   {GETOPT_VERSION_OPTION_DECL},
 104   {NULL, 0, NULL, 0}
 105 };
 106
 107 void
 108 usage (int status)
 109 {
 110   if (status != 0)
 111     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 112              program_name);
 113   else
 114     {
 115       printf (_("\
 116 Usage: %s [OPTION]... [FILE]...\n\
 117 "),
 118               program_name);
 119       fputs (_("\
 120 Convert tabs in each FILE to spaces, writing to standard output.\n\
 121 With no FILE, or when FILE is -, read standard input.\n\
 122 \n\
 123 "), stdout);
 124       fputs (_("\
 125 Mandatory arguments to long options are mandatory for short options too.\n\
 126 "), stdout);
 127       fputs (_("\
 128   -i, --initial       do not convert TABs after non whitespace\n\
 129   -t, --tabs=NUMBER   have tabs NUMBER characters apart, not 8\n\
 130 "), stdout);
 131       fputs (_("\
 132   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 133 "), stdout);
 134       fputs (HELP_OPTION_DESCRIPTION, stdout);
 135       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 136       if (POSIX2_VERSION < 200112)
 137         fputs (_("\
 138 \n\
 139 (obsolete) Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
 140 "), stdout);
 141       puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
 142     }
 143   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 144 }
 145
 146 /* Add tab stop TABVAL to the end of `tab_list', except
 147    if TABVAL is -1, do nothing. */
 148
 149 static void
 150 add_tabstop (int tabval)
 151 {
 152   if (tabval == -1)
 153     return;
 154   if (first_free_tab % TABLIST_BLOCK == 0)
 155     tab_list = (int *) xrealloc ((char *) tab_list,
 156                                  (first_free_tab
 157                                   + TABLIST_BLOCK * sizeof (tab_list[0])));
 158   tab_list[first_free_tab++] = tabval;
 159 }
 160
 161 /* Add the comma or blank separated list of tabstops STOPS
 162    to the list of tabstops. */
 163
 164 static void
 165 parse_tabstops (char *stops)
 166 {
 167   int tabval = -1;
 168
 169   for (; *stops; stops++)
 170     {
 171       if (*stops == ',' || ISBLANK (*stops))
 172         {
 173           add_tabstop (tabval);
 174           tabval = -1;
 175         }
 176       else if (ISDIGIT (*stops))
 177         {
 178           if (tabval == -1)
 179             tabval = 0;
 180           tabval = tabval * 10 + *stops - '0';
 181         }
 182       else
 183         error (EXIT_FAILURE, 0, _("tab size contains an invalid character"));
 184     }
 185
 186   add_tabstop (tabval);
 187 }
 188
 189 /* Check that the list of tabstops TABS, with ENTRIES entries,
 190    contains only nonzero, ascending values. */
 191
 192 static void
 193 validate_tabstops (int *tabs, int entries)
 194 {
 195   int prev_tab = 0;
 196   int i;
 197
 198   for (i = 0; i < entries; i++)
 199     {
 200       if (tabs[i] == 0)
 201         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 202       if (tabs[i] <= prev_tab)
 203         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 204       prev_tab = tabs[i];
 205     }
 206 }
 207
 208 /* Close the old stream pointer FP if it is non-NULL,
 209    and return a new one opened to read the next input file.
 210    Open a filename of `-' as the standard input.
 211    Return NULL if there are no more input files.  */
 212
 213 static FILE *
 214 next_file (FILE *fp)
 215 {
 216   static char *prev_file;
 217   char *file;
 218
 219   if (fp)
 220     {
 221       if (ferror (fp))
 222         {
 223           error (0, errno, "%s", prev_file);
 224           exit_status = 1;
 225         }
 226       if (fp == stdin)
 227         clearerr (fp);          /* Also clear EOF. */
 228       else if (fclose (fp) == EOF)
 229         {
 230           error (0, errno, "%s", prev_file);
 231           exit_status = 1;
 232         }
 233     }
 234
 235   while ((file = *file_list++) != NULL)
 236     {
 237       if (file[0] == '-' && file[1] == '\0')
 238         {
 239           have_read_stdin = 1;
 240           prev_file = file;
 241           return stdin;
 242         }
 243       fp = fopen (file, "r");
 244       if (fp)
 245         {
 246           prev_file = file;
 247           return fp;
 248         }
 249       error (0, errno, "%s", file);
 250       exit_status = 1;
 251     }
 252   return NULL;
 253 }
 254
 255 /* Change tabs to spaces, writing to stdout.
 256    Read each file in `file_list', in order. */
 257
 258 static void
 259 expand (void)
 260 {
 261   FILE *fp;                     /* Input stream. */
 262   int c;                        /* Each input character. */
 263   int tab_index = 0;            /* Index in `tab_list' of next tabstop. */
 264   int column = 0;               /* Column on screen of the next char. */
 265   int next_tab_column;          /* Column the next tab stop is on. */
 266   int convert = 1;              /* If nonzero, perform translations. */
 267
 268   fp = next_file ((FILE *) NULL);
 269   if (fp == NULL)
 270     return;
 271
 272   /* Binary I/O will preserve the original EOL style (DOS/Unix) of files.  */
 273   SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 274
 275   for (;;)
 276     {
 277       c = getc (fp);
 278       if (c == EOF)
 279         {
 280           fp = next_file (fp);
 281           if (fp == NULL)
 282             break;              /* No more files. */
 283           else
 284             {
 285               SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 286               continue;
 287             }
 288         }
 289
 290       if (c == '\n')
 291         {
 292           putchar (c);
 293           tab_index = 0;
 294           column = 0;
 295           convert = 1;
 296         }
 297       else if (c == '\t' && convert)
 298         {
 299           if (tab_size == 0)
 300             {
 301               /* Do not let tab_index == first_free_tab;
 302                  stop when it is 1 less. */
 303               while (tab_index < first_free_tab - 1
 304                      && column >= tab_list[tab_index])
 305                 tab_index++;
 306               next_tab_column = tab_list[tab_index];
 307               if (tab_index < first_free_tab - 1)
 308                 tab_index++;
 309               if (column >= next_tab_column)
 310                 next_tab_column = column + 1; /* Ran out of tab stops. */
 311             }
 312           else
 313             {
 314               next_tab_column = column + tab_size - column % tab_size;
 315             }
 316           while (column < next_tab_column)
 317             {
 318               putchar (' ');
 319               ++column;
 320             }
 321         }
 322       else
 323         {
 324           if (convert)
 325             {
 326               if (c == '\b')
 327                 {
 328                   if (column > 0)
 329                     --column;
 330                 }
 331               else
 332                 {
 333                   ++column;
 334                   if (convert_entire_line == 0)
 335                     convert = 0;
 336                 }
 337             }
 338           putchar (c);
 339         }
 340     }
 341 }
 342
 343 int
 344 main (int argc, char **argv)
 345 {
 346   int tabval = -1;              /* Value of tabstop being read, or -1. */
 347   int c;                        /* Option character. */
 348
 349   bool obsolete_tablist = false;
 350
 351   have_read_stdin = 0;
 352   exit_status = 0;
 353   convert_entire_line = 1;
 354   tab_list = NULL;
 355   first_free_tab = 0;
 356   program_name = argv[0];
 357   setlocale (LC_ALL, "");
 358   bindtextdomain (PACKAGE, LOCALEDIR);
 359   textdomain (PACKAGE);
 360
 361   atexit (close_stdout);
 362
 363   while ((c = getopt_long (argc, argv, shortopts, longopts, NULL)) != -1)
 364     {
 365       switch (c)
 366         {
 367         case 0:
 368           break;
 369
 370         default:
 371           usage (1);
 372         case 'i':
 373           convert_entire_line = 0;
 374           break;
 375         case 't':
 376           parse_tabstops (optarg);
 377           break;
 378         case_GETOPT_HELP_CHAR;
 379         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 380
 381 #if POSIX2_VERSION < 200112
 382         case ',':
 383           add_tabstop (tabval);
 384           tabval = -1;
 385           obsolete_tablist = true;
 386           break;
 387         case '0':
 388         case '1':
 389         case '2':
 390         case '3':
 391         case '4':
 392         case '5':
 393         case '6':
 394         case '7':
 395         case '8':
 396         case '9':
 397           if (tabval == -1)
 398             tabval = 0;
 399           tabval = tabval * 10 + c - '0';
 400           obsolete_tablist = true;
 401           break;
 402 #endif
 403         }
 404     }
 405
 406   if (OBSOLETE_OPTION_WARNINGS
 407       && obsolete_tablist && ! getenv ("POSIXLY_CORRECT"))
 408     error (0, 0,
 409            _("warning: `expand -TABLIST' is obsolete; use `expand -t TABLIST'"));
 410
 411   add_tabstop (tabval);
 412
 413   validate_tabstops (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   if (optind == argc)
 423     file_list = stdin_argv;
 424   else
 425     file_list = &argv[optind];
 426
 427   expand ();
 428
 429   if (have_read_stdin && fclose (stdin) == EOF)
 430     error (EXIT_FAILURE, errno, "-");
 431
 432   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 433 }