src/expand.c

   1 /* expand - convert tabs to spaces
   2    Copyright (C) 89, 91, 1995-2000 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 struct option const longopts[] =
  93 {
  94   {"tabs", required_argument, NULL, 't'},
  95   {"initial", no_argument, NULL, 'i'},
  96   {GETOPT_HELP_OPTION_DECL},
  97   {GETOPT_VERSION_OPTION_DECL},
  98   {NULL, 0, NULL, 0}
  99 };
 100
 101 void
 102 usage (int status)
 103 {
 104   if (status != 0)
 105     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 106              program_name);
 107   else
 108     {
 109       printf (_("\
 110 Usage: %s [OPTION]... [FILE]...\n\
 111 "),
 112               program_name);
 113       printf (_("\
 114 Convert tabs in each FILE to spaces, writing to standard output.\n\
 115 With no FILE, or when FILE is -, read standard input.\n\
 116 \n\
 117   -i, --initial       do not convert TABs after non whitespace\n\
 118   -t, --tabs=NUMBER   have tabs NUMBER characters apart, not 8\n\
 119   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 120       --help          display this help and exit\n\
 121       --version       output version information and exit\n\
 122 \n\
 123 Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
 124 "));
 125       puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
 126     }
 127   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 128 }
 129
 130 /* Add tab stop TABVAL to the end of `tab_list', except
 131    if TABVAL is -1, do nothing. */
 132
 133 static void
 134 add_tabstop (int tabval)
 135 {
 136   if (tabval == -1)
 137     return;
 138   if (first_free_tab % TABLIST_BLOCK == 0)
 139     tab_list = (int *) xrealloc ((char *) tab_list,
 140                                  (first_free_tab
 141                                   + TABLIST_BLOCK * sizeof (tab_list[0])));
 142   tab_list[first_free_tab++] = tabval;
 143 }
 144
 145 /* Add the comma or blank separated list of tabstops STOPS
 146    to the list of tabstops. */
 147
 148 static void
 149 parse_tabstops (char *stops)
 150 {
 151   int tabval = -1;
 152
 153   for (; *stops; stops++)
 154     {
 155       if (*stops == ',' || ISBLANK (*stops))
 156         {
 157           add_tabstop (tabval);
 158           tabval = -1;
 159         }
 160       else if (ISDIGIT (*stops))
 161         {
 162           if (tabval == -1)
 163             tabval = 0;
 164           tabval = tabval * 10 + *stops - '0';
 165         }
 166       else
 167         error (EXIT_FAILURE, 0, _("tab size contains an invalid character"));
 168     }
 169
 170   add_tabstop (tabval);
 171 }
 172
 173 /* Check that the list of tabstops TABS, with ENTRIES entries,
 174    contains only nonzero, ascending values. */
 175
 176 static void
 177 validate_tabstops (int *tabs, int entries)
 178 {
 179   int prev_tab = 0;
 180   int i;
 181
 182   for (i = 0; i < entries; i++)
 183     {
 184       if (tabs[i] == 0)
 185         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 186       if (tabs[i] <= prev_tab)
 187         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 188       prev_tab = tabs[i];
 189     }
 190 }
 191
 192 /* Close the old stream pointer FP if it is non-NULL,
 193    and return a new one opened to read the next input file.
 194    Open a filename of `-' as the standard input.
 195    Return NULL if there are no more input files.  */
 196
 197 static FILE *
 198 next_file (FILE *fp)
 199 {
 200   static char *prev_file;
 201   char *file;
 202
 203   if (fp)
 204     {
 205       if (ferror (fp))
 206         {
 207           error (0, errno, "%s", prev_file);
 208           exit_status = 1;
 209         }
 210       if (fp == stdin)
 211         clearerr (fp);          /* Also clear EOF. */
 212       else if (fclose (fp) == EOF)
 213         {
 214           error (0, errno, "%s", prev_file);
 215           exit_status = 1;
 216         }
 217     }
 218
 219   while ((file = *file_list++) != NULL)
 220     {
 221       if (file[0] == '-' && file[1] == '\0')
 222         {
 223           have_read_stdin = 1;
 224           prev_file = file;
 225           return stdin;
 226         }
 227       fp = fopen (file, "r");
 228       if (fp)
 229         {
 230           prev_file = file;
 231           return fp;
 232         }
 233       error (0, errno, "%s", file);
 234       exit_status = 1;
 235     }
 236   return NULL;
 237 }
 238
 239 /* Change tabs to spaces, writing to stdout.
 240    Read each file in `file_list', in order. */
 241
 242 static void
 243 expand (void)
 244 {
 245   FILE *fp;                     /* Input stream. */
 246   int c;                        /* Each input character. */
 247   int tab_index = 0;            /* Index in `tab_list' of next tabstop. */
 248   int column = 0;               /* Column on screen of the next char. */
 249   int next_tab_column;          /* Column the next tab stop is on. */
 250   int convert = 1;              /* If nonzero, perform translations. */
 251
 252   fp = next_file ((FILE *) NULL);
 253   if (fp == NULL)
 254     return;
 255
 256   /* Binary I/O will preserve the original EOL style (DOS/Unix) of files.  */
 257   SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 258
 259   for (;;)
 260     {
 261       c = getc (fp);
 262       if (c == EOF)
 263         {
 264           fp = next_file (fp);
 265           if (fp == NULL)
 266             break;              /* No more files. */
 267           else
 268             {
 269               SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 270               continue;
 271             }
 272         }
 273
 274       if (c == '\n')
 275         {
 276           putchar (c);
 277           tab_index = 0;
 278           column = 0;
 279           convert = 1;
 280         }
 281       else if (c == '\t' && convert)
 282         {
 283           if (tab_size == 0)
 284             {
 285               /* Do not let tab_index == first_free_tab;
 286                  stop when it is 1 less. */
 287               while (tab_index < first_free_tab - 1
 288                      && column >= tab_list[tab_index])
 289                 tab_index++;
 290               next_tab_column = tab_list[tab_index];
 291               if (tab_index < first_free_tab - 1)
 292                 tab_index++;
 293               if (column >= next_tab_column)
 294                 next_tab_column = column + 1; /* Ran out of tab stops. */
 295             }
 296           else
 297             {
 298               next_tab_column = column + tab_size - column % tab_size;
 299             }
 300           while (column < next_tab_column)
 301             {
 302               putchar (' ');
 303               ++column;
 304             }
 305         }
 306       else
 307         {
 308           if (convert)
 309             {
 310               if (c == '\b')
 311                 {
 312                   if (column > 0)
 313                     --column;
 314                 }
 315               else
 316                 {
 317                   ++column;
 318                   if (convert_entire_line == 0)
 319                     convert = 0;
 320                 }
 321             }
 322           putchar (c);
 323         }
 324     }
 325 }
 326
 327 int
 328 main (int argc, char **argv)
 329 {
 330   int tabval = -1;              /* Value of tabstop being read, or -1. */
 331   int c;                        /* Option character. */
 332
 333   have_read_stdin = 0;
 334   exit_status = 0;
 335   convert_entire_line = 1;
 336   tab_list = NULL;
 337   first_free_tab = 0;
 338   program_name = argv[0];
 339   setlocale (LC_ALL, "");
 340   bindtextdomain (PACKAGE, LOCALEDIR);
 341   textdomain (PACKAGE);
 342
 343   atexit (close_stdout);
 344
 345   while ((c = getopt_long (argc, argv, "it:,0123456789", longopts, NULL)) != -1)
 346     {
 347       switch (c)
 348         {
 349         case 0:
 350           break;
 351
 352         case '?':
 353           usage (1);
 354         case 'i':
 355           convert_entire_line = 0;
 356           break;
 357         case 't':
 358           parse_tabstops (optarg);
 359           break;
 360         case ',':
 361           add_tabstop (tabval);
 362           tabval = -1;
 363           break;
 364         case_GETOPT_HELP_CHAR;
 365         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 366         default:
 367           if (tabval == -1)
 368             tabval = 0;
 369           tabval = tabval * 10 + c - '0';
 370           break;
 371         }
 372     }
 373
 374   add_tabstop (tabval);
 375
 376   validate_tabstops (tab_list, first_free_tab);
 377
 378   if (first_free_tab == 0)
 379     tab_size = 8;
 380   else if (first_free_tab == 1)
 381     tab_size = tab_list[0];
 382   else
 383     tab_size = 0;
 384
 385   if (optind == argc)
 386     file_list = stdin_argv;
 387   else
 388     file_list = &argv[optind];
 389
 390   expand ();
 391
 392   if (have_read_stdin && fclose (stdin) == EOF)
 393     error (EXIT_FAILURE, errno, "-");
 394
 395   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 396 }