summaryrefslogtreecommitdiff
path: root/qmake/tools/qfile_unix.cpp
Side-by-side diff
Diffstat (limited to 'qmake/tools/qfile_unix.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--qmake/tools/qfile_unix.cpp13
1 files changed, 9 insertions, 4 deletions
diff --git a/qmake/tools/qfile_unix.cpp b/qmake/tools/qfile_unix.cpp
index 2d5a856..460bf06 100644
--- a/qmake/tools/qfile_unix.cpp
+++ b/qmake/tools/qfile_unix.cpp
@@ -182,506 +182,511 @@ bool QFile::open( int m )
#endif
return FALSE;
}
bool ok = TRUE;
struct stat st;
if ( isRaw() ) {
int oflags = O_RDONLY;
if ( isReadable() && isWritable() )
oflags = O_RDWR;
else if ( isWritable() )
oflags = O_WRONLY;
if ( flags() & IO_Append ) { // append to end of file?
if ( flags() & IO_Truncate )
oflags |= (O_CREAT | O_TRUNC);
else
oflags |= (O_APPEND | O_CREAT);
setFlags( flags() | IO_WriteOnly ); // append implies write
} else if ( isWritable() ) { // create/trunc if writable
if ( flags() & IO_Truncate )
oflags |= (O_CREAT | O_TRUNC);
else
oflags |= O_CREAT;
}
#if defined(HAS_TEXT_FILEMODE)
if ( isTranslated() )
oflags |= OPEN_TEXT;
else
oflags |= OPEN_BINARY;
#endif
#if defined(HAS_ASYNC_FILEMODE)
if ( isAsynchronous() )
oflags |= OPEN_ASYNC;
#endif
fd = qt_open( QFile::encodeName(fn), oflags, 0666 );
if ( fd != -1 ) { // open successful
::fstat( fd, &st ); // get the stat for later usage
} else {
ok = FALSE;
}
} else { // buffered file I/O
QCString perm;
char perm2[4];
bool try_create = FALSE;
if ( flags() & IO_Append ) { // append to end of file?
setFlags( flags() | IO_WriteOnly ); // append implies write
perm = isReadable() ? "a+" : "a";
} else {
if ( isReadWrite() ) {
if ( flags() & IO_Truncate ) {
perm = "w+";
} else {
perm = "r+";
try_create = TRUE; // try to create if not exists
}
} else if ( isReadable() ) {
perm = "r";
} else if ( isWritable() ) {
perm = "w";
}
}
qstrcpy( perm2, perm );
#if defined(HAS_TEXT_FILEMODE)
if ( isTranslated() )
strcat( perm2, "t" );
else
strcat( perm2, "b" );
#endif
for (;;) { // At most twice
fh = fopen( QFile::encodeName(fn), perm2 );
if ( !fh && try_create ) {
perm2[0] = 'w'; // try "w+" instead of "r+"
try_create = FALSE;
} else {
break;
}
}
if ( fh ) {
::fstat( fileno(fh), &st ); // get the stat for later usage
} else {
ok = FALSE;
}
}
if ( ok ) {
setState( IO_Open );
// on successful open the file stat was got; now test what type
// of file we have
if ( (st.st_mode & S_IFMT) != S_IFREG ) {
// non-seekable
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
} else {
length = (Offset)st.st_size;
ioIndex = (flags() & IO_Append) == 0 ? 0 : length;
if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
// try if you can read from it (if you can, it's a sequential
// device; e.g. a file in the /proc filesystem)
int c = getch();
if ( c != -1 ) {
ungetch(c);
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
}
}
}
} else {
init();
if ( errno == EMFILE ) // no more file handles/descrs
setStatus( IO_ResourceError );
else
setStatus( IO_OpenError );
}
return ok;
}
/*!
\overload
Opens a file in the mode \a m using an existing file handle \a f.
Returns TRUE if successful, otherwise FALSE.
Example:
\code
#include <stdio.h>
void printError( const char* msg )
{
QFile f;
f.open( IO_WriteOnly, stderr );
f.writeBlock( msg, qstrlen(msg) ); // write to stderr
f.close();
}
\endcode
When a QFile is opened using this function, close() does not actually
close the file, only flushes it.
\warning If \a f is \c stdin, \c stdout, \c stderr, you may not
be able to seek. See QIODevice::isSequentialAccess() for more
information.
\sa close()
*/
bool QFile::open( int m, FILE *f )
{
if ( isOpen() ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QFile::open: File already open" );
#endif
return FALSE;
}
init();
setMode( m &~IO_Raw );
setState( IO_Open );
fh = f;
ext_f = TRUE;
struct stat st;
::fstat( fileno(fh), &st );
#if defined(QT_LARGEFILE_SUPPORT)
ioIndex = (Offset)ftello( fh );
#else
ioIndex = (Offset)ftell( fh );
#endif
if ( (st.st_mode & S_IFMT) != S_IFREG || f == stdin ) { //stdin is non seekable
// non-seekable
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
} else {
length = (Offset)st.st_size;
if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
// try if you can read from it (if you can, it's a sequential
// device; e.g. a file in the /proc filesystem)
int c = getch();
if ( c != -1 ) {
ungetch(c);
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
}
}
}
return TRUE;
}
/*!
\overload
Opens a file in the mode \a m using an existing file descriptor \a f.
Returns TRUE if successful, otherwise FALSE.
When a QFile is opened using this function, close() does not actually
close the file.
The QFile that is opened using this function, is automatically set to be in
raw mode; this means that the file input/output functions are slow. If you
run into performance issues, you should try to use one of the other open
functions.
\warning If \a f is one of 0 (stdin), 1 (stdout) or 2 (stderr), you may not
be able to seek. size() is set to \c INT_MAX (in limits.h).
\sa close()
*/
bool QFile::open( int m, int f )
{
if ( isOpen() ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QFile::open: File already open" );
#endif
return FALSE;
}
init();
setMode( m |IO_Raw );
setState( IO_Open );
fd = f;
ext_f = TRUE;
struct stat st;
::fstat( fd, &st );
ioIndex = (Offset)::lseek(fd, 0, SEEK_CUR);
if ( (st.st_mode & S_IFMT) != S_IFREG || f == 0 ) { // stdin is not seekable...
// non-seekable
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
} else {
length = (Offset)st.st_size;
if ( length == 0 && isReadable() ) {
// try if you can read from it (if you can, it's a sequential
// device; e.g. a file in the /proc filesystem)
int c = getch();
if ( c != -1 ) {
ungetch(c);
setType( IO_Sequential );
length = INT_MAX;
ioIndex = 0;
}
resetStatus();
}
}
return TRUE;
}
/*!
Returns the file size.
\sa at()
*/
QIODevice::Offset QFile::size() const
{
struct stat st;
+ int ret = 0;
if ( isOpen() ) {
- ::fstat( fh ? fileno(fh) : fd, &st );
+ ret = ::fstat( fh ? fileno(fh) : fd, &st );
} else {
- ::stat( QFile::encodeName(fn), &st );
+ ret = ::stat( QFile::encodeName(fn), &st );
}
+ if ( ret == -1 )
+ return 0;
#if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_64BITOFFSET)
return (uint)st.st_size > UINT_MAX ? UINT_MAX : (QIODevice::Offset)st.st_size;
#else
return st.st_size;
#endif
}
/*!
\overload
Sets the file index to \a pos. Returns TRUE if successful;
otherwise returns FALSE.
Example:
\code
QFile f( "data.bin" );
f.open( IO_ReadOnly ); // index set to 0
f.at( 100 ); // set index to 100
f.at( f.at()+50 ); // set index to 150
f.at( f.size()-80 ); // set index to 80 before EOF
f.close();
\endcode
Use \c at() without arguments to retrieve the file offset.
\warning The result is undefined if the file was open()'ed using
the \c IO_Append specifier.
\sa size(), open()
*/
bool QFile::at( Offset pos )
{
if ( !isOpen() ) {
#if defined(QT_CHECK_STATE)
qWarning( "QFile::at: File is not open" );
#endif
return FALSE;
}
if ( isSequentialAccess() )
return FALSE;
bool ok;
if ( isRaw() ) {
off_t l = ::lseek( fd, pos, SEEK_SET );
ok = ( l != -1 );
pos = (Offset)l;
} else { // buffered file
#if defined(QT_LARGEFILE_SUPPORT)
ok = ( ::fseeko(fh, pos, SEEK_SET) == 0 );
#else
ok = ( ::fseek(fh, pos, SEEK_SET) == 0 );
#endif
}
if ( ok )
ioIndex = pos;
#if defined(QT_CHECK_RANGE)
else
#if defined(QT_LARGEFILE_SUPPORT) && defined(QT_ABI_64BITOFFSET)
qWarning( "QFile::at: Cannot set file position %llu", pos );
#else
qWarning( "QFile::at: Cannot set file position %lu", pos );
#endif
#endif
return ok;
}
/*!
\reimp
\warning We have experienced problems with some C libraries when a buffered
file is opened for both reading and writing. If a read operation takes place
immediately after a write operation, the read buffer contains garbage data.
Worse, the same garbage is written to the file. Calling flush() before
readBlock() solved this problem.
*/
Q_LONG QFile::readBlock( char *p, Q_ULONG len )
{
#if defined(QT_CHECK_NULL)
if ( !p )
qWarning( "QFile::readBlock: Null pointer error" );
#endif
#if defined(QT_CHECK_STATE)
if ( !isOpen() ) {
qWarning( "QFile::readBlock: File not open" );
return -1;
}
if ( !isReadable() ) {
qWarning( "QFile::readBlock: Read operation not permitted" );
return -1;
}
#endif
Q_ULONG nread = 0; // number of bytes read
if ( !ungetchBuffer.isEmpty() ) {
// need to add these to the returned string.
uint l = ungetchBuffer.length();
while( nread < l ) {
- *p = ungetchBuffer[ l - nread - 1 ];
+ *p = ungetchBuffer.at( l - nread - 1 );
p++;
nread++;
}
ungetchBuffer.truncate( l - nread );
}
if ( nread < len ) {
if ( isRaw() ) { // raw file
nread += ::read( fd, p, len-nread );
if ( len && nread <= 0 ) {
nread = 0;
setStatus(IO_ReadError);
}
} else { // buffered file
nread += fread( p, 1, len-nread, fh );
if ( (uint)nread != len ) {
if ( ferror( fh ) || nread==0 )
setStatus(IO_ReadError);
}
}
}
if ( !isSequentialAccess() )
ioIndex += nread;
return nread;
}
/*! \reimp
Writes \a len bytes from \a p to the file and returns the number of
bytes actually written.
Returns -1 if a serious error occurred.
\warning When working with buffered files, data may not be written
to the file at once. Call flush() to make sure the data is really
written.
\sa readBlock()
*/
Q_LONG QFile::writeBlock( const char *p, Q_ULONG len )
{
#if defined(QT_CHECK_NULL)
if ( p == 0 && len != 0 )
qWarning( "QFile::writeBlock: Null pointer error" );
#endif
#if defined(QT_CHECK_STATE)
if ( !isOpen() ) { // file not open
qWarning( "QFile::writeBlock: File not open" );
return -1;
}
if ( !isWritable() ) { // writing not permitted
qWarning( "QFile::writeBlock: Write operation not permitted" );
return -1;
}
#endif
Q_ULONG nwritten; // number of bytes written
if ( isRaw() ) // raw file
nwritten = ::write( fd, (void *)p, len );
else // buffered file
nwritten = fwrite( p, 1, len, fh );
if ( nwritten != len ) { // write error
if ( errno == ENOSPC ) // disk is full
setStatus( IO_ResourceError );
else
setStatus( IO_WriteError );
if ( !isSequentialAccess() ) {
if ( isRaw() ) // recalc file position
ioIndex = (Offset)::lseek( fd, 0, SEEK_CUR );
else
#if defined(QT_LARGEFILE_SUPPORT)
ioIndex = (Offset)::fseeko( fh, 0, SEEK_CUR );
#else
ioIndex = (Offset)::fseek( fh, 0, SEEK_CUR );
#endif
}
} else {
if ( !isSequentialAccess() )
ioIndex += nwritten;
}
if ( ioIndex > length ) // update file length
length = ioIndex;
return nwritten;
}
/*!
Returns the file handle of the file.
This is a small positive integer, suitable for use with C library
- functions such as fdopen() and fcntl(), as well as with QSocketNotifier.
+ functions such as fdopen() and fcntl(). On systems that use file
+ descriptors for sockets (ie. Unix systems, but not Windows) the handle
+ can be used with QSocketNotifier as well.
If the file is not open or there is an error, handle() returns -1.
\sa QSocketNotifier
*/
int QFile::handle() const
{
if ( !isOpen() )
return -1;
else if ( fh )
return fileno( fh );
else
return fd;
}
/*!
Closes an open file.
The file is not closed if it was opened with an existing file handle.
If the existing file handle is a \c FILE*, the file is flushed.
If the existing file handle is an \c int file descriptor, nothing
is done to the file.
Some "write-behind" filesystems may report an unspecified error on
closing the file. These errors only indicate that something may
have gone wrong since the previous open(). In such a case status()
reports IO_UnspecifiedError after close(), otherwise IO_Ok.
\sa open(), flush()
*/
void QFile::close()
{
bool ok = FALSE;
if ( isOpen() ) { // file is not open
if ( fh ) { // buffered file
if ( ext_f )
ok = fflush( fh ) != -1; // flush instead of closing
else
ok = fclose( fh ) != -1;
} else { // raw file
if ( ext_f )
ok = TRUE; // cannot close
else
ok = ::close( fd ) != -1;
}
init(); // restore internal state
}
if (!ok)
setStatus( IO_UnspecifiedError );
return;
}