environment.cpp 16.3 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
Eike Ziller's avatar
Eike Ziller committed
3 4
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
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
** 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
Eike Ziller's avatar
Eike Ziller committed
12 13
** a written agreement between you and The Qt Company.  For licensing terms and
** conditions see http://www.qt.io/terms-conditions.  For further information
Eike Ziller's avatar
Eike Ziller committed
14
** use the contact form at http://www.qt.io/contact-us.
15
**
16
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17
** Alternatively, this file may be used under the terms of the GNU Lesser
Eike Ziller's avatar
Eike Ziller committed
18 19 20 21 22 23
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
hjk's avatar
hjk committed
24
**
Eike Ziller's avatar
Eike Ziller committed
25 26
** In addition, as a special exception, The Qt Company gives you certain additional
** rights.  These rights are described in The Qt Company LGPL Exception
con's avatar
con committed
27 28
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
29
****************************************************************************/
hjk's avatar
hjk committed
30

con's avatar
con committed
31 32
#include "environment.h"

33
#include <QDir>
34
#include <QProcessEnvironment>
35
#include <QSet>
36 37 38 39 40 41
#include <QCoreApplication>

class SystemEnvironment : public Utils::Environment
{
public:
    SystemEnvironment()
42
        : Environment(QProcessEnvironment::systemEnvironment().toStringList())
43
    {
44 45 46
        if (Utils::HostOsInfo::isLinuxHost()) {
            QString ldLibraryPath = value(QLatin1String("LD_LIBRARY_PATH"));
            QDir lib(QCoreApplication::applicationDirPath());
47
            lib.cd(QLatin1String("../lib"));
48
            QString toReplace = lib.path();
49
            lib.cd(QLatin1String("qtcreator"));
50
            toReplace.append(QLatin1Char(':'));
51 52 53 54 55
            toReplace.append(lib.path());

            if (ldLibraryPath.startsWith(toReplace))
                set(QLatin1String("LD_LIBRARY_PATH"), ldLibraryPath.remove(0, toReplace.length()));
        }
56 57 58 59
    }
};

Q_GLOBAL_STATIC(SystemEnvironment, staticSystemEnvironment)
con's avatar
con committed
60

