cpptoolsplugin.cpp 17 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
3
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** Contact: http://www.qt-project.org/legal
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 12
** 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
** a written agreement between you and Digia.  For licensing terms and
Eike Ziller's avatar
Eike Ziller committed
13 14
** conditions see http://www.qt.io/licensing.  For further information
** 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 25 26
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt 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"
con's avatar
con committed
47

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

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

62 63 64 65 66 67
#include <QtPlugin>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QMenu>
#include <QAction>
68

hjk's avatar
hjk committed
69
using namespace Core;
70
using namespace CPlusPlus;
con's avatar
con committed
71

72 73 74
namespace CppTools {
namespace Internal {

con's avatar
con committed
75 76
enum { debug = 0 };

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

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

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

93 94 95 96 97
CppToolsPlugin *CppToolsPlugin::instance()
{
    return m_instance;
}

98 99 100 101 102
void CppToolsPlugin::clearHeaderSourceCache()
{
    m_headerSourceMapping.clear();
}

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

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

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

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

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

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


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

139 140
    m_settings = new CppToolsSettings(this); // force registration of cpp tools settings

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

150
    JsExpander::registerQObjectForJs(QLatin1String("Cpp"), new CppToolsJsExtension);
151

152 153 154 155 156 157 158
    CppLocatorData *locatorData = new CppLocatorData;
    connect(modelManager, SIGNAL(documentUpdated(CPlusPlus::Document::Ptr)),
            locatorData, SLOT(onDocumentUpdated(CPlusPlus::Document::Ptr)));

    connect(modelManager, SIGNAL(aboutToRemoveFiles(QStringList)),
            locatorData, SLOT(onAboutToRemoveFiles(QStringList)));

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

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

    // Actions
178
    Context context(CppEditor::Constants::CPPEDITOR_ID);
con's avatar
con committed
179 180

    QAction *switchAction = new QAction(tr("Switch Header/Source"), this);
hjk's avatar
hjk committed
181
    Command *command = ActionManager::registerAction(switchAction, Constants::SWITCH_HEADER_SOURCE, context, true);
con's avatar
con committed
182 183 184 185
    command->setDefaultKeySequence(QKeySequence(Qt::Key_F4));
    mcpptools->addAction(command);
    connect(switchAction, SIGNAL(triggered()), this, SLOT(switchHeaderSource()));

186
    QAction *openInNextSplitAction = new QAction(tr("Open Corresponding Header/Source in Next Split"), this);
hjk's avatar
hjk committed
187
    command = ActionManager::registerAction(openInNextSplitAction, Constants::OPEN_HEADER_SOURCE_IN_NEXT_SPLIT, context, true);
188 189 190
    command->setDefaultKeySequence(QKeySequence(Utils::HostOsInfo::isMacHost()
                                                ? tr("Meta+E, F4")
                                                : tr("Ctrl+E, F4")));
191 192 193
    mcpptools->addAction(command);
    connect(openInNextSplitAction, SIGNAL(triggered()), this, SLOT(switchHeaderSourceInNextSplit()));

194 195
    Core::VariableManager::registerVariable("Cpp:LicenseTemplate",
                                            tr("The license template."),
hjk's avatar
hjk committed
196
                                            [this]() { return CppToolsPlugin::licenseTemplate(); });
197
    Core::VariableManager::registerFileVariables("Cpp:LicenseTemplatePath",
Tobias Hunger's avatar
Tobias Hunger committed
198
                                                 tr("The configured path to the license template"),
hjk's avatar
hjk committed
199
                                                 [this]() { return CppToolsPlugin::licenseTemplatePath().toString(); });
200

con's avatar
con committed
201 202 203 204 205
    return true;
}

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

214
ExtensionSystem::IPlugin::ShutdownFlag CppToolsPlugin::aboutToShutdown()
215
{
216
    return SynchronousShutdown;
217 218
}

219 220 221 222 223
QSharedPointer<CppCodeModelSettings> CppToolsPlugin::codeModelSettings() const
{
    return m_codeModelSettings;
}

224 225 226 227 228
StringTable &CppToolsPlugin::stringTable()
{
    return instance()->m_stringTable;
}

con's avatar
con committed
229 230
void CppToolsPlugin::switchHeaderSource()
{
231
    CppTools::switchHeaderSource();
232 233 234 235 236
}

void CppToolsPlugin::switchHeaderSourceInNextSplit()
{
    QString otherFile = correspondingHeaderOrSource(
hjk's avatar
hjk committed
237
                EditorManager::currentDocument()->filePath());
238
    if (!otherFile.isEmpty())
hjk's avatar
hjk committed
239
        EditorManager::openEditor(otherFile, Id(), EditorManager::OpenInOtherSplit);
con's avatar
con committed
240 241
}

242
static QStringList findFilesInProject(const QString &name,
243
                                   const ProjectExplorer::Project *project)
con's avatar
con committed
244 245
{
    if (debug)
246 247 248
        qDebug() << Q_FUNC_INFO << name << project;

    if (!project)
249
        return QStringList();
250 251 252 253 254

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

// Return the suffixes that should be checked when trying to find a
// source belonging to a header and vice versa
265
static QStringList matchingCandidateSuffixes(ProjectFile::Kind kind)
con's avatar
con committed
266
{
267 268 269 270 271 272
    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
273 274 275 276
        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();
277 278
    case ProjectFile::CSource:
    case ProjectFile::ObjCSource:
hjk's avatar
hjk committed
279
        return MimeDatabase::findByType(QLatin1String(Constants::C_HEADER_MIMETYPE)).suffixes();
280 281 282 283
    case ProjectFile::CXXSource:
    case ProjectFile::ObjCXXSource:
    case ProjectFile::CudaSource:
    case ProjectFile::OpenCLSource:
hjk's avatar
hjk committed
284
        return MimeDatabase::findByType(QLatin1String(Constants::CPP_HEADER_MIMETYPE)).suffixes();
285 286
    default:
        return QStringList();
con's avatar
con committed
287 288 289
    }
}

290 291 292 293 294 295 296 297 298 299 300 301 302
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;
}

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
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;
}

