qdir.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qdir.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of QDir class
**
** Created : 950427
**
** Copyright (C) 1992-2003 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"
#include "qdir.h"

#ifndef QT_NO_DIR
#include <private/qdir_p.h>
#include "qfileinfo.h"
#include "qregexp.h"
#include "qstringlist.h"
#include <limits.h>

#if defined(Q_FS_FAT) && !defined(Q_OS_UNIX)
const bool CaseSensitiveFS = FALSE;
#else
const bool CaseSensitiveFS = TRUE;
#endif


QDir::QDir()
{
    dPath = QString::fromLatin1(".");
    init();
}

QDir::QDir( const QString &path, const QString &nameFilter,
            int sortSpec, int filterSpec )
{
    init();
    dPath = cleanDirPath( path );
    if ( dPath.isEmpty() )
        dPath = QString::fromLatin1(".");
    nameFilt = nameFilter;
    if ( nameFilt.isEmpty() )
        nameFilt = QString::fromLatin1("*");
    filtS = (FilterSpec)filterSpec;
    sortS = (SortSpec)sortSpec;
}

QDir::QDir( const QDir &d )
{
    dPath = d.dPath;
    fList = 0;
    fiList = 0;
    nameFilt = d.nameFilt;
    dirty = TRUE;
    allDirs = d.allDirs;
    filtS = d.filtS;
    sortS = d.sortS;
}

void QDir::refresh() const
{
    QDir* that = (QDir*) this;
    that->dirty = TRUE;
}

void QDir::init()
{
    fList = 0;
    fiList = 0;
    nameFilt = QString::fromLatin1("*");
    dirty = TRUE;
    allDirs = FALSE;
    filtS = All;
    sortS = SortSpec(Name | IgnoreCase);
}

QDir::~QDir()
{
    delete fList;
    delete fiList;
}


void QDir::setPath( const QString &path )
{
    dPath = cleanDirPath( path );
    if ( dPath.isEmpty() )
        dPath = QString::fromLatin1(".");
    dirty = TRUE;
}

QString QDir::absPath() const
{
    if ( QDir::isRelativePath(dPath) ) {
        QString tmp = currentDirPath();
        if ( tmp.right(1) != QString::fromLatin1("/") )
            tmp += '/';
        tmp += dPath;
        return cleanDirPath( tmp );
    } else {
        return cleanDirPath( dPath );
    }
}

QString QDir::dirName() const
{
    int pos = dPath.findRev( '/' );
    if ( pos == -1  )
        return dPath;
    return dPath.right( dPath.length() - pos - 1 );
}

QString QDir::filePath( const QString &fileName,
                        bool acceptAbsPath ) const
{
    if ( acceptAbsPath && !isRelativePath(fileName) )
        return QString(fileName);

    QString tmp = dPath;
    if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
                           fileName[0] != '/') )
        tmp += '/';
    tmp += fileName;
    return tmp;
}

QString QDir::absFilePath( const QString &fileName,
                           bool acceptAbsPath ) const
{
    if ( acceptAbsPath && !isRelativePath( fileName ) )
        return fileName;

    QString tmp = absPath();
#ifdef Q_OS_WIN32
    if ( fileName[0].isLetter() && fileName[1] == ':' ) {
        int drv = fileName.upper()[0].latin1() - 'A' + 1;
        if ( _getdrive() != drv ) {
            if ( qt_winunicode ) {
                TCHAR buf[PATH_MAX];
                ::_tgetdcwd( drv, buf, PATH_MAX );
                tmp.setUnicodeCodes( (ushort*)buf, ::_tcslen(buf) );
            } else {
                char buf[PATH_MAX];
                ::_getdcwd( drv, buf, PATH_MAX );
                tmp = buf;
            }
            if ( !tmp.endsWith("\\") )
                tmp += "\\";
            tmp += fileName.right( fileName.length() - 2 );
            int x;
            for ( x = 0; x < (int) tmp.length(); x++ ) {
                if ( tmp[x] == '\\' )
                    tmp[x] = '/';
            }
        }
    } else
#endif
    {
        if ( tmp.isEmpty() || (tmp[(int)tmp.length()-1] != '/' && !!fileName &&
                               fileName[0] != '/') )
            tmp += '/';
        tmp += fileName;
    }
    return tmp;
}


