glibc/stdio/linewrap.c

/* Word-wrapping and line-truncating streams.
Copyright (C) 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB.  If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.  */

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

#include <linewrap.h>

void __line_wrap_output (FILE *, int);

/* Install our hooks into a stream.  */
static inline void
wrap_stream (FILE *stream, struct line_wrap_data *d)
{
  static __io_close_fn lwclose;
  static __io_fileno_fn lwfileno;

  stream->__cookie = d;
  stream->__room_funcs.__output = &__line_wrap_output;
  stream->__io_funcs.__close = &lwclose;
  stream->__io_funcs.__fileno = &lwfileno;
  stream->__io_funcs.__seek = NULL; /* Cannot seek.  */
}

/* Restore a stream to its original state.  */
static inline void
unwrap_stream (FILE *stream, struct line_wrap_data *d)
{
  stream->__cookie = d->cookie;
  stream->__room_funcs.__output = d->output;
  stream->__io_funcs.__close = d->close;
  stream->__io_funcs.__fileno = d->fileno;
  stream->__io_funcs.__seek = d->seek;
}

/* If WRAPPER_COOKIE points to a 0 pointer, then STREAM is assumed to be
   wrapped, and will be unwrapped, storing the wrapper cookie into
   WRAPPER_COOKIE.  Otherwise, nothing is done.  */
static inline void
ensure_unwrapped (FILE *stream, struct line_wrap_data **wrapper_cookie)
{
  if (*wrapper_cookie == 0)
    {
      *wrapper_cookie = stream->__cookie;
      unwrap_stream (stream, *wrapper_cookie);
    }
}

/* If WRAPPER_COOKIE points to a non-0 pointer, then STREAM is assumed to
   *have been unwrapped with ensure_unwrapped, will be wrapped with
   *WRAPPER_COOKIE, and *WRAPPER_COOKIE zeroed.  Otherwise, nothing is done. */
static inline void
ensure_wrapped (FILE *stream, struct line_wrap_data **wrapper_cookie)
{
  if (*wrapper_cookie)
    {
      wrap_stream (stream, *wrapper_cookie);
      *wrapper_cookie = 0;
    }
}

/* Cookie io functions that might get called on a wrapped stream.
   Must pass the original cookie to the original functions.  */

static int
lwclose (void *cookie)
{
  struct line_wrap_data *d = cookie;
  return (*d->close) (d->cookie);
}

static int
lwfileno (void *cookie)
{
  struct line_wrap_data *d = cookie;
  return (*d->fileno) (d->cookie);
}

/* Process STREAM's buffer so that line wrapping is done from POINT_OFFS to
   the end of its buffer.  If WRAPPER_COOKIE is 0, and it's necessary to
   flush some data, STREAM is unwrapped, and the line wrap stdio cookie
   stored in WRAPPER_COOKIE; otherwise, stream is assumed to already be
   unwrapped, and WRAPPER_COOKIE to point to the line wrap data.  Returns C
   or EOF if C was output.  */
