[glibc.git] / argp / argp-fmtstream.h

/* Word-wrapping and line-truncating streams.
   Copyright (C) 1997-2013 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Written by Miles Bader <miles@gnu.ai.mit.edu>.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* This package emulates glibc `line_wrap_stream' semantics for systems that
   don't have that.  If the system does have it, it is just a wrapper for
   that.  This header file is only used internally while compiling argp, and
   shouldn't be installed.  */

#ifndef _ARGP_FMTSTREAM_H
#define _ARGP_FMTSTREAM_H

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

#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later.  */
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
#  define __attribute__(Spec) /* empty */
# endif
/* The __-protected variants of `format' and `printf' attributes
   are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) || __STRICT_ANSI__
#  define __format__ format
#  define __printf__ printf
# endif
#endif

#if defined (__GNU_LIBRARY__) && defined (HAVE_LINEWRAP_H)
/* line_wrap_stream is available, so use that.  */
#define ARGP_FMTSTREAM_USE_LINEWRAP
#endif

#ifdef ARGP_FMTSTREAM_USE_LINEWRAP
/* Just be a simple wrapper for line_wrap_stream; the semantics are
   *slightly* different, as line_wrap_stream doesn't actually make a new
   object, it just modifies the given stream (reversibly) to do
   line-wrapping.  Since we control who uses this code, it doesn't matter.  */

#include <linewrap.h>

typedef FILE *argp_fmtstream_t;

#define argp_make_fmtstream line_wrap_stream
#define __argp_make_fmtstream line_wrap_stream
#define argp_fmtstream_free line_unwrap_stream
#define __argp_fmtstream_free line_unwrap_stream

#define __argp_fmtstream_putc(fs,ch) putc(ch,fs)
#define argp_fmtstream_putc(fs,ch) putc(ch,fs)
#define __argp_fmtstream_puts(fs,str) fputs(str,fs)
#define argp_fmtstream_puts(fs,str) fputs(str,fs)
#define __argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
#define argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
#define __argp_fmtstream_printf fprintf
#define argp_fmtstream_printf fprintf

#define __argp_fmtstream_lmargin line_wrap_lmargin
#define argp_fmtstream_lmargin line_wrap_lmargin
#define __argp_fmtstream_set_lmargin line_wrap_set_lmargin
#define argp_fmtstream_set_lmargin line_wrap_set_lmargin
#define __argp_fmtstream_rmargin line_wrap_rmargin
#define argp_fmtstream_rmargin line_wrap_rmargin
#define __argp_fmtstream_set_rmargin line_wrap_set_rmargin
#define argp_fmtstream_set_rmargin line_wrap_set_rmargin
#define __argp_fmtstream_wmargin line_wrap_wmargin
#define argp_fmtstream_wmargin line_wrap_wmargin
#define __argp_fmtstream_set_wmargin line_wrap_set_wmargin
#define argp_fmtstream_set_wmargin line_wrap_set_wmargin
#define __argp_fmtstream_point line_wrap_point
#define argp_fmtstream_point line_wrap_point

#else /* !ARGP_FMTSTREAM_USE_LINEWRAP */
/* Guess we have to define our own version.  */

\f
struct argp_fmtstream
{
  FILE *stream;			/* The stream we're outputting to.  */

  size_t lmargin, rmargin;	/* Left and right margins.  */
  ssize_t wmargin;		/* Margin to wrap to, or -1 to truncate.  */

  /* Point in buffer to which we've processed for wrapping, but not output.  */
  size_t point_offs;
  /* Output column at POINT_OFFS, or -1 meaning 0 but don't add lmargin.  */
  ssize_t point_col;

  char *buf;			/* Output buffer.  */
  char *p;			/* Current end of text in BUF. */
  char *end;			/* Absolute end of BUF.  */
};

typedef struct argp_fmtstream *argp_fmtstream_t;

