int SimpleDeadlockDetector::init(const BoardState& s) {
std::vector<int> targets;
int index = 0;
for (auto i = s.begin(); i != s.end(); ++i, ++index) {
if (!isTarget(*i) && !isPackageOnTarget(*i)) {
continue;
}
targets.push_back(index);
}
Log::debug(LOG_GAMEIMPL, "Found %i targets", (int)targets.size());
BoardState copy(s);
index = 0;
for (auto i = s.begin(); i != s.end(); ++i, ++index) {
const char field = *i;
if (isPackage(field)) {
copy.clearFieldForIndex(index);
copy.setFieldForIndex(index, Sokoban::GROUND);
Log::debug(LOG_GAMEIMPL, "replaced package with ground at %i", index);
} else if (isPackageOnTarget(field)) {
copy.clearFieldForIndex(index);
copy.setFieldForIndex(index, Sokoban::TARGET);
Log::debug(LOG_GAMEIMPL, "replaced packageontarget with target at %i", index);
}
}
#ifdef DEBUG
Log::debug(LOG_GAMEIMPL, "board state:\n%s", copy.toString().c_str());
#endif
for (int targetIndex : targets) {
moveBackwards(copy, targetIndex);
}
index = 0;
for (auto i = copy.begin(); i != copy.end(); ++i, ++index) {
const char field = *i;
if (!isGround(field) && !isPackage(field)) {
continue;
}
if (_visited.find(index) != _visited.end()) {
continue;
}
#ifdef DEBUG
int col;
int row;
s.getColRowFromIndex(index, col, row);
Log::debug(LOG_GAMEIMPL, "Simple deadlock detected at %i:%i", col, row);
#endif
_deadlocks.insert(index);
}
Log::info(LOG_GAMEIMPL, "Found %i simple deadlocks", (int)_deadlocks.size());
Log::debug(LOG_GAMEIMPL, "Visited %i fields", (int)_visited.size());
_visited.clear();
return (int)_deadlocks.size();
}
bool SimpleDeadlockDetector::hasDeadlock(uint32_t millisStart, uint32_t millisTimeout, const BoardState& s) const {
int index = 0;
for (auto i = s.begin(); i != s.end(); ++i, ++index) {
TIMEOUTREACHED(millisStart + millisTimeout)
if (!isPackage(*i)) {
continue;
}
if (_deadlocks.find(index) != _deadlocks.end()) {
return true;
}
}
return false;
}
void DownloadsWidget::scanDownloadFolders(bool scanDownloads, bool scanImports)
{
QMutexLocker locker(&m_mutex);
QStringList dirs;
if (!m_watcher->directories().isEmpty())
m_watcher->removePaths(m_watcher->directories());
QMap<QString, Package> packages;
QMap<QString, Import> imports;
foreach (SettingsDir settingsDir, Settings::instance()->downloadDirectories()) {
QString dir = settingsDir.path;
dirs << dir;
QDirIterator it(dir, QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files, QDirIterator::Subdirectories | QDirIterator::FollowSymlinks);
while (it.hasNext()) {
it.next();
if (it.fileInfo().isDir())
dirs << it.filePath();
if (isPackage(it.fileInfo())) {
QString base = baseName(it.fileInfo());
if (packages.contains(base)) {
packages[base].files.append(it.filePath());
packages[base].size += it.fileInfo().size();
} else {
Package p;
p.baseName = base;
p.size = it.fileInfo().size();
p.files << it.filePath();
packages.insert(base, p);
}
} else if (isImportable(it.fileInfo()) || isSubtitle(it.fileInfo())) {
QString base = it.fileInfo().completeBaseName();
if (imports.contains(base)) {
if (isSubtitle(it.fileInfo()))
imports[base].extraFiles.append(it.filePath());
else
imports[base].files.append(it.filePath());
imports[base].size += it.fileInfo().size();
} else {
Import i;
i.baseName = base;
if (isSubtitle(it.fileInfo()))
i.extraFiles << it.filePath();
else
i.files << it.filePath();
i.size = it.fileInfo().size();
imports.insert(base, i);
}
}
}
}
//static
bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what)
{
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::BundleType) {
if (!data.hasFlags(QFileSystemMetaData::DirectoryType))
what |= QFileSystemMetaData::DirectoryType;
}
if (what & QFileSystemMetaData::HiddenAttribute) {
// Mac OS >= 10.5: st_flags & UF_HIDDEN
what |= QFileSystemMetaData::PosixStatFlags;
}
#endif // defined(Q_OS_MACX)
if (what & QFileSystemMetaData::PosixStatFlags)
what |= QFileSystemMetaData::PosixStatFlags;
if (what & QFileSystemMetaData::ExistsAttribute) {
// FIXME: Would other queries being performed provide this bit?
what |= QFileSystemMetaData::PosixStatFlags;
}
data.entryFlags &= ~what;
const char * nativeFilePath;
int nativeFilePathLength;
{
const QByteArray &path = entry.nativeFilePath();
nativeFilePath = path.constData();
nativeFilePathLength = path.size();
Q_UNUSED(nativeFilePathLength);
}
bool entryExists = true; // innocent until proven otherwise
QT_STATBUF statBuffer;
bool statBufferValid = false;
if (what & QFileSystemMetaData::LinkType) {
if (QT_LSTAT(nativeFilePath, &statBuffer) == 0) {
if (S_ISLNK(statBuffer.st_mode)) {
data.entryFlags |= QFileSystemMetaData::LinkType;
} else {
statBufferValid = true;
data.entryFlags &= ~QFileSystemMetaData::PosixStatFlags;
}
} else {
entryExists = false;
}
data.knownFlagsMask |= QFileSystemMetaData::LinkType;
}
if (statBufferValid || (what & QFileSystemMetaData::PosixStatFlags)) {
if (entryExists && !statBufferValid)
statBufferValid = (QT_STAT(nativeFilePath, &statBuffer) == 0);
if (statBufferValid)
data.fillFromStatBuf(statBuffer);
else {
entryExists = false;
data.creationTime_ = 0;
data.modificationTime_ = 0;
data.accessTime_ = 0;
data.size_ = 0;
data.userId_ = (uint) -2;
data.groupId_ = (uint) -2;
}
// reset the mask
data.knownFlagsMask |= QFileSystemMetaData::PosixStatFlags
| QFileSystemMetaData::ExistsAttribute;
}
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::AliasType)
{
if (entryExists) {
FSRef fref;
if (FSPathMakeRef((const UInt8 *)nativeFilePath, &fref, NULL) == noErr) {
Boolean isAlias, isFolder;
if (FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr) {
if (isAlias)
data.entryFlags |= QFileSystemMetaData::AliasType;
}
}
}
data.knownFlagsMask |= QFileSystemMetaData::AliasType;
}
#endif
if (what & QFileSystemMetaData::UserPermissions) {
// calculate user permissions
if (entryExists) {
if (what & QFileSystemMetaData::UserReadPermission) {
if (QT_ACCESS(nativeFilePath, R_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserReadPermission;
}
if (what & QFileSystemMetaData::UserWritePermission) {
if (QT_ACCESS(nativeFilePath, W_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserWritePermission;
}
if (what & QFileSystemMetaData::UserExecutePermission) {
if (QT_ACCESS(nativeFilePath, X_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserExecutePermission;
}
}
data.knownFlagsMask |= (what & QFileSystemMetaData::UserPermissions);
}
if (what & QFileSystemMetaData::HiddenAttribute
&& !data.isHidden()) {
QString fileName = entry.fileName();
if ((fileName.size() > 0 && fileName.at(0) == QLatin1Char('.'))
|| (entryExists && _q_isMacHidden(nativeFilePath)))
data.entryFlags |= QFileSystemMetaData::HiddenAttribute;
data.knownFlagsMask |= QFileSystemMetaData::HiddenAttribute;
}
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::BundleType) {
if (entryExists && isPackage(data, entry))
data.entryFlags |= QFileSystemMetaData::BundleType;
data.knownFlagsMask |= QFileSystemMetaData::BundleType;
}
#endif
if (!entryExists) {
data.clearFlags(what);
return false;
}
return data.hasFlags(what);
}
Dsymbol *ScopeDsymbol::search(Loc loc, Identifier *ident, int flags)
{
//printf("%s->ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident->toChars(), flags);
//if (strcmp(ident->toChars(),"c") == 0) *(char*)0=0;
if (Package *pkg = isPackage())
{
if (!pkg->isModule() && pkg->mod)
{
// Prefer full package name.
Dsymbol *s = pkg->symtab ? pkg->symtab->lookup(ident) : NULL;
if (s)
return s;
//printf("[%s] through pkdmod: %s\n", loc.toChars(), pkg->toChars());
return pkg->mod->search(loc, ident, flags);
}
}
// Look in symbols declared in this module
Dsymbol *s = symtab ? symtab->lookup(ident) : NULL;
//printf("\ts = %p, imports = %p, %d\n", s, imports, imports ? imports->dim : 0);
if (s)
{
//printf("\ts = '%s.%s'\n",toChars(),s->toChars());
}
else if (imports)
{
OverloadSet *a = NULL;
// Look in imported modules
for (size_t i = 0; i < imports->dim; i++)
{ Dsymbol *ss = (*imports)[i];
Dsymbol *s2;
// If private import, don't search it
if (flags & 1 && prots[i] == PROTprivate)
continue;
//printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss->toChars(), prots[i], ss->isModule(), ss->isImport());
/* Don't find private members if ss is a module
*/
s2 = ss->search(loc, ident, ss->isModule() ? 1 : 0);
if (!s)
s = s2;
else if (s2 && s != s2)
{
if (s->toAlias() == s2->toAlias() ||
s->getType() == s2->getType() && s->getType())
{
/* After following aliases, we found the same
* symbol, so it's not an ambiguity. But if one
* alias is deprecated or less accessible, prefer
* the other.
*/
if (s->isDeprecated() ||
s2->prot() > s->prot() && s2->prot() != PROTnone)
s = s2;
}
else
{
/* Two imports of the same module should be regarded as
* the same.
*/
Import *i1 = s->isImport();
Import *i2 = s2->isImport();
if (!(i1 && i2 &&
(i1->mod == i2->mod ||
(!i1->parent->isImport() && !i2->parent->isImport() &&
i1->ident->equals(i2->ident))
)
)
)
{
/* Bugzilla 8668:
* Public selective import adds AliasDeclaration in module.
* To make an overload set, resolve aliases in here and
* get actual overload roots which accessible via s and s2.
*/
s = s->toAlias();
s2 = s2->toAlias();
/* If both s2 and s are overloadable (though we only
* need to check s once)
*/
if (s2->isOverloadable() && (a || s->isOverloadable()))
{ if (!a)
a = new OverloadSet(s->ident);
/* Don't add to a[] if s2 is alias of previous sym
*/
for (size_t j = 0; j < a->a.dim; j++)
{ Dsymbol *s3 = a->a[j];
if (s2->toAlias() == s3->toAlias())
{
if (s3->isDeprecated() ||
s2->prot() > s3->prot() && s2->prot() != PROTnone)
a->a[j] = s2;
goto Lcontinue;
}
}
a->push(s2);
Lcontinue:
continue;
}
if (flags & 4) // if return NULL on ambiguity
return NULL;
if (!(flags & 2))
ScopeDsymbol::multiplyDefined(loc, s, s2);
break;
}
}
}
}
/* Build special symbol if we had multiple finds
*/
if (a)
{ assert(s);
a->push(s);
s = a;
}
if (s)
{
if (!(flags & 2))
{ Declaration *d = s->isDeclaration();
if (d && d->protection == PROTprivate &&
!d->parent->isTemplateMixin())
error(loc, "%s is private", d->toPrettyChars());
AggregateDeclaration *ad = s->isAggregateDeclaration();
if (ad && ad->protection == PROTprivate &&
!ad->parent->isTemplateMixin())
error(loc, "%s is private", ad->toPrettyChars());
EnumDeclaration *ed = s->isEnumDeclaration();
if (ed && ed->protection == PROTprivate &&
!ed->parent->isTemplateMixin())
error(loc, "%s is private", ed->toPrettyChars());
TemplateDeclaration *td = s->isTemplateDeclaration();
if (td && td->protection == PROTprivate &&
!td->parent->isTemplateMixin())
error(loc, "%s is private", td->toPrettyChars());
}
}
}
return s;
}
