src/unexpand.c

   1 /* unexpand - convert spaces to tabs
   2    Copyright (C) 89, 91, 95, 96, 1997, 1998 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 only maximal strings of initial blanks and tabs
  19    into tabs.
  20    Preserves backspace characters in the output; they decrement the
  21    column count for tab calculations.
  22    The default action is equivalent to -8.
  23
  24    Options:
  25    --tabs=tab1[,tab2[,...]]
  26    -t tab1[,tab2[,...]]
  27    -tab1[,tab2[,...]]   If only one tab stop is given, set the tabs tab1
  28                         spaces apart instead of the default 8.  Otherwise,
  29                         set the tabs at columns tab1, tab2, etc. (numbered from
  30                         0); replace any tabs beyond the tabstops given with
  31                         single spaces.
  32    --all
  33    -a                   Use tabs wherever they would replace 2 or more spaces,
  34                         not just at the beginnings of lines.
  35
  36    David MacKenzie <djm@gnu.ai.mit.edu> */
  37
  38 #include <config.h>
  39
  40 /* Get isblank from GNU libc.  */
  41 #define _GNU_SOURCE
  42
  43 #include <stdio.h>
  44 #include <getopt.h>
  45 #include <sys/types.h>
  46 #include "system.h"
  47
  48 #include "error.h"
  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, the rest of the line is printed
  70    unchanged.  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   {"all", no_argument, NULL, 'a'},
 102   {"help", no_argument, &show_help, 1},
 103   {"version", no_argument, &show_version, 1},
 104   {NULL, 0, NULL, 0}
 105 };
 106
 107 /* Add tab stop TABVAL to the end of `tab_list', except
 108    if TABVAL is -1, do nothing. */
 109
 110 static void
 111 add_tabstop (int tabval)
 112 {
 113   if (tabval == -1)
 114     return;
 115   if (first_free_tab % TABLIST_BLOCK == 0)
 116     tab_list = (int *) xrealloc ((char *) tab_list,
 117                                  first_free_tab + TABLIST_BLOCK);
 118   tab_list[first_free_tab++] = tabval;
 119 }
 120
 121 /* Add the comma or blank separated list of tabstops STOPS
 122    to the list of tabstops. */
 123
 124 static void
 125 parse_tabstops (const char *stops)
 126 {
 127   int tabval = -1;
 128
 129   for (; *stops; stops++)
 130     {
 131       if (*stops == ',' || ISBLANK (*stops))
 132         {
 133           add_tabstop (tabval);
 134           tabval = -1;
 135         }
 136       else if (ISDIGIT (*stops))
 137         {
 138           if (tabval == -1)
 139             tabval = 0;
 140           tabval = tabval * 10 + *stops - '0';
 141         }
 142       else
 143         error (EXIT_FAILURE, 0, _("tab size contains an invalid character"));
 144     }
 145
 146   add_tabstop (tabval);
 147 }
 148
 149 /* Check that the list of tabstops TABS, with ENTRIES entries,
 150    contains only nonzero, ascending values. */
 151
 152 static void
 153 validate_tabstops (const int *tabs, int entries)
 154 {
 155   int prev_tab = 0;
 156   int i;
 157
 158   for (i = 0; i < entries; i++)
 159     {
 160       if (tabs[i] == 0)
 161         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 162       if (tabs[i] <= prev_tab)
 163         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 164       prev_tab = tabs[i];
 165     }
 166 }
 167
 168 /* Close the old stream pointer FP if it is non-NULL,
 169    and return a new one opened to read the next input file.
 170    Open a filename of `-' as the standard input.
 171    Return NULL if there are no more input files.  */
 172
 173 static FILE *
 174 next_file (FILE *fp)
 175 {
 176   static char *prev_file;
 177   char *file;
 178
 179   if (fp)
 180     {
 181       if (ferror (fp))
 182         {
 183           error (0, errno, "%s", prev_file);
 184           exit_status = 1;
 185         }
 186       if (fp == stdin)
 187         clearerr (fp);          /* Also clear EOF. */
 188       else if (fclose (fp) == EOF)
 189         {
 190           error (0, errno, "%s", prev_file);
 191           exit_status = 1;
 192         }
 193     }
 194
 195   while ((file = *file_list++) != NULL)
 196     {
 197       if (file[0] == '-' && file[1] == '\0')
 198         {
 199           have_read_stdin = 1;
 200           prev_file = file;
 201           return stdin;
 202         }
 203       fp = fopen (file, "r");
 204       if (fp)
 205         {
 206           prev_file = file;
 207           return fp;
 208         }
 209       error (0, errno, "%s", file);
 210       exit_status = 1;
 211     }
 212   return NULL;
 213 }
 214
 215 /* Change spaces to tabs, writing to stdout.
 216    Read each file in `file_list', in order. */
 217
 218 static void
 219 unexpand (void)
 220 {
 221   FILE *fp;                     /* Input stream. */
 222   int c;                        /* Each input character. */
 223   /* Index in `tab_list' of next tabstop: */
 224   int tab_index = 0;            /* For calculating width of pending tabs. */
 225   int print_tab_index = 0;      /* For printing as many tabs as possible. */
 226   int column = 0;               /* Column on screen of next char. */
 227   int next_tab_column;          /* Column the next tab stop is on. */
 228   int convert = 1;              /* If nonzero, perform translations. */
 229   int pending = 0;              /* Pending columns of blanks. */
 230
 231   fp = next_file ((FILE *) NULL);
 232   if (fp == NULL)
 233     return;
 234
 235   for (;;)
 236     {
 237       c = getc (fp);
 238
 239       if (c == ' ' && convert)
 240         {
 241           ++pending;
 242           ++column;
 243         }
 244       else if (c == '\t' && convert)
 245         {
 246           if (tab_size == 0)
 247             {
 248               /* Do not let tab_index == first_free_tab;
 249                  stop when it is 1 less. */
 250               while (tab_index < first_free_tab - 1
 251                      && column >= tab_list[tab_index])
 252                 tab_index++;
 253               next_tab_column = tab_list[tab_index];
 254               if (tab_index < first_free_tab - 1)
 255                 tab_index++;
 256               if (column >= next_tab_column)
 257                 {
 258                   convert = 0;  /* Ran out of tab stops. */
 259                   goto flush_pend;
 260                 }
 261             }
 262           else
 263             {
 264               next_tab_column = column + tab_size - column % tab_size;
 265             }
 266           pending += next_tab_column - column;
 267           column = next_tab_column;
 268         }
 269       else
 270         {
 271         flush_pend:
 272           /* Flush pending spaces.  Print as many tabs as possible,
 273              then print the rest as spaces. */
 274           if (pending == 1)
 275             {
 276               putchar (' ');
 277               pending = 0;
 278             }
 279           column -= pending;
 280           while (pending != 0)
 281             {
 282               if (tab_size == 0)
 283                 {
 284                   /* Do not let print_tab_index == first_free_tab;
 285                      stop when it is 1 less. */
 286                   while (print_tab_index < first_free_tab - 1
 287                          && column >= tab_list[print_tab_index])
 288                     print_tab_index++;
 289                   next_tab_column = tab_list[print_tab_index];
 290                   if (print_tab_index < first_free_tab - 1)
 291                     print_tab_index++;
 292                 }
 293               else
 294                 {
 295                   next_tab_column = column + tab_size - column % tab_size;
 296                 }
 297               if (next_tab_column - column <= pending)
 298                 {
 299                   putchar ('\t');
 300                   pending -= next_tab_column - column;
 301                   column = next_tab_column;
 302                 }
 303               else
 304                 {
 305                   --print_tab_index;
 306                   column += pending;
 307                   while (pending != 0)
 308                     {
 309                       putchar (' ');
 310                       pending--;
 311                     }
 312                 }
 313             }
 314
 315           if (c == EOF)
 316             {
 317               fp = next_file (fp);
 318               if (fp == NULL)
 319                 break;          /* No more files. */
 320               else
 321                 continue;
 322             }
 323
 324           if (convert)
 325             {
 326               if (c == '\b')
 327                 {
 328                   if (column > 0)
 329                     --column;
 330                 }
 331               else
 332                 {
 333                   ++column;
 334                   if (convert_entire_line == 0)
 335                     convert = 0;
 336                 }
 337             }
 338
 339           putchar (c);
 340
 341           if (c == '\n')
 342             {
 343               tab_index = print_tab_index = 0;
 344               column = pending = 0;
 345               convert = 1;
 346             }
 347         }
 348     }
 349 }
 350
 351 static void
 352 usage (int status)
 353 {
 354   if (status != 0)
 355     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 356              program_name);
 357   else
 358     {
 359       printf (_("\
 360 Usage: %s [OPTION]... [FILE]...\n\
 361 "),
 362               program_name);
 363       printf (_("\
 364 Convert spaces in each FILE to tabs, writing to standard output.\n\
 365 With no FILE, or when FILE is -, read standard input.\n\
 366 \n\
 367   -a, --all           convert all whitespace, instead of initial whitespace\n\
 368   -t, --tabs=NUMBER   have tabs NUMBER characters apart instead of 8\n\
 369   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 370       --help          display this help and exit\n\
 371       --version       output version information and exit\n\
 372 \n\
 373 Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
 374 "));
 375       puts (_("\nReport bugs to <textutils-bugs@gnu.org>."));
 376     }
 377   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 378 }
 379
 380 int
 381 main (int argc, char **argv)
 382 {
 383   int tabval = -1;              /* Value of tabstop being read, or -1. */
 384   int c;                        /* Option character. */
 385
 386   program_name = argv[0];
 387   setlocale (LC_ALL, "");
 388   bindtextdomain (PACKAGE, LOCALEDIR);
 389   textdomain (PACKAGE);
 390
 391   have_read_stdin = 0;
 392   exit_status = 0;
 393   convert_entire_line = 0;
 394   tab_list = NULL;
 395   first_free_tab = 0;
 396
 397   while ((c = getopt_long (argc, argv, "at:,0123456789", longopts, NULL)) != -1)
 398     {
 399       switch (c)
 400         {
 401         case 0:
 402           break;
 403
 404         case '?':
 405           usage (1);
 406         case 'a':
 407           convert_entire_line = 1;
 408           break;
 409         case 't':
 410           convert_entire_line = 1;
 411           parse_tabstops (optarg);
 412           break;
 413         case ',':
 414           add_tabstop (tabval);
 415           tabval = -1;
 416           break;
 417         default:
 418           if (tabval == -1)
 419             tabval = 0;
 420           tabval = tabval * 10 + c - '0';
 421           break;
 422         }
 423     }
 424
 425   if (show_version)
 426     {
 427       printf ("unexpand (%s) %s\n", GNU_PACKAGE, VERSION);
 428       exit (EXIT_SUCCESS);
 429     }
 430
 431   if (show_help)
 432     usage (0);
 433
 434   add_tabstop (tabval);
 435
 436   validate_tabstops (tab_list, first_free_tab);
 437
 438   if (first_free_tab == 0)
 439     tab_size = 8;
 440   else if (first_free_tab == 1)
 441     tab_size = tab_list[0];
 442   else
 443     {
 444       /* Append a sentinel to the list of tab stop indices.  */
 445       add_tabstop (INT_MAX);
 446       tab_size = 0;
 447     }
 448
 449   if (optind == argc)
 450     file_list = stdin_argv;
 451   else
 452     file_list = &argv[optind];
 453
 454   unexpand ();
 455
 456   if (have_read_stdin && fclose (stdin) == EOF)
 457     error (EXIT_FAILURE, errno, "-");
 458   if (fclose (stdout) == EOF)
 459     error (EXIT_FAILURE, errno, _("write error"));
 460   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 461 }