QString AndroidToolChain::makeCommand(const Environment &env) const { FileName makePath = AndroidConfigurations::currentConfig().makePath(); if (makePath.exists()) return makePath.toString(); const Utils::FileNameList extraDirectories = Utils::transform(AndroidConfigurations::currentConfig().makeExtraSearchDirectories(), [](const QString &s) { return Utils::FileName::fromString(s); }); if (HostOsInfo::isWindowsHost()) { makePath = env.searchInPath("ma-make.exe", extraDirectories); if (!makePath.isEmpty()) return makePath.toString(); makePath = env.searchInPath("mingw32-make", extraDirectories); return makePath.isEmpty() ? QLatin1String("mingw32-make") : makePath.toString(); } makePath = env.searchInPath("make", extraDirectories); return makePath.isEmpty() ? "make" : makePath.toString(); }
void QmakeKitInformation::setup(Kit *k) { QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k); if (!version) return; FileName spec = QmakeKitInformation::mkspec(k); if (spec.isEmpty()) spec = version->mkspec(); ToolChain *tc = ToolChainKitInformation::toolChain(k); if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec))) { ToolChain *possibleTc = 0; foreach (ToolChain *current, ToolChainManager::toolChains()) { if (version->qtAbis().contains(current->targetAbi())) { possibleTc = current; if (current->suggestedMkspecList().contains(spec)) break; } } ToolChainKitInformation::setToolChain(k, possibleTc); }
bool BuildableHelperLibrary::buildHelper(const BuildHelperArguments &arguments, QString *log, QString *errorMessage) { const QChar newline = QLatin1Char('\n'); // Setup process QProcess proc; proc.setEnvironment(arguments.environment.toStringList()); proc.setWorkingDirectory(arguments.directory); proc.setProcessChannelMode(QProcess::MergedChannels); log->append(QCoreApplication::translate("ProjectExplorer::BuildableHelperLibrary", "Building helper \"%1\" in %2\n").arg(arguments.helperName, arguments.directory)); log->append(newline); const FileName makeFullPath = arguments.environment.searchInPath(arguments.makeCommand); if (QFileInfo::exists(arguments.directory + QLatin1String("/Makefile"))) { if (makeFullPath.isEmpty()) { *errorMessage = QCoreApplication::translate("ProjectExplorer::DebuggingHelperLibrary", "%1 not found in PATH\n").arg(arguments.makeCommand); return false; } const QString cleanTarget = QLatin1String("distclean"); log->append(QCoreApplication::translate("ProjectExplorer::BuildableHelperLibrary", "Running %1 %2...\n") .arg(makeFullPath.toUserOutput(), cleanTarget)); if (!runBuildProcess(proc, makeFullPath, QStringList(cleanTarget), 30, true, log, errorMessage)) return false; } QStringList qmakeArgs; if (!arguments.targetMode.isEmpty()) qmakeArgs << arguments.targetMode; if (!arguments.mkspec.isEmpty()) qmakeArgs << QLatin1String("-spec") << arguments.mkspec.toUserOutput(); qmakeArgs << arguments.proFilename; qmakeArgs << arguments.qmakeArguments; log->append(newline); log->append(QCoreApplication::translate("ProjectExplorer::BuildableHelperLibrary", "Running %1 %2 ...\n").arg(arguments.qmakeCommand.toUserOutput(), qmakeArgs.join(QLatin1Char(' ')))); if (!runBuildProcess(proc, arguments.qmakeCommand, qmakeArgs, 30, false, log, errorMessage)) return false; log->append(newline); if (makeFullPath.isEmpty()) { *errorMessage = QCoreApplication::translate("ProjectExplorer::BuildableHelperLibrary", "%1 not found in PATH\n").arg(arguments.makeCommand); return false; } log->append(QCoreApplication::translate("ProjectExplorer::BuildableHelperLibrary", "Running %1 %2 ...\n") .arg(makeFullPath.toUserOutput(), arguments.makeArguments.join(QLatin1Char(' ')))); if (!runBuildProcess(proc, makeFullPath, arguments.makeArguments, 120, false, log, errorMessage)) return false; return true; }
static FileName filePathValue(const FileName &value, const QStringList &candidateFileNames) { if (!value.isEmpty()) return value; const QList<FileName> additionalSearchPaths = sshSettings->searchPathRetriever(); for (const QString &candidate : candidateFileNames) { const FileName filePath = Environment::systemEnvironment() .searchInPath(candidate, additionalSearchPaths); if (!filePath.isEmpty()) return filePath; } return FileName(); }
QString AndroidToolChain::makeCommand(const Environment &env) const { QStringList extraDirectories = AndroidConfigurations::currentConfig().makeExtraSearchDirectories(); if (HostOsInfo::isWindowsHost()) { FileName tmp = env.searchInPath(QLatin1String("ma-make.exe"), extraDirectories); if (!tmp.isEmpty()) return QString(); tmp = env.searchInPath(QLatin1String("mingw32-make"), extraDirectories); return tmp.isEmpty() ? QLatin1String("mingw32-make") : tmp.toString(); } QString make = QLatin1String("make"); FileName tmp = env.searchInPath(make, extraDirectories); return tmp.isEmpty() ? make : tmp.toString(); }
QVariant QtKitInformation::defaultValue(ProjectExplorer::Kit *k) const { Q_UNUSED(k); // find "Qt in PATH": QList<BaseQtVersion *> versionList = QtVersionManager::unsortedVersions(); BaseQtVersion *result = findOrDefault(versionList, equal(&BaseQtVersion::autodetectionSource, QString::fromLatin1("PATH"))); if (result) return result->uniqueId(); // Legacy: Check for system qmake path: Remove in 3.5 (or later): // This check is expensive as it will potentially run binaries (qmake --version)! const FileName qmakePath = BuildableHelperLibrary::findSystemQt(Utils::Environment::systemEnvironment()); if (!qmakePath.isEmpty()) { result = findOrDefault(versionList, equal(&BaseQtVersion::qmakeCommand, qmakePath)); if (result) return result->uniqueId(); } // Use *any* desktop Qt: result = findOrDefault(versionList, equal(&BaseQtVersion::type, QString::fromLatin1(QtSupport::Constants::DESKTOPQT))); return result ? result->uniqueId() : -1; }
void GoToolChainConfigWidget::handleCompilerCommandChange() { bool haveCompiler = false; Abi currentAbi = m_abiWidget->currentAbi(); bool customAbi = m_abiWidget->isCustomAbi(); FileName path = m_compilerCommand->fileName(); QList<Abi> abiList; if (!path.isEmpty()) { QFileInfo fi(path.toFileInfo()); haveCompiler = fi.isExecutable() && fi.isFile(); } if (haveCompiler) { Environment env = Environment::systemEnvironment(); GccToolChain::addCommandPathToEnvironment(path, env); abiList = GoToolChain::guessGoAbi(path, env.toStringList()); } m_abiWidget->setEnabled(haveCompiler); // Find a good ABI for the new compiler: Abi newAbi; if (customAbi) newAbi = currentAbi; else if (abiList.contains(currentAbi)) newAbi = currentAbi; m_abiWidget->setAbis(abiList, newAbi); emit dirty(); }
/// /// Returns all arguments /// That is: possbile subpath /// spec /// config arguemnts /// moreArguments /// user arguments QString QMakeStep::allArguments(bool shorted) { QmakeBuildConfiguration *bc = qmakeBuildConfiguration(); QStringList arguments; if (bc->subNodeBuild()) arguments << bc->subNodeBuild()->path().toUserOutput(); else if (shorted) arguments << project()->projectFilePath().fileName(); else arguments << project()->projectFilePath().toUserOutput(); arguments << QLatin1String("-r"); bool userProvidedMkspec = false; for (QtcProcess::ConstArgIterator ait(m_userArgs); ait.next(); ) { if (ait.value() == QLatin1String("-spec")) { if (ait.next()) { userProvidedMkspec = true; break; } } } FileName specArg = mkspec(); if (!userProvidedMkspec && !specArg.isEmpty()) arguments << QLatin1String("-spec") << specArg.toUserOutput(); // Find out what flags we pass on to qmake arguments << bc->configCommandLineArguments(); arguments << deducedArguments().toArguments(); QString args = QtcProcess::joinArgs(arguments); // User arguments QtcProcess::addArgs(&args, m_userArgs); return args; }
// Find Qt installation by running qmake static QString findQtInstallPath(const FileName &qmakePath) { if (qmakePath.isEmpty()) return QString(); QProcess proc; QStringList args; args.append(QLatin1String("-query")); args.append(QLatin1String("QT_INSTALL_HEADERS")); proc.start(qmakePath.toString(), args); if (!proc.waitForStarted()) { qWarning("%s: Cannot start '%s': %s", Q_FUNC_INFO, qPrintable(qmakePath.toString()), qPrintable(proc.errorString())); return QString(); } proc.closeWriteChannel(); if (!proc.waitForFinished()) { SynchronousProcess::stopProcess(proc); qWarning("%s: Timeout running '%s'.", Q_FUNC_INFO, qPrintable(qmakePath.toString())); return QString(); } if (proc.exitStatus() != QProcess::NormalExit) { qWarning("%s: '%s' crashed.", Q_FUNC_INFO, qPrintable(qmakePath.toString())); return QString(); } const QByteArray ba = proc.readAllStandardOutput().trimmed(); QDir dir(QString::fromLocal8Bit(ba)); if (dir.exists() && dir.cdUp()) return dir.absolutePath(); return QString(); }
FileName AndroidConfigurations::openJDKBinPath() const { FileName path = m_config.openJDKLocation; if (!path.isEmpty()) return path.appendPath(QLatin1String("bin")); return path; }
QList<AndroidToolChainFactory::AndroidToolChainInformation> AndroidToolChainFactory::toolchainPathsForNdk(const FileName &ndkPath) { QList<AndroidToolChainInformation> result; if (ndkPath.isEmpty()) return result; QRegExp versionRegExp(NDKGccVersionRegExp); FileName path = ndkPath; QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(), QStringList() << QLatin1String("*"), QDir::Dirs); while (it.hasNext()) { const QString &fileName = FileName::fromString(it.next()).fileName(); int idx = versionRegExp.indexIn(fileName); if (idx == -1) continue; for (const ToolChain::Language lang : { ToolChain::Language::Cxx, ToolChain::Language::C }) { AndroidToolChainInformation ati; ati.language = lang; ati.version = fileName.mid(idx + 1); QString platform = fileName.left(idx); ati.abi = AndroidConfig::abiForToolChainPrefix(platform); if (ati.abi.architecture() == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported continue; ati.compilerCommand = AndroidConfigurations::currentConfig().gccPath(ati.abi, lang, ati.version); result.append(ati); } } return result; }
QString BaseQtVersion::defaultDisplayName(const QString &versionString, const FileName &qmakePath, bool fromPath) { QString location; if (qmakePath.isEmpty()) { location = QCoreApplication::translate("QtVersion", "<unknown>"); } else { // Deduce a description from '/foo/qt-folder/[qtbase]/bin/qmake' -> '/foo/qt-folder'. // '/usr' indicates System Qt 4.X on Linux. QDir dir = qmakePath.toFileInfo().absoluteDir(); do { const QString dirName = dir.dirName(); if (dirName == QLatin1String("usr")) { // System-installed Qt. location = QCoreApplication::translate("QtVersion", "System"); break; } location = dirName; // Also skip default checkouts named 'qt'. Parent dir might have descriptive name. if (dirName.compare(QLatin1String("bin"), Qt::CaseInsensitive) && dirName.compare(QLatin1String("qtbase"), Qt::CaseInsensitive) && dirName.compare(QLatin1String("qt"), Qt::CaseInsensitive)) { break; } } while (dir.cdUp()); } return fromPath ? QCoreApplication::translate("QtVersion", "Qt %1 in PATH (%2)").arg(versionString, location) : QCoreApplication::translate("QtVersion", "Qt %1 (%2)").arg(versionString, location); }
void ProjectTree::updateExternalFileWarning() { Core::IDocument *document = qobject_cast<Core::IDocument *>(sender()); if (!document || document->filePath().isEmpty()) return; Core::InfoBar *infoBar = document->infoBar(); Core::Id externalFileId(EXTERNAL_FILE_WARNING); if (!document->isModified()) { infoBar->removeInfo(externalFileId); return; } if (!infoBar->canInfoBeAdded(externalFileId)) return; const FileName fileName = document->filePath(); const QList<Project *> projects = SessionManager::projects(); if (projects.isEmpty()) return; foreach (Project *project, projects) { FileName projectDir = project->projectDirectory(); if (projectDir.isEmpty()) continue; if (fileName.isChildOf(projectDir)) return; // External file. Test if it under the same VCS QString topLevel; if (Core::VcsManager::findVersionControlForDirectory(projectDir.toString(), &topLevel) && fileName.isChildOf(FileName::fromString(topLevel))) { return; } }
void QmakeKitInformation::setup(Kit *k) { QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k); if (!version) return; if (version->type() == "Boot2Qt.QtVersionType") // HACK: Ignore boot2Qt kits! return; FileName spec = QmakeKitInformation::mkspec(k); if (spec.isEmpty()) spec = version->mkspec(); ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx); if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec))) { ToolChain *possibleTc = nullptr; foreach (ToolChain *current, ToolChainManager::toolChains()) { if (current->language() == ToolChain::Language::Cxx && version->qtAbis().contains(current->targetAbi())) { possibleTc = current; if (current->suggestedMkspecList().contains(spec)) break; } } if (possibleTc) ToolChainKitInformation::setToolChain(k, possibleTc); }
MemoryMapTestFixture() { FileName testDir = getTestDataDirectory(); if (!testDir.isEmpty()) { fileName = testDir / "maxdnn-memory-map-test-file"; } length = 16385; }
FileName SshSettings::askpassFilePath() { FileName candidate; candidate = sshSettings->askpassFilePath; if (candidate.isEmpty()) candidate = FileName::fromString(Environment::systemEnvironment().value("SSH_ASKPASS")); return filePathValue(candidate, QStringList{"qtc-askpass", "ssh-askpass"}); }
static QList<Abi> guessGccAbi(const FileName &path, const QStringList &env) { if (path.isEmpty()) return QList<Abi>(); QStringList arguments(QLatin1String("-dumpmachine")); QString machine = QString::fromLocal8Bit(runGcc(path, arguments, env)).trimmed(); return guessGccAbi(machine); }
FileName BaseQtVersion::mkspecsPath() const { FileName result = FileName::fromUserInput(qmakeProperty("QT_HOST_DATA")); if (result.isEmpty()) result = FileName::fromUserInput(qmakeProperty("QMAKE_MKSPECS")); else result.appendPath(QLatin1String("mkspecs")); return result; }
void PokySDKKitInformation::addToEnvironment(const Kit *kit, Environment &env) const { FileName pokyEnvFile = environmentFile(kit); if (pokyEnvFile.isEmpty()) return; PokyRunner runner(pokyEnvFile.toString()); QProcessEnvironment pokyEnv = runner.processEnvironment(); foreach (QString key, pokyEnv.keys()) env.set(key, pokyEnv.value(key)); }
QList<HeaderPath> GccToolChain::gccHeaderPaths(const FileName &gcc, const QStringList &args, const QStringList &env, const FileName &sysrootPath) { QList<HeaderPath> systemHeaderPaths; QStringList arguments; if (!sysrootPath.isEmpty()) arguments.append(QString::fromLatin1("--sysroot=%1").arg(sysrootPath.toString())); foreach (const QString &a, args) { if (a.startsWith(QLatin1String("-stdlib="))) arguments << a; } arguments << QLatin1String("-xc++") << QLatin1String("-E") << QLatin1String("-v") << QLatin1String("-"); QByteArray line; QByteArray data = runGcc(gcc, arguments, env); QBuffer cpp(&data); cpp.open(QIODevice::ReadOnly); while (cpp.canReadLine()) { line = cpp.readLine(); if (line.startsWith("#include")) break; } if (!line.isEmpty() && line.startsWith("#include")) { HeaderPath::Kind kind = HeaderPath::UserHeaderPath; while (cpp.canReadLine()) { line = cpp.readLine(); if (line.startsWith("#include")) { kind = HeaderPath::GlobalHeaderPath; } else if (! line.isEmpty() && QChar(QLatin1Char(line.at(0))).isSpace()) { HeaderPath::Kind thisHeaderKind = kind; line = line.trimmed(); const int index = line.indexOf(" (framework directory)"); if (index != -1) { line.truncate(index); thisHeaderKind = HeaderPath::FrameworkHeaderPath; } systemHeaderPaths.append(HeaderPath(QFile::decodeName(line), thisHeaderKind)); } else if (line.startsWith("End of search list.")) { break; } else { qWarning("%s: Ignoring line: %s", __FUNCTION__, line.constData()); } } } return systemHeaderPaths; }
QList<Task> QmakeKitInformation::validate(const Kit *k) const { QList<Task> result; QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k); FileName mkspec = QmakeKitInformation::mkspec(k); if (!version && !mkspec.isEmpty()) result << Task(Task::Warning, tr("No Qt version set, so mkspec is ignored."), FileName(), -1, Constants::TASK_CATEGORY_BUILDSYSTEM); if (version && !version->hasMkspec(mkspec)) result << Task(Task::Error, tr("Mkspec not found for Qt version."), FileName(), -1, Constants::TASK_CATEGORY_BUILDSYSTEM); return result; }
FileName CMakeBuildConfiguration::shadowBuildDirectory(const FileName &projectFilePath, const Kit *k, const QString &bcName, BuildConfiguration::BuildType buildType) { if (projectFilePath.isEmpty()) return FileName(); const QString projectName = projectFilePath.parentDir().fileName(); ProjectMacroExpander expander(projectName, k, bcName, buildType); QDir projectDir = QDir(Project::projectDirectory(projectFilePath).toString()); QString buildPath = expander.expand(Core::DocumentManager::buildDirectory()); return FileName::fromUserInput(projectDir.absoluteFilePath(buildPath)); }
QList<ToolChain *> AndroidToolChainFactory::autodetectToolChainsForNdk(const FileName &ndkPath, const QList<ToolChain *> &alreadyKnown) { QList<ToolChain *> result; if (ndkPath.isEmpty()) return result; QRegExp versionRegExp(NDKGccVersionRegExp); FileName path = ndkPath; QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(), QStringList() << QLatin1String("*"), QDir::Dirs); QHash<Abi, QList<AndroidToolChain *>> newestToolChainForArch; while (it.hasNext()) { const QString &fileName = FileName::fromString(it.next()).fileName(); int idx = versionRegExp.indexIn(fileName); if (idx == -1) continue; QString version = fileName.mid(idx + 1); QString platform = fileName.left(idx); Abi abi = AndroidConfig::abiForToolChainPrefix(platform); if (abi.architecture() == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported continue; QList<AndroidToolChain *> toolChainBundle; for (ToolChain::Language lang : { ToolChain::Language::Cxx, ToolChain::Language::C }) { FileName compilerPath = AndroidConfigurations::currentConfig().gccPath(abi, lang, version); AndroidToolChain *tc = findToolChain(compilerPath, lang, alreadyKnown); if (!tc) { tc = new AndroidToolChain(abi, version, lang, ToolChain::AutoDetection); tc->resetToolChain(compilerPath); } result.append(tc); toolChainBundle.append(tc); } auto it = newestToolChainForArch.constFind(abi); if (it == newestToolChainForArch.constEnd()) newestToolChainForArch.insert(abi, toolChainBundle); else if (versionCompareLess(it.value(), toolChainBundle)) newestToolChainForArch[abi] = toolChainBundle; } foreach (ToolChain *tc, result) { AndroidToolChain *atc = static_cast<AndroidToolChain *>(tc); atc->setSecondaryToolChain(!newestToolChainForArch.value(atc->targetAbi()).contains(atc)); }
QList<ToolChain *> AndroidToolChainFactory::autodetectToolChainsForNdk(const FileName &ndkPath, const QList<ToolChain *> &alreadyKnown) { QList<ToolChain *> result; if (ndkPath.isEmpty()) return result; QRegExp versionRegExp(NDKGccVersionRegExp); FileName path = ndkPath; QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(), QStringList("*"), QDir::Dirs); QHash<Abi, QList<AndroidToolChain *>> newestToolChainForArch; while (it.hasNext()) { const QString &fileName = FileName::fromString(it.next()).fileName(); int idx = versionRegExp.indexIn(fileName); if (idx == -1) continue; QString version = fileName.mid(idx + 1); QString platform = fileName.left(idx); Abi abi = AndroidConfig::abiForToolChainPrefix(platform); if (abi.architecture() == Abi::UnknownArchitecture) continue; QList<AndroidToolChain *> toolChainBundle; for (Core::Id lang : {ProjectExplorer::Constants::CXX_LANGUAGE_ID, ProjectExplorer::Constants::C_LANGUAGE_ID}) { FileName compilerPath = AndroidConfigurations::currentConfig().gccPath(abi, lang, version); AndroidToolChain *tc = findToolChain(compilerPath, lang, alreadyKnown); if (!tc || tc->originalTargetTriple().isEmpty()) { tc = new AndroidToolChain(abi, version, lang, ToolChain::AutoDetection); tc->resetToolChain(compilerPath); QTC_ASSERT(!tc->originalTargetTriple().isEmpty(), delete tc; continue); } result.append(tc); toolChainBundle.append(tc); } QTC_ASSERT(!toolChainBundle.isEmpty(), continue); auto it = newestToolChainForArch.constFind(abi); if (it == newestToolChainForArch.constEnd()) newestToolChainForArch.insert(abi, toolChainBundle); else if (versionCompareLess(it.value(), toolChainBundle)) newestToolChainForArch[abi] = toolChainBundle; }
FileName IosRunConfiguration::bundleDirectory() const { FileName res; Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit()); bool isDevice = (devType == Constants::IOS_DEVICE_TYPE); if (!isDevice && devType != Constants::IOS_SIMULATOR_TYPE) { qCWarning(iosLog) << "unexpected device type in bundleDirForTarget: " << devType.toString(); return res; } QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration()); if (bc) { QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project()); const QmakeProFileNode *node = 0; if (pro) node = pro->rootProjectNode(); if (node) node = node->findProFileFor(profilePath()); if (node) { TargetInformation ti = node->targetInformation(); if (ti.valid) res = FileName::fromString(ti.buildDir); } if (res.isEmpty()) res = bc->buildDirectory(); switch (bc->buildType()) { case BuildConfiguration::Debug : case BuildConfiguration::Unknown : if (isDevice) res.appendPath(QLatin1String("Debug-iphoneos")); else res.appendPath(QLatin1String("Debug-iphonesimulator")); break; case BuildConfiguration::Profile : case BuildConfiguration::Release : if (isDevice) res.appendPath(QLatin1String("Release-iphoneos")); else res.appendPath(QLatin1String("Release-iphonesimulator")); break; default: qCWarning(iosLog) << "IosBuildStep had an unknown buildType " << target()->activeBuildConfiguration()->buildType(); } } res.appendPath(applicationName() + QLatin1String(".app")); return res; }
FileName AndroidConfigurations::gdbPath(Abi::Architecture architecture) const { FileName gdbPath; switch (architecture) { case Abi::ArmArchitecture: gdbPath = m_config.armGdbLocation; break; case Abi::X86Architecture: gdbPath = m_config.x86GdbLocation; break; default: gdbPath = FileName::fromString(Unknown); break; } if (!gdbPath.isEmpty()) return gdbPath; return toolPath(architecture).append(QLatin1String("-gdb" QTC_HOST_EXE_SUFFIX)); }
void FileUtils::showInGraphicalShell(QWidget *parent, const QString &pathIn) { const QFileInfo fileInfo(pathIn); // Mac, Windows support folder or file. if (HostOsInfo::isWindowsHost()) { const FileName explorer = Environment::systemEnvironment().searchInPath(QLatin1String("explorer.exe")); if (explorer.isEmpty()) { QMessageBox::warning(parent, QApplication::translate("Core::Internal", "Launching Windows Explorer Failed"), QApplication::translate("Core::Internal", "Could not find explorer.exe in path to launch Windows Explorer.")); return; } QStringList param; if (!fileInfo.isDir()) param += QLatin1String("/select,"); param += QDir::toNativeSeparators(fileInfo.canonicalFilePath()); QProcess::startDetached(explorer.toString(), param); } else if (HostOsInfo::isMacHost()) { QStringList scriptArgs; scriptArgs << QLatin1String("-e") << QString::fromLatin1("tell application \"Finder\" to reveal POSIX file \"%1\"") .arg(fileInfo.canonicalFilePath()); QProcess::execute(QLatin1String("/usr/bin/osascript"), scriptArgs); scriptArgs.clear(); scriptArgs << QLatin1String("-e") << QLatin1String("tell application \"Finder\" to activate"); QProcess::execute(QLatin1String("/usr/bin/osascript"), scriptArgs); } else { // we cannot select a file here, because no file browser really supports it... const QString folder = fileInfo.isDir() ? fileInfo.absoluteFilePath() : fileInfo.filePath(); const QString app = UnixUtils::fileBrowser(ICore::settings()); QProcess browserProc; const QString browserArgs = UnixUtils::substituteFileBrowserParameters(app, folder); bool success = browserProc.startDetached(browserArgs); const QString error = QString::fromLocal8Bit(browserProc.readAllStandardError()); success = success && error.isEmpty(); if (!success) showGraphicalShellError(parent, app, error); } }
TensorIOTestFixture() : T(5, 6, 7, 8) { FileName testDir = getTestDataDirectory(); if (!testDir.isEmpty()) { fileName = testDir / "maxdnn-TensorIO-test-file"; } const Shape &s = T.getShape(); for (int g = 0; g < s.getNumImages(); ++g) { for (int h = 0; h < s.getNumChannels(); ++h) { for (int i = 0; i < s.getNumRows(); ++i) { for (int j = 0; j < s.getNumColumns(); ++j) { T(g, h, i, j) = g*h*i*j; } } } } }
void provideData(quint64 block) { const FileName fn = filePath(); if (fn.isEmpty()) return; QFile file(fn.toString()); if (file.open(QIODevice::ReadOnly)) { int blockSize = m_widget->dataBlockSize(); file.seek(block * blockSize); QByteArray data = file.read(blockSize); file.close(); const int dataSize = data.size(); if (dataSize != blockSize) data += QByteArray(blockSize - dataSize, 0); m_widget->addData(block, data); } else { QMessageBox::critical(ICore::mainWindow(), tr("File Error"), tr("Cannot open %1: %2").arg( fn.toUserOutput(), file.errorString())); } }
FileName AndroidConfigurations::gdbServerPath(Abi::Architecture architecture) const { FileName gdbServerPath; switch (architecture) { case Abi::ArmArchitecture: gdbServerPath = m_config.armGdbserverLocation; break; case Abi::X86Architecture: gdbServerPath = m_config.x86GdbserverLocation; break; default: gdbServerPath = FileName::fromString(Unknown); break; } if (!gdbServerPath.isEmpty()) return gdbServerPath; FileName path = m_config.ndkLocation; return path.appendPath(QString::fromLatin1("toolchains/%1-%2/prebuilt/gdbserver") .arg(toolchainPrefix(architecture)) .arg(m_config.ndkToolchainVersion)); }