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()));
142
143
144
145
    connect(DocumentManager::instance(), &DocumentManager::filesChangedInternally,
            [=](const QStringList &files) {
        modelManager->updateSourceFiles(files.toSet());
    });
Roberto Raggi's avatar
Roberto Raggi committed
146

147
148
149
150
151
152
153
    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)));

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

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

    // Actions
173
    Context context(CppEditor::Constants::CPPEDITOR_ID);
con's avatar
con committed
174
175

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

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

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

con's avatar
con committed
196
197
198
199
200
    return true;
}

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

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

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

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

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

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

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

    if (!project)
244
        return QStringList();
245
246
247
248
249

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

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

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

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

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

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

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

366
367
368
} // namespace Internal

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

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

    if (debug)
381
        qDebug() << Q_FUNC_INFO << fileName <<  kind;
con's avatar
con committed
382

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

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

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

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

410
411
    candidateFileNames += baseNamesWithAllPrefixes(candidateFileNames, isHeader);

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

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

con's avatar
con committed
450
451
452
    return QString();
}

453
} // namespace CppTools