src/expand.c

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