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>
Eike Ziller's avatar
Eike Ziller committed
62
#include <utils/mimetypes/mimedatabase.h>
63
#include <utils/qtcassert.h>
64

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

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

75 76 77
namespace CppTools {
namespace Internal {

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

hjk's avatar
hjk committed
200
    Utils::MacroExpander *expander = Utils::globalMacroExpander();
201 202 203 204 205 206
    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(); });
207

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

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

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

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

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

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

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

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

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

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

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

298 299 300 301 302 303 304 305 306 307 308 309 310
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;
}

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
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;
}

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

341 342 343 344 345 346 347 348 349
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;
}

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 377 378
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();
}

379 380 381
} // namespace Internal

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

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

    if (debug)
394
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
395

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

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

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

    const QDir absoluteDir = fi.absoluteDir();
417 418 419 420 421 422
    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);

423 424
    candidateFileNames += baseNamesWithAllPrefixes(candidateFileNames, isHeader);

425 426 427 428
    // 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
429
            const QString normalized = Utils::FileUtils::normalizePathName(candidateFilePath);
430 431 432 433 434 435 436
            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();
            }
437
        }
438 439
    }

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

    // Find files in other projects
449 450
    } else {
        CppModelManager *modelManager = CppModelManager::instance();
451 452
        QList<ProjectInfo> projectInfos = modelManager->projectInfos();
        foreach (const ProjectInfo &projectInfo, projectInfos) {
453 454 455 456 457 458 459 460
            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
461
    }
462

con's avatar
con committed
463 464 465
    return QString();
}

466
} // namespace CppTools