hjk's avatar
hjk committed
61
namespace Utils {
con's avatar
con committed
62

63 64 65 66 67 68 69 70 71 72
static bool sortEnvironmentItem(const EnvironmentItem &a, const EnvironmentItem &b)
{
    return a.name < b.name;
}

void EnvironmentItem::sort(QList<EnvironmentItem> *list)
{
    qSort(list->begin(), list->end(), &sortEnvironmentItem);
}

hjk's avatar
hjk committed
73
QList<EnvironmentItem> EnvironmentItem::fromStringList(const QStringList &list)
con's avatar
con committed
74 75 76
{
    QList<EnvironmentItem> result;
    foreach (const QString &string, list) {
77
        int pos = string.indexOf(QLatin1Char('='), 1);
hjk's avatar
hjk committed
78
        if (pos == -1) {
79
            EnvironmentItem item(string, QString());
con's avatar
con committed
80 81 82 83 84 85 86 87 88 89
            item.unset = true;
            result.append(item);
        } else {
            EnvironmentItem item(string.left(pos), string.mid(pos+1));
            result.append(item);
        }
    }
    return result;
}

hjk's avatar
hjk committed
90
QStringList EnvironmentItem::toStringList(const QList<EnvironmentItem> &list)
con's avatar
con committed
91 92 93
{
    QStringList result;
    foreach (const EnvironmentItem &item, list) {
hjk's avatar
hjk committed
94
        if (item.unset)
con's avatar
con committed
95 96
            result << QString(item.name);
        else
97
            result << QString(item.name + QLatin1Char('=') + item.value);
con's avatar
con committed
98 99 100 101
    }
    return result;
}

102
Environment::Environment(const QStringList &env, OsType osType) : m_osType(osType)
con's avatar
con committed
103
{
hjk's avatar
hjk committed
104
    foreach (const QString &s, env) {
105
        int i = s.indexOf(QLatin1Char('='), 1);
hjk's avatar
hjk committed
106
        if (i >= 0) {
107
            if (m_osType == OsTypeWindows)
108 109 110
                m_values.insert(s.left(i).toUpper(), s.mid(i+1));
            else
                m_values.insert(s.left(i), s.mid(i+1));
con's avatar
con committed
111 112 113 114
        }
    }
}

115
QStringList Environment::toStringList() const
con's avatar
con committed
116 117
{
    QStringList result;
118 119 120 121 122 123 124
    const QMap<QString, QString>::const_iterator end = m_values.constEnd();
    for (QMap<QString, QString>::const_iterator it = m_values.constBegin(); it != end; ++it) {
        QString entry = it.key();
        entry += QLatin1Char('=');
        entry += it.value();
        result.push_back(entry);
    }
con's avatar
con committed
125 126 127
    return result;
}

128 129 130 131 132 133 134 135 136
QProcessEnvironment Environment::toProcessEnvironment() const
{
    QProcessEnvironment result;
    const QMap<QString, QString>::const_iterator end = m_values.constEnd();
    for (QMap<QString, QString>::const_iterator it = m_values.constBegin(); it != end; ++it)
        result.insert(it.key(), it.value());
    return result;
}

con's avatar
con committed
137 138
void Environment::set(const QString &key, const QString &value)
{
139
    m_values.insert(m_osType == OsTypeWindows ? key.toUpper() : key, value);
con's avatar
con committed
140 141 142 143
}

void Environment::unset(const QString &key)
{
144
    m_values.remove(m_osType == OsTypeWindows ? key.toUpper() : key);
con's avatar
con committed
145 146 147 148
}

void Environment::appendOrSet(const QString &key, const QString &value, const QString &sep)
{
149
    const QString &_key = m_osType == OsTypeWindows ? key.toUpper() : key;
150
    QMap<QString, QString>::iterator it = m_values.find(_key);
151
    if (it == m_values.end()) {
con's avatar
con committed
152 153
        m_values.insert(_key, value);
    } else {
154 155 156 157
        // Append unless it is already there
        const QString toAppend = sep + value;
        if (!it.value().endsWith(toAppend))
            it.value().append(toAppend);
con's avatar
con committed
158 159 160 161 162
    }
}

void Environment::prependOrSet(const QString&key, const QString &value, const QString &sep)
{
163
    const QString &_key = m_osType == OsTypeWindows ? key.toUpper() : key;
164
    QMap<QString, QString>::iterator it = m_values.find(_key);
165
    if (it == m_values.end()) {
con's avatar
con committed
166 167
        m_values.insert(_key, value);
    } else {
168 169 170 171
        // Prepend unless it is already there
        const QString toPrepend = value + sep;
        if (!it.value().startsWith(toPrepend))
            it.value().prepend(toPrepend);
con's avatar
con committed
172 173 174 175 176
    }
}

void Environment::appendOrSetPath(const QString &value)
{
177
    appendOrSet(QLatin1String("PATH"), QDir::toNativeSeparators(value),
178
            QString(OsSpecificAspects(m_osType).pathListSeparator()));
con's avatar
con committed
179 180 181 182
}

void Environment::prependOrSetPath(const QString &value)
{
183
    prependOrSet(QLatin1String("PATH"), QDir::toNativeSeparators(value),
184
            QString(OsSpecificAspects(m_osType).pathListSeparator()));
con's avatar
con committed
185 186
}

187 188
void Environment::prependOrSetLibrarySearchPath(const QString &value)
{
189
    switch (m_osType) {
190
    case OsTypeWindows: {
191 192 193 194 195
        const QChar sep = QLatin1Char(';');
        const QLatin1String path("PATH");
        prependOrSet(path, QDir::toNativeSeparators(value), QString(sep));
        break;
    }
196 197
    case OsTypeLinux:
    case OsTypeOtherUnix: {
198 199 200 201 202 203 204 205
        const QChar sep = QLatin1Char(':');
        const QLatin1String path("LD_LIBRARY_PATH");
        prependOrSet(path, QDir::toNativeSeparators(value), QString(sep));
        break;
    }
    default: // we could set DYLD_LIBRARY_PATH on Mac but it is unnecessary in practice
        break;
    }
206 207
}

con's avatar
con committed
208 209
Environment Environment::systemEnvironment()
{
210
    return *staticSystemEnvironment();
con's avatar
con committed
211 212 213 214 215 216 217
}

void Environment::clear()
{
    m_values.clear();
}

218
FileName Environment::searchInDirectory(const QStringList &execs, QString directory) const
219 220 221
{
    const QChar slash = QLatin1Char('/');
    if (directory.isEmpty())
222
        return FileName();
223 224 225 226 227 228 229 230
    // Avoid turing / into // on windows which triggers windows to check
    // for network drives!
    if (!directory.endsWith(slash))
        directory += slash;

    foreach (const QString &exec, execs) {
        QFileInfo fi(directory + exec);
        if (fi.exists() && fi.isFile() && fi.isExecutable())
231
            return FileName::fromString(fi.absoluteFilePath());
232
    }
233
    return FileName();
234 235
}

236
QStringList Environment::appendExeExtensions(const QString &executable) const
con's avatar
con committed
237
{
238 239
    QFileInfo fi(executable);
    QStringList execs(executable);
240
    if (m_osType == OsTypeWindows) {
241
        // Check all the executable extensions on windows:
242 243 244
        // PATHEXT is only used if the executable has no extension
        if (fi.suffix().isEmpty()) {
            QStringList extensions = value(QLatin1String("PATHEXT")).split(QLatin1Char(';'));
245

246 247
            foreach (const QString &ext, extensions)
                execs << executable + ext.toLower();
248
        }
249
    }
250 251 252 253 254 255 256 257
    return execs;
}

FileName Environment::searchInPath(const QString &executable,
                                   const QStringList &additionalDirs) const
{
    if (executable.isEmpty())
        return FileName();
258

259 260 261 262 263 264 265 266 267
    QString exec = QDir::cleanPath(expandVariables(executable));
    QFileInfo fi(exec);

    QStringList execs = appendExeExtensions(exec);

    if (fi.isAbsolute()) {
        foreach (const QString &path, execs)
            if (QFile::exists(path))
                return FileName::fromString(path);
268
        return FileName::fromString(exec);
269
    }
270

271
    QSet<QString> alreadyChecked;
272
    foreach (const QString &dir, additionalDirs) {
273 274 275
        if (alreadyChecked.contains(dir))
            continue;
        alreadyChecked.insert(dir);
276
        FileName tmp = searchInDirectory(execs, dir);
277 278 279
        if (!tmp.isEmpty())
            return tmp;
    }
280

281
    if (executable.indexOf(QLatin1Char('/')) != -1)
282
        return FileName();
283 284

    foreach (const QString &p, path()) {
285 286 287
        if (alreadyChecked.contains(p))
            continue;
        alreadyChecked.insert(p);
288
        FileName tmp = searchInDirectory(execs, QDir::fromNativeSeparators(p));
289 290
        if (!tmp.isEmpty())
            return tmp;
291
    }
292
    return FileName();
con's avatar
con committed
293 294 295 296
}

QStringList Environment::path() const
{
297 298
    return m_values.value(QLatin1String("PATH"))
            .split(OsSpecificAspects(m_osType).pathListSeparator(), QString::SkipEmptyParts);
con's avatar
con committed
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
}

QString Environment::value(const QString &key) const
{
    return m_values.value(key);
}

QString Environment::key(Environment::const_iterator it) const
{
    return it.key();
}

QString Environment::value(Environment::const_iterator it) const
{
    return it.value();
}

Environment::const_iterator Environment::constBegin() const
{
    return m_values.constBegin();
}

Environment::const_iterator Environment::constEnd() const
{
    return m_values.constEnd();
}

326
Environment::const_iterator Environment::constFind(const QString &name) const
con's avatar
con committed
327 328
{
    QMap<QString, QString>::const_iterator it = m_values.constFind(name);
hjk's avatar
hjk committed
329
    if (it == m_values.constEnd())
con's avatar
con committed
330 331 332 333 334 335 336 337 338 339 340 341 342 343
        return constEnd();
    else
        return it;
}

int Environment::size() const
{
    return m_values.size();
}

void Environment::modify(const QList<EnvironmentItem> & list)
{
    Environment resultEnvironment = *this;
    foreach (const EnvironmentItem &item, list) {
hjk's avatar
hjk committed
344
        if (item.unset) {
con's avatar
con committed
345 346 347 348
            resultEnvironment.unset(item.name);
        } else {
            // TODO use variable expansion
            QString value = item.value;
hjk's avatar
hjk committed
349 350 351
            for (int i=0; i < value.size(); ++i) {
                if (value.at(i) == QLatin1Char('$')) {
                    if ((i + 1) < value.size()) {
con's avatar
con committed
352 353
                        const QChar &c = value.at(i+1);
                        int end = -1;
354 355 356 357
                        if (c == QLatin1Char('('))
                            end = value.indexOf(QLatin1Char(')'), i);
                        else if (c == QLatin1Char('{'))
                            end = value.indexOf(QLatin1Char('}'), i);
hjk's avatar
hjk committed
358
                        if (end != -1) {
con's avatar
con committed
359
                            const QString &name = value.mid(i+2, end-i-2);
360
                            Environment::const_iterator it = constFind(name);
hjk's avatar
hjk committed
361
                            if (it != constEnd())
con's avatar
con committed
362 363 364 365 366 367 368 369 370 371 372
                                value.replace(i, end-i+1, it.value());
                        }
                    }
                }
            }
            resultEnvironment.set(item.name, value);
        }
    }
    *this = resultEnvironment;
}

373 374 375 376 377 378 379 380
QList<EnvironmentItem> Environment::diff(const Environment &other) const
{
    QMap<QString, QString>::const_iterator thisIt = constBegin();
    QMap<QString, QString>::const_iterator otherIt = other.constBegin();

    QList<EnvironmentItem> result;
    while (thisIt != constEnd() || otherIt != other.constEnd()) {
        if (thisIt == constEnd()) {
381
            result.append(EnvironmentItem(otherIt.key(), otherIt.value()));
382 383
            ++otherIt;
        } else if (otherIt == constEnd()) {
384
            EnvironmentItem item(thisIt.key(), QString());
385 386 387 388
            item.unset = true;
            result.append(item);
            ++thisIt;
        } else if (thisIt.key() < otherIt.key()) {
389
            EnvironmentItem item(thisIt.key(), QString());
390 391 392 393
            item.unset = true;
            result.append(item);
            ++thisIt;
        } else if (thisIt.key() > otherIt.key()) {
394
            result.append(EnvironmentItem(otherIt.key(), otherIt.value()));
395 396
            ++otherIt;
        } else {
397
            result.append(EnvironmentItem(otherIt.key(), otherIt.value()));
398 399 400 401 402 403 404
            ++otherIt;
            ++thisIt;
        }
    }
    return result;
}

405
bool Environment::hasKey(const QString &key) const
406 407 408 409
{
    return m_values.contains(key);
}

410 411
QString Environment::userName() const
{
412
    return value(QLatin1String(m_osType == OsTypeWindows ? "USERNAME" : "USER"));
413 414
}

415
bool Environment::operator!=(const Environment &other) const
416 417 418 419
{
    return !(*this == other);
}

420
bool Environment::operator==(const Environment &other) const
421
{
422
    return m_osType == other.m_osType && m_values == other.m_values;
423 424
}

425 426 427
/** Expand environment variables in a string.
 *
 * Environment variables are accepted in the following forms:
428 429 430
 * $SOMEVAR, ${SOMEVAR} on Unix and %SOMEVAR% on Windows.
 * No escapes and quoting are supported.
 * If a variable is not found, it is not substituted.
431 432 433
 */
QString Environment::expandVariables(const QString &input) const
{
434 435
    QString result = input;

436
    if (m_osType == OsTypeWindows) {
437 438 439 440 441 442 443 444 445 446 447
        for (int vStart = -1, i = 0; i < result.length(); ) {
            if (result.at(i++) == QLatin1Char('%')) {
                if (vStart > 0) {
                    const_iterator it = m_values.constFind(result.mid(vStart, i - vStart - 1).toUpper());
                    if (it != m_values.constEnd()) {
                        result.replace(vStart - 1, i - vStart + 1, *it);
                        i = vStart - 1 + it->length();
                        vStart = -1;
                    } else {
                        vStart = i;
                    }
448 449 450 451 452
                } else {
                    vStart = i;
                }
            }
        }
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
    } else {
        enum { BASE, OPTIONALVARIABLEBRACE, VARIABLE, BRACEDVARIABLE } state = BASE;
        int vStart = -1;

        for (int i = 0; i < result.length();) {
            QChar c = result.at(i++);
            if (state == BASE) {
                if (c == QLatin1Char('$'))
                    state = OPTIONALVARIABLEBRACE;
            } else if (state == OPTIONALVARIABLEBRACE) {
                if (c == QLatin1Char('{')) {
                    state = BRACEDVARIABLE;
                    vStart = i;
                } else if (c.isLetterOrNumber() || c == QLatin1Char('_')) {
                    state = VARIABLE;
                    vStart = i - 1;
                } else {
                    state = BASE;
471
                }
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
            } else if (state == BRACEDVARIABLE) {
                if (c == QLatin1Char('}')) {
                    const_iterator it = m_values.constFind(result.mid(vStart, i - 1 - vStart));
                    if (it != constEnd()) {
                        result.replace(vStart - 2, i - vStart + 2, *it);
                        i = vStart - 2 + it->length();
                    }
                    state = BASE;
                }
            } else if (state == VARIABLE) {
                if (!c.isLetterOrNumber() && c != QLatin1Char('_')) {
                    const_iterator it = m_values.constFind(result.mid(vStart, i - vStart - 1));
                    if (it != constEnd()) {
                        result.replace(vStart - 1, i - vStart, *it);
                        i = vStart - 1 + it->length();
                    }
                    state = BASE;
489
                }
490 491
            }
        }
492 493 494 495 496
        if (state == VARIABLE) {
            const_iterator it = m_values.constFind(result.mid(vStart));
            if (it != constEnd())
                result.replace(vStart - 1, result.length() - vStart + 1, *it);
        }
497 498 499
    }
    return result;
}
500 501 502 503

QStringList Environment::expandVariables(const QStringList &variables) const
{
    QStringList results;
hjk's avatar
hjk committed
504
    foreach (const QString &i, variables)
505 506 507
        results << expandVariables(i);
    return results;
}
hjk's avatar
hjk committed
508 509

} // namespace Utils