QString QDir::convertSeparators( const QString &pathName )
{
    QString n( pathName );
#if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
    for ( int i=0; i<(int)n.length(); i++ ) {
        if ( n[i] == '/' )
            n[i] = '\\';
    }
#elif defined(Q_OS_MAC9)
        while(n.length() && n[0] == '/' ) n = n.right(n.length()-1);
    for ( int i=0; i<(int)n.length(); i++ ) {
        if ( n[i] == '/' )
            n[i] = ':';
    }
    if(n.contains(':') && n.left(1) != ':')
        n.prepend(':');
#endif
    return n;
}


bool QDir::cd( const QString &dirName, bool acceptAbsPath )
{
    if ( dirName.isEmpty() || dirName==QString::fromLatin1(".") )
        return TRUE;
    QString old = dPath;
    if ( acceptAbsPath && !isRelativePath(dirName) ) {
        dPath = cleanDirPath( dirName );
    } else {
        if ( !isRoot() ) {
            dPath += '/';
        } else if ( dirName == ".." ) {
            dPath = old;
            return FALSE;
        }
        dPath += dirName;
        if ( dirName.find('/') >= 0
                || old == QString::fromLatin1(".")
                || dirName == QString::fromLatin1("..") )
            dPath = cleanDirPath( dPath );
    }
    if ( !exists() ) {
        dPath = old;                    // regret
        return FALSE;
    }
    dirty = TRUE;
    return TRUE;
}

bool QDir::cdUp()
{
    return cd( QString::fromLatin1("..") );
}

void QDir::setNameFilter( const QString &nameFilter )
{
    nameFilt = nameFilter;
    if ( nameFilt.isEmpty() )
        nameFilt = QString::fromLatin1("*");
    dirty = TRUE;
}

void QDir::setFilter( int filterSpec )
{
    if ( filtS == (FilterSpec) filterSpec )
        return;
    filtS = (FilterSpec) filterSpec;
    dirty = TRUE;
}

// ### Unsorted+DirsFirst ? Unsorted+Reversed?

void QDir::setSorting( int sortSpec )
{
    if ( sortS == (SortSpec) sortSpec )
        return;
    sortS = (SortSpec) sortSpec;
    dirty = TRUE;
}

void QDir::setMatchAllDirs( bool enable )
{
    if ( (bool)allDirs == enable )
        return;
    allDirs = enable;
    dirty = TRUE;
}


uint QDir::count() const
{
    return (uint)entryList().count();
}

QString QDir::operator[]( int index ) const
{
    entryList();
    return fList && index >= 0 && index < (int)fList->count() ?
        (*fList)[index] : QString::null;
}


QStrList QDir::encodedEntryList( int filterSpec, int sortSpec ) const
{
    QStrList r;
    QStringList l = entryList(filterSpec,sortSpec);
    for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
        r.append( QFile::encodeName(*it) );
    }
    return r;
}

QStrList QDir::encodedEntryList( const QString &nameFilter,
                           int filterSpec,
                           int sortSpec ) const
{
    QStrList r;
    QStringList l = entryList(nameFilter,filterSpec,sortSpec);
    for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
        r.append( QFile::encodeName(*it) );
    }
    return r;
}



QStringList QDir::entryList( int filterSpec, int sortSpec ) const
{
    if ( !dirty && filterSpec == (int)DefaultFilter &&
                   sortSpec   == (int)DefaultSort )
        return *fList;
    return entryList( nameFilt, filterSpec, sortSpec );
}

QStringList QDir::entryList( const QString &nameFilter,
                                 int filterSpec, int sortSpec ) const
{
    if ( filterSpec == (int)DefaultFilter )
        filterSpec = filtS;
    if ( sortSpec == (int)DefaultSort )
        sortSpec = sortS;
    QDir *that = (QDir*)this;                   // mutable function
    if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) ) {
        if ( that->fList )
            return *that->fList;
    }
    return QStringList();
}