/* Return an argp_fmtstream that outputs to STREAM, and which 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 NULL if there was an error.  */
extern argp_fmtstream_t __argp_make_fmtstream (FILE *__stream,
					       size_t __lmargin,
					       size_t __rmargin,
					       ssize_t __wmargin);
extern argp_fmtstream_t argp_make_fmtstream (FILE *__stream,
					     size_t __lmargin,
					     size_t __rmargin,
					     ssize_t __wmargin);

/* Flush __FS to its stream, and free it (but don't close the stream).  */
extern void __argp_fmtstream_free (argp_fmtstream_t __fs);
extern void argp_fmtstream_free (argp_fmtstream_t __fs);

extern ssize_t __argp_fmtstream_printf (argp_fmtstream_t __fs,
					const char *__fmt, ...)
     __attribute__ ((__format__ (printf, 2, 3)));
extern ssize_t argp_fmtstream_printf (argp_fmtstream_t __fs,
				      const char *__fmt, ...)
     __attribute__ ((__format__ (printf, 2, 3)));

extern int __argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
extern int argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);

extern int __argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);
extern int argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);

extern size_t __argp_fmtstream_write (argp_fmtstream_t __fs,
				      const char *__str, size_t __len);
extern size_t argp_fmtstream_write (argp_fmtstream_t __fs,
				    const char *__str, size_t __len);
\f
/* Access macros for various bits of state.  */
#define argp_fmtstream_lmargin(__fs) ((__fs)->lmargin)
#define argp_fmtstream_rmargin(__fs) ((__fs)->rmargin)
#define argp_fmtstream_wmargin(__fs) ((__fs)->wmargin)
#define __argp_fmtstream_lmargin argp_fmtstream_lmargin
#define __argp_fmtstream_rmargin argp_fmtstream_rmargin
#define __argp_fmtstream_wmargin argp_fmtstream_wmargin

/* Set __FS's left margin to LMARGIN and return the old value.  */
extern size_t argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
					  size_t __lmargin);
extern size_t __argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
					    size_t __lmargin);

/* Set __FS's right margin to __RMARGIN and return the old value.  */
extern size_t argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
					  size_t __rmargin);
extern size_t __argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
					    size_t __rmargin);

/* Set __FS's wrap margin to __WMARGIN and return the old value.  */
extern size_t argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
					  size_t __wmargin);
extern size_t __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
					    size_t __wmargin);

/* Return the column number of the current output point in __FS.  */
extern size_t argp_fmtstream_point (argp_fmtstream_t __fs);
extern size_t __argp_fmtstream_point (argp_fmtstream_t __fs);

/* Internal routines.  */
extern void _argp_fmtstream_update (argp_fmtstream_t __fs);
extern void __argp_fmtstream_update (argp_fmtstream_t __fs);
extern int _argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
extern int __argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
\f
#ifdef __OPTIMIZE__
/* Inline versions of above routines.  */

#if !_LIBC
#define __argp_fmtstream_putc argp_fmtstream_putc
#define __argp_fmtstream_puts argp_fmtstream_puts
#define __argp_fmtstream_write argp_fmtstream_write
#define __argp_fmtstream_set_lmargin argp_fmtstream_set_lmargin
#define __argp_fmtstream_set_rmargin argp_fmtstream_set_rmargin
#define __argp_fmtstream_set_wmargin argp_fmtstream_set_wmargin
#define __argp_fmtstream_point argp_fmtstream_point
#define __argp_fmtstream_update _argp_fmtstream_update
#define __argp_fmtstream_ensure _argp_fmtstream_ensure
#endif

#ifndef ARGP_FS_EI
#define ARGP_FS_EI extern inline
#endif

ARGP_FS_EI size_t
__argp_fmtstream_write (argp_fmtstream_t __fs, const char *__str, size_t __len)
{
  if (__fs->p + __len <= __fs->end || __argp_fmtstream_ensure (__fs, __len))
    {
      memcpy (__fs->p, __str, __len);
      __fs->p += __len;
      return __len;
    }
  else
    return 0;
}

ARGP_FS_EI int
__argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str)
{
  size_t __len = strlen (__str);
  if (__len)
    {
      size_t __wrote = __argp_fmtstream_write (__fs, __str, __len);
      return __wrote == __len ? 0 : -1;
    }
  else
    return 0;
}

ARGP_FS_EI int
__argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch)
{
  if (__fs->p < __fs->end || __argp_fmtstream_ensure (__fs, 1))
    return *__fs->p++ = __ch;
  else
    return EOF;
}

/* Set __FS's left margin to __LMARGIN and return the old value.  */
ARGP_FS_EI size_t
__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
{
  size_t __old;
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
    __argp_fmtstream_update (__fs);
  __old = __fs->lmargin;
  __fs->lmargin = __lmargin;
  return __old;
}

/* Set __FS's right margin to __RMARGIN and return the old value.  */
ARGP_FS_EI size_t
__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
{
  size_t __old;
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
    __argp_fmtstream_update (__fs);
  __old = __fs->rmargin;
  __fs->rmargin = __rmargin;
  return __old;
}

/* Set FS's wrap margin to __WMARGIN and return the old value.  */
ARGP_FS_EI size_t
__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
{
  size_t __old;
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
    __argp_fmtstream_update (__fs);
  __old = __fs->wmargin;
  __fs->wmargin = __wmargin;
  return __old;
}

/* Return the column number of the current output point in __FS.  */
ARGP_FS_EI size_t
__argp_fmtstream_point (argp_fmtstream_t __fs)
{
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
    __argp_fmtstream_update (__fs);
  return __fs->point_col >= 0 ? __fs->point_col : 0;
}

#if !_LIBC
#undef __argp_fmtstream_putc
#undef __argp_fmtstream_puts
#undef __argp_fmtstream_write
#undef __argp_fmtstream_set_lmargin
#undef __argp_fmtstream_set_rmargin
#undef __argp_fmtstream_set_wmargin
#undef __argp_fmtstream_point
#undef __argp_fmtstream_update
#undef __argp_fmtstream_ensure
#endif

#endif /* __OPTIMIZE__ */

#endif /* ARGP_FMTSTREAM_USE_LINEWRAP */

#endif /* argp-fmtstream.h */
Commit	Line	Data
c84142e8	1	/* Word-wrapping and line-truncating streams.
568035b7	2	Copyright (C) 1997-2013 Free Software Foundation, Inc.
c84142e8 UD	3	This file is part of the GNU C Library.
	4	Written by Miles Bader <miles@gnu.ai.mit.edu>.
	5
	6	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	7	modify it under the terms of the GNU Lesser General Public
	8	License as published by the Free Software Foundation; either
	9	version 2.1 of the License, or (at your option) any later version.
c84142e8 UD	10
	11	The GNU C Library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	14	Lesser General Public License for more details.
c84142e8	15
41bdb6e2	16	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	17	License along with the GNU C Library; if not, see
59ba27a6 PE	18	<http://www.gnu.org/licenses/>. */
c84142e8 UD	19
	20	/* This package emulates glibc `line_wrap_stream' semantics for systems that
	21	don't have that. If the system does have it, it is just a wrapper for
	22	that. This header file is only used internally while compiling argp, and
	23	shouldn't be installed. */
	24
5107cf1d UD	25	#ifndef _ARGP_FMTSTREAM_H
5107cf1d UD	26	#define _ARGP_FMTSTREAM_H
c84142e8	27
c84142e8 UD	28	#include <stdio.h>
	29	#include <string.h>
	30	#include <unistd.h>
	31
f39941e4 UD	32	#ifndef __attribute__
	33	/* This feature is available in gcc versions 2.5 and later. */
	34	# if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) \|\| __STRICT_ANSI__
	35	# define __attribute__(Spec) /* empty */
	36	# endif
	37	/* The __-protected variants of `format' and `printf' attributes
	38	are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */
	39	# if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 7) \|\| __STRICT_ANSI__
	40	# define __format__ format
	41	# define __printf__ printf
	42	# endif
	43	#endif
	44
