/*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_FSTREAM_C
#define _STLP_FSTREAM_C
#ifndef _STLP_INTERNAL_FSTREAM_H
# include <stl/_fstream.h>
#endif
#ifndef _STLP_INTERNAL_LIMITS
# include <stl/_limits.h>
#endif
_STLP_BEGIN_NAMESPACE
# if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
// no wchar_t is supported for this mode
# define __BF_int_type__ int
# define __BF_pos_type__ streampos
# define __BF_off_type__ streamoff
# else
# define __BF_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type
# define __BF_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::pos_type
# define __BF_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::off_type
# endif
//----------------------------------------------------------------------
// Public basic_filebuf<> member functions
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::basic_filebuf()
: basic_streambuf<_CharT, _Traits>(), _M_base(),
_M_constant_width(false), _M_always_noconv(false),
_M_int_buf_dynamic(false),
_M_in_input_mode(false), _M_in_output_mode(false),
_M_in_error_mode(false), _M_in_putback_mode(false),
_M_int_buf(0), _M_int_buf_EOS(0),
_M_ext_buf(0), _M_ext_buf_EOS(0),
_M_ext_buf_converted(0), _M_ext_buf_end(0),
_M_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
_M_end_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
_M_mmap_base(0), _M_mmap_len(0),
_M_saved_eback(0), _M_saved_gptr(0), _M_saved_egptr(0),
_M_codecvt(0),
_M_width(1), _M_max_width(1)
{
this->_M_setup_codecvt(locale(), false);
}
template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::close() {
bool __ok = this->is_open();
if (_M_in_output_mode) {
__ok = __ok && !_Traits::eq_int_type(this->overflow(traits_type::eof()),
traits_type::eof());
__ok == __ok && this->_M_unshift();
}
else if (_M_in_input_mode)
this->_M_exit_input_mode();
// Note order of arguments. We close the file even if __ok is false.
__ok = _M_base._M_close() && __ok;
// Restore the initial state, except that we don't deallocate the buffer
// or mess with the cached codecvt information.
_M_state = _M_end_state = _State_type();
_M_ext_buf_converted = _M_ext_buf_end = 0;
_M_mmap_base = 0;
_M_mmap_len = 0;
this->setg(0, 0, 0);
this->setp(0, 0);
_M_saved_eback = _M_saved_gptr = _M_saved_egptr = 0;
_M_in_input_mode = _M_in_output_mode = _M_in_error_mode = _M_in_putback_mode
= false;
return __ok ? this : 0;
}
// This member function is called whenever we exit input mode.
// It unmaps the memory-mapped file, if any, and sets
// _M_in_input_mode to false.
template <class _CharT, class _Traits>
void basic_filebuf<_CharT, _Traits>::_M_exit_input_mode() {
if (_M_mmap_base != 0)
_M_base._M_unmap(_M_mmap_base, _M_mmap_len);
_M_in_input_mode = false;
_M_mmap_base = 0;
}
//----------------------------------------------------------------------
// basic_filebuf<> helper functions.
//----------------------------------------
// Helper functions for switching between modes.
// This member function is called if we're performing the first I/O
// operation on a filebuf, or if we're performing an input operation
// immediately after a seek.
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_switch_to_input_mode() {
if (this->is_open() && (((int)_M_base.__o_mode() & (int)ios_base::in) != 0)
&& (_M_in_output_mode == 0) && (_M_in_error_mode == 0)) {
if (!_M_int_buf && !_M_allocate_buffers())
return false;
_M_ext_buf_converted = _M_ext_buf;
_M_ext_buf_end = _M_ext_buf;
_M_end_state = _M_state;
_M_in_input_mode = true;
return true;
}
return false;
}
// This member function is called if we're performing the first I/O
// operation on a filebuf, or if we're performing an output operation
// immediately after a seek.
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_switch_to_output_mode() {
if (this->is_open() && (_M_base.__o_mode() & (int)ios_base::out) &&
_M_in_input_mode == 0 && _M_in_error_mode == 0) {
if (!_M_int_buf && !_M_allocate_buffers())
return false;
// In append mode, every write does an implicit seek to the end
// of the file. Whenever leaving output mode, the end of file
// get put in the initial shift state.
if (_M_base.__o_mode() & ios_base::app)
_M_state = _State_type();
this->setp(_M_int_buf, _M_int_buf_EOS - 1);
_M_in_output_mode = true;
return true;
}
return false;
}
//----------------------------------------
// Helper functions for input
// This member function is called if there is an error during input.
// It puts the filebuf in error mode, clear the get area buffer, and
// returns eof.
// returns eof. Error mode is sticky; it is cleared only by close or
// seek.
template <class _CharT, class _Traits>
__BF_int_type__
basic_filebuf<_CharT, _Traits>::_M_input_error() {
this->_M_exit_input_mode();
_M_in_output_mode = false;
_M_in_error_mode = true;
this->setg(0, 0, 0);
return traits_type::eof();
}
template <class _CharT, class _Traits>
__BF_int_type__
basic_filebuf<_CharT, _Traits>::_M_underflow_aux() {
// We have the state and file position from the end of the internal
// buffer. This round, they become the beginning of the internal buffer.
_M_state = _M_end_state;
// Fill the external buffer. Start with any leftover characters that
// didn't get converted last time.
if (_M_ext_buf_end > _M_ext_buf_converted)
_M_ext_buf_end = copy(_M_ext_buf_converted, _M_ext_buf_end, _M_ext_buf);
// boris : copy_backward did not work
//_M_ext_buf_end = copy_backward(_M_ext_buf_converted, _M_ext_buf_end,
//_M_ext_buf+ (_M_ext_buf_end - _M_ext_buf_converted));
else
_M_ext_buf_end = _M_ext_buf;
// Now fill the external buffer with characters from the file. This is
// a loop because occasionally we don't get enough external characters
// to make progress.
for (;;) {
ptrdiff_t __n = _M_base._M_read(_M_ext_buf_end, _M_ext_buf_EOS - _M_ext_buf_end);
// Don't enter error mode for a failed read. Error mode is sticky,
// and we might succeed if we try again.
if (__n <= 0)
return traits_type::eof();
// Convert the external buffer to internal characters.
_M_ext_buf_end += __n;
const char* __enext;
_CharT* __inext;
typename _Codecvt::result __status
= _M_codecvt->in(_M_end_state,
_M_ext_buf, _M_ext_buf_end, __enext,
_M_int_buf, _M_int_buf_EOS, __inext);
// Error conditions: (1) Return value of error. (2) Producing internal
// characters without consuming external characters. (3) In fixed-width
// encodings, producing an internal sequence whose length is inconsistent
// with that of the internal sequence. (4) Failure to produce any
// characters if we have enough characters in the external buffer, where
// "enough" means the largest possible width of a single character.
if (__status == _Codecvt::noconv)
return _Noconv_input<_Traits>::_M_doit(this);
else if (__status == _Codecvt::error ||
(__inext != _M_int_buf && __enext == _M_ext_buf) ||
(_M_constant_width &&
// __inext - _M_int_buf != _M_width * (__enext - _M_ext_buf)) ||
(__inext - _M_int_buf) * _M_width != (__enext - _M_ext_buf)) ||
(__inext == _M_int_buf && __enext - _M_ext_buf >= _M_max_width))
return _M_input_error();
else if (__inext != _M_int_buf) {
_M_ext_buf_converted = _M_ext_buf + (__enext - _M_ext_buf);
this->setg(_M_int_buf, _M_int_buf, __inext);
return traits_type::to_int_type(*_M_int_buf);
}
// We need to go around the loop again to get more external characters.
}
}
//----------------------------------------
// Helper functions for output
// This member function is called if there is an error during output.
// It puts the filebuf in error mode, clear the put area buffer, and
// returns eof. Error mode is sticky; it is cleared only by close or
// seek.
template <class _CharT, class _Traits>
__BF_int_type__
basic_filebuf<_CharT, _Traits>::_M_output_error() {
_M_in_output_mode = false;
_M_in_input_mode = false;
_M_in_error_mode = true;
this->setp(0, 0);
return traits_type::eof();
}
// Write whatever sequence of characters is necessary to get back to
// the initial shift state. This function overwrites the external
// buffer, changes the external file position, and changes the state.
// Precondition: the internal buffer is empty.
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_unshift() {
if (_M_in_output_mode && !_M_constant_width) {
typename _Codecvt::result __status;
do {
char* __enext = _M_ext_buf;
__status = _M_codecvt->unshift(_M_state,
_M_ext_buf, _M_ext_buf_EOS, __enext);
if (__status == _Codecvt::noconv ||
(__enext == _M_ext_buf && __status == _Codecvt::ok))
return true;
else if (__status == _Codecvt::error)
return false;
else if (!_M_write(_M_ext_buf, __enext - _M_ext_buf))
return false;
} while (__status == _Codecvt::partial);
}
return true;
}
//----------------------------------------
// Helper functions for buffer allocation and deallocation
// This member function is called when we're initializing a filebuf's
// internal and external buffers. The argument is the size of the
// internal buffer; the external buffer is sized using the character
// width in the current encoding. Preconditions: the buffers are currently
// null. __n >= 1. __buf is either a null pointer or a pointer to an
// array show size is at least __n.
// We need __n >= 1 for two different reasons. For input, the base
// class always needs a buffer because of the semantics of underflow().
// For output, we want to have an internal buffer that's larger by one
// element than the buffer that the base class knows about. (See
// basic_filebuf<>::overflow() for the reason.)
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_allocate_buffers(_CharT* __buf, streamsize __n) {
//The major hypothesis in the following implementation is that size_t is unsigned.
//We also need streamsize byte representation to be larger or equal to the int
//representation to correctly store the encoding information.
_STLP_STATIC_ASSERT(!numeric_limits<size_t>::is_signed &&
sizeof(streamsize) >= sizeof(int))
if (__buf == 0) {
streamsize __bufsize = __n * sizeof(_CharT);
//We first check that the streamsize representation can't overflow a size_t one.
//If it can, we check that __bufsize is not higher than the size_t max value.
if ((sizeof(streamsize) > sizeof(size_t)) &&
(__bufsize > __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)())))
return false;
_M_int_buf = __STATIC_CAST(_CharT*, malloc(__STATIC_CAST(size_t, __bufsize)));
if (!_M_int_buf)
return false;
_M_int_buf_dynamic = true;
}
else {
_M_int_buf = __buf;
_M_int_buf_dynamic = false;
}
streamsize __ebufsiz = (max)(__n * __STATIC_CAST(streamsize, _M_width),
__STATIC_CAST(streamsize, _M_codecvt->max_length()));
_M_ext_buf = 0;
if ((sizeof(streamsize) < sizeof(size_t)) ||
((sizeof(streamsize) == sizeof(size_t)) && numeric_limits<streamsize>::is_signed) ||
(__ebufsiz <= __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()))) {
_M_ext_buf = __STATIC_CAST(char*, malloc(__STATIC_CAST(size_t, __ebufsiz)));
}
if (!_M_ext_buf) {
_M_deallocate_buffers();
return false;
}
_M_int_buf_EOS = _M_int_buf + __STATIC_CAST(ptrdiff_t, __n);
_M_ext_buf_EOS = _M_ext_buf + __STATIC_CAST(ptrdiff_t, __ebufsiz);
return true;
}
// Abbreviation for the most common case.
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_allocate_buffers() {
// Choose a buffer that's at least 4096 characters long and that's a
// multiple of the page size.
streamsize __default_bufsiz =
((_M_base.__page_size() + 4095UL) / _M_base.__page_size()) * _M_base.__page_size();
return _M_allocate_buffers(0, __default_bufsiz);
}
template <class _CharT, class _Traits>
void basic_filebuf<_CharT, _Traits>::_M_deallocate_buffers() {
if (_M_int_buf_dynamic)
free(_M_int_buf);
free(_M_ext_buf);
_M_int_buf = 0;
_M_int_buf_EOS = 0;
_M_ext_buf = 0;
_M_ext_buf_EOS = 0;
}
//----------------------------------------
// Helper functiosn for seek and imbue
template <class _CharT, class _Traits>
bool basic_filebuf<_CharT, _Traits>::_M_seek_init(bool __do_unshift) {
// If we're in error mode, leave it.
_M_in_error_mode = false;
// Flush the output buffer if we're in output mode, and (conditionally)
// emit an unshift sequence.
if (_M_in_output_mode) {
bool __ok = !traits_type::eq_int_type(this->overflow(traits_type::eof()),
traits_type::eof());
if (__do_unshift)
__ok = __ok && this->_M_unshift();
if (!__ok) {
_M_in_output_mode = false;
_M_in_error_mode = true;
this->setp(0, 0);
return false;
}
}
// Discard putback characters, if any.
if (_M_in_input_mode && _M_in_putback_mode)
_M_exit_putback_mode();
return true;
}
/* Change the filebuf's locale. This member function has no effect
* unless it is called before any I/O is performed on the stream.
* This function is called on construction and on an imbue call. In the
* case of the construction the codecvt facet might be a custom one if
* the basic_filebuf user has instanciate it with a custom char_traits.
* The user will have to call imbue before any I/O operation.
*/
template <class _CharT, class _Traits>
void basic_filebuf<_CharT, _Traits>::_M_setup_codecvt(const locale& __loc, bool __on_imbue) {
if (has_facet<_Codecvt>(__loc)) {
_M_codecvt = &use_facet<_Codecvt>(__loc) ;
int __encoding = _M_codecvt->encoding();
_M_width = (max)(__encoding, 1);
_M_max_width = _M_codecvt->max_length();
_M_constant_width = __encoding > 0;
_M_always_noconv = _M_codecvt->always_noconv();
}
else {
_M_codecvt = 0;
_M_width = _M_max_width = 1;
_M_constant_width = _M_always_noconv = false;
if (__on_imbue) {
//This call will generate an exception reporting the problem.
use_facet<_Codecvt>(__loc);
}
}
}
_STLP_END_NAMESPACE
# undef __BF_int_type__
# undef __BF_pos_type__
# undef __BF_off_type__
#endif /* _STLP_FSTREAM_C */
// Local Variables:
// mode:C++
// End: