cpptoolsplugin.cpp 17.1 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
Eike Ziller's avatar
Eike Ziller committed
3 4
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
con's avatar
con committed
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
con's avatar
con committed
7
**
hjk's avatar
hjk committed
8 9 10 11
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
Eike Ziller's avatar
Eike Ziller committed
12 13
** a written agreement between you and The Qt Company.  For licensing terms and
** conditions see http://www.qt.io/terms-conditions.  For further information
Eike Ziller's avatar
Eike Ziller committed
14
** use the contact form at http://www.qt.io/contact-us.
15
**
16
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17
** Alternatively, this file may be used under the terms of the GNU Lesser
Eike Ziller's avatar
Eike Ziller committed
18 19 20 21 22 23
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
hjk's avatar
hjk committed
24
**
Eike Ziller's avatar
Eike Ziller committed
25 26
** In addition, as a special exception, The Qt Company gives you certain additional
** rights.  These rights are described in The Qt Company LGPL Exception
con's avatar
con committed
27 28
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
29
****************************************************************************/
hjk's avatar
hjk committed
30

31
#include "cpptoolsconstants.h"
32
#include "cpptoolsplugin.h"
33
#include "cppfilesettingspage.h"
34
#include "cppcodemodelsettingspage.h"
35
#include "cppcodestylesettingspage.h"
36
#include "cppclassesfilter.h"
37
#include "cppfunctionsfilter.h"
38
#include "cppcurrentdocumentfilter.h"
con's avatar
con committed
39
#include "cppmodelmanager.h"
con's avatar
con committed
40
#include "cpplocatorfilter.h"
41
#include "symbolsfindfilter.h"
42
#include "cpptoolsjsextension.h"
43
#include "cpptoolssettings.h"
44
#include "cpptoolsreuse.h"
45
#include "cppprojectfile.h"
46
#include "cpplocatordata.h"
47
#include "cppincludesfilter.h"
con's avatar
con committed
48

49
#include <coreplugin/actionmanager/actioncontainer.h>
50 51 52 53
#include <coreplugin/actionmanager/actionmanager.h>
#include <coreplugin/coreconstants.h>
#include <coreplugin/documentmanager.h>
#include <coreplugin/icore.h>
54
#include <coreplugin/jsexpander.h>
55
#include <coreplugin/vcsmanager.h>
con's avatar
con committed
56
#include <cppeditor/cppeditorconstants.h>
57
#include <projectexplorer/projecttree.h>
58

Orgad Shaneh's avatar
Orgad Shaneh committed
59
#include <utils/fileutils.h>
60
#include <utils/hostosinfo.h>
hjk's avatar
hjk committed
61
#include <utils/macroexpander.h>
62
#include <utils/qtcassert.h>
63

64 65 66 67 68 69
#include <QtPlugin>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QMenu>
#include <QAction>
70

hjk's avatar
hjk committed
71
using namespace Core;
72
using namespace CPlusPlus;
con's avatar
con committed
73

