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