3ce1f295	45	#if defined (__GNU_LIBRARY__) && defined (HAVE_LINEWRAP_H)
c84142e8 UD	46	/* line_wrap_stream is available, so use that. */
	47	#define ARGP_FMTSTREAM_USE_LINEWRAP
	48	#endif
	49
	50	#ifdef ARGP_FMTSTREAM_USE_LINEWRAP
	51	/* Just be a simple wrapper for line_wrap_stream; the semantics are
	52	slightly different, as line_wrap_stream doesn't actually make a new
	53	object, it just modifies the given stream (reversibly) to do
	54	line-wrapping. Since we control who uses this code, it doesn't matter. */
	55
	56	#include <linewrap.h>
	57
	58	typedef FILE *argp_fmtstream_t;
	59
	60	#define argp_make_fmtstream line_wrap_stream
	61	#define __argp_make_fmtstream line_wrap_stream
	62	#define argp_fmtstream_free line_unwrap_stream
	63	#define __argp_fmtstream_free line_unwrap_stream
	64
	65	#define __argp_fmtstream_putc(fs,ch) putc(ch,fs)
	66	#define argp_fmtstream_putc(fs,ch) putc(ch,fs)
	67	#define __argp_fmtstream_puts(fs,str) fputs(str,fs)
	68	#define argp_fmtstream_puts(fs,str) fputs(str,fs)
	69	#define __argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
	70	#define argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
	71	#define __argp_fmtstream_printf fprintf
	72	#define argp_fmtstream_printf fprintf
	73
	74	#define __argp_fmtstream_lmargin line_wrap_lmargin
	75	#define argp_fmtstream_lmargin line_wrap_lmargin
	76	#define __argp_fmtstream_set_lmargin line_wrap_set_lmargin
	77	#define argp_fmtstream_set_lmargin line_wrap_set_lmargin
	78	#define __argp_fmtstream_rmargin line_wrap_rmargin
	79	#define argp_fmtstream_rmargin line_wrap_rmargin
	80	#define __argp_fmtstream_set_rmargin line_wrap_set_rmargin
	81	#define argp_fmtstream_set_rmargin line_wrap_set_rmargin
	82	#define __argp_fmtstream_wmargin line_wrap_wmargin
	83	#define argp_fmtstream_wmargin line_wrap_wmargin
	84	#define __argp_fmtstream_set_wmargin line_wrap_set_wmargin
	85	#define argp_fmtstream_set_wmargin line_wrap_set_wmargin
	86	#define __argp_fmtstream_point line_wrap_point
	87	#define argp_fmtstream_point line_wrap_point
	88
	89	#else /* !ARGP_FMTSTREAM_USE_LINEWRAP */
	90	/* Guess we have to define our own version. */
	91