74 75 76
namespace CppTools {
namespace Internal {

con's avatar
con committed
77 78
enum { debug = 0 };

79
static CppToolsPlugin *m_instance = 0;
80
static QHash<QString, QString> m_headerSourceMapping;
con's avatar
con committed
81

82 83 84
CppToolsPlugin::CppToolsPlugin()
    : m_fileSettings(new CppFileSettings)
    , m_codeModelSettings(new CppCodeModelSettings)
con's avatar
con committed
85 86 87 88 89 90 91
{
    m_instance = this;
}

CppToolsPlugin::~CppToolsPlugin()
{
    m_instance = 0;
92
    delete CppModelManager::instance();
con's avatar
con committed
93 94
}

95 96 97 98 99
CppToolsPlugin *CppToolsPlugin::instance()
{
    return m_instance;
}

100 101 102 103 104
void CppToolsPlugin::clearHeaderSourceCache()
{
    m_headerSourceMapping.clear();
}

105 106 107 108 109 110 111 112 113 114
Utils::FileName CppToolsPlugin::licenseTemplatePath()
{
    return Utils::FileName::fromString(m_instance->m_fileSettings->licenseTemplatePath);
}

QString CppToolsPlugin::licenseTemplate()
{
    return m_instance->m_fileSettings->licenseTemplate();
}

115 116 117 118 119 120 121 122 123 124
const QStringList &CppToolsPlugin::headerSearchPaths()
{
    return m_instance->m_fileSettings->headerSearchPaths;
}

const QStringList &CppToolsPlugin::sourceSearchPaths()
{
    return m_instance->m_fileSettings->sourceSearchPaths;
}

125 126 127 128 129 130 131 132 133 134 135
const QStringList &CppToolsPlugin::headerPrefixes()
{
    return m_instance->m_fileSettings->headerPrefixes;
}

const QStringList &CppToolsPlugin::sourcePrefixes()
{
    return m_instance->m_fileSettings->sourcePrefixes;
}


136
bool CppToolsPlugin::initialize(const QStringList &arguments, QString *error)
con's avatar
con committed
137
{
138 139
    Q_UNUSED(arguments)
    Q_UNUSED(error)
140

141 142
    m_settings = new CppToolsSettings(this); // force registration of cpp tools settings

con's avatar
con committed
143
    // Objects
144
    CppModelManager *modelManager = CppModelManager::instance();
hjk's avatar
hjk committed
145
    connect(VcsManager::instance(), SIGNAL(repositoryChanged(QString)),
146
            modelManager, SLOT(updateModifiedSourceFiles()));
147 148 149 150
    connect(DocumentManager::instance(), &DocumentManager::filesChangedInternally,
            [=](const QStringList &files) {
        modelManager->updateSourceFiles(files.toSet());
    });
Roberto Raggi's avatar
Roberto Raggi committed
151

152
    JsExpander::registerQObjectForJs(QLatin1String("Cpp"), new CppToolsJsExtension);
153

154
    CppLocatorData *locatorData = new CppLocatorData;
Montel Laurent's avatar
Montel Laurent committed
155 156
    connect(modelManager, &CppModelManager::documentUpdated,
            locatorData, &CppLocatorData::onDocumentUpdated);
157

Montel Laurent's avatar
Montel Laurent committed
158 159
    connect(modelManager, &CppModelManager::aboutToRemoveFiles,
            locatorData, &CppLocatorData::onAboutToRemoveFiles);
160

161 162 163
    addAutoReleasedObject(locatorData);
    addAutoReleasedObject(new CppLocatorFilter(locatorData));
    addAutoReleasedObject(new CppClassesFilter(locatorData));
164
    addAutoReleasedObject(new CppIncludesFilter);
165
    addAutoReleasedObject(new CppFunctionsFilter(locatorData));
166
    addAutoReleasedObject(new CppCurrentDocumentFilter(modelManager, m_stringTable));
167
    addAutoReleasedObject(new CppFileSettingsPage(m_fileSettings));
168
    addAutoReleasedObject(new CppCodeModelSettingsPage(m_codeModelSettings));
169
    addAutoReleasedObject(new SymbolsFindFilter(modelManager));
170 171
    addAutoReleasedObject(new CppCodeStyleSettingsPage);

con's avatar
con committed
172
    // Menus
hjk's avatar
hjk committed
173 174
    ActionContainer *mtools = ActionManager::actionContainer(Core::Constants::M_TOOLS);
    ActionContainer *mcpptools = ActionManager::createMenu(CppTools::Constants::M_TOOLS_CPP);
con's avatar
con committed
175 176 177 178 179 180
    QMenu *menu = mcpptools->menu();
    menu->setTitle(tr("&C++"));
    menu->setEnabled(true);
    mtools->addMenu(mcpptools);

    // Actions
181
    Context context(CppEditor::Constants::CPPEDITOR_ID);
con's avatar
con committed
182 183

    QAction *switchAction = new QAction(tr("Switch Header/Source"), this);
hjk's avatar
hjk committed
184
    Command *command = ActionManager::registerAction(switchAction, Constants::SWITCH_HEADER_SOURCE, context, true);
con's avatar
con committed
185 186
    command->setDefaultKeySequence(QKeySequence(Qt::Key_F4));
    mcpptools->addAction(command);
Montel Laurent's avatar
Montel Laurent committed
187 188
    connect(switchAction, &QAction::triggered,
            this, &CppToolsPlugin::switchHeaderSource);
con's avatar
con committed
189

190
    QAction *openInNextSplitAction = new QAction(tr("Open Corresponding Header/Source in Next Split"), this);
hjk's avatar
hjk committed
191
    command = ActionManager::registerAction(openInNextSplitAction, Constants::OPEN_HEADER_SOURCE_IN_NEXT_SPLIT, context, true);
192 193 194
    command->setDefaultKeySequence(QKeySequence(Utils::HostOsInfo::isMacHost()
                                                ? tr("Meta+E, F4")
                                                : tr("Ctrl+E, F4")));
195
    mcpptools->addAction(command);
Montel Laurent's avatar
Montel Laurent committed
196 197
    connect(openInNextSplitAction, &QAction::triggered,
            this, &CppToolsPlugin::switchHeaderSourceInNextSplit);
198

hjk's avatar
hjk committed
199
    Utils::MacroExpander *expander = Utils::globalMacroExpander();
200 201 202 203 204 205
    expander->registerVariable("Cpp:LicenseTemplate",
                               tr("The license template."),
                               [this]() { return CppToolsPlugin::licenseTemplate(); });
    expander->registerFileVariables("Cpp:LicenseTemplatePath",
                                    tr("The configured path to the license template"),
                                    [this]() { return CppToolsPlugin::licenseTemplatePath().toString(); });
206

con's avatar
con committed
207 208 209 210 211
    return true;
}

void CppToolsPlugin::extensionsInitialized()
{
212 213
    // The Cpp editor plugin, which is loaded later on, registers the Cpp mime types,
    // so, apply settings here
hjk's avatar
hjk committed
214
    m_fileSettings->fromSettings(ICore::settings());
215 216
    if (!m_fileSettings->applySuffixesToMimeDB())
        qWarning("Unable to apply cpp suffixes to mime database (cpp mime types not found).\n");
217
    m_codeModelSettings->fromSettings(ICore::settings());
con's avatar
con committed
218 219
}

220
ExtensionSystem::IPlugin::ShutdownFlag CppToolsPlugin::aboutToShutdown()
221
{
222
    return SynchronousShutdown;
223 224
}

225 226 227 228 229
QSharedPointer<CppCodeModelSettings> CppToolsPlugin::codeModelSettings() const
{
    return m_codeModelSettings;
}

230 231 232 233 234
StringTable &CppToolsPlugin::stringTable()
{
    return instance()->m_stringTable;
}

con's avatar
con committed
235 236
void CppToolsPlugin::switchHeaderSource()
{
237
    CppTools::switchHeaderSource();
238 239 240 241 242
}

void CppToolsPlugin::switchHeaderSourceInNextSplit()
{
    QString otherFile = correspondingHeaderOrSource(
243
                EditorManager::currentDocument()->filePath().toString());
244
    if (!otherFile.isEmpty())
hjk's avatar
hjk committed
245
        EditorManager::openEditor(otherFile, Id(), EditorManager::OpenInOtherSplit);
con's avatar
con committed
246 247
}

248
static QStringList findFilesInProject(const QString &name,
249
                                   const ProjectExplorer::Project *project)
con's avatar
con committed
250 251
{
    if (debug)
252 253 254
        qDebug() << Q_FUNC_INFO << name << project;

    if (!project)
255
        return QStringList();
256 257 258 259 260

    QString pattern = QString(1, QLatin1Char('/'));
    pattern += name;
    const QStringList projectFiles = project->files(ProjectExplorer::Project::AllFiles);
    const QStringList::const_iterator pcend = projectFiles.constEnd();
261
    QStringList candidateList;
262 263
    for (QStringList::const_iterator it = projectFiles.constBegin(); it != pcend; ++it) {
        if (it->endsWith(pattern))
264
            candidateList.append(*it);
con's avatar
con committed
265
    }
266
    return candidateList;
con's avatar
con committed
267 268 269 270
}

// Return the suffixes that should be checked when trying to find a
// source belonging to a header and vice versa
271
static QStringList matchingCandidateSuffixes(ProjectFile::Kind kind)
con's avatar
con committed
272
{
273 274 275 276 277 278
    switch (kind) {
     // Note that C/C++ headers are undistinguishable
    case ProjectFile::CHeader:
    case ProjectFile::CXXHeader:
    case ProjectFile::ObjCHeader:
    case ProjectFile::ObjCXXHeader:
hjk's avatar
hjk committed
279 280 281 282
        return MimeDatabase::findByType(QLatin1String(Constants::C_SOURCE_MIMETYPE)).suffixes()
                + MimeDatabase::findByType(QLatin1String(Constants::CPP_SOURCE_MIMETYPE)).suffixes()
                + MimeDatabase::findByType(QLatin1String(Constants::OBJECTIVE_C_SOURCE_MIMETYPE)).suffixes()
                + MimeDatabase::findByType(QLatin1String(Constants::OBJECTIVE_CPP_SOURCE_MIMETYPE)).suffixes();
283 284
    case ProjectFile::CSource:
    case ProjectFile::ObjCSource:
hjk's avatar
hjk committed
285
        return MimeDatabase::findByType(QLatin1String(Constants::C_HEADER_MIMETYPE)).suffixes();
286 287 288 289
    case ProjectFile::CXXSource:
    case ProjectFile::ObjCXXSource:
    case ProjectFile::CudaSource:
    case ProjectFile::OpenCLSource:
hjk's avatar
hjk committed
290
        return MimeDatabase::findByType(QLatin1String(Constants::CPP_HEADER_MIMETYPE)).suffixes();
291 292
    default:
        return QStringList();
con's avatar
con committed
293 294 295
    }
}

296 297 298 299 300 301 302 303 304 305 306 307 308
static QStringList baseNameWithAllSuffixes(const QString &baseName, const QStringList &suffixes)
{
    QStringList result;
    const QChar dot = QLatin1Char('.');
    foreach (const QString &suffix, suffixes) {
        QString fileName = baseName;
        fileName += dot;
        fileName += suffix;
        result += fileName;
    }
    return result;
}

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
static QStringList baseNamesWithAllPrefixes(const QStringList &baseNames, bool isHeader)
{
    QStringList result;
    const QStringList &sourcePrefixes = m_instance->sourcePrefixes();
    const QStringList &headerPrefixes = m_instance->headerPrefixes();

    foreach (const QString &name, baseNames) {
        foreach (const QString &prefix, isHeader ? headerPrefixes : sourcePrefixes) {
            if (name.startsWith(prefix)) {
                QString nameWithoutPrefix = name.mid(prefix.size());
                result += nameWithoutPrefix;
                foreach (const QString &prefix, isHeader ? sourcePrefixes : headerPrefixes)
                    result += prefix + nameWithoutPrefix;
            }
        }
        foreach (const QString &prefix, isHeader ? sourcePrefixes : headerPrefixes)
            result += prefix + name;

    }
    return result;
}

331 332 333 334 335 336 337 338
static QStringList baseDirWithAllDirectories(const QDir &baseDir, const QStringList &directories)
{
    QStringList result;
    foreach (const QString &dir, directories)
        result << QDir::cleanPath(baseDir.absoluteFilePath(dir));
    return result;
}

339 340 341 342 343 344 345 346 347
static int commonStringLength(const QString &s1, const QString &s2)
{
    int length = qMin(s1.length(), s2.length());
    for (int i = 0; i < length; ++i)
        if (s1[i] != s2[i])
            return i;
    return length;
}

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
static QString correspondingHeaderOrSourceInProject(const QFileInfo &fileInfo,
                                                    const QStringList &candidateFileNames,
                                                    const ProjectExplorer::Project *project)
{
    QString bestFileName;
    int compareValue = 0;
    const QString filePath = fileInfo.filePath();
    foreach (const QString &candidateFileName, candidateFileNames) {
        const QStringList projectFiles = findFilesInProject(candidateFileName, project);
        // Find the file having the most common path with fileName
        foreach (const QString &projectFile, projectFiles) {
            int value = commonStringLength(filePath, projectFile);
            if (value > compareValue) {
                compareValue = value;
                bestFileName = projectFile;
            }
        }
    }
    if (!bestFileName.isEmpty()) {
        const QFileInfo candidateFi(bestFileName);
        QTC_ASSERT(candidateFi.isFile(), return QString());
        m_headerSourceMapping[fileInfo.absoluteFilePath()] = candidateFi.absoluteFilePath();
        m_headerSourceMapping[candidateFi.absoluteFilePath()] = fileInfo.absoluteFilePath();
        return candidateFi.absoluteFilePath();
    }

    return QString();
}

377 378 379
} // namespace Internal

QString correspondingHeaderOrSource(const QString &fileName, bool *wasHeader)
con's avatar
con committed
380
{
381
    using namespace Internal;
382

383
    const QFileInfo fi(fileName);
384 385
    ProjectFile::Kind kind = ProjectFile::classify(fileName);
    const bool isHeader = ProjectFile::isHeader(kind);
386
    if (wasHeader)
387 388
        *wasHeader = isHeader;
    if (m_headerSourceMapping.contains(fi.absoluteFilePath()))
389
        return m_headerSourceMapping.value(fi.absoluteFilePath());
con's avatar
con committed
390 391

    if (debug)
392
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
393

394
    if (kind == ProjectFile::Unclassified)
con's avatar
con committed
395 396
        return QString();

397
    const QString baseName = fi.completeBaseName();
398
    const QString privateHeaderSuffix = QLatin1String("_p");
399
    const QStringList suffixes = matchingCandidateSuffixes(kind);
con's avatar
con committed
400

401
    QStringList candidateFileNames = baseNameWithAllSuffixes(baseName, suffixes);
402
    if (isHeader) {
con's avatar
con committed
403 404 405
        if (baseName.endsWith(privateHeaderSuffix)) {
            QString sourceBaseName = baseName;
            sourceBaseName.truncate(sourceBaseName.size() - privateHeaderSuffix.size());
406
            candidateFileNames += baseNameWithAllSuffixes(sourceBaseName, suffixes);
con's avatar
con committed
407 408
        }
    } else {
409 410 411 412 413 414
        QString privateHeaderBaseName = baseName;
        privateHeaderBaseName.append(privateHeaderSuffix);
        candidateFileNames += baseNameWithAllSuffixes(privateHeaderBaseName, suffixes);
    }

    const QDir absoluteDir = fi.absoluteDir();
415 416 417 418 419 420
    QStringList candidateDirs(absoluteDir.absolutePath());
    // If directory is not root, try matching against its siblings
    const QStringList searchPaths = isHeader ? m_instance->sourceSearchPaths()
                                             : m_instance->headerSearchPaths();
    candidateDirs += baseDirWithAllDirectories(absoluteDir, searchPaths);

421 422
    candidateFileNames += baseNamesWithAllPrefixes(candidateFileNames, isHeader);

423 424 425 426
    // Try to find a file in the same or sibling directories first
    foreach (const QString &candidateDir, candidateDirs) {
        foreach (const QString &candidateFileName, candidateFileNames) {
            const QString candidateFilePath = candidateDir + QLatin1Char('/') + candidateFileName;
Orgad Shaneh's avatar
Orgad Shaneh committed
427
            const QString normalized = Utils::FileUtils::normalizePathName(candidateFilePath);
428 429 430 431 432 433 434
            const QFileInfo candidateFi(normalized);
            if (candidateFi.isFile()) {
                m_headerSourceMapping[fi.absoluteFilePath()] = candidateFi.absoluteFilePath();
                if (!isHeader || !baseName.endsWith(privateHeaderSuffix))
                    m_headerSourceMapping[candidateFi.absoluteFilePath()] = fi.absoluteFilePath();
                return candidateFi.absoluteFilePath();
            }
435
        }
436 437
    }

438
    // Find files in the current project
439
    ProjectExplorer::Project *currentProject = ProjectExplorer::ProjectTree::currentProject();
440 441 442 443 444 445 446
    if (currentProject) {
        const QString path = correspondingHeaderOrSourceInProject(fi, candidateFileNames,
                                                                  currentProject);
        if (!path.isEmpty())
            return path;

    // Find files in other projects
447 448
    } else {
        CppModelManager *modelManager = CppModelManager::instance();
449 450
        QList<ProjectInfo> projectInfos = modelManager->projectInfos();
        foreach (const ProjectInfo &projectInfo, projectInfos) {
451 452 453 454 455 456 457 458
            const ProjectExplorer::Project *project = projectInfo.project().data();
            if (project == currentProject)
                continue; // We have already checked the current project.

            const QString path = correspondingHeaderOrSourceInProject(fi, candidateFileNames, project);
            if (!path.isEmpty())
                return path;
        }
con's avatar
con committed
459
    }
460

con's avatar
con committed
461 462 463
    return QString();
}

464
} // namespace CppTools