// Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
// Copyright (c) 2016 Google, Inc.
//
// 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.
#ifndef ANDROID_DVR_PERFORMANCED_STDIO_FILEBUF_H_
#define ANDROID_DVR_PERFORMANCED_STDIO_FILEBUF_H_
#include <cstdio>
#include <istream>
#include <locale>
#include <streambuf>
namespace android {
namespace dvr {
// An implementation of std::basic_streambuf backed by a FILE pointer. This is
// ported from the internal llvm-libc++ support for std::cin. It's really
// unfortunate that we have to do this, but the C++11 standard is too pendantic
// to support creating streams from file descriptors or FILE pointers. This
// implementation uses all standard interfaces, except for the call to
// std::__throw_runtime_error(), which is only needed to deal with exceeding
// locale encoding limits. This class is meant to be used for reading system
// files, which don't require exotic locale support, so this call could be
// removed in the future, if necessary.
//
// Original source file: llvm-libcxx/llvm-libc++/include/__std_stream
// Original class name: __stdinbuf
//
template <class _CharT>
class stdio_filebuf
: public std::basic_streambuf<_CharT, std::char_traits<_CharT> > {
public:
typedef _CharT char_type;
typedef std::char_traits<char_type> 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;
explicit stdio_filebuf(FILE* __fp);
~stdio_filebuf() override;
protected:
virtual int_type underflow() override;
virtual int_type uflow() override;
virtual int_type pbackfail(int_type __c = traits_type::eof()) override;
virtual void imbue(const std::locale& __loc) override;
private:
FILE* __file_;
const std::codecvt<char_type, char, state_type>* __cv_;
state_type __st_;
int __encoding_;
int_type __last_consumed_;
bool __last_consumed_is_next_;
bool __always_noconv_;
stdio_filebuf(const stdio_filebuf&);
stdio_filebuf& operator=(const stdio_filebuf&);
int_type __getchar(bool __consume);
static const int __limit = 8;
};
template <class _CharT>
stdio_filebuf<_CharT>::stdio_filebuf(FILE* __fp)
: __file_(__fp),
__last_consumed_(traits_type::eof()),
__last_consumed_is_next_(false) {
imbue(this->getloc());
}
template <class _CharT>
stdio_filebuf<_CharT>::~stdio_filebuf() {
if (__file_)
fclose(__file_);
}
template <class _CharT>
void stdio_filebuf<_CharT>::imbue(const std::locale& __loc) {
__cv_ = &std::use_facet<std::codecvt<char_type, char, state_type> >(__loc);
__encoding_ = __cv_->encoding();
__always_noconv_ = __cv_->always_noconv();
if (__encoding_ > __limit)
std::__throw_runtime_error("unsupported locale for standard io");
}
template <class _CharT>
typename stdio_filebuf<_CharT>::int_type stdio_filebuf<_CharT>::underflow() {
return __getchar(false);
}
template <class _CharT>
typename stdio_filebuf<_CharT>::int_type stdio_filebuf<_CharT>::uflow() {
return __getchar(true);
}
template <class _CharT>
typename stdio_filebuf<_CharT>::int_type stdio_filebuf<_CharT>::__getchar(
bool __consume) {
if (__last_consumed_is_next_) {
int_type __result = __last_consumed_;
if (__consume) {
__last_consumed_ = traits_type::eof();
__last_consumed_is_next_ = false;
}
return __result;
}
char __extbuf[__limit];
int __nread = std::max(1, __encoding_);
for (int __i = 0; __i < __nread; ++__i) {
int __c = getc(__file_);
if (__c == EOF)
return traits_type::eof();
__extbuf[__i] = static_cast<char>(__c);
}
char_type __1buf;
if (__always_noconv_)
__1buf = static_cast<char_type>(__extbuf[0]);
else {
const char* __enxt;
char_type* __inxt;
std::codecvt_base::result __r;
do {
state_type __sv_st = __st_;
__r = __cv_->in(__st_, __extbuf, __extbuf + __nread, __enxt, &__1buf,
&__1buf + 1, __inxt);
switch (__r) {
case std::codecvt_base::ok:
break;
case std::codecvt_base::partial:
__st_ = __sv_st;
if (__nread == sizeof(__extbuf))
return traits_type::eof();
{
int __c = getc(__file_);
if (__c == EOF)
return traits_type::eof();
__extbuf[__nread] = static_cast<char>(__c);
}
++__nread;
break;
case std::codecvt_base::error:
return traits_type::eof();
case std::codecvt_base::noconv:
__1buf = static_cast<char_type>(__extbuf[0]);
break;
}
} while (__r == std::codecvt_base::partial);
}
if (!__consume) {
for (int __i = __nread; __i > 0;) {
if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
return traits_type::eof();
}
} else
__last_consumed_ = traits_type::to_int_type(__1buf);
return traits_type::to_int_type(__1buf);
}
template <class _CharT>
typename stdio_filebuf<_CharT>::int_type stdio_filebuf<_CharT>::pbackfail(
int_type __c) {
if (traits_type::eq_int_type(__c, traits_type::eof())) {
if (!__last_consumed_is_next_) {
__c = __last_consumed_;
__last_consumed_is_next_ =
!traits_type::eq_int_type(__last_consumed_, traits_type::eof());
}
return __c;
}
if (__last_consumed_is_next_) {
char __extbuf[__limit];
char* __enxt;
const char_type __ci = traits_type::to_char_type(__last_consumed_);
const char_type* __inxt;
switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt, __extbuf,
__extbuf + sizeof(__extbuf), __enxt)) {
case std::codecvt_base::ok:
break;
case std::codecvt_base::noconv:
__extbuf[0] = static_cast<char>(__last_consumed_);
__enxt = __extbuf + 1;
break;
case std::codecvt_base::partial:
case std::codecvt_base::error:
return traits_type::eof();
}
while (__enxt > __extbuf)
if (ungetc(*--__enxt, __file_) == EOF)
return traits_type::eof();
}
__last_consumed_ = __c;
__last_consumed_is_next_ = true;
return __c;
}
} // namespace dvr
} // namespace android
#endif // ANDROID_DVR_PERFORMANCED_STDIO_FILEBUF_H_