static inline int
lwupdate (FILE *stream, int c, struct line_wrap_data **wrapper_cookie)
{
  char *buf, *nl;
  size_t len;
  struct line_wrap_data *d = *wrapper_cookie ?: stream->__cookie;

  /* Scan the buffer for newlines.  */
  buf = stream->__buffer + d->point_offs;
  while ((buf < stream->__bufp || (c != EOF && c != '\n')) && !stream->__error)
    {
      size_t r;

      if (d->point_col == 0 && d->lmargin != 0)
	{
	  /* We are starting a new line.  Print spaces to the left margin.  */
	  const size_t pad = d->lmargin;
	  if (stream->__bufp + pad < stream->__put_limit)
	    {
	      /* We can fit in them in the buffer by moving the
		 buffer text up and filling in the beginning.  */
	      memmove (buf + pad, buf, stream->__bufp - buf);
	      stream->__bufp += pad; /* Compensate for bigger buffer. */
	      memset (buf, ' ', pad); /* Fill in the spaces.  */
	      buf += pad; /* Don't bother searching them.  */
	    }
	  else
	    {
	      /* No buffer space for spaces.  Must flush.  */
	      size_t i;
	      char *olimit;

	      ensure_unwrapped (stream, wrapper_cookie);

	      len = stream->__bufp - buf;
	      olimit = stream->__put_limit;
	      stream->__bufp = stream->__put_limit = buf;
	      for (i = 0; i < pad; ++i)
		(*d->output) (stream, ' ');
	      stream->__put_limit = olimit;
	      memmove (stream->__bufp, buf, len);
	      stream->__bufp += len;
	    }
	  d->point_col = pad;
	}

      len = stream->__bufp - buf;
      nl = memchr (buf, '\n', len);

      if (d->point_col < 0)
	d->point_col = 0;

      if (!nl)
	{
	  /* The buffer ends in a partial line.  */

	  if (d->point_col + len + (c != EOF && c != '\n') < d->rmargin)
	    {
	      /* The remaining buffer text is a partial line and fits
		 within the maximum line width.  Advance point for the
		 characters to be written and stop scanning.  */
	      d->point_col += len;
	      break;
	    }
	  else
	    /* Set the end-of-line pointer for the code below to
	       the end of the buffer.  */
	    nl = stream->__bufp;
	}
      else if (d->point_col + (nl - buf) < d->rmargin)
	{
	  /* The buffer contains a full line that fits within the maximum
	     line width.  Reset point and scan the next line.  */
	  d->point_col = 0;
	  buf = nl + 1;
	  continue;
	}

      /* This line is too long.  */
      r = d->rmargin - 1;

      if (d->wmargin < 0)
	{
	  /* Truncate the line by overwriting the excess with the
	     newline and anything after it in the buffer.  */
	  if (nl < stream->__bufp)
	    {
	      memmove (buf + (r - d->point_col), nl, stream->__bufp - nl);
	      stream->__bufp -= buf + (r - d->point_col) - nl;
	      /* Reset point for the next line and start scanning it.  */
	      d->point_col = 0;
	      buf += r + 1; /* Skip full line plus \n. */
	    }
	  else
	    {
	      /* The buffer ends with a partial line that is beyond the
		 maximum line width.  Advance point for the characters
		 written, and discard those past the max from the buffer.  */
	      d->point_col += len;
	      stream->__bufp -= d->point_col - r;
	      if (c != '\n')
		/* Swallow the extra character too.  */
		c = EOF;
	      break;
	    }
	}
      else
	{
	  /* Do word wrap.  Go to the column just past the maximum line
	     width and scan back for the beginning of the word there.
	     Then insert a line break.  */

	  char *p, *nextline;
	  int i;

	  p = buf + (r + 1 - d->point_col);
	  while (p >= buf && !isblank (*p))
	    --p;
	  nextline = p + 1;	/* This will begin the next line.  */

	  if (nextline > buf)
	    {
	      /* Swallow separating blanks.  */
	      do
		--p;
	      while (isblank (*p));
	      nl = p + 1;	/* The newline will replace the first blank. */
	    }
	  else
	    {
	      /* A single word that is greater than the maximum line width.
		 Oh well.  Put it on an overlong line by itself.  */
	      p = buf + (r + 1 - d->point_col);
	      /* Find the end of the long word.  */
	      do
		++p;
	      while (p < nl && !isblank (*p));
	      if (p == nl)
		{
		  /* It already ends a line.  No fussing required.  */
		  d->point_col = 0;
		  buf = nl + 1;
		  continue;
		}
	      /* We will move the newline to replace the first blank.  */
	      nl = p;
	      /* Swallow separating blanks.  */
	      do
		++p;
	      while (isblank (*p));
	      /* The next line will start here.  */
	      nextline = p;
	    }

	  /* Temporarily reset bufp to include just the first line.  */
	  stream->__bufp = nl;
	  if (nextline - (nl + 1) < d->wmargin)
	    /* The margin needs more blanks than we removed.
	       Output the first line so we can use the space.  */
	    {
	      ensure_unwrapped (stream, wrapper_cookie);
	      (*d->output) (stream, '\n');
	    }
	  else
	    /* We can fit the newline and blanks in before
	       the next word.  */
	    *stream->__bufp++ = '\n';

	  /* Reset the counter of what has been output this line.  If wmargin
	     is 0, we want to avoid the lmargin getting added, so we set
	     point_col to a magic value of -1 in that case.  */
	  d->point_col = d->wmargin ? d->wmargin : -1;

	  /* Add blanks up to the wrap margin column.  */
	  for (i = 0; i < d->wmargin; ++i)
	    *stream->__bufp++ = ' ';

	  /* Copy the tail of the original buffer into the current buffer
	     position.  */
	  if (stream->__bufp != nextline)
	    memmove (stream->__bufp, nextline, buf + len - nextline);
	  len -= nextline - buf;

	  /* Continue the scan on the remaining lines in the buffer.  */
	  buf = stream->__bufp;

	  /* Restore bufp to include all the remaining text.  */
	  stream->__bufp += len;
	}
    }

  /* Remember that we've scanned as far as the end of the buffer.  */
  d->point_offs = stream->__bufp - stream->__buffer;

  return c;
}