c84142e8 UD	92	\f
	93	struct argp_fmtstream
	94	{
	95	FILE stream; / The stream we're outputting to. */
	96
	97	size_t lmargin, rmargin; /* Left and right margins. */
	98	ssize_t wmargin; /* Margin to wrap to, or -1 to truncate. */
	99
	100	/* Point in buffer to which we've processed for wrapping, but not output. */
	101	size_t point_offs;
	102	/* Output column at POINT_OFFS, or -1 meaning 0 but don't add lmargin. */
	103	ssize_t point_col;
	104
	105	char buf; / Output buffer. */
	106	char p; / Current end of text in BUF. */
	107	char end; / Absolute end of BUF. */
	108	};
	109
	110	typedef struct argp_fmtstream *argp_fmtstream_t;
	111
	112	/* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
	113	written on it with LMARGIN spaces and limits them to RMARGIN columns
	114	total. If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
	115	replacing the whitespace before them with a newline and WMARGIN spaces.
	116	Otherwise, chars beyond RMARGIN are simply dropped until a newline.
	117	Returns NULL if there was an error. */
	118	extern argp_fmtstream_t __argp_make_fmtstream (FILE *__stream,
	119	size_t __lmargin,
	120	size_t __rmargin,
	121	ssize_t __wmargin);
	122	extern argp_fmtstream_t argp_make_fmtstream (FILE *__stream,
	123	size_t __lmargin,
	124	size_t __rmargin,
	125	ssize_t __wmargin);
	126
	127	/* Flush __FS to its stream, and free it (but don't close the stream). */
	128	extern void __argp_fmtstream_free (argp_fmtstream_t __fs);
	129	extern void argp_fmtstream_free (argp_fmtstream_t __fs);
	130
	131	extern ssize_t __argp_fmtstream_printf (argp_fmtstream_t __fs,
a784e502	132	const char *__fmt, ...)
c84142e8 UD	133	__attribute__ ((__format__ (printf, 2, 3)));
c84142e8 UD	134	extern ssize_t argp_fmtstream_printf (argp_fmtstream_t __fs,
a784e502	135	const char *__fmt, ...)
c84142e8 UD	136	__attribute__ ((__format__ (printf, 2, 3)));
	137
	138	extern int __argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
	139	extern int argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
	140
a784e502 UD	141	extern int __argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);
a784e502 UD	142	extern int argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);
c84142e8 UD	143
c84142e8 UD	144	extern size_t __argp_fmtstream_write (argp_fmtstream_t __fs,
a784e502	145	const char *__str, size_t __len);
c84142e8	146	extern size_t argp_fmtstream_write (argp_fmtstream_t __fs,
a784e502	147	const char *__str, size_t __len);
c84142e8 UD	148	\f
	149	/* Access macros for various bits of state. */
	150	#define argp_fmtstream_lmargin(__fs) ((__fs)->lmargin)
	151	#define argp_fmtstream_rmargin(__fs) ((__fs)->rmargin)
	152	#define argp_fmtstream_wmargin(__fs) ((__fs)->wmargin)
	153	#define __argp_fmtstream_lmargin argp_fmtstream_lmargin
	154	#define __argp_fmtstream_rmargin argp_fmtstream_rmargin
	155	#define __argp_fmtstream_wmargin argp_fmtstream_wmargin
	156
	157	/* Set __FS's left margin to LMARGIN and return the old value. */
	158	extern size_t argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
	159	size_t __lmargin);
	160	extern size_t __argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
	161	size_t __lmargin);
	162
	163	/* Set __FS's right margin to __RMARGIN and return the old value. */
	164	extern size_t argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
	165	size_t __rmargin);
	166	extern size_t __argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
	167	size_t __rmargin);
	168
	169	/* Set __FS's wrap margin to __WMARGIN and return the old value. */
	170	extern size_t argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
	171	size_t __wmargin);
	172	extern size_t __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
	173	size_t __wmargin);
	174
	175	/* Return the column number of the current output point in __FS. */
	176	extern size_t argp_fmtstream_point (argp_fmtstream_t __fs);
	177	extern size_t __argp_fmtstream_point (argp_fmtstream_t __fs);
	178
	179	/* Internal routines. */
	180	extern void _argp_fmtstream_update (argp_fmtstream_t __fs);
	181	extern void __argp_fmtstream_update (argp_fmtstream_t __fs);
	182	extern int _argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
	183	extern int __argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
	184	\f
	185	#ifdef __OPTIMIZE__
	186	/* Inline versions of above routines. */
	187
	188	#if !_LIBC
	189	#define __argp_fmtstream_putc argp_fmtstream_putc
	190	#define __argp_fmtstream_puts argp_fmtstream_puts
	191	#define __argp_fmtstream_write argp_fmtstream_write
	192	#define __argp_fmtstream_set_lmargin argp_fmtstream_set_lmargin
	193	#define __argp_fmtstream_set_rmargin argp_fmtstream_set_rmargin
	194	#define __argp_fmtstream_set_wmargin argp_fmtstream_set_wmargin
	195	#define __argp_fmtstream_point argp_fmtstream_point
	196	#define __argp_fmtstream_update _argp_fmtstream_update
	197	#define __argp_fmtstream_ensure _argp_fmtstream_ensure
	198	#endif
	199
	200	#ifndef ARGP_FS_EI
	201	#define ARGP_FS_EI extern inline
	202	#endif
	203
	204	ARGP_FS_EI size_t
