cpptoolsplugin.cpp 16.8 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 "cpptoolssettings.h"
42
#include "cpptoolsreuse.h"
43
#include "cppprojectfile.h"
44
#include "cpplocatordata.h"
con's avatar
con committed
45

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

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

59 60 61 62 63 64
#include <QtPlugin>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QMenu>
#include <QAction>
65

hjk's avatar
hjk committed
66
using namespace Core;
67
using namespace CPlusPlus;
con's avatar
con committed
68

69 70 71
namespace CppTools {
namespace Internal {

con's avatar
con committed
72 73
enum { debug = 0 };

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

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

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

90 91 92 93 94
CppToolsPlugin *CppToolsPlugin::instance()
{
    return m_instance;
}

95 96 97 98 99
void CppToolsPlugin::clearHeaderSourceCache()
{
    m_headerSourceMapping.clear();
}

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

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

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

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

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

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


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

136 137
    m_settings = new CppToolsSettings(this); // force registration of cpp tools settings

con's avatar
con committed
138
    // Objects
139
    CppModelManager *modelManager = CppModelManager::instance();
hjk's avatar
hjk committed
140
    connect(VcsManager::instance(), SIGNAL(repositoryChanged(QString)),
141
            modelManager, SLOT(updateModifiedSourceFiles()));
hjk's avatar
hjk committed
142
    connect(DocumentManager::instance(), SIGNAL(filesChangedInternally(QStringList)),
143
            modelManager, SLOT(updateSourceFiles(QStringList)));
Roberto Raggi's avatar
Roberto Raggi committed
144

145 146 147 148 149 150 151
    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)));

152 153 154 155
    addAutoReleasedObject(locatorData);
    addAutoReleasedObject(new CppLocatorFilter(locatorData));
    addAutoReleasedObject(new CppClassesFilter(locatorData));
    addAutoReleasedObject(new CppFunctionsFilter(locatorData));
156
    addAutoReleasedObject(new CppCurrentDocumentFilter(modelManager, m_stringTable));
157
    addAutoReleasedObject(new CppFileSettingsPage(m_fileSettings));
158
    addAutoReleasedObject(new CppCodeModelSettingsPage(m_codeModelSettings));
159
    addAutoReleasedObject(new SymbolsFindFilter(modelManager));
160 161
    addAutoReleasedObject(new CppCodeStyleSettingsPage);

con's avatar
con committed
162
    // Menus
hjk's avatar
hjk committed
163 164
    ActionContainer *mtools = ActionManager::actionContainer(Core::Constants::M_TOOLS);
    ActionContainer *mcpptools = ActionManager::createMenu(CppTools::Constants::M_TOOLS_CPP);
con's avatar
con committed
165 166 167 168 169 170
    QMenu *menu = mcpptools->menu();
    menu->setTitle(tr("&C++"));
    menu->setEnabled(true);
    mtools->addMenu(mcpptools);

    // Actions
hjk's avatar
hjk committed
171
    Context context(CppEditor::Constants::C_CPPEDITOR);
con's avatar
con committed
172 173

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

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

187 188 189 190 191 192 193
    Core::VariableManager::registerVariable("Cpp:LicenseTemplate",
                                            tr("The license template."),
                                            []() { return CppToolsPlugin::licenseTemplate(); });
    Core::VariableManager::registerFileVariables("Cpp:LicenseTemplatePath",
                                                 tr("The configured path to the license template."),
                                                 []() { return CppToolsPlugin::licenseTemplatePath().toString(); });

con's avatar
con committed
194 195 196 197 198
    return true;
}

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

207
ExtensionSystem::IPlugin::ShutdownFlag CppToolsPlugin::aboutToShutdown()
208
{
209
    return SynchronousShutdown;
210 211
}

212 213 214 215 216
QSharedPointer<CppCodeModelSettings> CppToolsPlugin::codeModelSettings() const
{
    return m_codeModelSettings;
}

217 218 219 220 221
StringTable &CppToolsPlugin::stringTable()
{
    return instance()->m_stringTable;
}