325 326 327 328 329 330 331 332
static QStringList baseDirWithAllDirectories(const QDir &baseDir, const QStringList &directories)
{
    QStringList result;
    foreach (const QString &dir, directories)
        result << QDir::cleanPath(baseDir.absoluteFilePath(dir));
    return result;
}

333 334 335 336 337 338 339 340 341
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;
}

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
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();
}

371 372 373
} // namespace Internal

QString correspondingHeaderOrSource(const QString &fileName, bool *wasHeader)
con's avatar
con committed
374
{
375
    using namespace Internal;
376

377
    const QFileInfo fi(fileName);
378 379
    ProjectFile::Kind kind = ProjectFile::classify(fileName);
    const bool isHeader = ProjectFile::isHeader(kind);
380
    if (wasHeader)
381 382
        *wasHeader = isHeader;
    if (m_headerSourceMapping.contains(fi.absoluteFilePath()))
383
        return m_headerSourceMapping.value(fi.absoluteFilePath());
con's avatar
con committed
384 385

    if (debug)
386
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
387

388
    if (kind == ProjectFile::Unclassified)
con's avatar
con committed
389 390
        return QString();

391
    const QString baseName = fi.completeBaseName();
392
    const QString privateHeaderSuffix = QLatin1String("_p");
393
    const QStringList suffixes = matchingCandidateSuffixes(kind);
con's avatar
con committed
394

395
    QStringList candidateFileNames = baseNameWithAllSuffixes(baseName, suffixes);
396
    if (isHeader) {
con's avatar
con committed
397 398 399
        if (baseName.endsWith(privateHeaderSuffix)) {
            QString sourceBaseName = baseName;
            sourceBaseName.truncate(sourceBaseName.size() - privateHeaderSuffix.size());
400
            candidateFileNames += baseNameWithAllSuffixes(sourceBaseName, suffixes);
con's avatar
con committed
401 402
        }
    } else {
403 404 405 406 407 408
        QString privateHeaderBaseName = baseName;
        privateHeaderBaseName.append(privateHeaderSuffix);
        candidateFileNames += baseNameWithAllSuffixes(privateHeaderBaseName, suffixes);
    }

    const QDir absoluteDir = fi.absoluteDir();
409 410 411 412 413 414
    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);

415 416
    candidateFileNames += baseNamesWithAllPrefixes(candidateFileNames, isHeader);

417 418 419 420
    // 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
421
            const QString normalized = Utils::FileUtils::normalizePathName(candidateFilePath);
422 423 424 425 426 427 428
            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();
            }
429
        }
430 431
    }

432 433 434 435 436 437 438 439 440
    // Find files in the current project
    ProjectExplorer::Project *currentProject = ProjectExplorer::ProjectExplorerPlugin::currentProject();
    if (currentProject) {
        const QString path = correspondingHeaderOrSourceInProject(fi, candidateFileNames,
                                                                  currentProject);
        if (!path.isEmpty())
            return path;

    // Find files in other projects
441 442
    } else {
        CppModelManager *modelManager = CppModelManager::instance();
443 444
        QList<ProjectInfo> projectInfos = modelManager->projectInfos();
        foreach (const ProjectInfo &projectInfo, projectInfos) {
445 446 447 448 449 450 451 452
            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
453
    }
454

con's avatar
con committed
455 456 457
    return QString();
}

458
} // namespace CppTools