clangparsingenvironment.cpp 4.41 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
57
    PathType ret;
    ret.project.reserve(paths.size());
    ret.system.reserve(paths.size());
    foreach (const auto& path, paths) {
58
        bool inProject = false;
59
        foreach (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
void ClangParsingEnvironment::setTranslationUnitUrl(const IndexedString& url)
107
{
108
    m_tuUrl = url;
109
110
}

111
IndexedString ClangParsingEnvironment::translationUnitUrl() const
112
{
113
114
115
116
117
118
119
120
121
122
123
    return m_tuUrl;
}

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

ClangParsingEnvironment::Quality ClangParsingEnvironment::quality() const
{
    return m_quality;
124
125
126
127
128
129
}

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

131
132
133
    for (auto it = m_defines.constBegin(); it != m_defines.constEnd(); ++it) {
        hash << qHash(it.key()) << qHash(it.value());
    }
134

135
136
137
138
    hash << m_includes.size();
    for (const auto& include : m_includes) {
        hash << qHash(include);
    }
139

140
141
142
143
144
    hash << m_frameworkDirectories.size();
    for (const auto& fwDir : m_frameworkDirectories) {
        hash << qHash(fwDir);
    }

145
    hash << qHash(m_pchInclude);
146
    hash << qHash(m_parserSettings.parserOptions);
147
148
149
150
151
152
153
    return hash;
}

bool ClangParsingEnvironment::operator==(const ClangParsingEnvironment& other) const
{
    return m_defines == other.m_defines
        && m_includes == other.m_includes
154
        && m_frameworkDirectories == other.m_frameworkDirectories
155
        && m_pchInclude == other.m_pchInclude
156
        && m_quality == other.m_quality
157
        && m_tuUrl == other.m_tuUrl
158
        && m_parserSettings == other.m_parserSettings;
159
160
}

161
void ClangParsingEnvironment::setParserSettings(const ParserSettings& parserSettings)
162
{
163
    m_parserSettings = parserSettings;
164
165
}

166
ParserSettings ClangParsingEnvironment::parserSettings() const
167
{
168
    return m_parserSettings;
169
}