clangparsingenvironment.cpp 4.76 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * This file is part of KDevelop
 *
 * Copyright 2014 Milian Wolff <mail@milianw.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "clangparsingenvironment.h"

using namespace KDevelop;

int ClangParsingEnvironment::type() const
{
    return CppParsingEnvironment;
}

31
32
33
34
35
36
37
38
39
40
void ClangParsingEnvironment::setProjectPaths(const Path::List& projectPaths)
{
    m_projectPaths = projectPaths;
}

Path::List ClangParsingEnvironment::projectPaths() const
{
    return m_projectPaths;
}

41
42
43
44
45
void ClangParsingEnvironment::addIncludes(const Path::List& includes)
{
    m_includes += includes;
}

46
47
48
49
50
51
52
void ClangParsingEnvironment::addFrameworkDirectories(const KDevelop::Path::List& frameworkDirectories)
{
    m_frameworkDirectories += frameworkDirectories;
}

template <typename PathType>
static PathType appendPaths(const KDevelop::Path::List &paths, const KDevelop::Path::List &projectPaths)
53
{
54
55
56
    PathType ret;
    ret.project.reserve(paths.size());
    ret.system.reserve(paths.size());
57
    for (const auto& path : paths) {
58
        bool inProject = false;
59
        for (const auto& project : projectPaths) {
60
61
62
63
64
65
66
67
68
69
70
71
            if (project.isParentOf(path) || project == path) {
                inProject = true;
                break;
            }
        }
        if (inProject) {
            ret.project.append(path);
        } else {
            ret.system.append(path);
        }
    }
    return ret;
72
73
}

74
75
76
77
78
79
80
81
82
83
ClangParsingEnvironment::IncludePaths ClangParsingEnvironment::includes() const
{
    return appendPaths<IncludePaths>(m_includes, m_projectPaths);
}

ClangParsingEnvironment::FrameworkDirectories ClangParsingEnvironment::frameworkDirectories() const
{
    return appendPaths<FrameworkDirectories>(m_frameworkDirectories, m_projectPaths);
}

84
85
void ClangParsingEnvironment::addDefines(const QHash<QString, QString>& defines)
{
86
87
88
    for (auto it = defines.constBegin(); it != defines.constEnd(); ++it) {
        m_defines[it.key()] = it.value();
    }
89
90
}

91
QMap<QString, QString> ClangParsingEnvironment::defines() const
92
93
94
95
96
97
98
99
100
101
102
103
104
105
{
    return m_defines;
}

void ClangParsingEnvironment::setPchInclude(const Path& path)
{
    m_pchInclude = path;
}

Path ClangParsingEnvironment::pchInclude() const
{
    return m_pchInclude;
}

106
107
108
109
110
111
112
113
114
115
void ClangParsingEnvironment::setWorkingDirectory(const Path& path)
{
    m_workingDirectory = path;
}

Path ClangParsingEnvironment::workingDirectory() const
{
    return m_workingDirectory;
}

116
void ClangParsingEnvironment::setTranslationUnitUrl(const IndexedString& url)
117
{
118
    m_tuUrl = url;
119
120
}

121
IndexedString ClangParsingEnvironment::translationUnitUrl() const
122
{
123
124
125
126
127
128
129
130
131
132
133
    return m_tuUrl;
}

void ClangParsingEnvironment::setQuality(Quality quality)
{
    m_quality = quality;
}

ClangParsingEnvironment::Quality ClangParsingEnvironment::quality() const
{
    return m_quality;
134
135
136
137
138
139
}

uint ClangParsingEnvironment::hash() const
{
    KDevHash hash;
    hash << m_defines.size();
140

141
142
143
    for (auto it = m_defines.constBegin(); it != m_defines.constEnd(); ++it) {
        hash << qHash(it.key()) << qHash(it.value());
    }
144

145
146
147
148
    hash << m_includes.size();
    for (const auto& include : m_includes) {
        hash << qHash(include);
    }
149

150
151
152
153
154
    hash << m_frameworkDirectories.size();
    for (const auto& fwDir : m_frameworkDirectories) {
        hash << qHash(fwDir);
    }

155
    hash << qHash(m_pchInclude);
156
    hash << qHash(m_parserSettings.parserOptions);
157
158
159
160
161
162
163
    return hash;
}

bool ClangParsingEnvironment::operator==(const ClangParsingEnvironment& other) const
{
    return m_defines == other.m_defines
        && m_includes == other.m_includes
164
        && m_frameworkDirectories == other.m_frameworkDirectories
165
        && m_pchInclude == other.m_pchInclude
166
        && m_quality == other.m_quality
167
        && m_tuUrl == other.m_tuUrl
168
        && m_parserSettings == other.m_parserSettings;
169
170
}

171
void ClangParsingEnvironment::setParserSettings(const ParserSettings& parserSettings)
172
{
173
    m_parserSettings = parserSettings;
174
175
}

176
ParserSettings ClangParsingEnvironment::parserSettings() const
177
{
178
    return m_parserSettings;
179
}
180
181
182
183
184
185

void ClangParsingEnvironment::addParserArguments(const QString& parserArguments)
{
    m_parserSettings.parserOptions += QLatin1Char(' ') + parserArguments;
}