diff --git a/src/fileaccess.cpp b/src/fileaccess.cpp index 2d07180..6aaacd6 100644 --- a/src/fileaccess.cpp +++ b/src/fileaccess.cpp @@ -1,1778 +1,1778 @@ /*************************************************************************** * Copyright (C) 2003-2011 by Joachim Eibl * * joachim.eibl at gmx.de * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * ***************************************************************************/ #include "fileaccess.h" #include "common.h" #include "progress.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef Q_OS_WIN #include #include #include #include #else #include // Needed for creating symbolic links via symlink(). #include #endif class FileAccess::Data { public: Data() { reset(); } void reset() { m_url = QUrl(); m_bValidData = false; m_name = QString(); //m_creationTime = QDateTime(); //m_accessTime = QDateTime(); m_bReadable = false; m_bExecutable = false; m_linkTarget = ""; //m_fileType = -1; m_bLocal = true; m_pParent = nullptr; } QUrl m_url; bool m_bLocal; bool m_bValidData; //QDateTime m_accessTime; //QDateTime m_creationTime; bool m_bReadable; bool m_bExecutable; //long m_fileType; // for testing only FileAccess* m_pParent; QString m_linkTarget; //QString m_user; //QString m_group; QString m_name; QString m_localCopy; QString m_statusText; // Might contain an error string, when the last operation didn't succeed. }; FileAccess::FileAccess(const QString& name, bool bWantToWrite) { m_pData = nullptr; m_bUseData = false; setFile(name, bWantToWrite); } FileAccess::FileAccess() { m_bUseData = false; m_bExists = false; m_bFile = false; m_bDir = false; m_bSymLink = false; m_bWritable = false; m_bHidden = false; m_pParent = nullptr; m_size = 0; } FileAccess::FileAccess(const FileAccess& other) { m_pData = nullptr; m_bUseData = false; *this = other; } void FileAccess::createData() { if(d() == nullptr) { FileAccess* pParent = m_pParent; // backup because in union with m_pData m_pData = new Data(); m_bUseData = true; m_pData->m_pParent = pParent; } } FileAccess& FileAccess::operator=(const FileAccess& other) { m_size = other.m_size; m_filePath = other.m_filePath; m_modificationTime = other.m_modificationTime; m_bSymLink = other.m_bSymLink; m_bFile = other.m_bFile; m_bDir = other.m_bDir; m_bExists = other.m_bExists; m_bWritable = other.m_bWritable; m_bHidden = other.m_bHidden; if(other.m_bUseData) { createData(); *m_pData = *other.m_pData; } else { if(m_bUseData) { delete m_pData; } m_bUseData = false; m_pParent = other.parent(); // should be 0 anyway } return *this; } FileAccess::~FileAccess() { if(m_bUseData) { if(!d()->m_localCopy.isEmpty()) { removeTempFile(d()->m_localCopy); } delete m_pData; } } static QString nicePath(const QFileInfo& fi) { QString fp = fi.filePath(); if(fp.length() > 2 && fp[0] == '.' && fp[1] == '/') { return fp.mid(2); } return fp; } // Two kinds of optimization are applied here: // 1. Speed: don't ask for data as long as it is not needed or cheap to get. // When opening a file it is early enough to ask for details. // 2. Memory usage: Don't store data that is not needed, and avoid redundancy. // For recursive directory trees don't store the full path if a parent is available. // Store urls only if files are not local. void FileAccess::setFile(const QFileInfo& fi, FileAccess* pParent) { m_filePath = pParent == nullptr ? fi.absoluteFilePath() : nicePath(fi.filePath()); // remove "./" at start m_bSymLink = fi.isSymLink(); if(m_bSymLink || (!m_bExists && m_filePath.contains("@@"))) { createData(); } if(m_bUseData) d()->m_pParent = pParent; else m_pParent = pParent; if(parent() || d()) // if a parent is specified then we arrive here because of listing a directory { m_bFile = fi.isFile(); m_bDir = fi.isDir(); m_bExists = fi.exists(); m_size = fi.size(); m_modificationTime = fi.lastModified(); m_bHidden = fi.isHidden(); #if defined(Q_OS_WIN) m_bWritable = pParent == 0 || fi.isWritable(); // in certain situations this might become a problem though #else m_bWritable = fi.isWritable(); #endif } if(d() != nullptr) { #if defined(Q_OS_WIN) // On some windows machines in a network this takes very long. // and it's not so important anyway. d()->m_bReadable = true; d()->m_bExecutable = false; #else d()->m_bReadable = fi.isReadable(); d()->m_bExecutable = fi.isExecutable(); #endif //d()->m_creationTime = fi.created(); //d()->m_modificationTime = fi.lastModified(); //d()->m_accessTime = fi.lastRead(); d()->m_name = fi.fileName(); if(m_bSymLink) { d()->m_linkTarget = fi.readLink(); #ifndef Q_OS_WIN // Unfortunately Qt5 symLinkTarget/readLink always returns an absolute path, even if the link is relative char s[PATH_MAX + 1]; - int len = readlink(QFile::encodeName(fi.absoluteFilePath()).constData(), s, PATH_MAX); + ssize_t len = readlink(QFile::encodeName(fi.absoluteFilePath()).constData(), s, PATH_MAX); if(len > 0) { s[len] = '\0'; d()->m_linkTarget = QFile::decodeName(s); } #endif } d()->m_bLocal = true; d()->m_bValidData = true; d()->m_url = QUrl::fromLocalFile(fi.filePath()); if(d()->m_url.isRelative()) { d()->m_url.setPath(absoluteFilePath()); } if(!m_bExists && absoluteFilePath().contains("@@")) { // Try reading a clearcase file d()->m_localCopy = FileAccess::tempFileName(); QString cmd = "cleartool get -to \"" + d()->m_localCopy + "\" \"" + absoluteFilePath() + "\""; QProcess process; process.start(cmd); process.waitForFinished(-1); //::system( cmd.local8Bit() ); QFile::setPermissions(d()->m_localCopy, QFile::ReadUser | QFile::WriteUser); // Clearcase creates a write protected file, allow delete. QFileInfo fi(d()->m_localCopy); #if defined(Q_OS_WIN) d()->m_bReadable = true; //fi.isReadable(); m_bWritable = true; //fi.isWritable(); d()->m_bExecutable = false; //fi.isExecutable(); #else d()->m_bReadable = fi.isReadable(); d()->m_bExecutable = fi.isExecutable(); #endif //d()->m_creationTime = fi.created(); //d()->m_accessTime = fi.lastRead(); m_bExists = fi.exists(); m_size = fi.size(); } } } void FileAccess::setFile(const QString& name, bool bWantToWrite) { m_bExists = false; m_bFile = false; m_bDir = false; m_bSymLink = false; m_size = 0; m_modificationTime = QDateTime(); if(d() != nullptr) { d()->reset(); d()->m_pParent = nullptr; } else m_pParent = nullptr; // Note: Checking if the filename-string is empty is necessary for Win95/98/ME. // The isFile() / isDir() queries would cause the program to crash. // (This is a Win95-bug which has been corrected only in WinNT/2000/XP.) if(!name.isEmpty()) { QUrl url = QUrl::fromUserInput(name, QString(), QUrl::AssumeLocalFile); // FileAccess tries to detect if the given name is an URL or a local file. // This is a problem if the filename looks like an URL (i.e. contains a colon ':'). // e.g. "file:f.txt" is a valid filename. // Most of the time it is sufficient to check if the file exists locally. // 2 Problems remain: // 1. When the local file exists and the remote location is wanted nevertheless. (unlikely) // 2. When the local file doesn't exist and should be written to. bool bExistsLocal = QDir().exists(name); if(url.isLocalFile() || url.isRelative() || !url.isValid() || bExistsLocal) // assuming that invalid means relative { QString localName = name; #if defined(Q_OS_WIN) if(localName.startsWith("/tmp/")) { // git on Cygwin will put files in /tmp // A workaround for the a native kdiff3 binary to find them... QString cygwinBin = getenv("CYGWIN_BIN"); if(!cygwinBin.isEmpty()) { localName = QString("%1\\..%2").arg(cygwinBin).arg(name); } } #endif if(!bExistsLocal && url.isLocalFile() && name.left(5).toLower() == "file:") { localName = url.path(); // I want the path without preceding "file:" } QFileInfo fi(localName); setFile(fi, nullptr); } else { createData(); d()->m_url = url; d()->m_name = d()->m_url.fileName(); d()->m_bLocal = false; FileAccessJobHandler jh(this); // A friend, which writes to the parameters of this class! jh.stat(2 /*all details*/, bWantToWrite); // returns bSuccess, ignored m_filePath = name; d()->m_bValidData = true; // After running stat() the variables are initialised // and valid even if the file doesn't exist and the stat // query failed. } } } void FileAccess::addPath(const QString& txt) { if(d() != nullptr && d()->m_url.isValid()) { QUrl url = d()->m_url.adjusted(QUrl::StripTrailingSlash); d()->m_url.setPath(url.path() + '/' + txt); setFile(d()->m_url.url()); // reinitialise } else { QString slash = (txt.isEmpty() || txt[0] == '/') ? "" : "/"; setFile(absoluteFilePath() + slash + txt); } } /* Filetype: S_IFMT 0170000 bitmask for the file type bitfields S_IFSOCK 0140000 socket S_IFLNK 0120000 symbolic link S_IFREG 0100000 regular file S_IFBLK 0060000 block device S_IFDIR 0040000 directory S_IFCHR 0020000 character device S_IFIFO 0010000 fifo S_ISUID 0004000 set UID bit S_ISGID 0002000 set GID bit (see below) S_ISVTX 0001000 sticky bit (see below) Access: S_IRWXU 00700 mask for file owner permissions S_IRUSR 00400 owner has read permission S_IWUSR 00200 owner has write permission S_IXUSR 00100 owner has execute permission S_IRWXG 00070 mask for group permissions S_IRGRP 00040 group has read permission S_IWGRP 00020 group has write permission S_IXGRP 00010 group has execute permission S_IRWXO 00007 mask for permissions for others (not in group) S_IROTH 00004 others have read permission S_IWOTH 00002 others have write permisson S_IXOTH 00001 others have execute permission */ //TODO: Change this to kf5/kde auto test #ifdef Q_OS_WIN void FileAccess::setUdsEntry(const KIO::UDSEntry&) { } // not needed if KDE is not available #else void FileAccess::setUdsEntry(const KIO::UDSEntry& e) { long acc = 0; long fileType = 0; QVector fields = e.fields(); for(QVector::ConstIterator ei = fields.constBegin(); ei != fields.constEnd(); ++ei) { uint f = *ei; switch(f) { case KIO::UDSEntry::UDS_SIZE: m_size = e.numberValue(f); break; //case KIO::UDSEntry::UDS_USER : d()->m_user = e.stringValue(f); break; //case KIO::UDSEntry::UDS_GROUP : d()->m_group = e.stringValue(f); break; case KIO::UDSEntry::UDS_NAME: m_filePath = e.stringValue(f); break; // During listDir the relative path is given here. case KIO::UDSEntry::UDS_MODIFICATION_TIME: m_modificationTime.setTime_t(e.numberValue(f)); break; //case KIO::UDSEntry::UDS_ACCESS_TIME : d()->m_accessTime.setTime_t( e.numberValue(f) ); break; //case KIO::UDSEntry::UDS_CREATION_TIME : d()->m_creationTime.setTime_t( e.numberValue(f) ); break; case KIO::UDSEntry::UDS_LINK_DEST: d()->m_linkTarget = e.stringValue(f); break; case KIO::UDSEntry::UDS_ACCESS: { acc = e.numberValue(f); d()->m_bReadable = (acc & S_IRUSR) != 0; m_bWritable = (acc & S_IWUSR) != 0; d()->m_bExecutable = (acc & S_IXUSR) != 0; break; } case KIO::UDSEntry::UDS_FILE_TYPE: { fileType = e.numberValue(f); m_bDir = (fileType & S_IFMT) == S_IFDIR; m_bFile = (fileType & S_IFMT) == S_IFREG; m_bSymLink = (fileType & S_IFMT) == S_IFLNK; m_bExists = fileType != 0; //d()->m_fileType = fileType; break; } case KIO::UDSEntry::UDS_URL: // m_url = QUrlFix( e.stringValue(f) ); break; case KIO::UDSEntry::UDS_MIME_TYPE: break; case KIO::UDSEntry::UDS_GUESSED_MIME_TYPE: break; case KIO::UDSEntry::UDS_XML_PROPERTIES: break; default: break; } } m_bExists = acc != 0 || fileType != 0; d()->m_bLocal = false; d()->m_bValidData = true; m_bSymLink = !d()->m_linkTarget.isEmpty(); if(d()->m_name.isEmpty()) { int pos = m_filePath.lastIndexOf('/') + 1; d()->m_name = m_filePath.mid(pos); } m_bHidden = d()->m_name[0] == '.'; } #endif bool FileAccess::isValid() const { return d() == nullptr ? !m_filePath.isEmpty() : d()->m_bValidData; } bool FileAccess::isFile() const { if(parent() || d()) return m_bFile; else return QFileInfo(absoluteFilePath()).isFile(); } bool FileAccess::isDir() const { if(parent() || d()) return m_bDir; else return QFileInfo(absoluteFilePath()).isDir(); } bool FileAccess::isSymLink() const { return m_bSymLink; } bool FileAccess::exists() const { if(parent() || d()) return m_bExists; else return QFileInfo::exists(absoluteFilePath()); } qint64 FileAccess::size() const { if(parent() || d()) return m_size; else return QFileInfo(absoluteFilePath()).size(); } QUrl FileAccess::url() const { if(d() != nullptr) return d()->m_url; else { QUrl url = QUrl::fromLocalFile(m_filePath); if(url.isRelative()) { url.setPath(absoluteFilePath()); } return url; } } bool FileAccess::isLocal() const { return d() == nullptr || d()->m_bLocal; } bool FileAccess::isReadable() const { #if defined(Q_OS_WIN) // On some windows machines in a network this takes very long to find out and it's not so important anyway. return true; #else if(d() != nullptr) return d()->m_bReadable; else return QFileInfo(absoluteFilePath()).isReadable(); #endif } bool FileAccess::isWritable() const { if(parent() || d()) return m_bWritable; else return QFileInfo(absoluteFilePath()).isWritable(); } bool FileAccess::isExecutable() const { #if defined(Q_OS_WIN) // On some windows machines in a network this takes very long to find out and it's not so important anyway. return true; #else if(d() != nullptr) return d()->m_bExecutable; else return QFileInfo(absoluteFilePath()).isExecutable(); #endif } bool FileAccess::isHidden() const { if(parent() || d()) return m_bHidden; else return QFileInfo(absoluteFilePath()).isHidden(); } QString FileAccess::readLink() const { if(d() != nullptr) return d()->m_linkTarget; else return QString(); } QString FileAccess::absoluteFilePath() const { if(parent() != nullptr) return parent()->absoluteFilePath() + "/" + m_filePath; else { if(m_filePath.isEmpty()) return QString(); if(!isLocal()) return m_filePath; // return complete url QFileInfo fi(m_filePath); if(fi.isAbsolute()) return m_filePath; else return fi.absoluteFilePath(); // Probably never reached } } // Full abs path // Just the name-part of the path, without parent directories QString FileAccess::fileName() const { if(d() != nullptr) return d()->m_name; else if(parent()) return m_filePath; else return QFileInfo(m_filePath).fileName(); } void FileAccess::setSharedName(const QString& name) { if(name == m_filePath) m_filePath = name; // reduce memory because string is only used once. } QString FileAccess::filePath() const { if(parent() && parent()->parent()) return parent()->filePath() + "/" + m_filePath; else return m_filePath; // The path-string that was used during construction } FileAccess* FileAccess::parent() const { if(m_bUseData) return d()->m_pParent; else return m_pParent; } FileAccess::Data* FileAccess::d() { if(m_bUseData) return m_pData; else return nullptr; } const FileAccess::Data* FileAccess::d() const { if(m_bUseData) return m_pData; else return nullptr; } QString FileAccess::prettyAbsPath() const { return isLocal() ? absoluteFilePath() : d()->m_url.toDisplayString(); } /* QDateTime FileAccess::created() const { if ( d()!=0 ) { if ( isLocal() && d()->m_creationTime.isNull() ) const_cast(this)->d()->m_creationTime = QFileInfo( absoluteFilePath() ).created(); return ( d()->m_creationTime.isValid() ? d()->m_creationTime : lastModified() ); } else { QDateTime created = QFileInfo( absoluteFilePath() ).created(); return created.isValid() ? created : lastModified(); } } */ QDateTime FileAccess::lastModified() const { if(isLocal() && m_modificationTime.isNull()) const_cast(this)->m_modificationTime = QFileInfo(absoluteFilePath()).lastModified(); return m_modificationTime; } /* QDateTime FileAccess::lastRead() const { QDateTime accessTime = d()!=0 ? d()->m_accessTime : QFileInfo( absoluteFilePath() ).lastRead(); return ( accessTime.isValid() ? accessTime : lastModified() ); } */ static bool interruptableReadFile(QFile& f, void* pDestBuffer, unsigned long maxLength) { ProgressProxy pp; const unsigned long maxChunkSize = 100000; unsigned long i = 0; pp.setMaxNofSteps(maxLength / maxChunkSize + 1); while(i < maxLength) { unsigned long nextLength = min2(maxLength - i, maxChunkSize); unsigned long reallyRead = f.read((char*)pDestBuffer + i, nextLength); if(reallyRead != nextLength) { return false; } i += reallyRead; pp.setCurrent(double(i) / maxLength); if(pp.wasCancelled()) return false; } return true; } bool FileAccess::readFile(void* pDestBuffer, unsigned long maxLength) { if(d() != nullptr && !d()->m_localCopy.isEmpty()) { QFile f(d()->m_localCopy); if(f.open(QIODevice::ReadOnly)) return interruptableReadFile(f, pDestBuffer, maxLength); // maxLength == f.read( (char*)pDestBuffer, maxLength ); } else if(isLocal()) { QFile f(absoluteFilePath()); if(f.open(QIODevice::ReadOnly)) return interruptableReadFile(f, pDestBuffer, maxLength); //maxLength == f.read( (char*)pDestBuffer, maxLength ); } else { FileAccessJobHandler jh(this); return jh.get(pDestBuffer, maxLength); } return false; } bool FileAccess::writeFile(const void* pSrcBuffer, unsigned long length) { ProgressProxy pp; if(isLocal()) { QFile f(absoluteFilePath()); if(f.open(QIODevice::WriteOnly)) { const unsigned long maxChunkSize = 100000; pp.setMaxNofSteps(length / maxChunkSize + 1); unsigned long i = 0; while(i < length) { unsigned long nextLength = min2(length - i, maxChunkSize); unsigned long reallyWritten = f.write((char*)pSrcBuffer + i, nextLength); if(reallyWritten != nextLength) { return false; } i += reallyWritten; pp.step(); if(pp.wasCancelled()) return false; } f.close(); #ifndef Q_OS_WIN if(isExecutable()) // value is true if the old file was executable { // Preserve attributes f.setPermissions(f.permissions() | QFile::ExeUser); //struct stat srcFileStatus; //int statResult = ::stat( filePath().toLocal8Bit().constData(), &srcFileStatus ); //if (statResult==0) //{ // ::chmod ( filePath().toLocal8Bit().constData(), srcFileStatus.st_mode | S_IXUSR ); //} } #endif return true; } } else { FileAccessJobHandler jh(this); return jh.put(pSrcBuffer, length, true /*overwrite*/); } return false; } bool FileAccess::copyFile(const QString& dest) { FileAccessJobHandler jh(this); return jh.copyFile(dest); // Handles local and remote copying. } bool FileAccess::rename(const QString& dest) { FileAccessJobHandler jh(this); return jh.rename(dest); } bool FileAccess::removeFile() { if(isLocal()) { return QDir().remove(absoluteFilePath()); } else { FileAccessJobHandler jh(this); return jh.removeFile(url()); } } bool FileAccess::removeFile(const QString& name) // static { return FileAccess(name).removeFile(); } bool FileAccess::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden, const QString& filePattern, const QString& fileAntiPattern, const QString& dirAntiPattern, bool bFollowDirLinks, bool bUseCvsIgnore) { FileAccessJobHandler jh(this); return jh.listDir(pDirList, bRecursive, bFindHidden, filePattern, fileAntiPattern, dirAntiPattern, bFollowDirLinks, bUseCvsIgnore); } QString FileAccess::tempFileName() { QTemporaryFile tmpFile; tmpFile.open(); //tmpFile.setAutoDelete( true ); // We only want the name. Delete the precreated file immediately. QString name = tmpFile.fileName() + ".2"; tmpFile.close(); return name; } bool FileAccess::removeTempFile(const QString& name) // static { if(name.endsWith(".2")) FileAccess(name.left(name.length() - 2)).removeFile(); return FileAccess(name).removeFile(); } bool FileAccess::makeDir(const QString& dirName) { FileAccessJobHandler fh(nullptr); return fh.mkDir(dirName); } bool FileAccess::removeDir(const QString& dirName) { FileAccessJobHandler fh(nullptr); return fh.rmDir(dirName); } #if defined(Q_OS_WIN) bool FileAccess::symLink(const QString& /*linkTarget*/, const QString& /*linkLocation*/) { return false; } #else bool FileAccess::symLink(const QString& linkTarget, const QString& linkLocation) { return 0 == ::symlink(linkTarget.toLocal8Bit().constData(), linkLocation.toLocal8Bit().constData()); //FileAccessJobHandler fh(0); //return fh.symLink( linkTarget, linkLocation ); } #endif bool FileAccess::exists(const QString& name) { FileAccess fa(name); return fa.exists(); } // If the size couldn't be determined by stat() then the file is copied to a local temp file. qint64 FileAccess::sizeForReading() { if(!isLocal() && m_size == 0) { // Size couldn't be determined. Copy the file to a local temp place. QString localCopy = tempFileName(); bool bSuccess = copyFile(localCopy); if(bSuccess) { QFileInfo fi(localCopy); m_size = fi.size(); d()->m_localCopy = localCopy; return m_size; } else { return 0; } } else return size(); } QString FileAccess::getStatusText() { return d() == nullptr ? QString() : d()->m_statusText; } void FileAccess::setStatusText(const QString& s) { if(!s.isEmpty() || d() != nullptr) { createData(); d()->m_statusText = s; } } QString FileAccess::cleanPath(const QString& path) // static { QUrl url = QUrl::fromUserInput(path, QString(""), QUrl::AssumeLocalFile); if(url.isLocalFile() || !url.isValid()) { return QDir().cleanPath(path); } else { return path; } } bool FileAccess::createBackup(const QString& bakExtension) { if(exists()) { createData(); setFile(absoluteFilePath()); // make sure Data is initialized // First rename the existing file to the bak-file. If a bak-file file exists, delete that. QString bakName = absoluteFilePath() + bakExtension; FileAccess bakFile(bakName, true /*bWantToWrite*/); if(bakFile.exists()) { bool bSuccess = bakFile.removeFile(); if(!bSuccess) { setStatusText(i18n("While trying to make a backup, deleting an older backup failed.\nFilename: %1", bakName)); return false; } } bool bSuccess = rename(bakName); if(!bSuccess) { setStatusText(i18n("While trying to make a backup, renaming failed.\nFilenames: %1 -> %2", absoluteFilePath(), bakName)); return false; } } return true; } FileAccessJobHandler::FileAccessJobHandler(FileAccess* pFileAccess) { m_pFileAccess = pFileAccess; m_bSuccess = false; } bool FileAccessJobHandler::stat(int detail, bool bWantToWrite) { m_bSuccess = false; m_pFileAccess->setStatusText(QString()); KIO::StatJob* pStatJob = KIO::stat(m_pFileAccess->url(), bWantToWrite ? KIO::StatJob::DestinationSide : KIO::StatJob::SourceSide, detail, KIO::HideProgressInfo); connect(pStatJob, &KIO::StatJob::result, this, &FileAccessJobHandler::slotStatResult); ProgressProxy::enterEventLoop(pStatJob, i18n("Getting file status: %1", m_pFileAccess->prettyAbsPath())); return m_bSuccess; } void FileAccessJobHandler::slotStatResult(KJob* pJob) { if(pJob->error()) { //pJob->uiDelegate()->showErrorMessage(); m_pFileAccess->m_bExists = false; m_bSuccess = true; } else { m_bSuccess = true; m_pFileAccess->d()->m_bValidData = true; const KIO::UDSEntry e = static_cast(pJob)->statResult(); m_pFileAccess->setUdsEntry(e); } ProgressProxy::exitEventLoop(); } bool FileAccessJobHandler::get(void* pDestBuffer, long maxLength) { ProgressProxyExtender pp; // Implicitly used in slotPercent() if(maxLength > 0 && !pp.wasCancelled()) { KIO::TransferJob* pJob = KIO::get(m_pFileAccess->url(), KIO::NoReload); m_transferredBytes = 0; m_pTransferBuffer = (char*)pDestBuffer; m_maxLength = maxLength; m_bSuccess = false; m_pFileAccess->setStatusText(QString()); connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); connect(pJob, &KIO::TransferJob::data, this, &FileAccessJobHandler::slotGetData); connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long))); ProgressProxy::enterEventLoop(pJob, i18n("Reading file: %1", m_pFileAccess->prettyAbsPath())); return m_bSuccess; } else return true; } void FileAccessJobHandler::slotGetData(KJob* pJob, const QByteArray& newData) { if(pJob->error()) { pJob->uiDelegate()->showErrorMessage(); } else { qint64 length = min2(qint64(newData.size()), m_maxLength - m_transferredBytes); ::memcpy(m_pTransferBuffer + m_transferredBytes, newData.data(), newData.size()); m_transferredBytes += length; } } bool FileAccessJobHandler::put(const void* pSrcBuffer, long maxLength, bool bOverwrite, bool bResume, int permissions) { ProgressProxyExtender pp; // Implicitly used in slotPercent() if(maxLength > 0) { KIO::TransferJob* pJob = KIO::put(m_pFileAccess->url(), permissions, KIO::HideProgressInfo | (bOverwrite ? KIO::Overwrite : KIO::DefaultFlags) | (bResume ? KIO::Resume : KIO::DefaultFlags)); m_transferredBytes = 0; m_pTransferBuffer = (char*)pSrcBuffer; m_maxLength = maxLength; m_bSuccess = false; m_pFileAccess->setStatusText(QString()); connect(pJob, &KIO::TransferJob::result, this, &FileAccessJobHandler::slotPutJobResult); connect(pJob, &KIO::TransferJob::dataReq, this, &FileAccessJobHandler::slotPutData); connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long))); ProgressProxy::enterEventLoop(pJob, i18n("Writing file: %1", m_pFileAccess->prettyAbsPath())); return m_bSuccess; } else return true; } void FileAccessJobHandler::slotPutData(KIO::Job* pJob, QByteArray& data) { if(pJob->error()) { pJob->uiDelegate()->showErrorMessage(); } else { qint64 maxChunkSize = 100000; qint64 length = min2(maxChunkSize, m_maxLength - m_transferredBytes); data.resize(length); if(data.size() == length) { if(length > 0) { ::memcpy(data.data(), m_pTransferBuffer + m_transferredBytes, data.size()); m_transferredBytes += length; } } else { KMessageBox::error(ProgressProxy::getDialog(), i18n("Out of memory")); data.resize(0); m_bSuccess = false; } } } void FileAccessJobHandler::slotPutJobResult(KJob* pJob) { if(pJob->error()) { pJob->uiDelegate()->showErrorMessage(); } else { m_bSuccess = (m_transferredBytes == m_maxLength); // Special success condition } ProgressProxy::exitEventLoop(); // Close the dialog, return from exec() } bool FileAccessJobHandler::mkDir(const QString& dirName) { QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile); if(dirName.isEmpty()) return false; else if(dirURL.isLocalFile() || dirURL.isRelative()) { return QDir().mkdir(dirURL.path()); } else { m_bSuccess = false; KIO::SimpleJob* pJob = KIO::mkdir(dirURL); connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); ProgressProxy::enterEventLoop(pJob, i18n("Making directory: %1", dirName)); return m_bSuccess; } } bool FileAccessJobHandler::rmDir(const QString& dirName) { QUrl dirURL = QUrl::fromUserInput(dirName, QString(""), QUrl::AssumeLocalFile); if(dirName.isEmpty()) return false; else if(dirURL.isLocalFile()) { return QDir().rmdir(dirURL.path()); } else { m_bSuccess = false; KIO::SimpleJob* pJob = KIO::rmdir(dirURL); connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); ProgressProxy::enterEventLoop(pJob, i18n("Removing directory: %1", dirName)); return m_bSuccess; } } bool FileAccessJobHandler::removeFile(const QUrl& fileName) { if(fileName.isEmpty()) return false; else { m_bSuccess = false; KIO::SimpleJob* pJob = KIO::file_delete(fileName, KIO::HideProgressInfo); connect(pJob, &KIO::SimpleJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); ProgressProxy::enterEventLoop(pJob, i18n("Removing file: %1", fileName.toDisplayString())); return m_bSuccess; } } bool FileAccessJobHandler::symLink(const QUrl& linkTarget, const QUrl& linkLocation) { if(linkTarget.isEmpty() || linkLocation.isEmpty()) return false; else { m_bSuccess = false; KIO::CopyJob* pJob = KIO::link(linkTarget, linkLocation, KIO::HideProgressInfo); connect(pJob, &KIO::CopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); ProgressProxy::enterEventLoop(pJob, i18n("Creating symbolic link: %1 -> %2", linkLocation.toDisplayString(), linkTarget.toDisplayString())); return m_bSuccess; } } bool FileAccessJobHandler::rename(const QString& dest) { if(dest.isEmpty()) return false; QUrl kurl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile); if(kurl.isRelative()) kurl = QUrl::fromUserInput(QDir().absoluteFilePath(dest), QString(""), QUrl::AssumeLocalFile); // assuming that invalid means relative if(m_pFileAccess->isLocal() && kurl.isLocalFile()) { return QDir().rename(m_pFileAccess->absoluteFilePath(), kurl.path()); } else { ProgressProxyExtender pp; int permissions = -1; m_bSuccess = false; KIO::FileCopyJob* pJob = KIO::file_move(m_pFileAccess->url(), kurl, permissions, KIO::HideProgressInfo); connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long))); ProgressProxy::enterEventLoop(pJob, i18n("Renaming file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest)); return m_bSuccess; } } void FileAccessJobHandler::slotSimpleJobResult(KJob* pJob) { if(pJob->error()) { pJob->uiDelegate()->showErrorMessage(); } else { m_bSuccess = true; } ProgressProxy::exitEventLoop(); // Close the dialog, return from exec() } // Copy local or remote files. bool FileAccessJobHandler::copyFile(const QString& dest) { ProgressProxyExtender pp; QUrl destUrl = QUrl::fromUserInput(dest, QString(""), QUrl::AssumeLocalFile); m_pFileAccess->setStatusText(QString()); if(!m_pFileAccess->isLocal() || !destUrl.isLocalFile()) // if either url is nonlocal { int permissions = (m_pFileAccess->isExecutable() ? 0111 : 0) + (m_pFileAccess->isWritable() ? 0222 : 0) + (m_pFileAccess->isReadable() ? 0444 : 0); m_bSuccess = false; KIO::FileCopyJob* pJob = KIO::file_copy(m_pFileAccess->url(), destUrl, permissions, KIO::HideProgressInfo); connect(pJob, &KIO::FileCopyJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); connect(pJob, SIGNAL(percent(KJob*, unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long))); ProgressProxy::enterEventLoop(pJob, i18n("Copying file: %1 -> %2", m_pFileAccess->prettyAbsPath(), dest)); return m_bSuccess; // Note that the KIO-slave preserves the original date, if this is supported. } // Both files are local: QString srcName = m_pFileAccess->absoluteFilePath(); QString destName = dest; QFile srcFile(srcName); QFile destFile(destName); bool bReadSuccess = srcFile.open(QIODevice::ReadOnly); if(bReadSuccess == false) { m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for reading failed. Filename: %1", srcName)); return false; } bool bWriteSuccess = destFile.open(QIODevice::WriteOnly); if(bWriteSuccess == false) { m_pFileAccess->setStatusText(i18n("Error during file copy operation: Opening file for writing failed. Filename: %1", destName)); return false; } std::vector buffer(100000); qint64 bufSize = buffer.size(); qint64 srcSize = srcFile.size(); while(srcSize > 0 && !pp.wasCancelled()) { qint64 readSize = srcFile.read(&buffer[0], min2(srcSize, bufSize)); if(readSize == -1 || readSize == 0) { m_pFileAccess->setStatusText(i18n("Error during file copy operation: Reading failed. Filename: %1", srcName)); return false; } srcSize -= readSize; while(readSize > 0) { qint64 writeSize = destFile.write(&buffer[0], readSize); if(writeSize == -1 || writeSize == 0) { m_pFileAccess->setStatusText(i18n("Error during file copy operation: Writing failed. Filename: %1", destName)); return false; } readSize -= writeSize; } destFile.flush(); pp.setCurrent((double)(srcFile.size() - srcSize) / srcFile.size(), false); } srcFile.close(); destFile.close(); // Update the times of the destFile #ifdef Q_OS_WIN struct _stat srcFileStatus; int statResult = ::_stat(srcName.toLocal8Bit().constData(), &srcFileStatus); if(statResult == 0) { _utimbuf destTimes; destTimes.actime = srcFileStatus.st_atime; /* time of last access */ destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */ _utime(destName.toLocal8Bit().constData(), &destTimes); _chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode); } #else struct stat srcFileStatus; int statResult = ::stat(srcName.toLocal8Bit().constData(), &srcFileStatus); if(statResult == 0) { utimbuf destTimes; destTimes.actime = srcFileStatus.st_atime; /* time of last access */ destTimes.modtime = srcFileStatus.st_mtime; /* time of last modification */ utime(destName.toLocal8Bit().constData(), &destTimes); chmod(destName.toLocal8Bit().constData(), srcFileStatus.st_mode); } #endif return true; } bool wildcardMultiMatch(const QString& wildcard, const QString& testString, bool bCaseSensitive) { static QHash s_patternMap; QStringList sl = wildcard.split(";"); for(QStringList::Iterator it = sl.begin(); it != sl.end(); ++it) { QHash::iterator patIt = s_patternMap.find(*it); if(patIt == s_patternMap.end()) { QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard); patIt = s_patternMap.insert(*it, pattern); } if(patIt.value().exactMatch(testString)) return true; } return false; } // class CvsIgnoreList from Cervisia cvsdir.cpp // Copyright (C) 1999-2002 Bernd Gehrmann // with elements from class StringMatcher // Copyright (c) 2003 Andre Woebbeking // Modifications for KDiff3 by Joachim Eibl class CvsIgnoreList { public: CvsIgnoreList() {} void init(FileAccess& dir, bool bUseLocalCvsIgnore); bool matches(const QString& fileName, bool bCaseSensitive) const; private: void addEntriesFromString(const QString& str); void addEntriesFromFile(const QString& name); void addEntry(const QString& entry); QStringList m_exactPatterns; QStringList m_startPatterns; QStringList m_endPatterns; QStringList m_generalPatterns; }; void CvsIgnoreList::init(FileAccess& dir, bool bUseLocalCvsIgnore) { static const char* ignorestr = ". .. core RCSLOG tags TAGS RCS SCCS .make.state " ".nse_depinfo #* .#* cvslog.* ,* CVS CVS.adm .del-* *.a *.olb *.o *.obj " "*.so *.Z *~ *.old *.elc *.ln *.bak *.BAK *.orig *.rej *.exe _$* *$"; addEntriesFromString(QString::fromLatin1(ignorestr)); addEntriesFromFile(QDir::homePath() + "/.cvsignore"); addEntriesFromString(QString::fromLocal8Bit(::getenv("CVSIGNORE"))); if(bUseLocalCvsIgnore) { FileAccess file(dir); file.addPath(".cvsignore"); int size = file.exists() ? file.sizeForReading() : 0; if(size > 0) { char* buf = new char[size]; if(buf != nullptr) { file.readFile(buf, size); int pos1 = 0; for(int pos = 0; pos <= size; ++pos) { if(pos == size || buf[pos] == ' ' || buf[pos] == '\t' || buf[pos] == '\n' || buf[pos] == '\r') { if(pos > pos1) { addEntry(QString::fromLatin1(&buf[pos1], pos - pos1)); } ++pos1; } } delete[] buf; } } } } void CvsIgnoreList::addEntriesFromString(const QString& str) { int posLast(0); int pos; while((pos = str.indexOf(' ', posLast)) >= 0) { if(pos > posLast) addEntry(str.mid(posLast, pos - posLast)); posLast = pos + 1; } if(posLast < static_cast(str.length())) addEntry(str.mid(posLast)); } void CvsIgnoreList::addEntriesFromFile(const QString& name) { QFile file(name); if(file.open(QIODevice::ReadOnly)) { QTextStream stream(&file); while(!stream.atEnd()) { addEntriesFromString(stream.readLine()); } } } void CvsIgnoreList::addEntry(const QString& pattern) { if(pattern != QString("!")) { if(pattern.isEmpty()) return; // The general match is general but slow. // Special tests for '*' and '?' at the beginning or end of a pattern // allow fast checks. // Count number of '*' and '?' unsigned int nofMetaCharacters = 0; const QChar* pos; pos = pattern.unicode(); const QChar* posEnd; posEnd = pos + pattern.length(); while(pos < posEnd) { if(*pos == QChar('*') || *pos == QChar('?')) ++nofMetaCharacters; ++pos; } if(nofMetaCharacters == 0) { m_exactPatterns.append(pattern); } else if(nofMetaCharacters == 1) { if(pattern.at(0) == QChar('*')) { m_endPatterns.append(pattern.right(pattern.length() - 1)); } else if(pattern.at(pattern.length() - 1) == QChar('*')) { m_startPatterns.append(pattern.left(pattern.length() - 1)); } else { m_generalPatterns.append(pattern.toLocal8Bit()); } } else { m_generalPatterns.append(pattern.toLocal8Bit()); } } else { m_exactPatterns.clear(); m_startPatterns.clear(); m_endPatterns.clear(); m_generalPatterns.clear(); } } bool CvsIgnoreList::matches(const QString& text, bool bCaseSensitive) const { if(m_exactPatterns.indexOf(text) >= 0) { return true; } QStringList::ConstIterator it; QStringList::ConstIterator itEnd; for(it = m_startPatterns.begin(), itEnd = m_startPatterns.end(); it != itEnd; ++it) { if(text.startsWith(*it)) { return true; } } for(it = m_endPatterns.begin(), itEnd = m_endPatterns.end(); it != itEnd; ++it) { if(text.mid(text.length() - (*it).length()) == *it) //(text.endsWith(*it)) { return true; } } /* for (QValueList::const_iterator it(m_generalPatterns.begin()), itEnd(m_generalPatterns.end()); it != itEnd; ++it) { if (::fnmatch(*it, text.local8Bit(), FNM_PATHNAME) == 0) { return true; } } */ for(it = m_generalPatterns.begin(); it != m_generalPatterns.end(); ++it) { QRegExp pattern(*it, bCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard); if(pattern.exactMatch(text)) return true; } return false; } static bool cvsIgnoreExists(t_DirectoryList* pDirList) { t_DirectoryList::iterator i; for(i = pDirList->begin(); i != pDirList->end(); ++i) { if(i->fileName() == ".cvsignore") return true; } return false; } bool FileAccessJobHandler::listDir(t_DirectoryList* pDirList, bool bRecursive, bool bFindHidden, const QString& filePattern, const QString& fileAntiPattern, const QString& dirAntiPattern, bool bFollowDirLinks, bool bUseCvsIgnore) { ProgressProxyExtender pp; m_pDirList = pDirList; m_pDirList->clear(); m_bFindHidden = bFindHidden; m_bRecursive = bRecursive; m_bFollowDirLinks = bFollowDirLinks; // Only relevant if bRecursive==true. m_fileAntiPattern = fileAntiPattern; m_filePattern = filePattern; m_dirAntiPattern = dirAntiPattern; if(pp.wasCancelled()) return true; // Cancelled is not an error. pp.setInformation(i18n("Reading directory: %1", m_pFileAccess->absoluteFilePath()), 0, false); if(m_pFileAccess->isLocal()) { QString currentPath = QDir::currentPath(); m_bSuccess = QDir::setCurrent(m_pFileAccess->absoluteFilePath()); if(m_bSuccess) { #ifndef Q_OS_WIN m_bSuccess = true; QDir dir("."); dir.setSorting(QDir::Name | QDir::DirsFirst); dir.setFilter(QDir::Files | QDir::Dirs | /* from KDE3 QDir::TypeMaskDirs | */ QDir::Hidden | QDir::System); QFileInfoList fiList = dir.entryInfoList(); if(fiList.isEmpty()) { // No Permission to read directory or other error. m_bSuccess = false; } else { foreach(const QFileInfo& fi, fiList) // for each file... { if(fi.fileName() == "." || fi.fileName() == "..") continue; FileAccess fa; fa.setFile(fi, m_pFileAccess); pDirList->push_back(fa); } } #else QString pattern = "*.*"; WIN32_FIND_DATA findData; Qt::HANDLE searchHandle = FindFirstFileW((const wchar_t*)pattern.utf16(), &findData); if(searchHandle != INVALID_HANDLE_VALUE) { QString absPath = m_pFileAccess->absoluteFilePath(); QString relPath = m_pFileAccess->filePath(); bool bFirst = true; while(!pp.wasCancelled()) { if(!bFirst) { if(!FindNextFileW(searchHandle, &findData)) break; } bFirst = false; FileAccess fa; fa.m_filePath = QString::fromUtf16((const ushort*)findData.cFileName); if(fa.m_filePath != "." && fa.m_filePath != "..") { fa.m_size = (qint64(findData.nFileSizeHigh) << 32) + findData.nFileSizeLow; FILETIME ft; SYSTEMTIME t; FileTimeToLocalFileTime(&findData.ftLastWriteTime, &ft); FileTimeToSystemTime(&ft, &t); fa.m_modificationTime = QDateTime(QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond)); //FileTimeToLocalFileTime( &findData.ftLastAccessTime, &ft ); FileTimeToSystemTime(&ft,&t); //fa.m_accessTime = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) ); //FileTimeToLocalFileTime( &findData.ftCreationTime, &ft ); FileTimeToSystemTime(&ft,&t); //fa.m_creationTime = QDateTime( QDate(t.wYear, t.wMonth, t.wDay), QTime(t.wHour, t.wMinute, t.wSecond) ); int a = findData.dwFileAttributes; fa.m_bWritable = (a & FILE_ATTRIBUTE_READONLY) == 0; fa.m_bDir = (a & FILE_ATTRIBUTE_DIRECTORY) != 0; fa.m_bFile = !fa.m_bDir; fa.m_bHidden = (a & FILE_ATTRIBUTE_HIDDEN) != 0; //fa.m_bExecutable = false; // Useless on windows fa.m_bExists = true; //fa.m_bReadable = true; //fa.m_bLocal = true; //fa.m_bValidData = true; fa.m_bSymLink = false; //fa.m_fileType = 0; //fa.m_filePath = fa.m_name; //fa.m_absoluteFilePath = absPath + "/" + fa.m_name; //fa.m_url.setPath( fa.m_absoluteFilePath ); if(fa.d()) fa.m_pData->m_pParent = m_pFileAccess; else fa.m_pParent = m_pFileAccess; pDirList->push_back(fa); } } FindClose(searchHandle); } else { QDir::setCurrent(currentPath); // restore current path return false; } #endif } QDir::setCurrent(currentPath); // restore current path } else { KIO::ListJob* pListJob = nullptr; pListJob = KIO::listDir(m_pFileAccess->url(), KIO::HideProgressInfo, true /*bFindHidden*/); m_bSuccess = false; if(pListJob != nullptr) { connect(pListJob, &KIO::ListJob::entries, this, &FileAccessJobHandler::slotListDirProcessNewEntries); connect(pListJob, &KIO::ListJob::result, this, &FileAccessJobHandler::slotSimpleJobResult); connect(pListJob, &KIO::ListJob::infoMessage, &pp, &ProgressProxyExtender::slotListDirInfoMessage); // This line makes the transfer via fish unreliable.:-( //connect( pListJob, SIGNAL(percent(KJob*,unsigned long)), &pp, SLOT(slotPercent(KJob*, unsigned long))); ProgressProxy::enterEventLoop(pListJob, i18n("Listing directory: %1", m_pFileAccess->prettyAbsPath())); } } CvsIgnoreList cvsIgnoreList; if(bUseCvsIgnore) { cvsIgnoreList.init(*m_pFileAccess, cvsIgnoreExists(pDirList)); } #if defined(Q_OS_WIN) bool bCaseSensitive = false; #else bool bCaseSensitive = true; #endif // Now remove all entries that should be ignored: t_DirectoryList::iterator i; for(i = pDirList->begin(); i != pDirList->end();) { t_DirectoryList::iterator i2 = i; ++i2; QString fn = i->fileName(); if((!bFindHidden && i->isHidden()) || (i->isFile() && (!wildcardMultiMatch(filePattern, fn, bCaseSensitive) || wildcardMultiMatch(fileAntiPattern, fn, bCaseSensitive))) || (i->isDir() && wildcardMultiMatch(dirAntiPattern, fn, bCaseSensitive)) || cvsIgnoreList.matches(fn, bCaseSensitive)) { // Remove it pDirList->erase(i); i = i2; } else { ++i; } } if(bRecursive) { t_DirectoryList subDirsList; t_DirectoryList::iterator i; for(i = m_pDirList->begin(); i != m_pDirList->end(); ++i) { if(i->isDir() && (!i->isSymLink() || m_bFollowDirLinks)) { t_DirectoryList dirList; i->listDir(&dirList, bRecursive, bFindHidden, filePattern, fileAntiPattern, dirAntiPattern, bFollowDirLinks, bUseCvsIgnore); t_DirectoryList::iterator j; for(j = dirList.begin(); j != dirList.end(); ++j) { if(j->parent() == nullptr) j->m_filePath = i->fileName() + "/" + j->m_filePath; } // append data onto the main list subDirsList.splice(subDirsList.end(), dirList); } } m_pDirList->splice(m_pDirList->end(), subDirsList); } return m_bSuccess; } void FileAccessJobHandler::slotListDirProcessNewEntries(KIO::Job*, const KIO::UDSEntryList& l) { //This function is called for non-local urls. Don't use QUrl::fromLocalFile here as it does not handle these. QUrl parentUrl = QUrl::fromUserInput(m_pFileAccess->absoluteFilePath(), QString(""), QUrl::AssumeLocalFile); KIO::UDSEntryList::ConstIterator i; for(i = l.begin(); i != l.end(); ++i) { const KIO::UDSEntry& e = *i; FileAccess fa; fa.createData(); fa.m_pData->m_pParent = m_pFileAccess; fa.setUdsEntry(e); if(fa.fileName() != "." && fa.fileName() != "..") { fa.d()->m_url = parentUrl; QUrl url = fa.d()->m_url.adjusted(QUrl::StripTrailingSlash); fa.d()->m_url.setPath(url.path() + "/" + fa.fileName()); //fa.d()->m_absoluteFilePath = fa.url().url(); m_pDirList->push_back(fa); } } } void ProgressProxyExtender::slotListDirInfoMessage(KJob*, const QString& msg) { setInformation(msg, 0); } void ProgressProxyExtender::slotPercent(KJob*, unsigned long percent) { setCurrent(percent); } //#include "fileaccess.moc" diff --git a/src/gnudiff_system.h b/src/gnudiff_system.h index 4b81d70..1791579 100644 --- a/src/gnudiff_system.h +++ b/src/gnudiff_system.h @@ -1,121 +1,120 @@ /* System dependent declarations. Modified for KDiff3 by Joachim Eibl 2003. The original file was part of GNU DIFF. Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1998, 2001, 2002 Free Software Foundation, Inc. GNU DIFF is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU DIFF is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef GNUDIFF_SYSTEM_H #define GNUDIFF_SYSTEM_H - - - +//contains some of the defines found here prevent duplicate define warnings +#include /* Don't bother to support K&R C compilers any more; it's not worth the trouble. These macros prevent some library modules from being compiled in K&R C mode. */ #define PARAMS(Args) Args #define PROTOTYPES 1 /* Verify a requirement at compile-time (unlike assert, which is runtime). */ #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; } /* Determine whether an integer type is signed, and its bounds. This code assumes two's (or one's!) complement with no holes. */ /* The extra casts work around common compiler bugs, e.g. Cray C 5.0.3.0 when t == time_t. */ #ifndef TYPE_SIGNED # define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) #endif #ifndef TYPE_MINIMUM # define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \ ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) \ : (t) 0)) #endif #ifndef TYPE_MAXIMUM # define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t))) #endif #include #include # include #ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 #endif #if !EXIT_FAILURE # undef EXIT_FAILURE /* Sony NEWS-OS 4.0C defines EXIT_FAILURE to 0. */ # define EXIT_FAILURE 1 #endif #define EXIT_TROUBLE 2 #include #ifndef SSIZE_MAX # define SSIZE_MAX TYPE_MAXIMUM (ssize_t) #endif #ifndef PTRDIFF_MAX # define PTRDIFF_MAX TYPE_MAXIMUM (ptrdiff_t) #endif #ifndef SIZE_MAX # define SIZE_MAX TYPE_MAXIMUM (size_t) #endif #ifndef UINTMAX_MAX # define UINTMAX_MAX TYPE_MAXIMUM (uintmax_t) #endif #include #include #include /* CTYPE_DOMAIN (C) is nonzero if the unsigned char C can safely be given as an argument to macros like `isspace'. */ # define CTYPE_DOMAIN(c) 1 #define ISPRINT(c) (CTYPE_DOMAIN (c) && isprint (c)) #define ISSPACE(c) (CTYPE_DOMAIN (c) && isspace (c)) # define TOLOWER(c) tolower (c) /* ISDIGIT differs from isdigit, as follows: - Its arg may be any int or unsigned int; it need not be an unsigned char. - It's guaranteed to evaluate its argument exactly once. - It's typically faster. POSIX 1003.1-2001 says that only '0' through '9' are digits. Prefer ISDIGIT to isdigit unless it's important to use the locale's definition of `digit' even when the host does not conform to POSIX. */ #define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9) #undef MIN #undef MAX #define MIN(a, b) ((a) <= (b) ? (a) : (b)) #define MAX(a, b) ((a) >= (b) ? (a) : (b)) /* The integer type of a line number. Since files are read into main memory, ptrdiff_t should be wide enough. */ typedef ptrdiff_t lin; #define LIN_MAX PTRDIFF_MAX verify (lin_is_signed, TYPE_SIGNED (lin)); verify (lin_is_wide_enough, sizeof (ptrdiff_t) <= sizeof (lin)); //verify (lin_is_printable_as_long, sizeof (lin) <= sizeof (long)); #endif