src/expand.c

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