///////////////////////////////////////////////////////////////////////////////
// This is a modified version of the std::basic_filebuf from libc++
// (http://libcxx.llvm.org/).
// It allows one to create basic_filebuf from an existing FILE* handle or file
// descriptor.
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source License licenses. See LICENSE.TXT for details (included at the
// bottom).
///////////////////////////////////////////////////////////////////////////////
#ifndef KALDI_UTIL_BASIC_FILEBUF_H_
#define KALDI_UTIL_BASIC_FILEBUF_H_
///////////////////////////////////////////////////////////////////////////////
#include <fstream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
///////////////////////////////////////////////////////////////////////////////
namespace kaldi {
///////////////////////////////////////////////////////////////////////////////
template <typename CharT, typename Traits = std::char_traits<CharT> >
class basic_filebuf : public std::basic_streambuf<CharT, Traits> {
public:
typedef CharT char_type;
typedef Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef typename traits_type::state_type state_type;
basic_filebuf();
basic_filebuf(basic_filebuf&& rhs);
virtual ~basic_filebuf();
basic_filebuf& operator=(basic_filebuf&& rhs);
void swap(basic_filebuf& rhs);
bool is_open() const;
basic_filebuf* open(const char* s, std::ios_base::openmode mode);
basic_filebuf* open(const std::string& s, std::ios_base::openmode mode);
basic_filebuf* open(int fd, std::ios_base::openmode mode);
basic_filebuf* open(FILE* f, std::ios_base::openmode mode);
basic_filebuf* close();
FILE* file() { return this->_M_file; }
int fd() { return fileno(this->_M_file); }
protected:
int_type underflow() override;
int_type pbackfail(int_type c = traits_type::eof()) override;
int_type overflow(int_type c = traits_type::eof()) override;
std::basic_streambuf<char_type, traits_type>*
setbuf(char_type* s, std::streamsize n) override;
pos_type seekoff(off_type off, std::ios_base::seekdir way,
std::ios_base::openmode wch =
std::ios_base::in | std::ios_base::out) override;
pos_type seekpos(pos_type sp,
std::ios_base::openmode wch =
std::ios_base::in | std::ios_base::out) override;
int sync() override;
void imbue(const std::locale& loc) override;
protected:
char* _M_extbuf;
const char* _M_extbufnext;
const char* _M_extbufend;
char _M_extbuf_min[8];
size_t _M_ebs;
char_type* _M_intbuf;
size_t _M_ibs;
FILE* _M_file;
const std::codecvt<char_type, char, state_type>* _M_cv;
state_type _M_st;
state_type _M_st_last;
std::ios_base::openmode _M_om;
std::ios_base::openmode _M_cm;
bool _M_owns_eb;
bool _M_owns_ib;
bool _M_always_noconv;
const char* _M_get_mode(std::ios_base::openmode mode);
bool _M_read_mode();
void _M_write_mode();
};
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>::basic_filebuf()
: _M_extbuf(nullptr),
_M_extbufnext(nullptr),
_M_extbufend(nullptr),
_M_ebs(0),
_M_intbuf(nullptr),
_M_ibs(0),
_M_file(nullptr),
_M_cv(nullptr),
_M_st(),
_M_st_last(),
_M_om(std::ios_base::openmode(0)),
_M_cm(std::ios_base::openmode(0)),
_M_owns_eb(false),
_M_owns_ib(false),
_M_always_noconv(false) {
if (std::has_facet<std::codecvt<char_type, char, state_type> >
(this->getloc())) {
_M_cv = &std::use_facet<std::codecvt<char_type, char, state_type> >
(this->getloc());
_M_always_noconv = _M_cv->always_noconv();
}
setbuf(0, 4096);
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>::basic_filebuf(basic_filebuf&& rhs)
: std::basic_streambuf<CharT, Traits>(rhs) {
if (rhs._M_extbuf == rhs._M_extbuf_min) {
_M_extbuf = _M_extbuf_min;
_M_extbufnext = _M_extbuf + (rhs._M_extbufnext - rhs._M_extbuf);
_M_extbufend = _M_extbuf + (rhs._M_extbufend - rhs._M_extbuf);
} else {
_M_extbuf = rhs._M_extbuf;
_M_extbufnext = rhs._M_extbufnext;
_M_extbufend = rhs._M_extbufend;
}
_M_ebs = rhs._M_ebs;
_M_intbuf = rhs._M_intbuf;
_M_ibs = rhs._M_ibs;
_M_file = rhs._M_file;
_M_cv = rhs._M_cv;
_M_st = rhs._M_st;
_M_st_last = rhs._M_st_last;
_M_om = rhs._M_om;
_M_cm = rhs._M_cm;
_M_owns_eb = rhs._M_owns_eb;
_M_owns_ib = rhs._M_owns_ib;
_M_always_noconv = rhs._M_always_noconv;
if (rhs.pbase()) {
if (rhs.pbase() == rhs._M_intbuf)
this->setp(_M_intbuf, _M_intbuf + (rhs. epptr() - rhs.pbase()));
else
this->setp(reinterpret_cast<char_type*>(_M_extbuf),
reinterpret_cast<char_type*>(_M_extbuf)
+ (rhs. epptr() - rhs.pbase()));
this->pbump(rhs. pptr() - rhs.pbase());
} else if (rhs.eback()) {
if (rhs.eback() == rhs._M_intbuf)
this->setg(_M_intbuf, _M_intbuf + (rhs.gptr() - rhs.eback()),
_M_intbuf + (rhs.egptr() - rhs.eback()));
else
this->setg(reinterpret_cast<char_type*>(_M_extbuf),
reinterpret_cast<char_type*>(_M_extbuf) +
(rhs.gptr() - rhs.eback()),
reinterpret_cast<char_type*>(_M_extbuf) +
(rhs.egptr() - rhs.eback()));
}
rhs._M_extbuf = nullptr;
rhs._M_extbufnext = nullptr;
rhs._M_extbufend = nullptr;
rhs._M_ebs = 0;
rhs._M_intbuf = nullptr;
rhs._M_ibs = 0;
rhs._M_file = nullptr;
rhs._M_st = state_type();
rhs._M_st_last = state_type();
rhs._M_om = std::ios_base::openmode(0);
rhs._M_cm = std::ios_base::openmode(0);
rhs._M_owns_eb = false;
rhs._M_owns_ib = false;
rhs.setg(0, 0, 0);
rhs.setp(0, 0);
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
inline
basic_filebuf<CharT, Traits>&
basic_filebuf<CharT, Traits>::operator=(basic_filebuf&& rhs) {
close();
swap(rhs);
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>::~basic_filebuf() {
// try
// {
// close();
// }
// catch (...)
// {
// }
if (_M_owns_eb)
delete [] _M_extbuf;
if (_M_owns_ib)
delete [] _M_intbuf;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
void
basic_filebuf<CharT, Traits>::swap(basic_filebuf& rhs) {
std::basic_streambuf<char_type, traits_type>::swap(rhs);
if (_M_extbuf != _M_extbuf_min && rhs._M_extbuf != rhs._M_extbuf_min) {
std::swap(_M_extbuf, rhs._M_extbuf);
std::swap(_M_extbufnext, rhs._M_extbufnext);
std::swap(_M_extbufend, rhs._M_extbufend);
} else {
ptrdiff_t ln = _M_extbufnext - _M_extbuf;
ptrdiff_t le = _M_extbufend - _M_extbuf;
ptrdiff_t rn = rhs._M_extbufnext - rhs._M_extbuf;
ptrdiff_t re = rhs._M_extbufend - rhs._M_extbuf;
if (_M_extbuf == _M_extbuf_min && rhs._M_extbuf != rhs._M_extbuf_min) {
_M_extbuf = rhs._M_extbuf;
rhs._M_extbuf = rhs._M_extbuf_min;
} else if (_M_extbuf != _M_extbuf_min &&
rhs._M_extbuf == rhs._M_extbuf_min) {
rhs._M_extbuf = _M_extbuf;
_M_extbuf = _M_extbuf_min;
}
_M_extbufnext = _M_extbuf + rn;
_M_extbufend = _M_extbuf + re;
rhs._M_extbufnext = rhs._M_extbuf + ln;
rhs._M_extbufend = rhs._M_extbuf + le;
}
std::swap(_M_ebs, rhs._M_ebs);
std::swap(_M_intbuf, rhs._M_intbuf);
std::swap(_M_ibs, rhs._M_ibs);
std::swap(_M_file, rhs._M_file);
std::swap(_M_cv, rhs._M_cv);
std::swap(_M_st, rhs._M_st);
std::swap(_M_st_last, rhs._M_st_last);
std::swap(_M_om, rhs._M_om);
std::swap(_M_cm, rhs._M_cm);
std::swap(_M_owns_eb, rhs._M_owns_eb);
std::swap(_M_owns_ib, rhs._M_owns_ib);
std::swap(_M_always_noconv, rhs._M_always_noconv);
if (this->eback() == reinterpret_cast<char_type*>(rhs._M_extbuf_min)) {
ptrdiff_t n = this->gptr() - this->eback();
ptrdiff_t e = this->egptr() - this->eback();
this->setg(reinterpret_cast<char_type*>(_M_extbuf_min),
reinterpret_cast<char_type*>(_M_extbuf_min) + n,
reinterpret_cast<char_type*>(_M_extbuf_min) + e);
} else if (this->pbase() ==
reinterpret_cast<char_type*>(rhs._M_extbuf_min)) {
ptrdiff_t n = this->pptr() - this->pbase();
ptrdiff_t e = this->epptr() - this->pbase();
this->setp(reinterpret_cast<char_type*>(_M_extbuf_min),
reinterpret_cast<char_type*>(_M_extbuf_min) + e);
this->pbump(n);
}
if (rhs.eback() == reinterpret_cast<char_type*>(_M_extbuf_min)) {
ptrdiff_t n = rhs.gptr() - rhs.eback();
ptrdiff_t e = rhs.egptr() - rhs.eback();
rhs.setg(reinterpret_cast<char_type*>(rhs._M_extbuf_min),
reinterpret_cast<char_type*>(rhs._M_extbuf_min) + n,
reinterpret_cast<char_type*>(rhs._M_extbuf_min) + e);
} else if (rhs.pbase() == reinterpret_cast<char_type*>(_M_extbuf_min)) {
ptrdiff_t n = rhs.pptr() - rhs.pbase();
ptrdiff_t e = rhs.epptr() - rhs.pbase();
rhs.setp(reinterpret_cast<char_type*>(rhs._M_extbuf_min),
reinterpret_cast<char_type*>(rhs._M_extbuf_min) + e);
rhs.pbump(n);
}
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
inline
void
swap(basic_filebuf<CharT, Traits>& x, basic_filebuf<CharT, Traits>& y) {
x.swap(y);
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
inline
bool
basic_filebuf<CharT, Traits>::is_open() const {
return _M_file != nullptr;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
const char* basic_filebuf<CharT, Traits>::
_M_get_mode(std::ios_base::openmode mode) {
switch ((mode & ~std::ios_base::ate) | 0) {
case std::ios_base::out:
case std::ios_base::out | std::ios_base::trunc:
return "w";
case std::ios_base::out | std::ios_base::app:
case std::ios_base::app:
return "a";
break;
case std::ios_base::in:
return "r";
case std::ios_base::in | std::ios_base::out:
return "r+";
case std::ios_base::in | std::ios_base::out | std::ios_base::trunc:
return "w+";
case std::ios_base::in | std::ios_base::out | std::ios_base::app:
case std::ios_base::in | std::ios_base::app:
return "a+";
case std::ios_base::out | std::ios_base::binary:
case std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:
return "wb";
case std::ios_base::out | std::ios_base::app | std::ios_base::binary:
case std::ios_base::app | std::ios_base::binary:
return "ab";
case std::ios_base::in | std::ios_base::binary:
return "rb";
case std::ios_base::in | std::ios_base::out | std::ios_base::binary:
return "r+b";
case std::ios_base::in | std::ios_base::out | std::ios_base::trunc |
std::ios_base::binary:
return "w+b";
case std::ios_base::in | std::ios_base::out | std::ios_base::app |
std::ios_base::binary:
case std::ios_base::in | std::ios_base::app | std::ios_base::binary:
return "a+b";
default:
return nullptr;
}
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::
open(const char* s, std::ios_base::openmode mode) {
basic_filebuf<CharT, Traits>* rt = nullptr;
if (_M_file == nullptr) {
const char* md= _M_get_mode(mode);
if (md) {
_M_file = fopen(s, md);
if (_M_file) {
rt = this;
_M_om = mode;
if (mode & std::ios_base::ate) {
if (fseek(_M_file, 0, SEEK_END)) {
fclose(_M_file);
_M_file = nullptr;
rt = nullptr;
}
}
}
}
}
return rt;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
inline
basic_filebuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::open(const std::string& s,
std::ios_base::openmode mode) {
return open(s.c_str(), mode);
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::open(int fd, std::ios_base::openmode mode) {
const char* md= this->_M_get_mode(mode);
if (md) {
this->_M_file= fdopen(fd, md);
this->_M_om = mode;
return this;
} else {
return nullptr;
}
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::open(FILE* f, std::ios_base::openmode mode) {
this->_M_file = f;
this->_M_om = mode;
return this;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
basic_filebuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::close() {
basic_filebuf<CharT, Traits>* rt = nullptr;
if (_M_file) {
rt = this;
std::unique_ptr<FILE, int(*)(FILE*)> h(_M_file, fclose);
if (sync())
rt = nullptr;
if (fclose(h.release()) == 0)
_M_file = nullptr;
else
rt = nullptr;
}
return rt;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
typename basic_filebuf<CharT, Traits>::int_type
basic_filebuf<CharT, Traits>::underflow() {
if (_M_file == nullptr)
return traits_type::eof();
bool initial = _M_read_mode();
char_type buf;
if (this->gptr() == nullptr)
this->setg(&buf, &buf+1, &buf+1);
const size_t unget_sz = initial ? 0 : std::
min<size_t>((this->egptr() - this->eback()) / 2, 4);
int_type c = traits_type::eof();
if (this->gptr() == this->egptr()) {
memmove(this->eback(), this->egptr() - unget_sz,
unget_sz * sizeof(char_type));
if (_M_always_noconv) {
size_t nmemb = static_cast<size_t>
(this->egptr() - this->eback() - unget_sz);
nmemb = fread(this->eback() + unget_sz, 1, nmemb, _M_file);
if (nmemb != 0) {
this->setg(this->eback(),
this->eback() + unget_sz,
this->eback() + unget_sz + nmemb);
c = traits_type::to_int_type(*this->gptr());
}
} else {
memmove(_M_extbuf, _M_extbufnext, _M_extbufend - _M_extbufnext);
_M_extbufnext = _M_extbuf + (_M_extbufend - _M_extbufnext);
_M_extbufend = _M_extbuf +
(_M_extbuf == _M_extbuf_min ? sizeof(_M_extbuf_min) : _M_ebs);
size_t nmemb = std::min(static_cast<size_t>(_M_ibs - unget_sz),
static_cast<size_t>
(_M_extbufend - _M_extbufnext));
std::codecvt_base::result r;
_M_st_last = _M_st;
size_t nr = fread(
reinterpret_cast<void*>(const_cast<char_type*>(_M_extbufnext)),
1, nmemb, _M_file);
if (nr != 0) {
if (!_M_cv)
throw std::bad_cast();
_M_extbufend = _M_extbufnext + nr;
char_type* inext;
r = _M_cv->in(_M_st, _M_extbuf, _M_extbufend, _M_extbufnext,
this->eback() + unget_sz,
this->eback() + _M_ibs, inext);
if (r == std::codecvt_base::noconv) {
this->setg(reinterpret_cast<char_type*>(_M_extbuf),
reinterpret_cast<char_type*>(_M_extbuf),
const_cast<char_type*>(_M_extbufend));
c = traits_type::to_int_type(*this->gptr());
} else if (inext != this->eback() + unget_sz) {
this->setg(this->eback(), this->eback() + unget_sz, inext);
c = traits_type::to_int_type(*this->gptr());
}
}
}
} else {
c = traits_type::to_int_type(*this->gptr());
}
if (this->eback() == &buf)
this->setg(0, 0, 0);
return c;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
typename basic_filebuf<CharT, Traits>::int_type
basic_filebuf<CharT, Traits>::pbackfail(int_type c) {
if (_M_file && this->eback() < this->gptr()) {
if (traits_type::eq_int_type(c, traits_type::eof())) {
this->gbump(-1);
return traits_type::not_eof(c);
}
if ((_M_om & std::ios_base::out) ||
traits_type::eq(traits_type::to_char_type(c), this->gptr()[-1])) {
this->gbump(-1);
*this->gptr() = traits_type::to_char_type(c);
return c;
}
}
return traits_type::eof();
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
typename basic_filebuf<CharT, Traits>::int_type
basic_filebuf<CharT, Traits>::overflow(int_type c) {
if (_M_file == nullptr)
return traits_type::eof();
_M_write_mode();
char_type buf;
char_type* pb_save = this->pbase();
char_type* epb_save = this->epptr();
if (!traits_type::eq_int_type(c, traits_type::eof())) {
if (this->pptr() == nullptr)
this->setp(&buf, &buf+1);
*this->pptr() = traits_type::to_char_type(c);
this->pbump(1);
}
if (this->pptr() != this->pbase()) {
if (_M_always_noconv) {
size_t nmemb = static_cast<size_t>(this->pptr() - this->pbase());
if (fwrite(this->pbase(), sizeof(char_type),
nmemb, _M_file) != nmemb)
return traits_type::eof();
} else {
char* extbe = _M_extbuf;
std::codecvt_base::result r;
do {
if (!_M_cv)
throw std::bad_cast();
const char_type* e;
r = _M_cv->out(_M_st, this->pbase(), this->pptr(), e,
_M_extbuf, _M_extbuf + _M_ebs, extbe);
if (e == this->pbase())
return traits_type::eof();
if (r == std::codecvt_base::noconv) {
size_t nmemb = static_cast<size_t>
(this->pptr() - this->pbase());
if (fwrite(this->pbase(), 1, nmemb, _M_file) != nmemb)
return traits_type::eof();
} else if (r == std::codecvt_base::ok ||
r == std::codecvt_base::partial) {
size_t nmemb = static_cast<size_t>(extbe - _M_extbuf);
if (fwrite(_M_extbuf, 1, nmemb, _M_file) != nmemb)
return traits_type::eof();
if (r == std::codecvt_base::partial) {
this->setp(const_cast<char_type*>(e),
this->pptr());
this->pbump(this->epptr() - this->pbase());
}
} else {
return traits_type::eof();
}
} while (r == std::codecvt_base::partial);
}
this->setp(pb_save, epb_save);
}
return traits_type::not_eof(c);
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
std::basic_streambuf<CharT, Traits>*
basic_filebuf<CharT, Traits>::setbuf(char_type* s, std::streamsize n) {
this->setg(0, 0, 0);
this->setp(0, 0);
if (_M_owns_eb)
delete [] _M_extbuf;
if (_M_owns_ib)
delete [] _M_intbuf;
_M_ebs = n;
if (_M_ebs > sizeof(_M_extbuf_min)) {
if (_M_always_noconv && s) {
_M_extbuf = reinterpret_cast<char*>(s);
_M_owns_eb = false;
} else {
_M_extbuf = new char[_M_ebs];
_M_owns_eb = true;
}
} else {
_M_extbuf = _M_extbuf_min;
_M_ebs = sizeof(_M_extbuf_min);
_M_owns_eb = false;
}
if (!_M_always_noconv) {
_M_ibs = std::max<std::streamsize>(n, sizeof(_M_extbuf_min));
if (s && _M_ibs >= sizeof(_M_extbuf_min)) {
_M_intbuf = s;
_M_owns_ib = false;
} else {
_M_intbuf = new char_type[_M_ibs];
_M_owns_ib = true;
}
} else {
_M_ibs = 0;
_M_intbuf = 0;
_M_owns_ib = false;
}
return this;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
typename basic_filebuf<CharT, Traits>::pos_type
basic_filebuf<CharT, Traits>::seekoff(off_type off, std::ios_base::seekdir way,
std::ios_base::openmode) {
if (!_M_cv)
throw std::bad_cast();
int width = _M_cv->encoding();
if (_M_file == nullptr || (width <= 0 && off != 0) || sync())
return pos_type(off_type(-1));
// width > 0 || off == 0
int whence;
switch (way) {
case std::ios_base::beg:
whence = SEEK_SET;
break;
case std::ios_base::cur:
whence = SEEK_CUR;
break;
case std::ios_base::end:
whence = SEEK_END;
break;
default:
return pos_type(off_type(-1));
}
#if _WIN32
if (fseek(_M_file, width > 0 ? width * off : 0, whence))
return pos_type(off_type(-1));
pos_type r = ftell(_M_file);
#else
if (fseeko(_M_file, width > 0 ? width * off : 0, whence))
return pos_type(off_type(-1));
pos_type r = ftello(_M_file);
#endif
r.state(_M_st);
return r;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
typename basic_filebuf<CharT, Traits>::pos_type
basic_filebuf<CharT, Traits>::seekpos(pos_type sp, std::ios_base::openmode) {
if (_M_file == nullptr || sync())
return pos_type(off_type(-1));
#if _WIN32
if (fseek(_M_file, sp, SEEK_SET))
return pos_type(off_type(-1));
#else
if (fseeko(_M_file, sp, SEEK_SET))
return pos_type(off_type(-1));
#endif
_M_st = sp.state();
return sp;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
int
basic_filebuf<CharT, Traits>::sync() {
if (_M_file == nullptr)
return 0;
if (!_M_cv)
throw std::bad_cast();
if (_M_cm & std::ios_base::out) {
if (this->pptr() != this->pbase())
if (overflow() == traits_type::eof())
return -1;
std::codecvt_base::result r;
do {
char* extbe;
r = _M_cv->unshift(_M_st, _M_extbuf, _M_extbuf + _M_ebs, extbe);
size_t nmemb = static_cast<size_t>(extbe - _M_extbuf);
if (fwrite(_M_extbuf, 1, nmemb, _M_file) != nmemb)
return -1;
} while (r == std::codecvt_base::partial);
if (r == std::codecvt_base::error)
return -1;
if (fflush(_M_file))
return -1;
} else if (_M_cm & std::ios_base::in) {
off_type c;
state_type state = _M_st_last;
bool update_st = false;
if (_M_always_noconv) {
c = this->egptr() - this->gptr();
} else {
int width = _M_cv->encoding();
c = _M_extbufend - _M_extbufnext;
if (width > 0) {
c += width * (this->egptr() - this->gptr());
} else {
if (this->gptr() != this->egptr()) {
const int off = _M_cv->length(state, _M_extbuf,
_M_extbufnext,
this->gptr() - this->eback());
c += _M_extbufnext - _M_extbuf - off;
update_st = true;
}
}
}
#if _WIN32
if (fseek(_M_file_, -c, SEEK_CUR))
return -1;
#else
if (fseeko(_M_file, -c, SEEK_CUR))
return -1;
#endif
if (update_st)
_M_st = state;
_M_extbufnext = _M_extbufend = _M_extbuf;
this->setg(0, 0, 0);
_M_cm = std::ios_base::openmode(0);
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
void
basic_filebuf<CharT, Traits>::imbue(const std::locale& loc) {
sync();
_M_cv = &std::use_facet<std::codecvt<char_type, char, state_type> >(loc);
bool old_anc = _M_always_noconv;
_M_always_noconv = _M_cv->always_noconv();
if (old_anc != _M_always_noconv) {
this->setg(0, 0, 0);
this->setp(0, 0);
// invariant, char_type is char, else we couldn't get here
// need to dump _M_intbuf
if (_M_always_noconv) {
if (_M_owns_eb)
delete [] _M_extbuf;
_M_owns_eb = _M_owns_ib;
_M_ebs = _M_ibs;
_M_extbuf = reinterpret_cast<char*>(_M_intbuf);
_M_ibs = 0;
_M_intbuf = nullptr;
_M_owns_ib = false;
} else { // need to obtain an _M_intbuf.
// If _M_extbuf is user-supplied, use it, else new _M_intbuf
if (!_M_owns_eb && _M_extbuf != _M_extbuf_min) {
_M_ibs = _M_ebs;
_M_intbuf = reinterpret_cast<char_type*>(_M_extbuf);
_M_owns_ib = false;
_M_extbuf = new char[_M_ebs];
_M_owns_eb = true;
} else {
_M_ibs = _M_ebs;
_M_intbuf = new char_type[_M_ibs];
_M_owns_ib = true;
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
bool
basic_filebuf<CharT, Traits>::_M_read_mode() {
if (!(_M_cm & std::ios_base::in)) {
this->setp(0, 0);
if (_M_always_noconv)
this->setg(reinterpret_cast<char_type*>(_M_extbuf),
reinterpret_cast<char_type*>(_M_extbuf) + _M_ebs,
reinterpret_cast<char_type*>(_M_extbuf) + _M_ebs);
else
this->setg(_M_intbuf, _M_intbuf + _M_ibs, _M_intbuf + _M_ibs);
_M_cm = std::ios_base::in;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
template <class CharT, class Traits>
void
basic_filebuf<CharT, Traits>::_M_write_mode() {
if (!(_M_cm & std::ios_base::out)) {
this->setg(0, 0, 0);
if (_M_ebs > sizeof(_M_extbuf_min)) {
if (_M_always_noconv)
this->setp(reinterpret_cast<char_type*>(_M_extbuf),
reinterpret_cast<char_type*>(_M_extbuf) +
(_M_ebs - 1));
else
this->setp(_M_intbuf, _M_intbuf + (_M_ibs - 1));
} else {
this->setp(0, 0);
}
_M_cm = std::ios_base::out;
}
}
///////////////////////////////////////////////////////////////////////////////
}
///////////////////////////////////////////////////////////////////////////////
#endif // KALDI_UTIL_BASIC_FILEBUF_H_
///////////////////////////////////////////////////////////////////////////////
/*
* ============================================================================
* libc++ License
* ============================================================================
*
* The libc++ library is dual licensed under both the University of Illinois
* "BSD-Like" license and the MIT license. As a user of this code you may
* choose to use it under either license. As a contributor, you agree to allow
* your code to be used under both.
*
* Full text of the relevant licenses is included below.
*
* ============================================================================
*
* University of Illinois/NCSA
* Open Source License
*
* Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT (included below)
*
* All rights reserved.
*
* Developed by:
*
* LLVM Team
*
* University of Illinois at Urbana-Champaign
*
* http://llvm.org
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal with
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimers.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimers in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the names of the LLVM Team, University of Illinois at
* Urbana-Champaign, nor the names of its contributors may be used to
* endorse or promote products derived from this Software without specific
* prior written permission.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
* SOFTWARE.
*
* ==============================================================================
*
* Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT (included below)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* ==============================================================================
*
* This file is a partial list of people who have contributed to the LLVM/libc++
* project. If you have contributed a patch or made some other contribution to
* LLVM/libc++, please submit a patch to this file to add yourself, and it will be
* done!
*
* The list is sorted by surname and formatted to allow easy grepping and
* beautification by scripts. The fields are: name (N), email (E), web-address
* (W), PGP key ID and fingerprint (P), description (D), and snail-mail address
* (S).
*
* N: Saleem Abdulrasool
* E: compnerd@compnerd.org
* D: Minor patches and Linux fixes.
*
* N: Dimitry Andric
* E: dimitry@andric.com
* D: Visibility fixes, minor FreeBSD portability patches.
*
* N: Holger Arnold
* E: holgerar@gmail.com
* D: Minor fix.
*
* N: Ruben Van Boxem
* E: vanboxem dot ruben at gmail dot com
* D: Initial Windows patches.
*
* N: David Chisnall
* E: theraven at theravensnest dot org
* D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.
*
* N: Marshall Clow
* E: mclow.lists@gmail.com
* E: marshall@idio.com
* D: C++14 support, patches and bug fixes.
*
* N: Bill Fisher
* E: william.w.fisher@gmail.com
* D: Regex bug fixes.
*
* N: Matthew Dempsky
* E: matthew@dempsky.org
* D: Minor patches and bug fixes.
*
* N: Google Inc.
* D: Copyright owner and contributor of the CityHash algorithm
*
* N: Howard Hinnant
* E: hhinnant@apple.com
* D: Architect and primary author of libc++
*
* N: Hyeon-bin Jeong
* E: tuhertz@gmail.com
* D: Minor patches and bug fixes.
*
* N: Argyrios Kyrtzidis
* E: kyrtzidis@apple.com
* D: Bug fixes.
*
* N: Bruce Mitchener, Jr.
* E: bruce.mitchener@gmail.com
* D: Emscripten-related changes.
*
* N: Michel Morin
* E: mimomorin@gmail.com
* D: Minor patches to is_convertible.
*
* N: Andrew Morrow
* E: andrew.c.morrow@gmail.com
* D: Minor patches and Linux fixes.
*
* N: Arvid Picciani
* E: aep at exys dot org
* D: Minor patches and musl port.
*
* N: Bjorn Reese
* E: breese@users.sourceforge.net
* D: Initial regex prototype
*
* N: Nico Rieck
* E: nico.rieck@gmail.com
* D: Windows fixes
*
* N: Jonathan Sauer
* D: Minor patches, mostly related to constexpr
*
* N: Craig Silverstein
* E: csilvers@google.com
* D: Implemented Cityhash as the string hash function on 64-bit machines
*
* N: Richard Smith
* D: Minor patches.
*
* N: Joerg Sonnenberger
* E: joerg@NetBSD.org
* D: NetBSD port.
*
* N: Stephan Tolksdorf
* E: st@quanttec.com
* D: Minor <atomic> fix
*
* N: Michael van der Westhuizen
* E: r1mikey at gmail dot com
*
* N: Klaas de Vries
* E: klaas at klaasgaaf dot nl
* D: Minor bug fix.
*
* N: Zhang Xiongpang
* E: zhangxiongpang@gmail.com
* D: Minor patches and bug fixes.
*
* N: Xing Xue
* E: xingxue@ca.ibm.com
* D: AIX port
*
* N: Zhihao Yuan
* E: lichray@gmail.com
* D: Standard compatibility fixes.
*
* N: Jeffrey Yasskin
* E: jyasskin@gmail.com
* E: jyasskin@google.com
* D: Linux fixes.
*/