* cp-tree.h (struct lang_decl_flags): Add comdat.

[official-gcc.git] / libio / iostream.texi

\input texinfo                                 @c -*-Texinfo-*-
@c Copyright (c) 1993 Free Software Foundation, Inc.

@c %**start of header 
@setfilename iostream.info
@settitle The GNU C++ Iostream Library
@setchapternewpage odd
@c %**end of header

@ifinfo
@format
START-INFO-DIR-ENTRY
* iostream: (iostream).                    The C++ input/output facility.
END-INFO-DIR-ENTRY
@end format

This file describes libio, the GNU library for C++ iostreams and C stdio.

libio includes software developed by the University of California,
Berkeley.

Copyright (C) 1993 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions.
@end ifinfo

@finalout
@syncodeindex fn cp
@syncodeindex vr cp

@titlepage
@title The GNU C++ Iostream Library
@subtitle Reference Manual for @code{libio} Version 0.64
@sp 3
@author Per Bothner @hfill @code{bothner@@cygnus.com}
@author Cygnus Support @hfill @code{doc@@cygnus.com}
@page

@vskip 0pt plus 1filll
Copyright @copyright{} 1993 Free Software Foundation, Inc.

@code{libio} includes software developed by the University of
California, Berkeley.

@code{libio} uses floating-point software written by David M. Gay, which
includes the following notice:

@quotation
The author of this software is David M. Gay.

Copyright (c) 1991 by AT&T.

Permission to use, copy, modify, and distribute this software for any
purpose without fee is hereby granted, provided that this entire notice
is included in all copies of any software which is or includes a copy
or modification of this software and in all copies of the supporting
documentation for such software.

THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
@end quotation

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions.
@end titlepage

@ifinfo
@node Top
@top The GNU C++ Iostream Library

This file provides reference information on the GNU C++ iostream library
(@code{libio}), version 0.64.

@menu
* Introduction::
* Operators::                   Operators and default streams.
* Streams::                     Stream classes.
* Files and Strings::           Classes for files and strings.
* Streambuf::                   Using the streambuf layer.
* Stdio::                       C input and output.
* Index::
@end menu
@end ifinfo

@node Introduction
@chapter Introduction

The iostream classes implement most of the features of AT&T version 2.0
iostream library classes, and most of the features of the ANSI X3J16
library draft (which is based on the AT&T design).

This manual is meant as a reference; for tutorial material on iostreams,
see the corresponding section of any recent popular introduction to C++.

@menu
* Copying::             Special GNU licensing terms for libio.
* Acknowledgements::    Contributors to GNU iostream.
@end menu

@node Copying
@section Licensing terms for @code{libio}

Since the @code{iostream} classes are so fundamental to standard C++,
the Free Software Foundation has agreed to a special exception to its
standard license, when you link programs with @code{libio.a}:

@quotation
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License.
@end quotation

The code is under the @sc{gnu} General Public License (version 2) for
all other purposes than linking with this library; that means that you
can modify and redistribute the code as usual, but remember that if you
do, your modifications, and anything you link with the modified code,
must be available to others on the same terms.

These functions are also available as part of the @code{libg++}
library; if you link with that library instead of @code{libio}, the
@sc{gnu} Library General Public License applies.

@node Acknowledgements
@section Acknowledgements

Per Bothner wrote most of the @code{iostream} library, but some portions
have their origins elsewhere in the free software community.  Heinz
Seidl wrote the IO manipulators.  The floating-point conversion software
is by David M. Gay of AT&T.  Some code was derived from parts of BSD
4.4, which was written at the University of California, Berkeley.

The iostream classes are found in the @code{libio} library.  An early
version was originally distributed in @code{libg++}, and they are still
included there as well, for convenience if you need other @code{libg++}
classes.  Doug Lea was the original author of @code{libg++}, and some of
the file-management code still in @code{libio} is his.

Various people found bugs or offered suggestions.  Hongjiu Lu worked
hard to use the library as the default stdio implementation for Linux,
and has provided much stress-testing of the library.

@node Operators
@chapter Operators and Default Streams

The @sc{gnu} iostream library, @file{libio}, implements the standard
input and output facilities for C++.  These facilities are roughly
analogous (in their purpose and ubiquity, at least) with those defined
by the C @file{stdio} functions.

Although these definitions come from a library, rather than being part
of the ``core language'', they are sufficiently central to be specified
in the latest working papers for C++.

You can use two operators defined in this library for basic input and
output operations.  They are familiar from any C++ introductory
textbook: @code{<<} for output, and @code{>>} for input.  (Think of data
flowing in the direction of the ``arrows''.)

These operators are often used in conjunction with three streams that
are open by default: 

@deftypevar ostream cout
The standard output stream, analogous to the C @code{stdout}.
@end deftypevar

@deftypevar istream cin
The standard input stream, analogous to the C @code{stdin}.
@end deftypevar

@deftypevar ostream cerr
An alternative output stream for errors, analogous to the C
@code{stderr}.
@end deftypevar

@noindent
For example, this bare-bones C++ version of the traditional ``hello''
program uses @code{<<} and @code{cout}:

@example
#include <iostream.h>

int main(int argc, char **argv)
@{
  cout << "Well, hi there.\n";
  return 0;
@}
@end example

Casual use of these operators may be seductive, but---other than in
writing throwaway code for your own use---it is not necessarily simpler
than managing input and output in any other language.  For example,
robust code should check the state of the input and output streams
between operations (for example, using the method @code{good}).
@xref{States,,Checking the state of a stream}.  You may also need to
adjust maximum input or output field widths, using manipulators like
@code{setw} or @code{setprecision}.

@defop Operator ostream <<
Write output to an open output stream of class @code{ostream}.
Defined by this library on any @var{object} of a C++ primitive type, and
on other classes of the library.  You can overload the definition for any
of your own applications' classes.

Returns a reference to the implied argument @code{*this} (the open stream it
writes on), permitting statements like
@example
cout << "The value of i is " << i << "\n";
@end example
@end defop

@defop Operator istream >>
Read input from an open input stream of class @code{istream}.  Defined
by this library on primitive numeric, pointer, and string types; you can
extend the definition for any of your own applications' classes.

Returns a reference to the implied argument @code{*this} (the open stream
it reads), permitting multiple inputs in one statement.
@end defop

@node Streams
@chapter Stream Classes

The previous chapter referred in passing to the classes @code{ostream}
and @code{istream}, for output and input respectively.  These classes
share certain properties, captured in their base class @code{ios}.

@menu
* Ios::       Shared properties.
* Ostream::   Managing output streams.
* Istream::   Managing input streams.
* Iostream::  Input and output together.
@end menu

@node Ios
@section Shared properties: class @code{ios}

The base class @code{ios} provides methods to test and manage the state
of input or output streams.

@code{ios} delegates the job of actually reading and writing bytes to
the abstract class @code{streambuf}, which is designed to provide
buffered streams (compatible with C, in the @sc{gnu} implementation).
@xref{Streambuf,,Using the @code{streambuf} layer}, for information on
the facilities available at the @code{streambuf} level.

@deftypefn Constructor {} ios::ios ([streambuf* @var{sb} @w{[, ostream*} @var{tie}])
The @code{ios} constructor by default initializes a new @code{ios}, and
if you supply a @code{streambuf} @var{sb} to associate with it, sets the
state @code{good} in the new @code{ios} object.  It also sets the
default properties of the new object.

@ignore
@c FIXME--future: this (a) doesn't work, (b) is controversial at ANSI
An @code{ios} without a @code{streambuf} has the state @code{bad} until
you supply a @code{streambuf}; you can do that by assigning a new value
to the @code{ios} with @samp{=}.
@end ignore

You can also supply an optional second argument @var{tie} to the
constructor: if present, it is an initial value for @code{ios::tie}, to
associate the new @code{ios} object with another stream.
@end deftypefn

@deftypefn Destructor {} ios::~ios ()
The @code{ios} destructor is virtual, permitting application-specific
behavior when a stream is closed---typically, the destructor frees any
storage associated with the stream and releases any other associated
objects.
@end deftypefn

@c FIXME-future:  Is @deftypefn really the best way of displaying these?

@c FIXME-future: Undocumented: ios::_throw_failure, ios::exceptions; things
@c controlled by _STREAM_COMPAT; ios::Init; ios::_IO_fix_vtable.

@menu
* States::              Checking the state of a stream.
* Format Control::      Choices in formatting.
* Manipulators::        Convenient ways of changing stream properties.
* Extending::           Extended data fields.
* Synchronization::     Synchronizing related streams.
* Streambuf from Ios::  Reaching the underlying streambuf.
@end menu

@node States
@subsection Checking the state of a stream

Use this collection of methods to test for (or signal) errors and other
exceptional conditions of streams:

@deftypefn Method {ios::operator void*} () const
You can do a quick check on the state of the most recent operation on a
stream by examining a pointer to the stream itself.  The pointer is
arbitrary except for its truth value; it is true if no failures have
occurred (@code{ios::fail} is not true).  For example, you might ask for
input on @code{cin} only if all prior output operations succeeded:

@example
if (cout)
@{
  // Everything OK so far
  cin >> new_value;
  @dots{}
@}
@end example
@end deftypefn

@deftypefn Method {ios::operator !} () const
In case it is more convenient to check whether something has failed, the
operator @code{!} returns true if @code{ios::fail} is true (an operation
has failed).  For example,
you might issue an error message if input failed:

@example
if (!cin)
@{
  // Oops
  cerr << "Eh?\n";
@}
@end example
@end deftypefn

@deftypefn Method iostate ios::rdstate () const
Return the state flags for this stream.  The value is from the
enumeration @code{iostate}.  You can test for any combination of

@vtable @code
@item goodbit
There are no indications of exceptional states on this stream.

@item eofbit
End of file.

@item failbit
An operation has failed on this stream; this usually indicates bad
format of input.

@item badbit
The stream is unusable.
@end vtable
@end deftypefn

@deftypefn Method void ios::setstate (iostate @var{state})
@findex ios::set
Set the state flag for this stream to @var{state} @emph{in addition to}
any state flags already set.  Synonym (for upward compatibility):
@code{ios::set}.

See @code{ios::clear} to set the stream state without regard to existing
state flags.  See @code{ios::good}, @code{ios::eof}, @code{ios::fail},
and @code{ios::bad}, to test the state.
@end deftypefn

@deftypefn Method int ios::good () const
Test the state flags associated with this stream; true if no error
indicators are set.
@end deftypefn

@deftypefn Method int ios::bad () const
Test whether a stream is marked as unusable.  (Whether
@code{ios::badbit} is set.)
@end deftypefn

@deftypefn Method int ios::eof () const
True if end of file was reached on this stream.  (If @code{ios::eofbit}
is set.)
@end deftypefn

@deftypefn Method int ios::fail () const
Test for any kind of failure on this stream: @emph{either} some
operation failed, @emph{or} the stream is marked as bad.  (If either
@code{ios::failbit} or @code{ios::badbit} is set.)
@end deftypefn

@deftypefn Method void ios::clear (iostate @var{state})
@c FIXME-future: There is some complication to do with buffering and _throw_failure
Set the state indication for this stream to the argument @var{state}.
You may call @code{ios::clear} with no argument, in which case the state
is set to @code{good} (no errors pending).

See @code{ios::good}, @code{ios::eof}, @code{ios::fail}, and
@code{ios::bad}, to test the state; see @code{ios::set} or
@code{ios::setstate} for an alternative way of setting the state.
@end deftypefn

@node Format Control
@subsection Choices in formatting

These methods control (or report on) settings for some details of
controlling streams, primarily to do with formatting output:

@deftypefn Method char ios::fill () const
Report on the padding character in use.
@end deftypefn

@deftypefn Method char ios::fill (char @var{padding})
Set the padding character.  You can also use the manipulator
@code{setfill}.  @xref{Manipulators,,Changing stream properties in
expressions}.

Default: blank.
@end deftypefn

@deftypefn Method int ios::precision () const
Report the number of significant digits currently in use for output of
floating point numbers.

Default: @code{6}.
@end deftypefn

@deftypefn Method int ios::precision (int @var{signif})
Set the number of significant digits (for input and output numeric
conversions) to @var{signif}.

@findex setprecision
@cindex setting @code{ios::precision}
You can also use the manipulator @code{setprecision} for this purpose.
@xref{Manipulators,,Changing stream properties using manipulators}.
@end deftypefn

@deftypefn Method int ios::width () const
Report the current output field width setting (the number of
characters to write on the next @samp{<<} output operation).

Default: @code{0}, which means to use as many characters as necessary.
@end deftypefn

@deftypefn Method int ios::width (int @var{num})
Set the input field width setting to @var{num}.  Return the
@emph{previous} value for this stream.

@findex setw
@cindex setting @code{ios::width}
This value resets to zero (the default) every time you use @samp{<<}; it is
essentially an additional implicit argument to that operator.  You can
also use the manipulator @code{setw} for this purpose.
@xref{Manipulators,,Changing stream properties using manipulators}.
@end deftypefn

@need 2000
@deftypefn Method fmtflags ios::flags () const
Return the current value of the complete collection of flags controlling
the format state.  These are the flags and their meanings when set:

@vtable @code
@item ios::dec
@itemx ios::oct
@itemx ios::hex
What numeric base to use in converting integers from internal to display
representation, or vice versa: decimal, octal, or hexadecimal,
respectively.  (You can change the base using the manipulator
@code{setbase}, or any of the manipulators @code{dec}, @code{oct}, or
@code{hex}; @pxref{Manipulators,,Changing stream properties in
expressions}.)

On input, if none of these flags is set, read numeric constants
according to the prefix: decimal if no prefix (or a @samp{.} suffix),
octal if a @samp{0} prefix is present, hexadecimal if a @samp{0x} prefix
is present.

Default: @code{dec}.

@item ios::fixed
Avoid scientific notation, and always show a fixed number of digits after
the decimal point, according to the output precision in effect.
Use @code{ios::precision} to set precision.

@item ios::left
@itemx ios::right
@itemx ios::internal
Where output is to appear in a fixed-width field; left-justified,
right-justified, or with padding in the middle (e.g. between a numeric
sign and the associated value), respectively.

@item ios::scientific
Use scientific (exponential) notation to display numbers.

@item ios::showbase
Display the conventional prefix as a visual indicator of the conversion
base: no prefix for decimal, @samp{0} for octal, @samp{0x} for hexadecimal.

@item ios::showpoint
Display a decimal point and trailing zeros after it to fill out numeric
fields, even when redundant.

@item ios::showpos
Display a positive sign on display of positive numbers.

@item ios::skipws
Skip white space.  (On by default).

@item ios::stdio
Flush the C @code{stdio} streams @code{stdout} and @code{stderr} after
each output operation (for programs that mix C and C++ output conventions).

@item ios::unitbuf
Flush after each output operation.

@item ios::uppercase
Use upper-case characters for the non-numeral elements in numeric
displays; for instance, @samp{0X7A} rather than @samp{0x7a}, or
@samp{3.14E+09} rather than @samp{3.14e+09}.
@end vtable
@end deftypefn

@deftypefn Method fmtflags ios::flags (fmtflags @var{value})
Set @var{value} as the complete collection of flags controlling the
format state.  The flag values are described under @samp{ios::flags ()}.

Use @code{ios::setf} or @code{ios::unsetf} to change one property at a
time.
@end deftypefn

@deftypefn Method fmtflags ios::setf (fmtflags @var{flag})
Set one particular flag (of those described for @samp{ios::flags ()};
return the complete collection of flags @emph{previously} in effect.
(Use @code{ios::unsetf} to cancel.)
@end deftypefn

@deftypefn Method fmtflags ios::setf (fmtflags @var{flag}, fmtflags @var{mask})
Clear the flag values indicated by @var{mask}, then set any of them that
are also in @var{flag}.  (Flag values are described for @samp{ios::flags
()}.)  Return the complete collection of flags @emph{previously} in
effect.  (See @code{ios::unsetf} for another way of clearing flags.)
@end deftypefn

@deftypefn Method fmtflags ios::unsetf (fmtflags @var{flag})
Make certain @var{flag} (a combination of flag values described for
@samp{ios::flags ()}) is not set for this stream; converse of
@code{ios::setf}.  Returns the old values of those flags.
@c FIXME-future: should probably be fixed to give same result as setf.
@end deftypefn

@node Manipulators
@subsection Changing stream properties using manipulators

For convenience, @var{manipulators} provide a way to change certain
properties of streams, or otherwise affect them, in the middle of
expressions involving @samp{<<} or @samp{>>}.  For example, you might
write

@example
cout << "|" << setfill('*') << setw(5) << 234 << "|";
@end example

@noindent
to produce @samp{|**234|} as output.

@deftypefn Manipulator {} ws
Skip whitespace.
@end deftypefn

@deftypefn Manipulator {} flush
Flush an output stream.  For example, @samp{cout << @dots{} <<flush;}
has the same effect as @samp{cout << @dots{}; cout.flush();}.
@end deftypefn

@deftypefn Manipulator {} endl
Write an end of line character @samp{\n}, then flushes the output stream.
@end deftypefn

@deftypefn Manipulator {} ends
Write @samp{\0} (the string terminator character).
@end deftypefn

@deftypefn Manipulator {} setprecision (int @var{signif})
You can change the value of @code{ios::precision} in @samp{<<}
expressions with the manipulator @samp{setprecision(@var{signif})}; for
example,

@example
cout << setprecision(2) << 4.567;
@end example

@noindent
prints @samp{4.6}.  Requires @file{#include <iomanip.h>}.
@end deftypefn

@deftypefn Manipulator {} setw (int @var{n})
You can change the value of @code{ios::width} in @samp{<<} expressions
with the manipulator @samp{setw(@var{n})}; for example,

@example
cout << setw(5) << 234;
@end example

@noindent
prints @w{@samp{  234}} with two leading blanks.  Requires @file{#include
<iomanip.h>}.
@end deftypefn

@deftypefn Manipulator {} setbase (int @var{base})
Where @var{base} is one of @code{10} (decimal), @code{8} (octal), or
@code{16} (hexadecimal), change the base value for numeric
representations.  Requires @file{#include <iomanip.h>}.
@end deftypefn

@deftypefn Manipulator {} dec
Select decimal base; equivalent to @samp{setbase(10)}.
@end deftypefn

@deftypefn Manipulator {} hex
Select hexadecimal base; equivalent to @samp{setbase(16)}.
@end deftypefn

@deftypefn Manipulator {} oct
Select octal base; equivalent to @samp{setbase(8)}.
@end deftypefn

@deftypefn Manipulator {} setfill (char @var{padding})
Set the padding character, in the same way as @code{ios::fill}.
Requires @file{#include <iomanip.h>}.
@end deftypefn

@node Extending
@subsection Extended data fields

A related collection of methods allows you to extend this collection of
flags and parameters for your own applications, without risk of conflict
between them:

@deftypefn Method {static fmtflags} ios::bitalloc ()
Reserve a bit (the single bit on in the result) to use as a flag.  Using
@code{bitalloc} guards against conflict between two packages that use
@code{ios} objects for different purposes.

This method is available for upward compatibility, but is not in the
@sc{ansi} working paper.  The number of bits available is limited; a
return value of @code{0} means no bit is available.
@end deftypefn

@deftypefn Method {static int} ios::xalloc ()
Reserve space for a long integer or pointer parameter.  The result is a
unique nonnegative integer.  You can use it as an index to
@code{ios::iword} or @code{ios::pword}.  Use @code{xalloc} to arrange
for arbitrary special-purpose data in your @code{ios} objects, without
risk of conflict between packages designed for different purposes.
@end deftypefn

@deftypefn Method long& ios::iword (int @var{index})
Return a reference to arbitrary data, of long integer type, stored in an
@code{ios} instance.  @var{index}, conventionally returned from
@code{ios::xalloc}, identifies what particular data you need.
@end deftypefn

@deftypefn Method long ios::iword (int @var{index}) const
Return the actual value of a long integer stored in an @code{ios}.
@end deftypefn

@deftypefn Method void*& ios::pword (int @var{index})
Return a reference to an arbitrary pointer, stored in an @code{ios}
instance.  @var{index}, originally returned from @code{ios::xalloc},
identifies what particular pointer you need.
@end deftypefn

@deftypefn Method void* ios::pword (int @var{index}) const
Return the actual value of a pointer stored in an @code{ios}.
@end deftypefn

@node Synchronization
@subsection Synchronizing related streams

You can use these methods to synchronize related streams with
one another:

@deftypefn Method ostream* ios::tie () const
Report on what output stream, if any, is to be flushed before accessing
this one.  A pointer value of @code{0} means no stream is tied.
@end deftypefn

@deftypefn Method ostream* ios::tie (ostream* @var{assoc})
Declare that output stream @var{assoc} must be flushed before accessing
this stream.
@end deftypefn

@deftypefn Method int ios::sync_with_stdio ([int @var{switch}])
Unless iostreams and C @code{stdio} are designed to work together, you
may have to choose between efficient C++ streams output and output
compatible with C @code{stdio}.  Use @samp{ios::sync_with_stdio()} to
select C compatibility.

The argument @var{switch} is a @sc{gnu} extension; use @code{0} as the
argument to choose output that is not necessarily compatible with C
@code{stdio}.  The default value for @var{switch} is @code{1}.

If you install the @code{stdio} implementation that comes with @sc{gnu}
@code{libio}, there are compatible input/output facilities for both C
and C++.  In that situation, this method is unnecessary---but you may
still want to write programs that call it, for portability.
@end deftypefn

@node Streambuf from Ios
@subsection Reaching the underlying @code{streambuf}

Finally, you can use this method to access the underlying object:

@deftypefn Method streambuf* ios::rdbuf () const
Return a pointer to the @code{streambuf} object that underlies this
@code{ios}.
@end deftypefn

@node Ostream
@section Managing output streams: class @code{ostream}

Objects of class @code{ostream} inherit the generic methods from
@code{ios}, and in addition have the following methods available.
Declarations for this class come from @file{iostream.h}.

@deftypefn Constructor {} ostream::ostream ()
The simplest form of the constructor for an @code{ostream} simply
allocates a new @code{ios} object.
@end deftypefn

@deftypefn Constructor {} ostream::ostream (streambuf* @var{sb} @w{[, ostream} @var{tie}])
This alternative constructor requires a first argument @var{sb} of type
@code{streambuf*}, to use an existing open stream for output.  It also
accepts an optional second argument @var{tie}, to specify a related
@code{ostream*} as the initial value for @code{ios::tie}.

If you give the @code{ostream} a @code{streambuf} explicitly, using
this constructor, the @var{sb} is @emph{not} destroyed (or deleted or
closed) when the @code{ostream} is destroyed.
@end deftypefn

@menu
* Writing::             Writing on an ostream.
* Output Position::     Repositioning an ostream.
* Ostream Housekeeping:: Miscellaneous ostream utilities.
@end menu

@node Writing
@subsection Writing on an @code{ostream}

These methods write on an @code{ostream} (you may also use the operator
@code{<<}; @pxref{Operators,,Operators and Default Streams}).

@deftypefn Method ostream& ostream::put (char @var{c})
Write the single character @var{c}.
@end deftypefn

@deftypefn Method ostream& ostream::write (@var{string}, int @var{length})
Write @var{length} characters of a string to this @code{ostream},
beginning at the pointer @var{string}.

@var{string} may have any of these types: @code{char*}, @code{unsigned
char*}, @code{signed char*}.
@end deftypefn

@deftypefn Method ostream& ostream::form (const char *@var{format}, ...)
A @sc{gnu} extension, similar to @code{fprintf(@var{file},
@var{format}, ...)}.

@var{format} is a @code{printf}-style format control string, which is used
to format the (variable number of) arguments, printing the result on
this @code{ostream}.  See @code{ostream::vform} for a version that uses
an argument list rather than a variable number of arguments.
@end deftypefn

@deftypefn Method ostream& ostream::vform (const char *@var{format}, va_list @var{args})
A @sc{gnu} extension, similar to @code{vfprintf(@var{file},
@var{format}, @var{args})}.

@var{format} is a @code{printf}-style format control string, which is used
to format the argument list @var{args}, printing the result on
this @code{ostream}.  See @code{ostream::form} for a version that uses a
variable number of arguments rather than an argument list.
@end deftypefn

@node Output Position
@subsection Repositioning an @code{ostream}

You can control the output position (on output streams that actually
support positions, typically files) with these methods:
@c FIXME-future: sort out which classes support this and which
@c don't; fstream, filebuf?  And what is failure condition when not supported?

@deftypefn Method streampos ostream::tellp ()
Return the current write position in the stream.
@end deftypefn

@deftypefn Method ostream& ostream::seekp (streampos @var{loc})
Reset the output position to @var{loc} (which is usually the result of a
previous call to @code{ostream::tellp}).  @var{loc} specifies an
absolute position in the output stream.
@end deftypefn

@deftypefn Method ostream& ostream::seekp (streamoff @var{loc}, @var{rel})
@findex ios::seekdir
Reset the output position to @var{loc}, relative to the beginning, end,
or current output position in the stream, as indicated by @var{rel} (a
value from the enumeration @code{ios::seekdir}):

@vtable @code
@item beg
Interpret @var{loc} as an absolute offset from the beginning of the
file.

@item cur
Interpret @var{loc} as an offset relative to the current output
position.

@item end
Interpret @var{loc} as an offset from the current end of the output
stream.
@end vtable
@end deftypefn

@node Ostream Housekeeping
@subsection Miscellaneous @code{ostream} utilities

You may need to use these @code{ostream} methods for housekeeping:

@deftypefn Method ostream& flush ()
Deliver any pending buffered output for this @code{ostream}.
@end deftypefn

@deftypefn Method int ostream::opfx ()
@code{opfx} is a @dfn{prefix} method for operations on @code{ostream}
objects; it is designed to be called before any further processing.  See
@code{ostream::osfx} for the converse.
@c FIXME-future: specify sometime which methods start with opfx.

@code{opfx} tests that the stream is in state @code{good}, and if so
flushes any stream tied to this one.

The result is @code{1} when @code{opfx} succeeds; else (if the stream state is
not @code{good}), the result is @code{0}.
@end deftypefn

@deftypefn Method void ostream::osfx ()
@code{osfx} is a @dfn{suffix} method for operations on @code{ostream}
objects; it is designed to be called at the conclusion of any processing.  All
the @code{ostream} methods end by calling @code{osfx}.  See
@code{ostream::opfx} for the converse.

If the @code{unitbuf} flag is set for this stream, @code{osfx} flushes
any buffered output for it.

If the @code{stdio} flag is set for this stream, @code{osfx} flushes any
output buffered for the C output streams @file{stdout} and @file{stderr}.
@end deftypefn

@node Istream
@section Managing input streams: class @code{istream}

Class @code{istream} objects are specialized for input; as for
@code{ostream}, they are derived from @code{ios}, so you can use any of
the general-purpose methods from that base class.  Declarations for this
class also come from @file{iostream.h}.

@deftypefn Constructor {} istream::istream ()
When used without arguments, the @code{istream} constructor simply
allocates a new @code{ios} object and initializes the input counter (the
value reported by @code{istream::gcount}) to @code{0}.
@end deftypefn

@deftypefn Constructor {} istream::istream (streambuf *@var{sb} @w{[, ostream} @var{tie}])
You can also call the constructor with one or two arguments.  The first
argument @var{sb} is a @code{streambuf*}; if you supply this pointer,
the constructor uses that @code{streambuf} for input.
You can use the second optional argument @var{tie} to specify a related
output stream as the initial value for @code{ios::tie}.

If you give the @code{istream} a @code{streambuf} explicitly, using
this constructor, the @var{sb} is @emph{not} destroyed (or deleted or
closed) when the @code{ostream} is destroyed.
@end deftypefn

@menu
* Char Input::          Reading one character.
* String Input::        Reading strings.
* Input Position::      Repositioning an istream.
* Istream Housekeeping:: Miscellaneous istream utilities.
@end menu

@node Char Input
@subsection Reading one character

Use these methods to read a single character from the input stream:

@deftypefn Method int istream::get ()
Read a single character (or @code{EOF}) from the input stream, returning
it (coerced to an unsigned char) as the result.
@end deftypefn

@deftypefn Method istream& istream::get (char& @var{c})
Read a single character from the input stream, into @code{&@var{c}}.
@end deftypefn

@deftypefn Method int istream::peek ()
Return the next available input character, but @emph{without} changing
the current input position.
@end deftypefn

@node String Input
@subsection Reading strings

Use these methods to read strings (for example, a line at a time) from
the input stream:

@deftypefn Method istream& istream::get (char* @var{c}, int @var{len} @w{[, char} @var{delim}])
Read a string from the input stream, into the array at @var{c}.

The remaining arguments limit how much to read: up to @samp{len-1}
characters, or up to (but not including) the first occurrence in the
input of a particular delimiter character @var{delim}---newline
(@code{\n}) by default.  (Naturally, if the stream reaches end of file
first, that too will terminate reading.)

If @var{delim} was present in the input, it remains available as if
unread; to discard it instead, see @code{iostream::getline}.

@code{get} writes @samp{\0} at the end of the string, regardless
of which condition terminates the read.
@end deftypefn

@deftypefn Method istream& istream::get (streambuf& @var{sb} @w{[, char} @var{delim}])
Read characters from the input stream and copy them on the
@code{streambuf} object @var{sb}.  Copying ends either just before the
next instance of the delimiter character @var{delim} (newline @code{\n}
by default), or when either stream ends.   If @var{delim} was present in
the input, it remains available as if unread.
@end deftypefn

@deftypefn Method istream& istream::getline (@var{charptr}, int @var{len} @w{[, char} @var{delim}])
Read a line from the input stream, into the array at @var{charptr}.
@var{charptr} may be any of three kinds of pointer: @code{char*},
@code{unsigned char*}, or @code{signed char*}.

The remaining arguments limit how much to read: up to (but not
including) the first occurrence in the input of a line delimiter
character @var{delim}---newline (@code{\n}) by default, or up to
@samp{len-1} characters (or to end of file, if that happens sooner).

If @code{getline} succeeds in reading a ``full line'', it also discards
the trailing delimiter character from the input stream.  (To preserve it
as available input, see the similar form of @code{iostream::get}.)

If @var{delim} was @emph{not} found before @var{len} characters or end
of file, @code{getline} sets the @code{ios::fail} flag, as well as the
@code{ios::eof} flag if appropriate.

@code{getline} writes a null character at the end of the string, regardless
of which condition terminates the read.
@end deftypefn

@deftypefn Method istream& istream::read (@var{pointer}, int @var{len})
Read @var{len} bytes into the location at @var{pointer}, unless the
input ends first.

@var{pointer} may be of type @code{char*}, @code{void*}, @code{unsigned
char*}, or @code{signed char*}.

If the @code{istream} ends before reading @var{len} bytes, @code{read}
sets the @code{ios::fail} flag.
@end deftypefn

@deftypefn Method istream& istream::gets (char **@var{s} @w{[, char} @var{delim}])
A @sc{gnu} extension, to read an arbitrarily long string
from the current input position to the next instance of the @var{delim}
character (newline @code{\n} by default).

To permit reading a string of arbitrary length, @code{gets} allocates
whatever memory is required.  Notice that the first argument @var{s} is
an address to record a character pointer, rather than the pointer
itself.
@end deftypefn

@deftypefn Method istream& istream::scan (const char *format ...)
A @sc{gnu} extension, similar to @code{fscanf(@var{file},
@var{format}, ...)}.  The @var{format} is a @code{scanf}-style format
control string, which is used to read the variables in the remainder of
the argument list from the @code{istream}.
@end deftypefn

@deftypefn Method istream& istream::vscan (const char *format, va_list args)
Like @code{istream::scan}, but takes a single @code{va_list} argument.
@end deftypefn

@node Input Position
@subsection Repositioning an @code{istream}

Use these methods to control the current input position:

@deftypefn Method streampos istream::tellg ()
Return the current read position, so that you can save it and return to
it later with @code{istream::seekg}.
@end deftypefn

@deftypefn Method istream& istream::seekg (streampos @var{p})
Reset the input pointer (if the input device permits it) to @var{p},
usually the result of an earlier call to @code{istream::tellg}.
@end deftypefn

@deftypefn Method istream& istream::seekg (streamoff @var{offset}, ios::seek_dir @var{ref})
Reset the input pointer (if the input device permits it) to @var{offset}
characters from the beginning of the input, the current position, or the
end of input.  Specify how to interpret @var{offset} with one of these
values for the second argument:

@vtable @code
@item ios::beg
Interpret @var{loc} as an absolute offset from the beginning of the
file.

@item ios::cur
Interpret @var{loc} as an offset relative to the current output
position.

@item ios::end
Interpret @var{loc} as an offset from the current end of the output
stream.
@end vtable
@end deftypefn

@node Istream Housekeeping
@subsection Miscellaneous @code{istream} utilities

Use these methods for housekeeping on @code{istream} objects:

@deftypefn Method int istream::gcount ()
Report how many characters were read from this @code{istream} in the
last unformatted input operation.
@c FIXME! Define "unformatted input" somewhere...
@end deftypefn

@deftypefn Method int istream::ipfx (int @var{keepwhite})
Ensure that the @code{istream} object is ready for reading; check for
errors and end of file and flush any tied stream.  @code{ipfx} skips
whitespace if you specify @code{0} as the @var{keepwhite}
argument, @emph{and} @code{ios::skipws} is set for this stream.

To avoid skipping whitespace (regardless of the @code{skipws} setting on
the stream), use @code{1} as the argument.

Call @code{istream::ipfx} to simplify writing your own methods for reading
@code{istream} objects.
@end deftypefn

@deftypefn Method void istream::isfx ()
A placeholder for compliance with the draft @sc{ansi} standard; this
method does nothing whatever.

If you wish to write portable standard-conforming code on @code{istream}
objects, call @code{isfx} after any operation that reads from an
@code{istream}; if @code{istream::ipfx} has any special effects that
must be cancelled when done, @code{istream::isfx} will cancel them.
@end deftypefn

@deftypefn Method istream& istream::ignore ([int @var{n}] @w{[, int} @var{delim}])
Discard some number of characters pending input.  The first optional
argument @var{n} specifies how many characters to skip.  The second
optional argument @var{delim} specifies a ``boundary'' character:
@code{ignore} returns immediately if this character appears in the
input.

By default, @var{delim} is @code{EOF}; that is, if you do not specify a
second argument, only the count @var{n} restricts how much to ignore
(while input is still available).

If you do not specify how many characters to ignore, @code{ignore}
returns after discarding only one character.
@end deftypefn

@deftypefn Method istream& istream::putback (char @var{ch})
Attempts to back up one character, replacing the character backed-up
over by @var{ch}.  Returns @code{EOF} if this is not allowed.  Putting
back the most recently read character is always allowed.  (This method
corresponds to the C function @code{ungetc}.)
@end deftypefn

@deftypefn Method istream& istream::unget ()
Attempt to back up one character.
@end deftypefn

@node Iostream
@section Input and output together: class @code{iostream}

If you need to use the same stream for input and output, you can use an
object of the class @code{iostream}, which is derived from @emph{both}
@code{istream} and @code{ostream}.

The constructors for @code{iostream} behave just like the constructors
for @code{istream}.

@deftypefn Constructor {} iostream::iostream ()
When used without arguments, the @code{iostream} constructor simply
allocates a new @code{ios} object, and initializes the input counter
(the value reported by @code{istream::gcount}) to @code{0}.
@end deftypefn

@deftypefn Constructor {} iostream::iostream (streambuf* @var{sb} @w{[, ostream*} @var{tie}])
You can also call a constructor with one or two arguments.  The first
argument @var{sb} is a @code{streambuf*}; if you supply this pointer,
the constructor uses that @code{streambuf} for input and output.

You can use the optional second argument @var{tie} (an @code{ostream*})
to specify a related output stream as the initial value for
@code{ios::tie}.
@end deftypefn

@cindex @code{iostream} destructor
@cindex destructor for @code{iostream}
As for @code{ostream} and @code{istream}, @code{iostream} simply uses
the @code{ios} destructor.  However, an @code{iostream} is not deleted by
its destructor.

You can use all the @code{istream}, @code{ostream}, and @code{ios}
methods with an @code{iostream} object.

@node Files and Strings
@chapter Classes for Files and Strings

There are two very common special cases of input and output: using files,
and using strings in memory.

@code{libio} defines four specialized classes for these cases:

@ftable @code
@item ifstream
Methods for reading files.

@item ofstream
Methods for writing files.

@item istrstream
Methods for reading strings from memory.

@item ostrstream
Methods for writing strings in memory.
@end ftable

@menu
* Files::       Reading and writing files.
* Strings::     Reading and writing strings in memory.
@end menu

@node Files
@section Reading and writing files

These methods are declared in @file{fstream.h}.

@findex ifstream
@cindex class @code{ifstream}
You can read data from class @code{ifstream} with any operation from class
@code{istream}.  There are also a few specialized facilities:

@deftypefn Constructor {} ifstream::ifstream ()
Make an @code{ifstream} associated with a new file for input.  (If you
use this version of the constructor, you need to call
@code{ifstream::open} before actually reading anything)
@end deftypefn

@deftypefn Constructor {} ifstream::ifstream (int @var{fd})
Make an @code{ifstream} for reading from a file that was already open,
using file descriptor @var{fd}.  (This constructor is compatible with
other versions of iostreams for @sc{posix} systems, but is not part of
the @sc{ansi} working paper.)
@end deftypefn

@deftypefn Constructor {} ifstream::ifstream (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
Open a file @code{*@var{fname}} for this @code{ifstream} object.

By default, the file is opened for input (with @code{ios::in} as
@var{mode}).  If you use this constructor, the file will be closed when
the @code{ifstream} is destroyed.

You can use the optional argument @var{mode} to specify how to open the
file, by combining these enumerated values (with @samp{|} bitwise or).
(These values are actually defined in class @code{ios}, so that all
file-related streams may inherit them.)  Only some of these modes are
defined in the latest draft @sc{ansi} specification; if portability is
important, you may wish to avoid the others.

@vtable @code
@item ios::in
Open for input.  (Included in @sc{ansi} draft.)

@item ios::out
Open for output.  (Included in @sc{ansi} draft.)

@item ios::ate
Set the initial input (or output) position to the end of the file.

@item ios::app
Seek to end of file before each write.  (Included in @sc{ansi} draft.)

@item ios::trunc
Guarantee a fresh file; discard any contents that were previously
associated with it.

@item ios::nocreate
Guarantee an existing file; fail if the specified file did not already
exist.

@item ios::noreplace
Guarantee a new file; fail if the specified file already existed.

@item ios::bin
Open as a binary file (on systems where binary and text files have different
properties, typically how @samp{\n} is mapped; included in @sc{ansi} draft).
@end vtable

@noindent
The last optional argument @var{prot} is specific to Unix-like systems;
it specifies the file protection (by default @samp{644}).
@end deftypefn

@deftypefn Method void ifstream::open (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
Open a file explicitly after the associated @code{ifstream} object
already exists (for instance, after using the default constructor).  The
arguments, options and defaults all have the same meanings as in the
fully specified @code{ifstream} constructor.
@end deftypefn

@findex ostream
@cindex class @code{ostream}
You can write data to class @code{ofstream} with any operation from class
@code{ostream}.  There are also a few specialized facilities:

@deftypefn Constructor {} ofstream::ofstream ()
Make an @code{ofstream} associated with a new file for output.
@end deftypefn

@deftypefn Constructor {} ofstream::ofstream (int @var{fd})
Make an @code{ofstream} for writing to a file that was already open,
using file descriptor @var{fd}.
@end deftypefn

@deftypefn Constructor {} ofstream::ofstream (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
Open a file @code{*@var{fname}} for this @code{ofstream} object.

By default, the file is opened for output (with @code{ios::out} as @var{mode}).
You can use the optional argument @var{mode} to specify how to open the
file, just as described for @code{ifstream::ifstream}.

The last optional argument @var{prot} specifies the file protection (by
default @samp{644}).
@end deftypefn

@deftypefn Destructor {} ofstream::~ofstream ()
The files associated with @code{ofstream} objects are closed when the
corresponding object is destroyed.
@end deftypefn

@deftypefn Method void ofstream::open (const char* @var{fname} @w{[, int} @var{mode} @w{[, int} @var{prot}]])
Open a file explicitly after the associated @code{ofstream} object
already exists (for instance, after using the default constructor).  The
arguments, options and defaults all have the same meanings as in the
fully specified @code{ofstream} constructor.
@end deftypefn

@findex fstream
@cindex class @code{fstream}
The class @code{fstream} combines the facilities of @code{ifstream} and
@code{ofstream}, just as @code{iostream} combines @code{istream} and
@code{ostream}.

@c FIXME-future: say something about fstream constructor, maybe.

@findex fstreambase
@cindex class @code{fstreambase}
The class @code{fstreambase} underlies both @code{ifstream} and
@code{ofstream}.  They both inherit this additional method:

@deftypefn Method void fstreambase::close ()
Close the file associated with this object, and set @code{ios::fail} in
this object to mark the event.
@end deftypefn

@node Strings
@section Reading and writing in memory

@c FIXME!! Per, there's a lot of guesswork here---please check carefully!

@findex istrstream
@cindex class @code{istrstream}
@findex ostrstream
@cindex class @code{ostrstream}
@findex strstream
@cindex class @code{strstream}
@findex strstreambase
@cindex class @code{strstreambase}
@findex strstreambuf
@cindex class @code{strstreambuf}
The classes @code{istrstream}, @code{ostrstream}, and @code{strstream}
provide some additional features for reading and writing strings in
memory---both static strings, and dynamically allocated strings.  The
underlying class @code{strstreambase} provides some features common to
all three; @code{strstreambuf} underlies that in turn.

@c FIXME-future:  Document strstreambuf methods one day, when we document
@c streambuf more fully.

@deftypefn Constructor {} istrstream::istrstream (const char* @var{str} @w{[, int} @var{size}])
Associate the new input string class @code{istrstream} with an existing
static string starting at @var{str}, of size @var{size}.  If you do not
specify @var{size}, the string is treated as a @code{NUL} terminated string.
@end deftypefn

@deftypefn Constructor {} ostrstream::ostrstream ()
Create a new stream for output to a dynamically managed string, which
will grow as needed.
@end deftypefn

@deftypefn Constructor {} ostrstream::ostrstream (char* @var{str}, int @var{size} [,int @var{mode}])
A new stream for output to a statically defined string of length
@var{size}, starting at @var{str}.  You may optionally specify one of
the modes described for @code{ifstream::ifstream}; if you do not specify
one, the new stream is simply open for output, with mode @code{ios::out}.
@end deftypefn

@deftypefn Method int ostrstream::pcount ()
Report the current length of the string associated with this @code{ostrstream}.
@end deftypefn

@deftypefn Method char* ostrstream::str ()
A pointer to the string managed by this @code{ostrstream}.  Implies
@samp{ostrstream::freeze()}.

Note that if you want the string to be nul-terminated,
you must do that yourself (perhaps by writing ends to the stream).
@end deftypefn

@deftypefn Method void ostrstream::freeze ([int @var{n}])
If @var{n} is nonzero (the default), declare that the string associated
with this @code{ostrstream} is not to change dynamically; while frozen,
it will not be reallocated if it needs more space, and it will not be
deallocated when the @code{ostrstream} is destroyed.  Use
@samp{freeze(1)} if you refer to the string as a pointer after creating
it via @code{ostrstream} facilities.

@samp{freeze(0)} cancels this declaration, allowing a dynamically
allocated string to be freed when its @code{ostrstream} is destroyed.

If this @code{ostrstream} is already static---that is, if it was created
to manage an existing statically allocated string---@code{freeze} is
unnecessary, and has no effect.
@end deftypefn

@deftypefn Method int ostrstream::frozen ()
Test whether @code{freeze(1)} is in effect for this string.
@end deftypefn

@deftypefn Method strstreambuf* strstreambase::rdbuf ()
A pointer to the underlying @code{strstreambuf}.
@end deftypefn

@node Streambuf
@chapter Using the @code{streambuf} Layer

The @code{istream} and @code{ostream} classes are meant to handle
conversion between objects in your program and their textual representation.

By contrast, the underlying @code{streambuf} class is for transferring
raw bytes between your program, and input sources or output sinks.
Different @code{streambuf} subclasses connect to different kinds of
sources and sinks.

The @sc{gnu} implementation of @code{streambuf} is still evolving; we
describe only some of the highlights.

@menu
* Areas::               Areas in a streambuf.
* Overflow::            Simple output re-direction
* Formatting::          C-style formatting for streambuf objects.
* Stdiobuf::            Wrappers for C stdio.
* Procbuf::             Reading/writing from/to a pipe
* Backing Up::          Marking and returning to a position.
* Indirectbuf::         Forwarding I/O activity.
@end menu

@node Areas
@section Areas of a @code{streambuf}

Streambuf buffer management is fairly sophisticated (this is a
nice way to say ``complicated'').  The standard protocol
has the following ``areas'':

@itemize @bullet
@item
@cindex put area
The @dfn{put area} contains characters waiting for output.

@item
@cindex get area
The @dfn{get area} contains characters available for reading.
@end itemize

The @sc{gnu} @code{streambuf} design extends this, but the details are
still evolving.

The following methods are used to manipulate these areas.
These are all protected methods, which are intended to be
used by virtual function in classes derived from @code{streambuf}.
They are also all ANSI/ISO-standard, and the ugly names
are traditional.
(Note that if a pointer points to the 'end' of an area,
it means that it points to the character after the area.)

@deftypefn Method char* streambuf::pbase () const
Returns a pointer to the start of the put area.
@end deftypefn

@deftypefn Method char* streambuf::epptr () const
Returns a pointer to the end of the put area.
@end deftypefn

@deftypefn Method char* streambuf::pptr () const
If @code{pptr() < epptr ()}, the @code{pptr()}
returns a pointer to the current put position.
(In that case, the next write will
overwrite @code{*pptr()}, and increment @code{pptr()}.)
Otherwise, there is no put position available
(and the next character written will cause @code{streambuf::overflow}
to be called).
@end deftypefn

@deftypefn Method void streambuf::pbump (int @var{N})
Add @var{N} to the current put pointer.
No error checking is done.
@end deftypefn

@deftypefn Method void streambuf::setp (char* @var{P}, char* @var{E})
Sets the start of the put area to @var{P}, the end of the put area to @var{E},
and the current put pointer to @var{P} (also).
@end deftypefn

@deftypefn Method char* streambuf::eback () const
Returns a pointer to the start of the get area.
@end deftypefn

@deftypefn Method char* streambuf::egptr () const
Returns a pointer to the end of the get area.
@end deftypefn

@deftypefn Method char* streambuf::gptr () const
If @code{gptr() < egptr ()}, then @code{gptr()}
returns a pointer to the current get position.
(In that case the next read will read @code{*gptr()},
and possibly increment @code{gptr()}.)
Otherwise, there is no read position available
(and the next read will cause @code{streambuf::underflow}
to be called).
@end deftypefn

@deftypefn Method void streambuf:gbump (int @var{N})
Add @var{N} to the current get pointer.
No error checking is done.
@end deftypefn

@deftypefn Method void streambuf::setg (char* @var{B}, char* @var{P}, char* @var{E})
Sets the start of the get area to @var{B}, the end of the get area to @var{E},
and the current put pointer to @var{P}.
@end deftypefn

@node Overflow
@section Simple output re-direction by redefining @code{overflow}

Suppose you have a function @code{write_to_window} that
writes characters to a @code{window} object.  If you want to use the
ostream function to write to it, here is one (portable) way to do it.
This depends on the default buffering (if any).

@cartouche
@smallexample
#include <iostream.h>
/* Returns number of characters successfully written to @var{win}. */
extern int write_to_window (window* win, char* text, int length);

class windowbuf : public streambuf @{
    window* win;
  public:
    windowbuf (window* w) @{ win = w; @}
    int sync ();
    int overflow (int ch);
    // Defining xsputn is an optional optimization.
    // (streamsize was recently added to ANSI C++, not portable yet.)
    streamsize xsputn (char* text, streamsize n);
@};

int windowbuf::sync ()
@{ streamsize n = pptr () - pbase ();
  return (n && write_to_window (win, pbase (), n) != n) ? EOF : 0;
@}

int windowbuf::overflow (int ch)
@{ streamsize n = pptr () - pbase ();
  if (n && sync ())
    return EOF;
  if (ch != EOF)
    @{
      char cbuf[1];
      cbuf[0] = ch;
      if (write_to_window (win, cbuf, 1) != 1)
        return EOF;
    @}
  pbump (-n);  // Reset pptr().
  return 0;
@}

streamsize windowbuf::xsputn (char* text, streamsize n)
@{ return sync () == EOF ? 0 : write_to_window (win, text, n); @}

int
main (int argc, char**argv)
@{
  window *win = ...;
  windowbuf wbuf(win);
  ostream wstr(&wbuf);
  wstr << "Hello world!\n";
@}
@end smallexample
@end cartouche



@node Formatting
@section C-style formatting for @code{streambuf} objects

The @sc{gnu} @code{streambuf} class supports @code{printf}-like
formatting and scanning.

@deftypefn Method int streambuf::form (const char *@var{format}, ...)
Similar to @code{fprintf(@var{file}, @var{format}, ...)}.
The @var{format} is a @code{printf}-style format control string, which is used
to format the (variable number of) arguments, printing the result on
the @code{this} streambuf.  The result is the number of characters printed.
@end deftypefn

@deftypefn Method int streambuf::vform (const char *@var{format}, va_list @var{args})
Similar to @code{vfprintf(@var{file}, @var{format}, @var{args})}.
The @var{format} is a @code{printf}-style format control string, which is used
to format the argument list @var{args}, printing the result on
the @code{this} streambuf.  The result is the number of characters printed.
@end deftypefn

@deftypefn Method int streambuf::scan (const char *@var{format}, ...)
Similar to @code{fscanf(@var{file}, @var{format}, ...)}.
The @var{format} is a @code{scanf}-style format control string, which is used
to read the (variable number of) arguments from the @code{this} streambuf.
The result is the number of items assigned, or @code{EOF} in case of
input failure before any conversion.
@end deftypefn

@deftypefn Method int streambuf::vscan (const char *@var{format}, va_list @var{args})
Like @code{streambuf::scan}, but takes a single @code{va_list} argument.
@end deftypefn

@node Stdiobuf
@section Wrappers for C @code{stdio}

A @dfn{stdiobuf} is a @code{streambuf} object that points to
a @code{FILE} object (as defined by @code{stdio.h}).
All @code{streambuf} operations on the @code{stdiobuf} are forwarded
to the @code{FILE}.  Thus the @code{stdiobuf} object provides a
wrapper around a @code{FILE}, allowing use of @code{streambuf}
operations on a @code{FILE}.  This can be useful when mixing
C code with C++ code.

The pre-defined streams @code{cin}, @code{cout}, and @code{cerr} are
normally implemented as @code{stdiobuf} objects that point to
respectively @code{stdin}, @code{stdout}, and @code{stderr}.  This is
convenient, but it does cost some extra overhead.

If you set things up to use the implementation of @code{stdio} provided
with this library, then @code{cin}, @code{cout}, and @code{cerr} will be
set up to to use @code{stdiobuf} objects, since you get their benefits
for free.  @xref{Stdio,,C Input and Output}.

@ignore
@c FIXME-future: setbuf is not yet documented, hence this para is not useful.
Note that if you use @code{setbuf} to give a buffer to a @code{stdiobuf},
that buffer will provide intermediate buffering in addition that
whatever is done by the @code{FILE}.
@end ignore

@node Procbuf
@section Reading/writing from/to a pipe

The @dfn{procbuf} class is a @sc{gnu} extension.  It is derived from
@code{streambuf}.  A @code{procbuf} can be @dfn{closed} (in which case
it does nothing), or @dfn{open} (in which case it allows communicating
through a pipe with some other program).

@deftypefn Constructor {} procbuf::procbuf ()
Creates a @code{procbuf} in a @dfn{closed} state.
@end deftypefn

@deftypefn Method procbuf* procbuf::open (const char *@var{command}, int @var{mode})
Uses the shell (@file{/bin/sh}) to run a program specified by @var{command}.

If @var{mode} is @samp{ios::in}, standard output from the program is sent
to a pipe; you can read from the pipe by reading from the
@code{procbuf}.  (This is similar to @w{@samp{popen(@var{command}, "r")}}.)

If @var{mode} is @samp{ios::out}, output written written to the
@code{procbuf} is written to a pipe; the program is set up to read its
standard input from (the other end of) the pipe.  (This is similar to
@w{@samp{popen(@var{command}, "w")}}.)

The @code{procbuf} must start out in the @dfn{closed} state.
Returns @samp{*this} on success, and @samp{NULL} on failure.
@end deftypefn

@deftypefn Constructor {} procbuf::procbuf (const char *@var{command}, int @var{mode})
Calls @samp{procbuf::open (@var{command}, @var{mode})}.
@end deftypefn

@deftypefn Method procbuf* procbuf::close ()
Waits for the program to finish executing,
and then cleans up the resources used.
Returns @samp{*this} on success, and @samp{NULL} on failure.
@end deftypefn

@deftypefn Destructor {} procbuf::~procbuf ()
Calls @samp{procbuf::close}.
@end deftypefn

@node Backing Up
@section Backing up

The @sc{gnu} iostream library allows you to ask a @code{streambuf} to
remember the current position.  This allows you to go back to this
position later, after reading further.  You can back up arbitrary
amounts, even on unbuffered files or multiple buffers' worth, as long as
you tell the library in advance.  This unbounded backup is very useful
for scanning and parsing applications.  This example shows a typical
scenario:

@cartouche
@smallexample
// Read either "dog", "hound", or "hounddog".
// If "dog" is found, return 1.
// If "hound" is found, return 2.
// If "hounddog" is found, return 3.
// If none of these are found, return -1.
int my_scan(streambuf* sb)
@{
    streammarker fence(sb);
    char buffer[20];
    // Try reading "hounddog":
    if (sb->sgetn(buffer, 8) == 8
        && strncmp(buffer, "hounddog", 8) == 0)
      return 3;
    // No, no "hounddog":  Back up to 'fence'
    sb->seekmark(fence); // 
    // ... and try reading "dog":
    if (sb->sgetn(buffer, 3) == 3
        && strncmp(buffer, "dog", 3) == 0)
      return 1;
    // No, no "dog" either:  Back up to 'fence'
    sb->seekmark(fence); // 
    // ... and try reading "hound":
    if (sb->sgetn(buffer, 5) == 5
        && strncmp(buffer, "hound", 5) == 0)
      return 2;
    // No, no "hound" either:  Back up and signal failure.
    sb->seekmark(fence); // Backup to 'fence'
    return -1;
@}
@end smallexample
@end cartouche

@deftypefn Constructor {} streammarker::streammarker (streambuf* @var{sbuf})
Create a @code{streammarker} associated with @var{sbuf}
that remembers the current position of the get pointer.
@end deftypefn

@deftypefn Method int streammarker::delta (streammarker& @var{mark2})
Return the difference between the get positions corresponding
to @code{*this} and @var{mark2} (which must point into the same
@code{streambuffer} as @code{this}).
@end deftypefn

@deftypefn Method int streammarker::delta ()
Return the position relative to the streambuffer's current get position.
@end deftypefn

@deftypefn Method int streambuf::seekmark (streammarker& @var{mark})
Move the get pointer to where it (logically) was when @var{mark}
was constructed.
@end deftypefn

@node Indirectbuf
@section Forwarding I/O activity

An @dfn{indirectbuf} is one that forwards all of its I/O requests
to another streambuf.

@ignore
@c FIXME-future: get_stream and put_stream are so far undocumented.
All get-related requests are sent to get_stream().
All put-related requests are sent to put_stream().
@end ignore

An @code{indirectbuf} can be used to implement Common Lisp
synonym-streams and two-way-streams:

@example
class synonymbuf : public indirectbuf @{
   Symbol *sym;
   synonymbuf(Symbol *s) @{ sym = s; @}
   virtual streambuf *lookup_stream(int mode) @{
       return coerce_to_streambuf(lookup_value(sym)); @}
@};
@end example

@node Stdio
@chapter C Input and Output

@code{libio} is distributed with a complete implementation of the ANSI C
@code{stdio} facility.  It is implemented using @code{streambuf}
objects.  @xref{Stdiobuf,,Wrappers for C @code{stdio}}.

The @code{stdio} package is intended as a replacement for the whatever
@code{stdio} is in your C library.
@ignore
@c FIXME-future:  This is not useful unless we specify what problems.
It can co-exist with C libraries that have alternate implementations of
stdio, but there may be some problems.
@end ignore
Since @code{stdio} works best when you build @code{libc} to contain it, and
that may be inconvenient, it is not installed by default.

Extensions beyond @sc{ansi}:

@itemize @bullet
@item
A stdio @code{FILE} is identical to a streambuf.
Hence there is no need to worry about synchronizing C and C++
input/output---they are by definition always synchronized.

@item
If you create a new streambuf sub-class (in C++), you can use it as a
@code{FILE} from C.  Thus the system is extensible using the standard
@code{streambuf} protocol.

@item
You can arbitrarily mix reading and writing, without having to seek
in between.

@item
Unbounded @code{ungetc()} buffer.
@end itemize

@ignore
@c FIXME-future: Per says this is not ready to go public at v0.5
@node Libio buffer management
@chapter Libio buffer management

The libio user functions present an abstract sequence of characters,
that they read and write from.  A number of buffers are used to go
between the user program and the abstract sequence.  These buffers are
concrete arrays of characters that contain some sub-sequence of the
abstract sequence.

The libio buffer management protocol is fairly complex.  Its design is
based on the C++ @code{streambuf} protocol, so that the C++
@code{streambuf} classes can be trivially implemented on top of the
libio protocol.

The @dfn{write area} contains characters waiting for output.

The @dfn{read area} contains characters available for reading.

The @dfn{reserve area} is available to virtual methods.
Usually, the get and/or put areas are part of the reserve area.

The @dfn{main get area} contains characters that have
been read in from the character source, but not yet
read by the application.

The @dfn{backup area} contains previously read data that is being saved
because of a user request, or that have been "unread" (put back).
@end ignore

@ignore
@c Per says this design is not finished
@node Streambuf internals
@chapter Streambuf internals

@menu
* Buffer management::
* Filebuf internals::
@end menu

@node Buffer management
@section Buffer management

@subsection Areas

NOTE:  This chapter is due for an update.

Streambuf buffer management is fairly sophisticated (this is a
nice way to say "complicated").  The standard protocol
has the following "areas":

@itemize @bullet
@cindex put area
@item
The @dfn{put area} contains characters waiting for output.
@cindex get area
@item
The @dfn{get area} contains characters available for reading.
@cindex reserve area
@item
The @dfn{reserve area} is available to virtual methods.
Usually, the get and/or put areas are part of the reserve area.
@end itemize

The @sc{gnu} @code{streambuf} design extends this by supporting two
get areas:
@itemize @bullet
@cindex main get area
@item
The @dfn{main get area} contains characters that have
been read in from the character source, but not yet
read by the application.
@cindex backup area
@item
The @dfn{backup area} contains previously read data that is being
saved because of a user request, or that have been "unread" (putback).
@end itemize

The backup and the main get area are logically contiguous:  That is,
the first character of the main get area follows the last character
of the backup area.

The @dfn{current get area} is whichever one of the backup or
main get areas that is currently being read from.
The other of the two is the @dfn{non-current get area}.

@subsection Pointers

The following @code{char*} pointers define the various areas.

@deftypefn Method char* streambuf::base ()
The start of the reserve area.
@end deftypefn

@deftypefn Method char* streambuf::ebuf ()
The end of the reserve area.
@end deftypefn

@deftypefn Method char* streambuf::Gbase ()
The start of the main get area.
@end deftypefn

@deftypefn Method char* streambuf::eGptr ()
The end of the main get area.
@end deftypefn

@deftypefn Method char* streambuf::Bbase ()
The start of the backup area.
@end deftypefn

@deftypefn Method char* streambuf::Bptr ()
The start of the used part of the backup area.
The area (@code{Bptr()} .. @code{eBptr()}) contains data that has been
pushed back, while (@code{Bbase()} .. @code{eBptr()}) contains unused
space available for future putbacks.
@end deftypefn

@deftypefn Method char* streambuf::eBptr ()
The end of the backup area.
@end deftypefn

@deftypefn Method char* streambuf::Nbase ()
The start of the non-current get area (either @code{main_gbase} or @code{backup_gbase}).
@end deftypefn

@deftypefn Method char* streambuf::eNptr ()
The end of the non-current get area.
@end deftypefn

@node Filebuf internals
@section Filebuf internals

The @code{filebuf} is used a lot, so it is importamt that it be
efficient.  It is also supports rather complex semantics.
so let us examine its implementation.

@subsection Tied read and write pointers

The streambuf model allows completely independent read and write pointers.
However, a @code{filebuf} has only a single logical pointer used
for both reads and writes.  Since the @code{streambuf} protocol
uses @code{gptr()} for reading and @code{pptr()} for writing,
we map the logical file pointer into either @code{gptr()} or @code{pptr()}
at different times.

@itemize @bullet
@item
Reading is allowed when @code{gptr() < egptr()}, which we call get mode.

@item
Writing is allowed when @code{pptr() < epptr()}, which we call put mode.
@end itemize

@noindent
A @code{filebuf} cannot be in get mode and put mode at the same time.

We have up to two buffers:

@itemize @bullet
@item
The backup area, defined by @code{Bbase()}, @code{Bptr()}, and @code{eBptr()}.
This can be empty.

@item
The reserve area, which also contains the main get area.
For an unbuffered file, the (@code{shortbuf()}..@code{shortbuf()+1}) is used,
where @code{shortbuf()} points to a 1-byte buffer that is part of
the @code{filebuf}.
@end itemize

@noindent
The file system's idea of the current position is @code{eGptr()}.

Characters that have been written into a buffer but not yet written
out (flushed) to the file systems are those between @code{pbase()}
and @code{pptr()}.

The end of the valid data bytes is:
@code{pptr() > eGptr() && pptr() < ebuf() ? pptr() : eGptr()}.

If the @code{filebuf} is unbuffered or line buffered,
the @code{eptr()} is @code{pbase()}.  This forces a call
to @code{overflow()} on each put of a character.
The logical @code{epptr()} is @code{epptr() ? ebuf() : NULL}.
(If the buffer is read-only, set @code{pbase()}, @code{pptr()},
and @code{epptr()} to @code{NULL}. NOT!)
@end ignore

@node Index
@unnumbered Index
@printindex cp

@contents
@bye