Update.
[kopensolaris-gnu/glibc.git] / stdio / linewrap.c
index e821cc3..d91f3a4 100644 (file)
@@ -1,63 +1,48 @@
 /* Word-wrapping and line-truncating streams.
-Copyright (C) 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+   Copyright (C) 1996, 1997 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 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.
+   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.  */
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 
-/* We keep this data for each line-wrapping stream.  */
-
-struct data
-  {
-    const size_t *lmargin, *rmargin; /* Left and right margins.  */
-    const size_t *wrapmargin;  /* Margin to wrap to, or null to truncate.  */
-    size_t point;              /* Current column of last chars flushed.  */
-
-    /* Original cookie and hooks from the stream.  */
-    void *cookie;
-    void (*output) (FILE *, int);
-    __io_close_fn *close;
-    __io_fileno_fn *fileno;
-    __io_seek_fn *seek;
-  };
+#include <linewrap.h>
+\f
+void __line_wrap_output (FILE *, int);
 
 /* Install our hooks into a stream.  */
-
 static inline void
-wrap_stream (FILE *stream, struct data *d)
+wrap_stream (FILE *stream, struct line_wrap_data *d)
 {
-  static void lwoutput (FILE *, int);
   static __io_close_fn lwclose;
   static __io_fileno_fn lwfileno;
 
   stream->__cookie = d;
-  stream->__room_funcs.__output = &lwoutput;
+  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 data *d)
+unwrap_stream (FILE *stream, struct line_wrap_data *d)
 {
   stream->__cookie = d->cookie;
   stream->__room_funcs.__output = d->output;
@@ -65,6 +50,32 @@ unwrap_stream (FILE *stream, struct data *d)
   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;
+    }
+}
 \f
 /* Cookie io functions that might get called on a wrapped stream.
    Must pass the original cookie to the original functions.  */
@@ -72,41 +83,40 @@ unwrap_stream (FILE *stream, struct data *d)
 static int
 lwclose (void *cookie)
 {
-  struct data *d = cookie;
+  struct line_wrap_data *d = cookie;
   return (*d->close) (d->cookie);
 }
 
 static int
 lwfileno (void *cookie)
 {
-  struct data *d = cookie;
+  struct line_wrap_data *d = cookie;
   return (*d->fileno) (d->cookie);
 }
 \f
-/* This function is called when STREAM must be flushed.
-   C is EOF or a character to be appended to the buffer contents.  */
-
-static void
-lwoutput (FILE *stream, int c)
+/* 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;
-
-  /* Extract our data and restore the stream's original cookie
-     and output function so writes we do really go out.  */
-  struct data *d = stream->__cookie;
-  unwrap_stream (stream, d);
+  struct line_wrap_data *d = *wrapper_cookie ?: stream->__cookie;
 
   /* Scan the buffer for newlines.  */
-  for (buf = stream->__buffer;
-       (buf < stream->__bufp || (c != EOF && c != '\n')) && !stream->__error)
+  buf = stream->__buffer + d->point_offs;
+  while ((buf < stream->__bufp || (c != EOF && c != '\n')) && !stream->__error)
     {
       size_t r;
 
-      if (d->point == 0 && d->lmargin && *d->lmargin != 0)
+      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;
+         const size_t pad = d->lmargin;
          if (stream->__bufp + pad < stream->__put_limit)
            {
              /* We can fit in them in the buffer by moving the
@@ -122,32 +132,36 @@ lwoutput (FILE *stream, int c)
              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;
-             memcpy (stream->__bufp, buf, len);
+             memmove (stream->__bufp, buf, len);
              stream->__bufp += len;
            }
-         d->point = pad;
+         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->rmargin ||
-             d->point + len + (c != EOF && c != '\n') <= d->rmargin)
+         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 += len;
+             d->point_col += len;
              break;
            }
          else
@@ -155,28 +169,28 @@ lwoutput (FILE *stream, int c)
               the end of the buffer.  */
            nl = stream->__bufp;
        }
-      else if (!d->rmargin || d->point + (nl - buf) <= d->rmargin)
+      else if ((size_t) 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 = 0;
+         d->point_col = 0;
          buf = nl + 1;
          continue;
        }
 
       /* This line is too long.  */
-      r = *d->rmargin;
+      r = d->rmargin - 1;
 
-      if (! d->wrapmargin)
+      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)
            {
-             memcpy (buf + (r - d->point), nl, stream->__bufp - nl);
-             stream->__bufp -= buf + (r - d->point) - nl;
+             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 = 0;
+             d->point_col = 0;
              buf += r + 1; /* Skip full line plus \n. */
            }
          else
