src/unexpand.c

   1 /* unexpand - convert spaces to tabs
   2    Copyright (C) 89, 91, 1995-1998, 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
  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 #include <stdio.h>
  41 #include <getopt.h>
  42 #include <sys/types.h>
  43 #include "system.h"
  44
  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 /* The name this program was run with. */
  56 char *program_name;
  57
  58 /* If nonzero, convert blanks even after nonblank characters have been
  59    read on the line. */
  60 static int convert_entire_line;
  61
  62 /* If nonzero, the size of all tab stops.  If zero, use `tab_list' instead. */
  63 static int tab_size;
  64
  65 /* Array of the explicit column numbers of the tab stops;
  66    after `tab_list' is exhausted, the rest of the line is printed
  67    unchanged.  The first column is column 0. */
  68 static int *tab_list;
  69
  70 /* The index of the first invalid element of `tab_list',
  71    where the next element can be added. */
  72 static int first_free_tab;
  73
  74 /* Null-terminated array of input filenames. */
  75 static char **file_list;
  76
  77 /* Default for `file_list' if no files are given on the command line. */
  78 static char *stdin_argv[] =
  79 {
  80   "-", NULL
  81 };
  82
  83 /* Nonzero if we have ever read standard input. */
  84 static int have_read_stdin;
  85
  86 /* Status to return to the system. */
  87 static int exit_status;
  88
  89 /* If nonzero, display usage information and exit.  */
  90 static int show_help;
  91
  92 /* If nonzero, print the version on standard output then exit.  */
  93 static int show_version;
  94
  95 static struct option const longopts[] =
  96 {
  97   {"tabs", required_argument, NULL, 't'},
  98   {"all", no_argument, NULL, 'a'},
  99   {"help", no_argument, &show_help, 1},
 100   {"version", no_argument, &show_version, 1},
 101   {NULL, 0, NULL, 0}
 102 };
 103
 104 /* Add tab stop TABVAL to the end of `tab_list', except
 105    if TABVAL is -1, do nothing. */
 106
 107 static void
 108 add_tabstop (int tabval)
 109 {
 110   if (tabval == -1)
 111     return;
 112   if (first_free_tab % TABLIST_BLOCK == 0)
 113     tab_list = (int *) xrealloc ((char *) tab_list,
 114                                  first_free_tab + TABLIST_BLOCK);
 115   tab_list[first_free_tab++] = tabval;
 116 }
 117
 118 /* Add the comma or blank separated list of tabstops STOPS
 119    to the list of tabstops. */
 120
 121 static void
 122 parse_tabstops (const char *stops)
 123 {
 124   int tabval = -1;
 125
 126   for (; *stops; stops++)
 127     {
 128       if (*stops == ',' || ISBLANK (*stops))
 129         {
 130           add_tabstop (tabval);
 131           tabval = -1;
 132         }
 133       else if (ISDIGIT (*stops))
 134         {
 135           if (tabval == -1)
 136             tabval = 0;
 137           tabval = tabval * 10 + *stops - '0';
 138         }
 139       else
 140         error (EXIT_FAILURE, 0, _("tab size contains an invalid character"));
 141     }
 142
 143   add_tabstop (tabval);
 144 }
 145
 146 /* Check that the list of tabstops TABS, with ENTRIES entries,
 147    contains only nonzero, ascending values. */
 148
 149 static void
 150 validate_tabstops (const int *tabs, int entries)
 151 {
 152   int prev_tab = 0;
 153   int i;
 154
 155   for (i = 0; i < entries; i++)
 156     {
 157       if (tabs[i] == 0)
 158         error (EXIT_FAILURE, 0, _("tab size cannot be 0"));
 159       if (tabs[i] <= prev_tab)
 160         error (EXIT_FAILURE, 0, _("tab sizes must be ascending"));
 161       prev_tab = tabs[i];
 162     }
 163 }
 164
 165 /* Close the old stream pointer FP if it is non-NULL,
 166    and return a new one opened to read the next input file.
 167    Open a filename of `-' as the standard input.
 168    Return NULL if there are no more input files.  */
 169
 170 static FILE *
 171 next_file (FILE *fp)
 172 {
 173   static char *prev_file;
 174   char *file;
 175
 176   if (fp)
 177     {
 178       if (ferror (fp))
 179         {
 180           error (0, errno, "%s", prev_file);
 181           exit_status = 1;
 182         }
 183       if (fp == stdin)
 184         clearerr (fp);          /* Also clear EOF. */
 185       else if (fclose (fp) == EOF)
 186         {
 187           error (0, errno, "%s", prev_file);
 188           exit_status = 1;
 189         }
 190     }
 191
 192   while ((file = *file_list++) != NULL)
 193     {
 194       if (file[0] == '-' && file[1] == '\0')
 195         {
 196           have_read_stdin = 1;
 197           prev_file = file;
 198           return stdin;
 199         }
 200       fp = fopen (file, "r");
 201       if (fp)
 202         {
 203           prev_file = file;
 204           return fp;
 205         }
 206       error (0, errno, "%s", file);
 207       exit_status = 1;
 208     }
 209   return NULL;
 210 }
 211
 212 /* Change spaces to tabs, writing to stdout.
 213    Read each file in `file_list', in order. */
 214
 215 static void
 216 unexpand (void)
 217 {
 218   FILE *fp;                     /* Input stream. */
 219   int c;                        /* Each input character. */
 220   /* Index in `tab_list' of next tabstop: */
 221   int tab_index = 0;            /* For calculating width of pending tabs. */
 222   int print_tab_index = 0;      /* For printing as many tabs as possible. */
 223   int column = 0;               /* Column on screen of next char. */
 224   int next_tab_column;          /* Column the next tab stop is on. */
 225   int convert = 1;              /* If nonzero, perform translations. */
 226   int pending = 0;              /* Pending columns of blanks. */
 227
 228   fp = next_file ((FILE *) NULL);
 229   if (fp == NULL)
 230     return;
 231
 232   /* Binary I/O will preserve the original EOL style (DOS/Unix) of files.  */
 233   SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 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                 {
 322                   SET_BINARY2 (fileno (fp), STDOUT_FILENO);
 323                   continue;
 324                 }
 325             }
 326
 327           if (convert)
 328             {
 329               if (c == '\b')
 330                 {
 331                   if (column > 0)
 332                     --column;
 333                 }
 334               else
 335                 {
 336                   ++column;
 337                   if (convert_entire_line == 0)
 338                     convert = 0;
 339                 }
 340             }
 341
 342           putchar (c);
 343
 344           if (c == '\n')
 345             {
 346               tab_index = print_tab_index = 0;
 347               column = pending = 0;
 348               convert = 1;
 349             }
 350         }
 351     }
 352 }
 353
 354 void
 355 usage (int status)
 356 {
 357   if (status != 0)
 358     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 359              program_name);
 360   else
 361     {
 362       printf (_("\
 363 Usage: %s [OPTION]... [FILE]...\n\
 364 "),
 365               program_name);
 366       printf (_("\
 367 Convert spaces in each FILE to tabs, writing to standard output.\n\
 368 With no FILE, or when FILE is -, read standard input.\n\
 369 \n\
 370   -a, --all           convert all whitespace, instead of initial whitespace\n\
 371   -t, --tabs=NUMBER   have tabs NUMBER characters apart instead of 8\n\
 372   -t, --tabs=LIST     use comma separated list of explicit tab positions\n\
 373       --help          display this help and exit\n\
 374       --version       output version information and exit\n\
 375 \n\
 376 Instead of -t NUMBER or -t LIST, -NUMBER or -LIST may be used.\n\
 377 "));
 378       puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
 379     }
 380   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 381 }
 382
 383 int
 384 main (int argc, char **argv)
 385 {
 386   int tabval = -1;              /* Value of tabstop being read, or -1. */
 387   int c;                        /* Option character. */
 388
 389   program_name = argv[0];
 390   setlocale (LC_ALL, "");
 391   bindtextdomain (PACKAGE, LOCALEDIR);
 392   textdomain (PACKAGE);
 393
 394   have_read_stdin = 0;
 395   exit_status = 0;
 396   convert_entire_line = 0;
 397   tab_list = NULL;
 398   first_free_tab = 0;
 399
 400   while ((c = getopt_long (argc, argv, "at:,0123456789", longopts, NULL)) != -1)
 401     {
 402       switch (c)
 403         {
 404         case 0:
 405           break;
 406
 407         case '?':
 408           usage (1);
 409         case 'a':
 410           convert_entire_line = 1;
 411           break;
 412         case 't':
 413           convert_entire_line = 1;
 414           parse_tabstops (optarg);
 415           break;
 416         case ',':
 417           add_tabstop (tabval);
 418           tabval = -1;
 419           break;
 420         default:
 421           if (tabval == -1)
 422             tabval = 0;
 423           tabval = tabval * 10 + c - '0';
 424           break;
 425         }
 426     }
 427
 428   if (show_version)
 429     {
 430       printf ("unexpand (%s) %s\n", GNU_PACKAGE, VERSION);
 431       exit (EXIT_SUCCESS);
 432     }
 433
 434   if (show_help)
 435     usage (0);
 436
 437   add_tabstop (tabval);
 438
 439   validate_tabstops (tab_list, first_free_tab);
 440
 441   if (first_free_tab == 0)
 442     tab_size = 8;
 443   else if (first_free_tab == 1)
 444     tab_size = tab_list[0];
 445   else
 446     {
 447       /* Append a sentinel to the list of tab stop indices.  */
 448       add_tabstop (INT_MAX);
 449       tab_size = 0;
 450     }
 451
 452   if (optind == argc)
 453     file_list = stdin_argv;
 454   else
 455     file_list = &argv[optind];
 456
 457   unexpand ();
 458
 459   if (have_read_stdin && fclose (stdin) == EOF)
 460     error (EXIT_FAILURE, errno, "-");
 461   if (fclose (stdout) == EOF)
 462     error (EXIT_FAILURE, errno, _("write error"));
 463   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 464 }