qfile.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qfile.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of QFile class
**
** Created : 930812
**
** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qplatformdefs.h"

// POSIX Large File Support redefines open -> open64
#if defined(open)
# undef open
#endif

// POSIX Large File Support redefines truncate -> truncate64
#if defined(truncate)
# undef truncate
#endif

#include "qfile.h"


extern bool qt_file_access( const QString& fn, int t );

QFile::QFile()
{
    init();
}

QFile::QFile( const QString &name )
    : fn(name)
{
    init();
}


QFile::~QFile()
{
    close();
}


void QFile::init()
{
    setFlags( IO_Direct );
    setStatus( IO_Ok );
    fh     = 0;
    fd     = 0;
    length = 0;
    ioIndex = 0;
    ext_f  = FALSE;                             // not an external file handle
}


void QFile::setName( const QString &name )
{
    if ( isOpen() ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QFile::setName: File is open" );
#endif
        close();
    }
    fn = name;
}

bool QFile::exists() const
{
    return qt_file_access( fn, F_OK );
}

bool QFile::exists( const QString &fileName )
{
    return qt_file_access( fileName, F_OK );
}


bool QFile::remove()
{
    close();
    return remove( fn );
}

#if defined(Q_OS_MAC) || defined(Q_OS_MSDOS) || defined(Q_OS_WIN32) || defined(Q_OS_OS2)
# define HAS_TEXT_FILEMODE                      // has translate/text filemode
#endif
#if defined(O_NONBLOCK)
# define HAS_ASYNC_FILEMODE
# define OPEN_ASYNC O_NONBLOCK
#elif defined(O_NDELAY)
# define HAS_ASYNC_FILEMODE
# define OPEN_ASYNC O_NDELAY
#endif

void QFile::flush()
{
    if ( isOpen() && fh )                       // can only flush open/buffered
        fflush( fh );                           //   file
}

bool QFile::atEnd() const
{
    if ( !isOpen() ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QFile::atEnd: File is not open" );
#endif
        return FALSE;
    }
    if ( isDirectAccess() && !isTranslated() ) {
        if ( at() < length )
            return FALSE;
    }
    return QIODevice::atEnd();
}

Q_LONG QFile::readLine( char *p, Q_ULONG maxlen )
{
    if ( maxlen == 0 )                          // application bug?
        return 0;
#if defined(QT_CHECK_STATE)
    Q_CHECK_PTR( p );
    if ( !isOpen() ) {                          // file not open
        qWarning( "QFile::readLine: File not open" );
        return -1;
    }
    if ( !isReadable() ) {                      // reading not permitted
        qWarning( "QFile::readLine: Read operation not permitted" );
        return -1;
    }
#endif
    Q_LONG nread;                               // number of bytes read
    if ( isRaw() ) {                            // raw file
        nread = QIODevice::readLine( p, maxlen );
    } else {                                    // buffered file
        p = fgets( p, maxlen, fh );
        if ( p ) {
            nread = qstrlen( p );
            if ( !isSequentialAccess() )
                ioIndex += nread;
        } else {
            nread = -1;
            setStatus(IO_ReadError);
        }
    }
    return nread;
}


Q_LONG QFile::readLine( QString& s, Q_ULONG maxlen )
{
    QByteArray ba(maxlen);
    Q_LONG l = readLine(ba.data(),maxlen);
    if ( l >= 0 ) {
        ba.truncate(l);
        s = QString(ba);
    }
    return l;
}


int QFile::getch()
{
#if defined(QT_CHECK_STATE)
    if ( !isOpen() ) {                          // file not open
        qWarning( "QFile::getch: File not open" );
        return EOF;
    }
    if ( !isReadable() ) {                      // reading not permitted
        qWarning( "QFile::getch: Read operation not permitted" );
        return EOF;
    }
#endif

    int ch;

    if ( !ungetchBuffer.isEmpty() ) {
        int len = ungetchBuffer.length();
        ch = ungetchBuffer[ len-1 ];
        ungetchBuffer.truncate( len - 1 );
        return ch;
    }

    if ( isRaw() ) {                            // raw file (inefficient)
        char buf[1];
        ch = readBlock( buf, 1 ) == 1 ? buf[0] : EOF;
    } else {                                    // buffered file
        if ( (ch = getc( fh )) != EOF )
            if ( !isSequentialAccess() )
                ioIndex++;
        else
            setStatus(IO_ReadError);
    }
    return ch;
}

int QFile::putch( int ch )
{
#if defined(QT_CHECK_STATE)
    if ( !isOpen() ) {                          // file not open
        qWarning( "QFile::putch: File not open" );
        return EOF;
    }
    if ( !isWritable() ) {                      // writing not permitted
        qWarning( "QFile::putch: Write operation not permitted" );
        return EOF;
    }
#endif
    if ( isRaw() ) {                            // raw file (inefficient)
        char buf[1];
        buf[0] = ch;
        ch = writeBlock( buf, 1 ) == 1 ? ch : EOF;
    } else {                                    // buffered file
        if ( (ch = putc( ch, fh )) != EOF ) {
            if ( !isSequentialAccess() )
                ioIndex++;
            if ( ioIndex > length )             // update file length
                length = ioIndex;
        } else {
            setStatus(IO_WriteError);
        }
    }
    return ch;
}

int QFile::ungetch( int ch )
{
#if defined(QT_CHECK_STATE)
    if ( !isOpen() ) {                          // file not open
        qWarning( "QFile::ungetch: File not open" );
        return EOF;
    }
    if ( !isReadable() ) {                      // reading not permitted
        qWarning( "QFile::ungetch: Read operation not permitted" );
        return EOF;
    }
#endif
    if ( ch == EOF )                            // cannot unget EOF
        return ch;

    if ( isSequentialAccess() && !fh) {
        // pipe or similar => we cannot ungetch, so do it manually
        ungetchBuffer +=ch;
        return ch;
    }

    if ( isRaw() ) {                            // raw file (very inefficient)
        char buf[1];
        at( ioIndex-1 );
        buf[0] = ch;
        if ( writeBlock(buf, 1) == 1 )
            at ( ioIndex-1 );
        else
            ch = EOF;
    } else {                                    // buffered file
        if ( (ch = ungetc(ch, fh)) != EOF )
            if ( !isSequentialAccess() )
                ioIndex--;
        else
            setStatus( IO_ReadError );
    }
    return ch;
}


static QCString locale_encoder( const QString &fileName )
{
    return fileName.local8Bit();
}


static QFile::EncoderFn encoder = locale_encoder;

QCString QFile::encodeName( const QString &fileName )
{
    return (*encoder)(fileName);
}

void QFile::setEncodingFunction( EncoderFn f )
{
    encoder = f;
}

static
QString locale_decoder( const QCString &localFileName )
{
    return QString::fromLocal8Bit(localFileName);
}

static QFile::DecoderFn decoder = locale_decoder;

QString QFile::decodeName( const QCString &localFileName )
{
    return (*decoder)(localFileName);
}

void QFile::setDecodingFunction( DecoderFn f )
{
    decoder = f;
}

---