1 // Wrapper of C-language FILE struct -*- C++ -*-
3 // Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 2, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING. If not, write to the Free
18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction. Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License. This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
31 // ISO C++ 14882: 27.8 File-based streams
34 #include <bits/basic_file.h>
38 #ifdef _GLIBCXX_HAVE_POLL
42 // Pick up ioctl on Solaris 2.8
43 #ifdef _GLIBCXX_HAVE_UNISTD_H
47 // Pick up FIONREAD on Solaris 2
48 #ifdef _GLIBCXX_HAVE_SYS_IOCTL_H
50 #include <sys/ioctl.h>
53 // Pick up FIONREAD on Solaris 2.5.
54 #ifdef _GLIBCXX_HAVE_SYS_FILIO_H
55 #include <sys/filio.h>
58 #ifdef _GLIBCXX_HAVE_SYS_UIO_H
62 #if defined(_GLIBCXX_HAVE_S_ISREG) || defined(_GLIBCXX_HAVE_S_IFREG)
63 # include <sys/stat.h>
64 # ifdef _GLIBCXX_HAVE_S_ISREG
65 # define _GLIBCXX_ISREG(x) S_ISREG(x)
67 # define _GLIBCXX_ISREG(x) (((x) & S_IFMT) == S_IFREG)
71 #include <limits> // For <off_t>::max() and min()
73 namespace __gnu_internal
75 // Map ios_base::openmode flags to a string for use in fopen().
76 // Table of valid combinations as given in [lib.filebuf.members]/2.
78 fopen_mode(std::ios_base::openmode mode)
82 in = std::ios_base::in,
83 out = std::ios_base::out,
84 trunc = std::ios_base::trunc,
85 app = std::ios_base::app,
86 binary = std::ios_base::binary
89 switch (mode & (in|out|trunc|app|binary))
91 case ( out ): return "w";
92 case ( out |app ): return "a";
93 case ( out|trunc ): return "w";
94 case (in ): return "r";
95 case (in|out ): return "r+";
96 case (in|out|trunc ): return "w+";
98 case ( out |binary): return "wb";
99 case ( out |app|binary): return "ab";
100 case ( out|trunc |binary): return "wb";
101 case (in |binary): return "rb";
102 case (in|out |binary): return "r+b";
103 case (in|out|trunc |binary): return "w+b";
105 default: return 0; // invalid
109 // Wrapper handling partial write.
110 static std::streamsize
111 xwrite(int __fd, const char* __s, std::streamsize __n)
113 std::streamsize __nleft = __n;
117 const std::streamsize __ret = write(__fd, __s, __nleft);
118 if (__ret == -1L && errno == EINTR)
130 return __n - __nleft;
133 #ifdef _GLIBCXX_HAVE_WRITEV
134 // Wrapper handling partial writev.
135 static std::streamsize
136 xwritev(int __fd, const char* __s1, std::streamsize __n1,
137 const char* __s2, std::streamsize __n2)
139 std::streamsize __nleft = __n1 + __n2;
140 std::streamsize __n1_left = __n1;
142 struct iovec __iov[2];
143 __iov[1].iov_base = const_cast<char*>(__s2);
144 __iov[1].iov_len = __n2;
148 __iov[0].iov_base = const_cast<char*>(__s1);
149 __iov[0].iov_len = __n1_left;
151 const std::streamsize __ret = writev(__fd, __iov, 2);
152 if (__ret == -1L && errno == EINTR)
161 const std::streamsize __off = __ret - __n1_left;
164 __nleft -= xwrite(__fd, __s2 + __off, __n2 - __off);
172 return __n1 + __n2 - __nleft;
175 } // namespace __gnu_internal
179 // Definitions for __basic_file<char>.
180 __basic_file<char>::__basic_file(__c_lock* /*__lock*/)
181 : _M_cfile(NULL), _M_cfile_created(false) { }
183 __basic_file<char>::~__basic_file()
187 __basic_file<char>::sys_open(__c_file* __file, ios_base::openmode)
189 __basic_file* __ret = NULL;
190 if (!this->is_open() && __file)
195 __err = this->sync();
196 while (__err && errno == EINTR);
200 _M_cfile_created = false;
208 __basic_file<char>::sys_open(int __fd, ios_base::openmode __mode)
210 __basic_file* __ret = NULL;
211 const char* __c_mode = __gnu_internal::fopen_mode(__mode);
212 if (__c_mode && !this->is_open() && (_M_cfile = fdopen(__fd, __c_mode)))
215 _M_cfile_created = true;
217 setvbuf(_M_cfile, __buf, _IONBF, 0);
224 __basic_file<char>::open(const char* __name, ios_base::openmode __mode,
227 __basic_file* __ret = NULL;
228 const char* __c_mode = __gnu_internal::fopen_mode(__mode);
229 if (__c_mode && !this->is_open())
231 #ifdef _GLIBCXX_USE_LFS
232 if ((_M_cfile = fopen64(__name, __c_mode)))
234 if ((_M_cfile = fopen(__name, __c_mode)))
237 _M_cfile_created = true;
245 __basic_file<char>::is_open() const
246 { return _M_cfile != 0; }
249 __basic_file<char>::fd()
250 { return fileno(_M_cfile); }
253 __basic_file<char>::file()
257 __basic_file<char>::close()
259 __basic_file* __ret = static_cast<__basic_file*>(NULL);
263 if (_M_cfile_created)
265 // In general, no need to zero errno in advance if checking
266 // for error first. However, C89/C99 (at variance with IEEE
267 // 1003.1, f.i.) do not mandate that fclose must set errno
271 __err = fclose(_M_cfile);
272 while (__err && errno == EINTR);
282 __basic_file<char>::xsgetn(char* __s, streamsize __n)
286 __ret = read(this->fd(), __s, __n);
287 while (__ret == -1L && errno == EINTR);
292 __basic_file<char>::xsputn(const char* __s, streamsize __n)
293 { return __gnu_internal::xwrite(this->fd(), __s, __n); }
296 __basic_file<char>::xsputn_2(const char* __s1, streamsize __n1,
297 const char* __s2, streamsize __n2)
299 streamsize __ret = 0;
300 #ifdef _GLIBCXX_HAVE_WRITEV
301 __ret = __gnu_internal::xwritev(this->fd(), __s1, __n1, __s2, __n2);
304 __ret = __gnu_internal::xwrite(this->fd(), __s1, __n1);
307 __ret += __gnu_internal::xwrite(this->fd(), __s2, __n2);
313 __basic_file<char>::seekoff(streamoff __off, ios_base::seekdir __way)
315 #ifdef _GLIBCXX_USE_LFS
316 return lseek64(this->fd(), __off, __way);
318 if (__off > std::numeric_limits<off_t>::max()
319 || __off < std::numeric_limits<off_t>::min())
321 return lseek(this->fd(), __off, __way);
326 __basic_file<char>::sync()
327 { return fflush(_M_cfile); }
330 __basic_file<char>::showmanyc()
333 // Pipes and sockets.
334 #ifdef _GLIBCXX_FIONREAD_TAKES_OFF_T
339 int __r = ioctl(this->fd(), FIONREAD, &__num);
340 if (!__r && __num >= 0)
344 #ifdef _GLIBCXX_HAVE_POLL
346 struct pollfd __pfd[1];
347 __pfd[0].fd = this->fd();
348 __pfd[0].events = POLLIN;
349 if (poll(__pfd, 1, 0) <= 0)
353 #if defined(_GLIBCXX_HAVE_S_ISREG) || defined(_GLIBCXX_HAVE_S_IFREG)
355 struct stat __buffer;
356 int __ret = fstat(this->fd(), &__buffer);
357 if (!__ret && _GLIBCXX_ISREG(__buffer.st_mode))
358 return __buffer.st_size - lseek(this->fd(), 0, ios_base::cur);