src/expand.c

   1 /* expand - convert tabs to spaces
   2    Copyright (C) 89, 91, 95, 1996 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 /* 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 "error.h"
  46
  47 /* The number of bytes added at a time to the amount of memory
  48    allocated for the output line. */
  49 #define OUTPUT_BLOCK 256
  50
  51 /* The number of bytes added at a time to the amount of memory
  52    allocated for the list of tabstops. */
  53 #define TABLIST_BLOCK 256
  54
  55 char *xmalloc ();
  56 char *xrealloc ();
  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 /* If nonzero, display usage information and exit.  */
  93 static int show_help;
  94
  95 /* If nonzero, print the version on standard output then exit.  */
  96 static int show_version;
  97
  98 static struct option const longopts[] =
  99 {
 100   {"tabs", required_argument, NULL, 't'},
 101   {"initial", no_argument, NULL, 'i'},
 102   {"help", no_argument, &show_help, 1},
 103   {"version", no_argument, &show_version, 1},
 104   {NULL, 0, NULL, 0}
 105 };
 106
 107 static void
 108 usage (int status)
 109 {
 110   if (status != 0)
 111     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 112              program_name);
 113   else
 114     {
 115       printf (_("\
 116 Usage: %s [OPTION]... [FILE]...\n\
 117 "),
 118               program_name);
 119       printf (_("\
 120 Convert tabs in each FILE to spaces, writing to standard output.\n\
 121 With no FILE, or when FILE is -, read standard input.\n\
 122 \n\
 123   -i, --initial       do not convert TABs after non whitespace\n\
 124   -t, --tabs=NUMBER   have tabs NUMBER characters apart, not 8\n\
 125   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 126       --help          display this help and exit\n\
 127       --version       output version information and exit\n\
 128 \n\
 129 Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
 130 "));
 131       puts (_("\nReport bugs to textutils-bugs@gnu.ai.mit.edu"));
 132     }
 133   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 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 (EXIT_FAILURE, 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 (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 191       if (tabs[i] <= prev_tab)
 192         error (EXIT_FAILURE, 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 int
 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   setlocale (LC_ALL, "");
 338   bindtextdomain (PACKAGE, LOCALEDIR);
 339   textdomain (PACKAGE);
 340
 341   while ((c = getopt_long (argc, argv, "it:,0123456789", longopts, NULL)) != -1)
 342     {
 343       switch (c)
 344         {
 345         case 0:
 346           break;
 347
 348         case '?':
 349           usage (1);
 350         case 'i':
 351           convert_entire_line = 0;
 352           break;
 353         case 't':
 354           parse_tabstops (optarg);
 355           break;
 356         case ',':
 357           add_tabstop (tabval);
 358           tabval = -1;
 359           break;
 360         default:
 361           if (tabval == -1)
 362             tabval = 0;
 363           tabval = tabval * 10 + c - '0';
 364           break;
 365         }
 366     }
 367
 368   if (show_version)
 369     {
 370       printf ("expand (%s) %s\n", GNU_PACKAGE, VERSION);
 371       exit (EXIT_SUCCESS);
 372     }
 373
 374   if (show_help)
 375     usage (0);
 376
 377   add_tabstop (tabval);
 378
 379   validate_tabstops (tab_list, first_free_tab);
 380
 381   if (first_free_tab == 0)
 382     tab_size = 8;
 383   else if (first_free_tab == 1)
 384     tab_size = tab_list[0];
 385   else
 386     tab_size = 0;
 387
 388   if (optind == argc)
 389     file_list = stdin_argv;
 390   else
 391     file_list = &argv[optind];
 392
 393   expand ();
 394
 395   if (have_read_stdin && fclose (stdin) == EOF)
 396     error (EXIT_FAILURE, errno, "-");
 397   if (ferror (stdout) || fclose (stdout) == EOF)
 398     error (EXIT_FAILURE, errno, _("write error"));
 399
 400   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 401 }