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