src/expand.c

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