source: trunk/athena/bin/just/just.c @ 13628

/* Copyright 1985, 1998 by the Massachusetts Institute of Technology.
 *
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in
 * advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 */

static const char rcsid[] = "$Id: just.c,v 1.6 1999-09-24 20:36:09 danw Exp $";

/*
 * fill/just filter
 *
 * Initial Coding 7 Feb 80, bbn:yba.
 * Version of 21 Sep 83, fsi:yba
 * Rehashed 18 Mar 85, mit:yba
 *
 *
 * Use: fill [line_length]      (1 <= line_length <= 510.)
 *      just [line_length]
 *
 * Will fill lines or fill and justify lines to line_length (default
 * LINESIZE, below).
 *
 * Word longer than line_length are truncated!
 * Tabs are converted on input; double space at end of sentence is
 *     preserved.  Indentation for first line of paragraph preserved;
 *     subsequent lines have indentation of second line (if present).
 */

/* Globals */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXLINE 512
#define LINESIZE 65     /* default line_length */

#define min(x,y) ((x) < (y) ? (x) : (y))
#define max(x,y) ((x) > (y) ? (x) : (y))

int just;               /* bool: fill (false) or just (true)? */
int nwords = 0;
int line_width = LINESIZE;
int inval = 0;          /* indentation from left margin */

char inbuf[MAXLINE], outbuf[MAXLINE], wordbuf[MAXLINE];
char *inptr = inbuf, *outptr = outbuf, *wordptr = wordbuf;

char *me;

static int getword(void);
static void putword(void);
static void spread(void);
static void usage(void);
static int isbreak(int c);

int main(int argc, char **argv)
{
  int nlp = 0;          /* # lines in current paragraph */
  int i;
  char c;

  me = strrchr(argv[0], '/');   /* fill or just? */
  if (me == NULL)               /* No prefix to strip? */
    me = argv[0];

  if (argc > 2)
    usage();

  if (argc > 1)
    line_width = max(min(MAXLINE - 2, atoi(argv[1])), 1);

  just = !strcmp(me, "just");

  outbuf[0] = '\0';
  while (fgets(inbuf, MAXLINE, stdin))
    {
      inptr = inbuf;

      /* Check for blank lines and breaks (last line of paragraph, etc.) */
      while (*inptr == '\n')
        {
          if (nwords > 0)       /* break? */
            {
              puts(outbuf);     /* never justify this line */
              outptr = outbuf;
              outbuf[0] = '\0';
              nwords = 0;
              nlp = 0;
            }
          else
            putchar(*inptr++);  /* blank line */
        }

      if (nlp == 0 && (*inptr != '\0')) /* 1st line of paragraph */
        {
          while (*inptr == ' ' || *inptr == '\t')
            {
              if (*inptr == ' ')
                *outptr++ = *inptr++;
              else              /* convert tabs */
                {
                  inptr++;
                  i = (*outptr = '\0', strlen(outbuf));
                  do
                    *outptr++ = ' ';
                  while (++i % 8 != 0 && (outptr < &outbuf[line_width - 1]));
                }
            }
          *outptr = '\0';
          /*
           * Above we read from the buffered 1st line of the paragraph;
           * below note that we are looking at stdin again,
           * reading the second line (if any) of that paragraph
           */
          for (inval = 0; (c = getchar ()) == ' ' || (c == '\t');)
            {
              if (c == '\t')
                while (++inval % 8 != 0 && (inval < (line_width - 1)));
              else
                inval++;
            }

          if (!feof (stdin))
            ungetc(c, stdin);
          nlp++;
        }

      while (getword ())
        putword ();
    }

    if (outptr != outbuf)
      puts(outbuf);
    exit(0);
}

/*
 * getword -- returns true if it got a word; copies a word from inptr to outptr
 */

static int getword(void)
{
  wordptr = wordbuf;
  while (*inptr == ' ' || *inptr == '\t')
    inptr++;
  while (*inptr != ' ' && *inptr != '\t' && *inptr != '\n' && *inptr != '\0')
    *wordptr++ = *inptr++;

  /* add an extra space after end of sentence if it was present in source,
   * or if at the end of a line.
   */

  if (wordptr != wordbuf && isbreak(*(inptr - 1)) &&
      (*(inptr + 1) == ' ' || *inptr == '\n'))
    *wordptr++ = ' ';

  *wordptr = '\0';
  return strlen(wordbuf);
}

/*
 * putword -- write a word into outbuf if it fits, pads and writes the
 *      buffer as appropriate
 */

static void putword (void)
{
  int i = inval;
  int sl = strlen(wordbuf) + strlen(outbuf);

  if (*(wordptr - 1) == ' ' && sl == line_width)
    {
      *--wordptr = '\0';        /* get rid of space at end of line */
      sl--;                     /* if it would put us over by one */
    }
  if (sl >= line_width)
    {
      while (*(outptr - 1) == ' ')/* no spaces at end of line */
        *--outptr = '\0';
      if (just)
        spread();
      *outptr = '\n';
      *++outptr = '\0';
      fputs(outbuf, stdout);
      outptr = outbuf;
      nwords = 0;
      while (i--)
        *outptr++ = ' ';
    }
  else
    if (outptr != outbuf && nwords)
      *outptr++ = ' ';

  outptr = strchr(strcpy(outptr, wordbuf), '\0');
  nwords++;
}

/* spread -- spread out lines using the justification algorithm of
 *      Kernighan and Plauger, "Software Tools", Chap. 7, pg. 241
 *      (1976 edition)
 */

static void spread(void)
{
  static int dir = 0;
  int nextra = line_width - strlen(outbuf), ne, nholes, nb;
  char *ip, *jp;

  if (nextra > 0 && nwords > 1)
    {
      dir = 1 - dir;            /* alternate side to put extra space on */
      ne = nextra;
      nholes = nwords - 1;
      ip = outptr - 1;
      jp = min(&outbuf[line_width], (ip + ne));
      outptr = jp + 1;
      while (ip < jp)
        {
          *jp = *ip;
          if (*ip == ' ')
            {
              if (dir == 0)
                nb = (ne - 1) / nholes + 1;
              else
                nb = ne / nholes;
              ne -= nb;
              nholes--;
              for (; nb > 0; nb--)
                *--jp = ' ';
              while (*(ip - 1) == ' ')
                *--jp = *--ip;/* protected space */
            }
          ip--;
          jp--;
        }
    }
}

/*
 * usage -- usage message; because this is used as an editor filter,
 *      copy the input to the output if being misued -- this prevents
 *      the user's entire input from disappearing in vi, pen, etc.
 */

static void usage(void)
{
  int c;

  fprintf(stderr, "%s: Usage is %s [line width].\n", me, me);

  while ((c = getchar ()) != EOF)
    putchar(c);

  exit(1);
}

/*
 * isbreak -- is a character a member of the "ends a sentence" set?
 */

static int isbreak(int c)
{
  switch (c)
    {
    case '.': 
    case '!': 
    case '?': 
    case ':': 
      return (c);               /* true */
    default: 
      return (0);               /* false */
    }
}