const QFileInfoList *QDir::entryInfoList( int filterSpec, int sortSpec ) const
{
    if ( !dirty && filterSpec == (int)DefaultFilter &&
                   sortSpec   == (int)DefaultSort )
        return fiList;
    return entryInfoList( nameFilt, filterSpec, sortSpec );
}

const QFileInfoList *QDir::entryInfoList( const QString &nameFilter,
                                          int filterSpec, int sortSpec ) const
{
    if ( filterSpec == (int)DefaultFilter )
        filterSpec = filtS;
    if ( sortSpec == (int)DefaultSort )
        sortSpec = sortS;
    QDir *that = (QDir*)this;                   // mutable function
    if ( that->readDirEntries(nameFilter, filterSpec, sortSpec) )
        return that->fiList;
    else
        return 0;
}

bool QDir::exists() const
{
    QFileInfo fi( dPath );
    return fi.exists() && fi.isDir();
}

bool QDir::isRelative() const
{
    return isRelativePath( dPath );
}

void QDir::convertToAbs()
{
    dPath = absPath();
}

QDir &QDir::operator=( const QDir &d )
{
    dPath    = d.dPath;
    delete fList;
    fList    = 0;
    delete fiList;
    fiList   = 0;
    nameFilt = d.nameFilt;
    dirty    = TRUE;
    allDirs  = d.allDirs;
    filtS    = d.filtS;
    sortS    = d.sortS;
    return *this;
}

QDir &QDir::operator=( const QString &path )
{
    dPath = cleanDirPath( path );
    dirty = TRUE;
    return *this;
}


bool QDir::operator==( const QDir &d ) const
{
    return dPath    == d.dPath &&
           nameFilt == d.nameFilt &&
           allDirs  == d.allDirs &&
           filtS    == d.filtS &&
           sortS    == d.sortS;
}


bool QDir::remove( const QString &fileName, bool acceptAbsPath )
{
    if ( fileName.isEmpty() ) {
#if defined(QT_CHECK_NULL)
        qWarning( "QDir::remove: Empty or null file name" );
#endif
        return FALSE;
    }
    QString p = filePath( fileName, acceptAbsPath );
    return QFile::remove( p );
}

bool QDir::exists( const QString &name, bool acceptAbsPath ) //### const in 4.0
{
    if ( name.isEmpty() ) {
#if defined(QT_CHECK_NULL)
        qWarning( "QDir::exists: Empty or null file name" );
#endif
        return FALSE;
    }
    QString tmp = filePath( name, acceptAbsPath );
    return QFile::exists( tmp );
}

char QDir::separator()
{
#if defined(Q_OS_UNIX)
    return '/';
#elif defined (Q_FS_FAT) || defined(Q_WS_WIN)
    return '\\';
#elif defined (Q_OS_MAC)
    return ':';
#else
    return '/';
#endif
}

QDir QDir::current()
{
    return QDir( currentDirPath() );
}

QDir QDir::home()
{
    return QDir( homeDirPath() );
}

QDir QDir::root()
{
    return QDir( rootDirPath() );
}

QValueList<QRegExp> qt_makeFilterList( const QString &filter )
{
    QValueList<QRegExp> regExps;
    if ( filter.isEmpty() )
        return regExps;

    QChar sep( ';' );
    int i = filter.find( sep, 0 );
    if ( i == -1 && filter.find( ' ', 0 ) != -1 )
        sep = QChar( ' ' );

    QStringList list = QStringList::split( sep, filter );
    QStringList::Iterator it = list.begin();
    while ( it != list.end() ) {
        regExps << QRegExp( (*it).stripWhiteSpace(), CaseSensitiveFS, TRUE );
        ++it;
    }
    return regExps;
}

bool qt_matchFilterList( const QValueList<QRegExp>& filters,
                         const QString &fileName )
{
    QValueList<QRegExp>::ConstIterator rit = filters.begin();
    while ( rit != filters.end() ) {
        if ( (*rit).exactMatch(fileName) )
            return TRUE;
        ++rit;
    }
    return FALSE;
}