/* This function is called when STREAM must be flushed.
   C is EOF or a character to be appended to the buffer contents.  */
void
__line_wrap_output (FILE *stream, int c)
{
  struct line_wrap_data *d = 0;

  c = lwupdate (stream, c, &d);

  if (!stream->__error)
    {
      ensure_unwrapped (stream, &d);
      (*d->output) (stream, c);
      d->point_offs = 0;	/* The buffer now holds nothing.  */
      if (c == '\n')
	d->point_col = 0;
      else if (c != EOF)
	++d->point_col;
    }

  ensure_wrapped (stream, &d);
}

/* Modify STREAM so that it prefixes lines written on it with LMARGIN spaces
   and limits them to RMARGIN columns total.  If WMARGIN >= 0, words that
   extend past RMARGIN are wrapped by replacing the whitespace before them
   with a newline and WMARGIN spaces.  Otherwise, chars beyond RMARGIN are
   simply dropped until a newline.  Returns STREAM after modifying it, or
   NULL if there was an error.  */
FILE *
line_wrap_stream (FILE *stream, size_t lmargin, size_t rmargin, size_t wmargin)
{
  struct line_wrap_data *d = malloc (sizeof *d);

  if (!d)
    return NULL;

  /* Ensure full setup before we start tweaking.  */
  fflush (stream);

  /* Initialize our wrapping state.  */
  d->point_col = 0;
  d->point_offs = 0;

  /* Save the original cookie and output and close hooks.  */
  d->cookie = stream->__cookie;
  d->output = stream->__room_funcs.__output;
  d->close = stream->__io_funcs.__close;
  d->fileno = stream->__io_funcs.__fileno;

  /* Take over the stream.  */
  wrap_stream (stream, d);

  /* Line-wrapping streams are normally line-buffered.  This is not
     required, just assumed desired.  The wrapping feature should continue
     to work if the stream is switched to full or no buffering.  */
  stream->__linebuf = 1;

  d->lmargin = lmargin;
  d->rmargin = rmargin;
  d->wmargin = wmargin;

  return stream;
}

/* Remove the hooks placed in STREAM by `line_wrap_stream'.  */
void
line_unwrap_stream (FILE *stream)
{
  struct line_wrap_data *d = stream->__cookie;
  unwrap_stream (stream, d);
  free (d);
}

/* Functions on wrapped streams.  */

/* Returns true if STREAM is line wrapped.  */
inline int
line_wrapped (FILE *stream)
{
  return (stream->__room_funcs.__output == &__line_wrap_output);
}

/* If STREAM is not line-wrapped, return 0.  Otherwise all pending text
   buffered text in STREAM so that the POINT_OFFS field refers to the last
   position in the stdio buffer, and return the line wrap state object for
   STREAM.  Since all text has been processed, this means that (1) the
   POINT_COL field refers to the column at which any new text would be added,
   and (2) any changes to the margin parameters will only affect new text.  */
