Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
679 lines (554 sloc) 18.5 KB
/* Copyright (C) 2004 Garrett A. Kajmowicz
This file is part of the uClibc++ Library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __STD_HEADER_FSTREAM
#define __STD_HEADER_FSTREAM 1
#include<basic_definitions>
#include <cstdio>
#include <cstdlib>
#include <streambuf>
#include <istream>
#include <ostream>
#include <char_traits>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#ifdef __UCLIBCXX_HAS_WCHAR__
#include <cwchar>
#include <cwctype>
#endif //__UCLIBCXX_HAS_WCHAR__
#pragma GCC visibility push(default)
namespace std{
template <class C, class T> class basic_filebuf;
typedef basic_filebuf<char> filebuf;
#ifdef __UCLIBCXX_HAS_WCHAR__
typedef basic_filebuf<wchar_t> wfilebuf;
#endif
template <class charT, class traits> class _UCXXEXPORT basic_filebuf
: public basic_streambuf<charT,traits>
{
#ifdef __UCLIBCXX_SUPPORT_CDIR__
friend ios_base::Init::Init(); //Needed for cout/cin stuff
#endif
public:
// Types (inherited from basic_streambuf:
typedef typename basic_streambuf<charT, traits>::char_type char_type;
typedef typename basic_streambuf<charT, traits>::int_type int_type;
typedef typename basic_streambuf<charT, traits>::pos_type pos_type;
typedef typename basic_streambuf<charT, traits>::off_type off_type;
typedef traits traits_type;
//Constructors/destructor:
_UCXXEXPORT basic_filebuf() : basic_streambuf<charT, traits>(), fp(0), pbuffer(0), gbuffer(0)
{
append=false;
pbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
gbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
setp(pbuffer, pbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
//Position get buffer so that there is no data available
setg(gbuffer, gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__,
gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
}
_UCXXEXPORT virtual ~basic_filebuf(){
sync();
close();
delete [] pbuffer;
delete [] gbuffer;
pbuffer = 0;
gbuffer = 0;
}
//Members:
_UCXXEXPORT bool is_open() const{
if(fp == 0){
return false;
}
return true;
}
_UCXXEXPORT basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode){
bool move_end = (mode & ios_base::ate) != 0;
if(is_open() !=false){ //Must call close() first
return 0;
}
basic_streambuf<charT,traits>::openedFor = mode;
mode = mode & ~ios_base::ate;
if(mode == ios_base::out || mode == (ios_base::out | ios_base::trunc)){
fp = fopen(s, "w" );
}else if((mode & ios_base::app) && ! (mode & ios_base::trunc)){
if(mode & ios_base::binary){
if(mode & ios_base::in){
fp = fopen(s, "a+b");
}else{
fp = fopen(s, "ab");
}
}else{
if(mode & ios_base::in){
fp = fopen(s, "a+");
}else{
fp = fopen(s, "a");
}
}
}else if(mode == ios_base::in){
fp = fopen(s, "r");
}else if(mode == (ios_base::in | ios_base::out)){
fp = fopen(s, "r+");
}else if(mode == (ios_base::in | ios_base::out | ios_base::trunc)){
fp = fopen(s, "w+");
}else if(mode == (ios_base::binary | ios_base::out)){
fp = fopen(s, "wb");
}else if(mode == (ios_base::in | ios_base::binary)){
fp = fopen(s, "rb");
}else if(mode == (ios_base::in | ios_base::binary | ios_base::out)){
fp = fopen(s, "r+b");
}else if(mode==(ios_base::binary | ios_base::out | ios_base::trunc)){
fp = fopen(s, "w+b");
}else if(mode == (ios_base::in | ios_base::binary | ios_base::out | ios_base::trunc)){
fp = fopen(s, "w+b");
}
if(fp == 0){
return 0;
}
if(ferror(fp)){
fclose(fp);
fp=0;
return 0;
}
int retval = 0;
//Check to make sure the stream is good
if(move_end == true){
retval = fseek(fp, 0, SEEK_END);
}else{
retval = fseek(fp, 0, SEEK_SET);
}
if(retval!=0){ //Seek error
fclose(fp);
fp=0;
return 0;
}
basic_streambuf<charT,traits>::mgnext = basic_streambuf<charT,traits>::mgend;
return this;
}
_UCXXEXPORT basic_filebuf<charT,traits>* close(){
if(fp != 0 && fp != stdin && fp != stdout && fp !=stderr ){
overflow();
sync();
int retval = fclose(fp);
if(retval !=0){ //Error of some sort
return 0;
}
fp=0;
}
return this;
}
protected:
_UCXXEXPORT basic_filebuf(const basic_filebuf<charT,traits> &){ }
_UCXXEXPORT basic_filebuf<charT,traits> & operator=(const basic_filebuf<charT,traits> &){ return *this; }
//Overridden virtual functions:
virtual _UCXXEXPORT int showmanyc(){
return basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
}
virtual _UCXXEXPORT int_type underflow(){
/* Some variables used internally:
Buffer pointers:
charT * mgbeg;
charT * mgnext;
charT * mgend;
eback() returns mgbeg
gptr() returns mgnext
egptr() returns mgend
gbump(int n) mgnext+=n
*/
if(!is_open()){
return traits::eof();
}
if(basic_streambuf<charT,traits>::eback() == 0){
//No buffer, so...
charT c;
int retval;
retval = fread(&c, sizeof(charT), 1, fp);
if(retval == 0 || feof(fp) || ferror(fp) ){
return traits::eof();
}
return traits::to_int_type(c);
}
if(basic_streambuf<charT,traits>::eback() == basic_streambuf<charT,traits>::gptr()){ //Buffer is full
return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
}
//Shift entire buffer back to the begining
size_t offset = basic_streambuf<charT,traits>::gptr() - basic_streambuf<charT,traits>::eback();
size_t amountData = basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
for(charT * i = basic_streambuf<charT,traits>::gptr(); i < basic_streambuf<charT,traits>::egptr(); ++i){
*(i-offset) = *i;
}
size_t retval = 0;
//Save operating flags from file descriptor
int fcntl_flags = fcntl(fileno(fp), F_GETFL);
retval = 0;
//Set to non_blocking mode
fcntl(fileno(fp), F_SETFL, fcntl_flags | O_NONBLOCK);
//Fill rest of buffer
retval = fread(basic_streambuf<charT,traits>::egptr() -
basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
sizeof(charT),
offset,
fp
);
//Clear problems where we didn't read in enough characters
if(EAGAIN == errno){
clearerr(fp);
}
//Restore file descriptor clase
fcntl(fileno(fp), F_SETFL, fcntl_flags);
//Now we are going to make sure that we read in at least one character. The hard way.
if(retval == 0){
fcntl_flags = fcntl(fileno(fp), F_GETFL);
//Set to blocking mode
fcntl(fileno(fp), F_SETFL, fcntl_flags & ~O_NONBLOCK);
retval = fread(basic_streambuf<charT,traits>::egptr() -
basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
sizeof(charT),
1,
fp
);
//Restore file descriptor clase
fcntl(fileno(fp), F_SETFL, fcntl_flags);
}
if(retval !=offset){ //Slide buffer forward again
for(size_t i = 0; i < amountData + retval; ++i){
*(basic_streambuf<charT,traits>::egptr() - i - 1) =
*(basic_streambuf<charT,traits>::eback() + amountData + retval - i - 1);
}
}
basic_streambuf<charT,traits>::mgnext -= retval;
if( (retval <= 0 && feof(fp)) || ferror(fp) ){
return traits::eof();
}
return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
}
virtual _UCXXEXPORT int_type uflow(){
bool dobump = (basic_streambuf<charT,traits>::gptr() != 0);
int_type retval = underflow();
if(dobump){
basic_streambuf<charT,traits>::gbump(1);
}
return retval;
}
virtual _UCXXEXPORT int_type pbackfail(int_type c = traits::eof()){
if(is_open() == false ||
basic_streambuf<charT,traits>::gptr() == basic_streambuf<charT,traits>::eback())
{
return traits::eof();
}
if(traits::eq_int_type(c,traits::eof()) == false){
if(traits::eq(traits::to_char_type(c), basic_streambuf<charT,traits>::gptr()[-1]) == true){
basic_streambuf<charT,traits>::gbump(-1);
}else{
basic_streambuf<charT,traits>::gbump(-1);
basic_streambuf<charT,traits>::gptr()[0] = c;
}
return c;
}else{
basic_streambuf<charT,traits>::gbump(-1);
return traits::not_eof(c);
}
}
virtual _UCXXEXPORT int_type overflow(int_type c = traits::eof()){
if(is_open() == false){
//Can't do much
return traits::eof();
}
if(basic_streambuf<charT,traits>::pbase() == 0){ //Unbuffered - elliminate dupe code below
if(fputc(c, fp) == EOF){
return traits::eof();
}
return c;
}
if(basic_streambuf<charT,traits>::pbase() == 0 && traits::eq_int_type(c,traits::eof()) ){
//Nothing to flush
return traits::not_eof(c);
}
size_t r = basic_streambuf<charT,traits>::pptr() - basic_streambuf<charT,traits>::pbase();
if( r == 0 && traits::eq_int_type(c,traits::eof()) ){
return traits::not_eof(c);
}else if (r == 0 ){
if(fputc(c, fp) == EOF){
return traits::eof();
}
return c;
}
size_t totalChars = r;
char_type *buffer = 0;
if(traits::eq_int_type(c,traits::eof())){
buffer = new char_type[r];
}else{
buffer = new char_type[r+1];
buffer[r] = c;
totalChars++;
}
traits::copy(buffer, basic_streambuf<charT,traits>::pbase(), r);
// memcpy(buffer, basic_streambuf<charT,traits>::pbase(), r);
size_t retval = fwrite(buffer, sizeof(charT), totalChars, fp);
if(retval !=totalChars){
if(retval == 0){
delete [] buffer;
return traits::eof();
}
basic_streambuf<charT,traits>::pbump(-retval);
fprintf(stderr, "***** Did not write the full buffer out. Should be: %d, actually: %d\n",
totalChars, retval);
}else{
basic_streambuf<charT,traits>::pbump(-r);
}
delete [] buffer;
return traits::not_eof(c);
}
virtual _UCXXEXPORT basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n){
if(s == 0 && n == 0){ //Unbuffered
if(pbuffer !=0){
delete [] pbuffer;
}
if(gbuffer !=0){
delete [] gbuffer;
}
pbuffer = 0;
gbuffer = 0;
}else if(basic_streambuf<charT,traits>::gptr() !=0 &&
basic_streambuf<charT,traits>::gptr()==basic_streambuf<charT,traits>::egptr())
{
delete [] pbuffer;
pbuffer = s;
}
return this;
}
virtual _UCXXEXPORT pos_type seekoff(off_type off, ios_base::seekdir way,
ios_base::openmode = ios_base::in | ios_base::out)
{
if(is_open() == false){
return -1;
}
int whence = SEEK_SET; // if(way == basic_ios<charT>::beg)
off_type position = off;
if(way == basic_ios<charT>::cur){
whence = SEEK_CUR;
position -= (basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
}else if(way == basic_ios<charT>::end){
whence = SEEK_END;
}
sync();
int retval = fseek(
fp,
sizeof(charT)*(position),
whence
);
//Invalidate read buffer
basic_streambuf<charT,traits>::gbump(
basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr()
);
if(-1 != retval){
retval = ftell(fp);
}
return retval;
}
virtual _UCXXEXPORT pos_type seekpos(pos_type sp, ios_base::openmode = ios_base::in | ios_base::out){
if(is_open() == false){
return -1;
}
sync();
int retval = fseek(fp,sizeof(charT)* sp, SEEK_SET);
//Invalidate read buffer
basic_streambuf<charT,traits>::gbump(basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
if(retval > -1){
return sp;
}
return -1;
}
virtual _UCXXEXPORT int sync(){
if(pbuffer !=0){
if(overflow() == traits::eof()){
return -1;
}
}
if(0 != fp && 0 != fflush(fp)){
return -1;
}
return 0;
}
virtual _UCXXEXPORT void imbue(const locale&){
return;
}
virtual _UCXXEXPORT streamsize xsputn(const char_type* s, streamsize n){
if(is_open() == false){
return 0;
}
//Check to see if buffered
//Check to see if we can buffer the data
streamsize buffer_avail = basic_streambuf<charT,traits>::epptr() - basic_streambuf<charT,traits>::pptr();
if(n > buffer_avail){ //Flush buffer and write directly
overflow(); //Flush the buffer
return fwrite(s, sizeof(charT), n, fp);
}
//Add to buffer to be written later
traits::copy(basic_streambuf<charT,traits>::pptr(), s, n);
basic_streambuf<charT,traits>::pbump(n);
return n;
}
FILE * fp;
char_type * pbuffer;
char_type * gbuffer;
bool append;
};
#ifdef __UCLIBCXX_HAS_WCHAR__
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
basic_filebuf<wchar_t, char_traits<wchar_t> >::overflow(int_type c);
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
basic_filebuf<wchar_t, char_traits<wchar_t> >::underflow();
#endif //__UCLIBCXX_HAS_WCHAR__
#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
#ifndef __UCLIBCXX_COMPILE_FSTREAM__
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
template <> _UCXXEXPORT filebuf::basic_filebuf();
template <> _UCXXEXPORT filebuf::~basic_filebuf();
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
template <> _UCXXEXPORT filebuf::int_type filebuf::pbackfail(filebuf::int_type c);
template <> _UCXXEXPORT filebuf * filebuf::open(const char* s, ios_base::openmode mode);
template <> _UCXXEXPORT filebuf * filebuf::close();
template <> _UCXXEXPORT filebuf::int_type filebuf::overflow(filebuf::int_type c);
template <> _UCXXEXPORT filebuf::int_type filebuf::underflow ();
template <> _UCXXEXPORT basic_streambuf<char, char_traits<char> > * filebuf::setbuf(char * s, streamsize n);
template <> _UCXXEXPORT streamsize filebuf::xsputn(const char* s, streamsize n);
#endif
#endif
template <class charT, class traits> class _UCXXEXPORT basic_ifstream
: public basic_istream<charT,traits>
{
public:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
_UCXXEXPORT basic_ifstream(): basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb){
//Passing the address of sb
}
explicit _UCXXEXPORT basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in)
: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb)
{
if(sb.open(s, mode) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
virtual _UCXXEXPORT ~basic_ifstream(){
}
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
return (basic_filebuf<charT,traits>*)&sb;
}
_UCXXEXPORT bool is_open() const{
return sb.is_open();
}
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in){
if(sb.open(s, mode) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
_UCXXEXPORT void close(){
sb.close();
}
private:
basic_filebuf<charT,traits> sb;
};
template <class charT, class traits> class _UCXXEXPORT basic_ofstream
: public basic_ostream<charT,traits>
{
public:
typedef charT char_type;
typedef typename traits::int_type int_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
_UCXXEXPORT basic_ofstream() : basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb){
}
virtual _UCXXEXPORT ~basic_ofstream();
explicit _UCXXEXPORT basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc) :
basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb)
{
if(sb.open(s, mode | ios_base::out ) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
return (basic_filebuf<charT,traits>*)&sb;
}
_UCXXEXPORT bool is_open() const{
return sb.is_open();
}
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc){
if(sb.open(s, mode) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
_UCXXEXPORT void close(){
sb.close();
}
private:
basic_filebuf<charT,traits> sb;
};
template <class charT, class traits> _UCXXEXPORT basic_ofstream<charT, traits>::~basic_ofstream(){
basic_ostream<charT, traits>::flush();
}
template <class charT, class traits> class _UCXXEXPORT basic_fstream
: public basic_iostream<charT,traits>
{
public:
typedef charT char_type;
typedef typename traits::int_type ins_type;
typedef typename traits::pos_type pos_type;
typedef typename traits::off_type off_type;
_UCXXEXPORT basic_fstream(): basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb){ }
explicit _UCXXEXPORT basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out):
basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb)
{
if(sb.open(s, mode) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
return (basic_filebuf<charT,traits>*)&sb;
}
_UCXXEXPORT bool is_open() const{
return sb.is_open();
}
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out){
if(sb.open(s, mode) == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
}
}
_UCXXEXPORT void close(){
sb.close();
}
private:
basic_filebuf<charT,traits> sb;
};
#if 0
#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
#ifndef __UCLIBCXX_COMPILE_FSTREAM__
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream();
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream(const char* s, ios_base::openmode mode);
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::~basic_ofstream();
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream();
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream(const char* s, ios_base::openmode mode);
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::~basic_ifstream();
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
#endif
#endif
#endif
}
#pragma GCC visibility pop
#endif