src/expand.c

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