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
@@ -390,101 +390,104 @@ bool QFile::open( int m, FILE *f )
 
 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
@@ -493,188 +496,190 @@ bool QFile::at( Offset pos )
 #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;
         }