src/unexpand.c

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