a784e502	205	__argp_fmtstream_write (argp_fmtstream_t __fs, const char *__str, size_t __len)
c84142e8 UD	206	{
	207	if (__fs->p + __len <= __fs->end \|\| __argp_fmtstream_ensure (__fs, __len))
	208	{
	209	memcpy (__fs->p, __str, __len);
	210	__fs->p += __len;
	211	return __len;
	212	}
	213	else
	214	return 0;
	215	}
	216
	217	ARGP_FS_EI int
a784e502	218	__argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str)
c84142e8 UD	219	{
	220	size_t __len = strlen (__str);
	221	if (__len)
	222	{
	223	size_t __wrote = __argp_fmtstream_write (__fs, __str, __len);
	224	return __wrote == __len ? 0 : -1;
	225	}
	226	else
	227	return 0;
	228	}
	229
	230	ARGP_FS_EI int
	231	__argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch)
	232	{
	233	if (__fs->p < __fs->end \|\| __argp_fmtstream_ensure (__fs, 1))
	234	return *__fs->p++ = __ch;
	235	else
	236	return EOF;
	237	}
	238
	239	/* Set __FS's left margin to __LMARGIN and return the old value. */
	240	ARGP_FS_EI size_t
	241	__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
	242	{
	243	size_t __old;
c131718c	244	if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
c84142e8 UD	245	__argp_fmtstream_update (__fs);
	246	__old = __fs->lmargin;
	247	__fs->lmargin = __lmargin;
	248	return __old;
	249	}
	250
	251	/* Set __FS's right margin to __RMARGIN and return the old value. */
	252	ARGP_FS_EI size_t
	253	__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
	254	{
	255	size_t __old;
c131718c	256	if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
c84142e8 UD	257	__argp_fmtstream_update (__fs);
	258	__old = __fs->rmargin;
	259	__fs->rmargin = __rmargin;
	260	return __old;
	261	}
	262
	263	/* Set FS's wrap margin to __WMARGIN and return the old value. */
	264	ARGP_FS_EI size_t
	265	__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
	266	{
	267	size_t __old;
c131718c	268	if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
c84142e8 UD	269	__argp_fmtstream_update (__fs);
	270	__old = __fs->wmargin;
	271	__fs->wmargin = __wmargin;
	272	return __old;
	273	}
	274
	275	/* Return the column number of the current output point in __FS. */
	276	ARGP_FS_EI size_t
	277	__argp_fmtstream_point (argp_fmtstream_t __fs)
	278	{
c131718c	279	if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
c84142e8 UD	280	__argp_fmtstream_update (__fs);
	281	return __fs->point_col >= 0 ? __fs->point_col : 0;
	282	}
	283
	284	#if !_LIBC
	285	#undef __argp_fmtstream_putc
	286	#undef __argp_fmtstream_puts
	287	#undef __argp_fmtstream_write
	288	#undef __argp_fmtstream_set_lmargin
	289	#undef __argp_fmtstream_set_rmargin
	290	#undef __argp_fmtstream_set_wmargin
	291	#undef __argp_fmtstream_point
	292	#undef __argp_fmtstream_update
	293	#undef __argp_fmtstream_ensure
	294	#endif
	295
	296	#endif /* __OPTIMIZE__ */
	297
	298	#endif /* ARGP_FMTSTREAM_USE_LINEWRAP */
	299
5107cf1d	300	#endif /* argp-fmtstream.h */