src/expand.c

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