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