@@ -184,8 +198,8 @@ lwoutput (FILE *stream, int c)
              /* 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 += len;
-             stream->__bufp -= d->point - r;
+             d->point_col += len;
+             stream->__bufp -= d->point_col - r;
              if (c != '\n')
                /* Swallow the extra character too.  */
                c = EOF;
@@ -201,7 +215,7 @@ lwoutput (FILE *stream, int c)
          char *p, *nextline;
          int i;
 
-         p = buf + (r + 1 - d->point);
+         p = buf + (r + 1 - d->point_col);
          while (p >= buf && !isblank (*p))
            --p;
          nextline = p + 1;     /* This will begin the next line.  */
@@ -218,7 +232,7 @@ lwoutput (FILE *stream, int c)
            {
              /* 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);
+             p = buf + (r + 1 - d->point_col);
              /* Find the end of the long word.  */
              do
                ++p;
@@ -226,7 +240,7 @@ lwoutput (FILE *stream, int c)
              if (p == nl)
                {
                  /* It already ends a line.  No fussing required.  */
-                 d->point = 0;
+                 d->point_col = 0;
                  buf = nl + 1;
                  continue;
                }
@@ -242,26 +256,31 @@ lwoutput (FILE *stream, int c)
 
          /* Temporarily reset bufp to include just the first line.  */
          stream->__bufp = nl;
-         if (nextline - (nl + 1) < d->wrap)
+         if (nextline - (nl + 1) < d->wmargin)
            /* The margin needs more blanks than we removed.
               Output the first line so we can use the space.  */
-           (*d->output) (stream, '\n');
+           {
+             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.  */
-         d->point = 0;
+         /* 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->wrap; ++i)
+         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)
-           memcpy (stream->__bufp, nextline, buf + len - nextline);
+           memmove (stream->__bufp, nextline, buf + len - nextline);
          len -= nextline - buf;
 
          /* Continue the scan on the remaining lines in the buffer.  */
@@ -272,31 +291,45 @@ lwoutput (FILE *stream, int c)
        }
     }
 
+  /* Remember that we've scanned as far as the end of the buffer.  */
+  d->point_offs = stream->__bufp - stream->__buffer;
+
+  return c;
+}
+\f
+/* 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 = 0;
+       d->point_col = 0;
       else if (c != EOF)
-       ++d->point;
+       ++d->point_col;
     }
 
-  wrap_stream (stream, d);
+  ensure_wrapped (stream, &d);
 }
 \f
-/* Modify STREAM so that it prefixes lines written on it with *LMARGIN
-   spaces and limits them to *RMARGIN columns total.  If WRAP is not null,
-   words that extend past *RMARGIN are wrapped by replacing the whitespace
-   before them with a newline and *WRAP spaces.  Otherwise, chars beyond
-   *RMARGIN are simply dropped until a newline.  Returns STREAM after
-   modifying it, or NULL if there was an error.  The pointers passed are
-   stored in the stream and so must remain valid until `line_unwrap_stream'
-   is called; the values pointed to can be changed between stdio calls.  */
-
+/* 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 *wrap)
+line_wrap_stream (FILE *stream, size_t lmargin, size_t rmargin, ssize_t wmargin)
 {
-  struct data *d = malloc (sizeof *d);
+  struct line_wrap_data *d = malloc (sizeof *d);
 
   if (!d)
     return NULL;
@@ -305,13 +338,15 @@ line_wrap_stream (FILE *stream, size_t *lmargin, size_t *rmargin, size_t *wrap)
   fflush (stream);
 
   /* Initialize our wrapping state.  */
-  d->point = 0;
+  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;
+  d->seek = stream->__io_funcs.__seek;
 
   /* Take over the stream.  */
   wrap_stream (stream, d);
@@ -321,25 +356,158 @@ line_wrap_stream (FILE *stream, size_t *lmargin, size_t *rmargin, size_t *wrap)
      to work if the stream is switched to full or no buffering.  */
   stream->__linebuf = 1;
 
-#define        ref(arg)        d->arg = arg
-  ref (lmargin);
-  ref (rmargin);
-  ref (wrap);
-#undef ref
+  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 data *d = stream->__cookie;
+  struct line_wrap_data *d = stream->__cookie;
   unwrap_stream (stream, d);
   free (d);
 }
 \f
+/* 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;
+}
+\f
+/* 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;
+}
+\f
 #ifdef TEST
 int
 main (int argc, char **argv)