Changeset 363 for trunk/src


Ignore:
Timestamp:
Nov 30, 2009, 6:52:30 PM (16 years ago)
Author:
Dmitry A. Kuminov
Message:

global: Reverted r355, r356, r361, r362 (see #78).

Location:
trunk/src/corelib/io
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/corelib/io/qdir.cpp

    r355 r363  
    732732{
    733733    Q_D(const QDir);
    734 
    735 #ifdef Q_OS_OS2
    736 
    737     if (isAbsolutePath(fileName) || !d->data->fileEngine)
    738         return QDir::fromNativeSeparators(fileName);
    739 
    740     // On OS/2, paths like "A:bbb.txt" and "\ccc.dat" are not absolute and
    741     // therefore require special processing here
    742     QString ret;
    743     if (isRelativePath(d->data->path)) {
    744         if (d->data->path.startsWith(QLatin1Char('/')) ||
    745             (d->data->path.length() >= 2 &&
    746              d->data->path.at(0).isLetter() && d->data->path.at(1) == QLatin1Char(':'))) {
    747             ret = d->data->fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
    748         } else {
    749 #ifndef QT_NO_FSFILEENGINE
    750             //get pwd
    751             ret = QFSFileEngine::currentPath(fileName);
    752 #endif
    753             if(!d->data->path.isEmpty() && d->data->path != QLatin1String(".")) {
    754                 if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
    755                     ret += QLatin1Char('/');
    756                 ret += d->data->path;
    757             }
    758         }
    759     } else {
    760         ret = d->data->path;
    761     }
    762     if (!fileName.isEmpty()) {
    763         QString fn = QDir::fromNativeSeparators(fileName);
    764         if (fn.length() >= 2 &&
    765             fn.at(0).isLetter() && fn.at(1) == QLatin1Char(':')) {
    766             ret = QFileInfo(fn).absoluteFilePath();
    767         } else {
    768             if (fn.startsWith(QLatin1Char('/')) && !ret.isEmpty())
    769                 ret = ret.left(2); // take the drive name
    770             else if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
    771                 ret += QLatin1Char('/'); // append the missing slash
    772             ret += fn;
    773         }
    774     }
    775     return ret;
    776 
    777 #else // #ifdef Q_OS_OS2
    778 
    779734    if (isAbsolutePath(fileName))
    780735        return fileName;
    … …  
    798753    }
    799754    return ret;
    800 
    801 #endif // #ifdef Q_OS_OS2
    802755}
    803756

  • trunk/src/corelib/io/qfileinfo.cpp

    r355 r363  
    586586    drive letter, except for network shares that are not mapped to a
    587587    drive letter, in which case the path will begin '//sharename/'.
    588     QFileInfo will uppercase drive letters. Note that QDir does not
    589     normally do this. The code snippet below shows this.
     588    QFileInfo will uppercase drive letters. Note that QDir does not
     589    this. The code snippet below shows this.
    590590
    591591    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp newstuff

  • trunk/src/corelib/io/qfsfileengine_os2.cpp

    r361 r363  
    650650static bool isRelativePath(const QString &path)
    651651{
    652         // On OS/2, "A:bbb.txt" and "/ccc.dat" are relative paths
    653     return !(path.startsWith(QLatin1String("//")) ||
    654              (path.length() >= 2 && path.at(0).isLetter() &&
    655               path.at(1) == QLatin1Char(':') &&
    656               // we treat "D:" as absolute while "D:aaa" as relative
    657               (path.length() == 2 || path.at(2) == QLatin1Char('/'))));
     652    return !(path.startsWith(QLatin1Char('/'))
     653        || (path.length() >= 2
     654        && ((path.at(0).isLetter() && path.at(1) == QLatin1Char(':'))
     655        || (path.at(0) == QLatin1Char('/') && path.at(1) == QLatin1Char('/')))));                // drive, e.g. a:
    658656}
    659657
    … …  
    688686    } else if(file == AbsoluteName || file == AbsolutePathName) {
    689687        QString ret;
    690         if (isRelativePath()) {
    691             if ((d->filePath.size() > 2 && d->filePath.at(1) == QLatin1Char(':') &&
    692                  d->filePath.at(2) != QLatin1Char('/')) ||    // path relative to the current dir of the given drive, so Z:a.txt -> Z:\currentpath\a.txt
    693                 (d->filePath.startsWith(QLatin1Char('/')))) { // path relative to the root of the current drive, so \a.txt -> Z:\a.txt
     688
     689        if (!isRelativePath()) {
     690            if (d->filePath.size() > 2 && d->filePath.at(1) == QLatin1Char(':')
     691                && d->filePath.at(2) != QLatin1Char('/') || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
     692                d->filePath.startsWith(QLatin1Char('/'))    // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
     693                ) {
    694694                char buf[PATH_MAX+1];
    695695                strcpy(buf, QFile::encodeName(d->filePath).constData());
    696696                _abspath(buf, buf, sizeof(buf));
    697                 ret = QDir::cleanPath(QFile::decodeName(buf));
    698                 if (::isRelativePath(ret)) {
    699                     // still relative, this means we have "Z:aaa" but there is no such drive Z:
    700                     // just assume root is the current dir on Z:
    701                     Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    702                     ret.insert(2, QLatin1Char('/'));
    703                 }
     697                ret = QFile::decodeName(buf);
    704698            } else {
    705                 ret = QDir::cleanPath(QDir::currentPath() + QLatin1Char('/') + d->filePath);
     699                ret = ;
    706700            }
    707701        } else {
    708             ret = d->filePath;
     702            ret = ;
    709703        }
    710704
    711705        // The path should be absolute at this point.
    712         // On OS/2, the absolute path always contains a "X:/" at the begining
    713         // where X is the drive letter, or "//" if it's a network share
    714         if (!ret.startsWith(QLatin1String("//"))) {
     706        // From the docs :
     707        // Absolute paths begin with the directory separator "/"
     708        // (optionally preceded by a drive specification under Windows).
     709        if (ret.at(0) != QLatin1Char('/')) {
    715710            Q_ASSERT(ret.length() >= 2);
    716711            Q_ASSERT(ret.at(0).isLetter());
    717712            Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    718             if (ret.length() == 2) {
    719                 // we are missing the slash in the "drive root dir" case, append it
    720                 ret += QLatin1Char('/');
    721             } else {
    722                 Q_ASSERT(ret.at(2) == QLatin1Char('/'));
    723             }
    724713
    725714            // Force uppercase drive letters.
    … …  
    729718        if (file == AbsolutePathName) {
    730719            int slash = ret.lastIndexOf(QLatin1Char('/'));
    731             if (!ret.startsWith(QLatin1String("//"))) {
    732                 Q_ASSERT(slash >= 2);
    733                 if (slash == 2)
    734                     ret = ret.left(3);  // include the slash if it's "X:/"
    735                 else
    736                     ret = ret.left(slash);
    737             } else {
    738                 Q_ASSERT(slash >= 1);
    739                 if (slash == 1)
    740                     ret = ret.left(3);  // include the slash if it's "//"
    741                 else
    742                     ret = ret.left(slash);
    743             }
     720            if (slash < 0)
     721                return ret;
     722            else if (ret.at(0) != QLatin1Char('/') && slash == 2)
     723                return ret.left(3);      // include the slash
     724            else
     725                return ret.left(slash > 0 ? slash : 1);
    744726        }
    745727        return ret;
    … …  
    751733        if (!ret.isEmpty() && file == CanonicalPathName) {
    752734            int slash = ret.lastIndexOf(QLatin1Char('/'));
    753             if (!ret.startsWith(QLatin1String("//"))) {
    754                 Q_ASSERT(slash >= 2);
    755                 if (slash == 2)
    756                     ret = ret.left(3);  // include the slash if it's "X:/"
    757                 else
    758                     ret = ret.left(slash);
    759             } else {
    760                 Q_ASSERT(slash >= 1);
    761                 if (slash == 1)
    762                     ret = ret.left(3);  // include the slash if it's "//"
    763                 else
    764                     ret = ret.left(slash);
    765             }
     735            if (slash == -1)
     736                ret = QDir::currentPath();
     737            else if (slash == 0)
     738                ret = QLatin1String("/");
     739            ret = ret.left(slash);
    766740        }
    767741        return ret;
    … …  
    774748                QString target = QDir::fromNativeSeparators(QFile::decodeName(QByteArray(buf)));
    775749                QString ret;
    776                 if (::isRelativePath(target)) {
    777                     if ((target.size() > 2 && target.at(1) == QLatin1Char(':') &&
    778                          target.at(2) != QLatin1Char('/')) ||    // path relative to the current dir of the given drive, so Z:a.txt -> Z:\currentpath\a.txt
    779                         (target.startsWith(QLatin1Char('/')))) { // path relative to the root of the current drive, so \a.txt -> Z:\a.txt
     750                if (!::isRelativePath(target)) {
     751                    if (target.size() > 2 && target.at(1) == QLatin1Char(':')
     752                        && target.at(2) != QLatin1Char('/') || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
     753                        target.startsWith(QLatin1Char('/'))    // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
     754                        ) {
    780755                        char buf[PATH_MAX+1];
    781756                        strcpy(buf, QFile::encodeName(target).constData());
    782757                        _abspath(buf, buf, sizeof(buf));
    783                         ret = QDir::cleanPath(QFile::decodeName(buf));
    784                         if (::isRelativePath(ret)) {
    785                             // still relative, this means we have "Z:aaa" but there is no such drive Z:
    786                             // just assume root is the current dir on Z:
    787                             Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    788                             ret.insert(2, QLatin1Char('/'));
    789                         }
     758                        ret = QFile::decodeName(buf);
    790759                    } else {
    791                         if (S_ISDIR(d->st.st_mode)) {
    792                             QDir parent(d->filePath);
    793                             parent.cdUp();
    794                             ret = parent.path();
    795                             if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
    796                                 ret += QLatin1Char('/');
    797                         }
    798                         ret += target;
    799 
    800                         if (::isRelativePath(ret)) {
    801                             if (!isRelativePath()) {
    802                                 ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
    803                                             + QLatin1Char('/'));
    804                             } else {
    805                                 ret.prepend(QDir::currentPath() + QLatin1Char('/'));
    806                             }
    807                         }
    808                         ret = QDir::cleanPath(ret);
    809                         if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
    810                             ret.chop(1);
     760                        ret = target;
    811761                    }
    812762                } else {
    813                     ret = target;
     763                    if (S_ISDIR(d->st.st_mode)) {
     764                        QDir parent(d->filePath);
     765                        parent.cdUp();
     766                        ret = parent.path();
     767                        if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
     768                            ret += QLatin1Char('/');
     769                    }
     770                    ret += target;
     771
     772                    if (::isRelativePath(ret)) {
     773                        if (!isRelativePath()) {
     774                            ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
     775                                        + QLatin1Char('/'));
     776                        } else {
     777                            ret.prepend(QDir::currentPath() + QLatin1Char('/'));
     778                        }
     779                    }
     780                    ret = QDir::cleanPath(ret);
     781                    if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
     782                        ret.chop(1);
    814783                }
    815784
    816 
    817785                // The path should be absolute at this point.
    818                 // On OS/2, the absolute path always contains a "X:/" at the begining
    819                 // where X is the drive letter, or "//" if it's a network share
    820                 if (!ret.startsWith(QLatin1String("//"))) {
     786                // From the docs :
     787                // Absolute paths begin with the directory separator "/"
     788                // (optionally preceded by a drive specification under Windows).
     789                if (ret.at(0) != QLatin1Char('/')) {
    821790                    Q_ASSERT(ret.length() >= 2);
    822791                    Q_ASSERT(ret.at(0).isLetter());
    823792                    Q_ASSERT(ret.at(1) == QLatin1Char(':'));
    824                     if (ret.length() == 2) {
    825                         // we are missing the slash in the "drive root dir" case, append it
    826                         ret += QLatin1Char('/');
    827                     } else {
    828                         Q_ASSERT(ret.at(2) == QLatin1Char('/'));
    829                     }
    830793
    831794                    // Force uppercase drive letters.
Note: See TracChangeset for help on using the changeset viewer.