bool QDir::match( const QStringList &filters, const QString &fileName )
{
    QStringList::ConstIterator sit = filters.begin();
    while ( sit != filters.end() ) {
        QRegExp rx( *sit, CaseSensitiveFS, TRUE );
        if ( rx.exactMatch(fileName) )
            return TRUE;
        ++sit;
    }
    return FALSE;
}

bool QDir::match( const QString &filter, const QString &fileName )
{
    return qt_matchFilterList( qt_makeFilterList(filter), fileName );
}


QString QDir::cleanDirPath( const QString &filePath )
{
    QString name = filePath;
    QString newPath;

    if ( name.isEmpty() )
        return name;

    slashify( name );

    bool addedSeparator;
    if ( isRelativePath(name) ) {
        addedSeparator = TRUE;
        name.insert( 0, '/' );
    } else {
        addedSeparator = FALSE;
    }

    int ePos, pos, upLevel;

    pos = ePos = name.length();
    upLevel = 0;
    int len;

    while ( pos && (pos = name.findRev('/',--pos)) != -1 ) {
        len = ePos - pos - 1;
        if ( len == 2 && name.at(pos + 1) == '.'
                      && name.at(pos + 2) == '.' ) {
            upLevel++;
        } else {
            if ( len != 0 && (len != 1 || name.at(pos + 1) != '.') ) {
                if ( !upLevel )
                    newPath = QString::fromLatin1("/")
                        + name.mid(pos + 1, len) + newPath;
                else
                    upLevel--;
            }
        }
        ePos = pos;
    }
    if ( addedSeparator ) {
        while ( upLevel-- )
            newPath.insert( 0, QString::fromLatin1("/..") );
        if ( !newPath.isEmpty() )
            newPath.remove( 0, 1 );
        else
            newPath = QString::fromLatin1(".");
    } else {
        if ( newPath.isEmpty() )
            newPath = QString::fromLatin1("/");
#if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
        if ( name[0] == '/' ) {
            if ( name[1] == '/' )               // "\\machine\x\ ..."
                newPath.insert( 0, '/' );
        } else {
            newPath = name.left(2) + newPath;
        }
#endif
    }
    return newPath;
}

int qt_cmp_si_sortSpec;

#if defined(Q_C_CALLBACKS)
extern "C" {
#endif

#ifdef Q_OS_TEMP
int __cdecl qt_cmp_si( const void *n1, const void *n2 )
#else
int qt_cmp_si( const void *n1, const void *n2 )
#endif
{
    if ( !n1 || !n2 )
        return 0;

    QDirSortItem* f1 = (QDirSortItem*)n1;
    QDirSortItem* f2 = (QDirSortItem*)n2;

    if ( qt_cmp_si_sortSpec & QDir::DirsFirst )
        if ( f1->item->isDir() != f2->item->isDir() )
            return f1->item->isDir() ? -1 : 1;

    int r = 0;
    int sortBy = qt_cmp_si_sortSpec & QDir::SortByMask;

    switch ( sortBy ) {
      case QDir::Time:
        r = f1->item->lastModified().secsTo(f2->item->lastModified());
        break;
      case QDir::Size:
        r = f2->item->size() - f1->item->size();
        break;
      default:
        ;
    }

    if ( r == 0 && sortBy != QDir::Unsorted ) {
        // Still not sorted - sort by name
        bool ic = qt_cmp_si_sortSpec & QDir::IgnoreCase;

        if ( f1->filename_cache.isNull() )
            f1->filename_cache = ic ? f1->item->fileName().lower()
                                    : f1->item->fileName();
        if ( f2->filename_cache.isNull() )
            f2->filename_cache = ic ? f2->item->fileName().lower()
                                    : f2->item->fileName();

        r = f1->filename_cache.compare(f2->filename_cache);
    }

    if ( r == 0 ) {
        // Enforce an order - the order the items appear in the array
        r = (char*)n1 - (char*)n2;
    }

    if ( qt_cmp_si_sortSpec & QDir::Reversed )
        return -r;
    else
        return r;
}

#if defined(Q_C_CALLBACKS)
}
#endif

#endif // QT_NO_DIR

---