struct line_wrap_data *
__line_wrap_update (FILE *stream)
{
  if (line_wrapped (stream))
    {
      struct line_wrap_data *d = stream->__cookie, *wc = 0;

      if (stream->__linebuf_active)
	/* This is an active line-buffered stream, so its put-limit is set to
	   the beginning of the buffer in order to force a __flshfp call on
	   each putc (see below).  We undo this hack here (by setting the
	   limit to the end of the buffer) to simplify the interface with the
	   output-room function.  */
	stream->__put_limit = stream->__buffer + stream->__bufsize;

      lwupdate (stream, EOF, &wc);

      if (stream->__linebuf)
	{
	  /* This is a line-buffered stream, and it is now ready to do some
	     output.  We call this an "active line-buffered stream".  We set
	     the put_limit to the beginning of the buffer, so the next `putc'
	     call will force a call to flshfp.  Setting the linebuf_active
	     flag tells the code above (on the next call) to undo this
	     hackery.  */
	  stream->__put_limit = stream->__buffer;
	  stream->__linebuf_active = 1;
	}

      ensure_wrapped (stream, &wc);

      return d;
    }
  else
    return 0;
}

/* If STREAM is not line-wrapped return -1, else return its left margin.  */
inline size_t
line_wrap_lmargin (FILE *stream)
{
  if (! line_wrapped (stream))
    return -1;
  return ((struct line_wrap_data *)stream->__cookie)->lmargin;
}

/* If STREAM is not line-wrapped return -1, else set its left margin to
   LMARGIN and return the old value.  */
inline size_t
line_wrap_set_lmargin (FILE *stream, size_t lmargin)
{
  struct line_wrap_data *d = __line_wrap_update (stream);
  if (d)
    {
      size_t old = d->lmargin;
      d->lmargin = lmargin;
      return old;
    }
  else
    return -1;
}

/* If STREAM is not line-wrapped return -1, else return its left margin.  */
inline size_t
line_wrap_rmargin (FILE *stream)
{
  if (! line_wrapped (stream))
    return -1;
  return ((struct line_wrap_data *)stream->__cookie)->rmargin;
}

/* If STREAM is not line-wrapped return -1, else set its right margin to
   RMARGIN and return the old value.  */
inline size_t
line_wrap_set_rmargin (FILE *stream, size_t rmargin)
{
  struct line_wrap_data *d = __line_wrap_update (stream);
  if (d)
    {
      size_t old = d->rmargin;
      d->rmargin = rmargin;
      return old;
    }
  else
    return -1;
}

/* If STREAM is not line-wrapped return -1, else return its wrap margin.  */
inline size_t
line_wrap_wmargin (FILE *stream)
{
  if (! line_wrapped (stream))
    return -1;
  return ((struct line_wrap_data *)stream->__cookie)->wmargin;
}

/* If STREAM is not line-wrapped return -1, else set its left margin to
   WMARGIN and return the old value.  */
inline size_t
line_wrap_set_wmargin (FILE *stream, size_t wmargin)
{
  struct line_wrap_data *d = __line_wrap_update (stream);
  if (d)
    {
      size_t old = d->wmargin;
      d->wmargin = wmargin;
      return old;
    }
  else
    return -1;
}

/* If STREAM is not line-wrapped return -1, else return the column number of
   the current output point.  */
inline size_t
line_wrap_point (FILE *stream)
{
  struct line_wrap_data *d = __line_wrap_update (stream);
  return d ? (d->point_col >= 0 ? d->point_col : 0) : -1;
}

#ifdef TEST
int
main (int argc, char **argv)
{
  int c;
  puts ("stopme");
  line_wrap_stream (stdout, atoi (argv[1]), atoi (argv[2] ?: "-1"));
  while ((c = getchar()) != EOF) putchar (c);
  return 0;
}
#endif