cpptoolsplugin.cpp 16.9 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 13 14
** 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
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15
**
16
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17 18 19 20 21 22 23 24 25
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** 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
26 27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
hjk's avatar
hjk committed
29

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

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

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

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

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

71 72 73
namespace CppTools {
namespace Internal {

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

151 152 153 154 155 156 157
    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)));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

370 371 372
} // namespace Internal

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

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

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

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

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

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

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

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

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

431 432 433 434 435 436 437 438 439
    // 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
440 441
    } else {
        CppModelManager *modelManager = CppModelManager::instance();
442 443
        QList<ProjectInfo> projectInfos = modelManager->projectInfos();
        foreach (const ProjectInfo &projectInfo, projectInfos) {
444 445 446 447 448 449 450 451
            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
452
    }
453

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

457
} // namespace CppTools