about summary refs log tree commit diff
path: root/stdio
diff options
context:
space:
mode:
Diffstat (limited to 'stdio')
-rw-r--r--stdio/linewrap.c183
-rw-r--r--stdio/linewrap.h189
-rw-r--r--stdio/stdio.h16
3 files changed, 316 insertions, 72 deletions
diff --git a/stdio/linewrap.c b/stdio/linewrap.c
index e821cc3575..7f6576f29b 100644
--- a/stdio/linewrap.c
+++ b/stdio/linewrap.c
@@ -22,42 +22,27 @@ Cambridge, MA 02139, USA.  */
 #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>
+
+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;
@@ -72,41 +57,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);
 }
 
 /* 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)
+void
+__line_wrap_output (FILE *stream, int c)
 {
   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;
+  struct line_wrap_data *d = stream->__cookie;
   unwrap_stream (stream, d);
 
   /* Scan the buffer for newlines.  */
-  for (buf = stream->__buffer;
-       (buf < stream->__bufp || (c != EOF && c != '\n')) && !stream->__error)
+  buf = stream->__buffer;
+  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 == 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
@@ -141,8 +125,7 @@ lwoutput (FILE *stream, int c)
 	{
 	  /* The buffer ends in a partial line.  */
 
-	  if (!d->rmargin ||
-	      d->point + len + (c != EOF && c != '\n') <= d->rmargin)
+	  if (d->point + 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
@@ -155,7 +138,7 @@ 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 (d->point + (nl - buf) <= d->rmargin)
 	{
 	  /* The buffer contains a full line that fits within the maximum
 	     line width.  Reset point and scan the next line.  */
@@ -165,9 +148,9 @@ lwoutput (FILE *stream, int c)
 	}
 
       /* This line is too long.  */
-      r = *d->rmargin;
+      r = d->rmargin;
 
-      if (! d->wrapmargin)
+      if (d->wmargin < 0)
 	{
 	  /* Truncate the line by overwriting the excess with the
 	     newline and anything after it in the buffer.  */
@@ -242,7 +225,7 @@ 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');
@@ -255,7 +238,7 @@ lwoutput (FILE *stream, int c)
 	  d->point = 0;
 
 	  /* 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
@@ -284,19 +267,16 @@ lwoutput (FILE *stream, int c)
   wrap_stream (stream, d);
 }
 
-/* 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, size_t wmargin)
 {
-  struct data *d = malloc (sizeof *d);
+  struct line_wrap_data *d = malloc (sizeof *d);
 
   if (!d)
     return NULL;
@@ -321,25 +301,116 @@ 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);
 }
 
+/* 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 -1, else return its left margin.  */
+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.  */
+size_t
+line_wrap_set_lmargin (FILE *stream, size_t lmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->lmargin;
+      d->lmargin = lmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return its left margin.  */
+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.  */
+size_t
+line_wrap_set_rmargin (FILE *stream, size_t rmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->rmargin;
+      d->rmargin = rmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return its wrap margin.  */
+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.  */
+size_t
+line_wrap_set_wmargin (FILE *stream, size_t wmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->wmargin;
+      d->wmargin = wmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return the column number of
+   the current output point.  */
+size_t
+line_wrap_point (FILE *stream)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  return ((struct line_wrap_data *)stream->__cookie)->point;
+}
+
 #ifdef TEST
 int
 main (int argc, char **argv)
diff --git a/stdio/linewrap.h b/stdio/linewrap.h
new file mode 100644
index 0000000000..7ba337fad2
--- /dev/null
+++ b/stdio/linewrap.h
@@ -0,0 +1,189 @@
+/* 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.  */
+
+#ifndef __LINEWRAP_H__
+#define __LINEWRAP_H__
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include <features.h>
+
+#include <string.h>		/* Need size_t.  */
+
+__BEGIN_DECLS
+
+/* We keep this data for each line-wrapping stream.  */
+struct line_wrap_data
+  {
+    size_t lmargin, rmargin;	/* Left and right margins.  */
+    size_t wmargin;		/* Margin to wrap to, or -1 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;
+  };
+
+/* 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);
+
+/* Remove the hooks placed in STREAM by `line_wrap_stream'.  */
+void line_unwrap_stream (FILE *stream);
+
+/* Returns true if STREAM is line wrapped.  */
+extern inline int line_wrapped (FILE *stream); 
+
+/* If STREAM is not line-wrapped return -1, else return its left margin.  */
+extern size_t line_wrap_lmargin (FILE *stream); 
+
+/* If STREAM is not line-wrapped return -1, else set its left margin to
+   LMARGIN and return the old value.  */
+extern size_t line_wrap_set_lmargin (FILE *stream, size_t lmargin); 
+
+/* If STREAM is not line-wrapped return -1, else return its left margin.  */
+extern size_t line_wrap_rmargin (FILE *stream); 
+
+/* If STREAM is not line-wrapped return -1, else set its right margin to
+   RMARGIN and return the old value.  */
+extern size_t line_wrap_set_rmargin (FILE *stream, size_t rmargin); 
+
+/* If STREAM is not line-wrapped return -1, else return its wrap margin.  */
+extern size_t line_wrap_wmargin (FILE *stream); 
+
+/* If STREAM is not line-wrapped return -1, else set its left margin to
+   WMARGIN and return the old value.  */
+extern size_t line_wrap_set_wmargin (FILE *stream, size_t wmargin); 
+
+/* If STREAM is not line-wrapped return -1, else return the column number of
+   the current output point.  */
+extern size_t line_wrap_point (FILE *stream); 
+
+
+#ifdef	__OPTIMIZE__
+
+extern void __line_wrap_output (FILE *, int); /* private */
+
+/* Returns true if STREAM is line wrapped.  */
+extern inline int
+line_wrapped (FILE *stream)
+{
+  return (stream->__room_funcs.__output == &__line_wrap_output);
+}
+
+/* If STREAM is not line-wrapped return -1, else return its left margin.  */
+extern 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.  */
+extern inline size_t
+line_wrap_set_lmargin (FILE *stream, size_t lmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->lmargin;
+      d->lmargin = lmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return its left margin.  */
+extern 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.  */
+extern inline size_t
+line_wrap_set_rmargin (FILE *stream, size_t rmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->rmargin;
+      d->rmargin = rmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return its wrap margin.  */
+extern 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.  */
+extern inline size_t
+line_wrap_set_wmargin (FILE *stream, size_t wmargin)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  else
+    {
+      struct line_wrap_data *d = stream->__cookie;
+      size_t old = d->wmargin;
+      d->wmargin = wmargin;
+      return old;
+    }
+}
+
+/* If STREAM is not line-wrapped return -1, else return the column number of
+   the current output point.  */
+extern inline size_t
+line_wrap_point (FILE *stream)
+{
+  if (! line_wrapped (stream))
+    return -1;
+  return ((struct line_wrap_data *)stream->__cookie)->point;
+}
+
+#endif /* Optimizing.  */
+
+__END_DECLS
+
+#endif /* __LINEWRAP_H__ */
diff --git a/stdio/stdio.h b/stdio/stdio.h
index efaf2b95bf..38bfc148d7 100644
--- a/stdio/stdio.h
+++ b/stdio/stdio.h
@@ -353,22 +353,6 @@ extern FILE *fmemopen __P ((__ptr_t __s, size_t __len, __const char *__modes));
    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
    and the number of characters written on fflush or fclose.  */
 extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
-
-
-/* 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.  */
-extern FILE *line_wrap_stream __P ((FILE *__stream,
-				    size_t *__lmargin, size_t *__rmargin,
-				    size_t *__wrap));
-
-/* Remove the hooks placed in STREAM by `line_wrap_stream'.  */
-extern void line_unwrap_stream __P ((FILE *__stream));
 #endif