con's avatar
con committed
222 223
void CppToolsPlugin::switchHeaderSource()
{
224
    CppTools::switchHeaderSource();
225 226 227 228 229
}

void CppToolsPlugin::switchHeaderSourceInNextSplit()
{
    QString otherFile = correspondingHeaderOrSource(
hjk's avatar
hjk committed
230
                EditorManager::currentDocument()->filePath());
231
    if (!otherFile.isEmpty())
hjk's avatar
hjk committed
232
        EditorManager::openEditor(otherFile, Id(), EditorManager::OpenInOtherSplit);
con's avatar
con committed
233 234
}

235
static QStringList findFilesInProject(const QString &name,
236
                                   const ProjectExplorer::Project *project)
con's avatar
con committed
237 238
{
    if (debug)
239 240 241
        qDebug() << Q_FUNC_INFO << name << project;

    if (!project)
242
        return QStringList();
243 244 245 246 247

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

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

283 284 285 286 287 288 289 290 291 292 293 294 295
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;
}

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
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;
}

318 319 320 321 322 323 324 325
static QStringList baseDirWithAllDirectories(const QDir &baseDir, const QStringList &directories)
{
    QStringList result;
    foreach (const QString &dir, directories)
        result << QDir::cleanPath(baseDir.absoluteFilePath(dir));
    return result;
}

326 327 328 329 330 331 332 333 334
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;
}

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
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();
}

364 365 366
} // namespace Internal

QString correspondingHeaderOrSource(const QString &fileName, bool *wasHeader)
con's avatar
con committed
367
{
368
    using namespace Internal;
369

370
    const QFileInfo fi(fileName);
371 372
    ProjectFile::Kind kind = ProjectFile::classify(fileName);
    const bool isHeader = ProjectFile::isHeader(kind);
373
    if (wasHeader)
374 375
        *wasHeader = isHeader;
    if (m_headerSourceMapping.contains(fi.absoluteFilePath()))
376
        return m_headerSourceMapping.value(fi.absoluteFilePath());
con's avatar
con committed
377 378

    if (debug)
379
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
380

381
    if (kind == ProjectFile::Unclassified)
con's avatar
con committed
382 383
        return QString();

384
    const QString baseName = fi.completeBaseName();
385
    const QString privateHeaderSuffix = QLatin1String("_p");
386
    const QStringList suffixes = matchingCandidateSuffixes(kind);
con's avatar
con committed
387

388
    QStringList candidateFileNames = baseNameWithAllSuffixes(baseName, suffixes);
389
    if (isHeader) {
con's avatar
con committed
390 391 392
        if (baseName.endsWith(privateHeaderSuffix)) {
            QString sourceBaseName = baseName;
            sourceBaseName.truncate(sourceBaseName.size() - privateHeaderSuffix.size());
393
            candidateFileNames += baseNameWithAllSuffixes(sourceBaseName, suffixes);
con's avatar
con committed
394 395
        }
    } else {
396 397 398 399 400 401
        QString privateHeaderBaseName = baseName;
        privateHeaderBaseName.append(privateHeaderSuffix);
        candidateFileNames += baseNameWithAllSuffixes(privateHeaderBaseName, suffixes);
    }

    const QDir absoluteDir = fi.absoluteDir();
402 403 404 405 406 407
    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);

408 409
    candidateFileNames += baseNamesWithAllPrefixes(candidateFileNames, isHeader);

410 411 412 413
    // 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
414
            const QString normalized = Utils::FileUtils::normalizePathName(candidateFilePath);
415 416 417 418 419 420 421
            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();
            }
422
        }
423 424
    }

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
    // 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
    CppModelManager *modelManager = CppModelManager::instance();
    QList<CppModelManagerInterface::ProjectInfo> projectInfos = modelManager->projectInfos();
    foreach (const CppModelManagerInterface::ProjectInfo &projectInfo, projectInfos) {
        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
445
    }
446

con's avatar
con committed
447 448 449
    return QString();
}

450
} // namespace CppTools
con's avatar
con committed
451

452
Q_EXPORT_PLUGIN(CppTools::Internal::CppToolsPlugin)