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