feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
b92c22a1025c3100e9f4060fea2824d3dc86d79a
qt-creator/src/plugins/projectexplorer/customparser.cpp

686 lines
24 KiB
C++
Raw Normal View History

Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
/****************************************************************************
**
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** Copyright (C) 2016 Andre Hartmann.
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
** Contact: aha_1980@gmx.de
**
** This file is part of Qt Creator.
**
** 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
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
**
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
**
****************************************************************************/
#include "customparser.h"
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
#include "projectexplorerconstants.h"
ProjectExplorer: Fix release build And compile on macOS. Amends c15e09e0fe880c5. Change-Id: I39395f341e8590104dd96348aa8fc12d437dbd28 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2020-05-12 08:32:38 +02:00
#include "projectexplorer.h"
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
#include "task.h"
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
#include <coreplugin/icore.h>
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
#include <utils/qtcassert.h>
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
#include <QCheckBox>
#include <QLabel>
#include <QPair>
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
#include <QString>
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
#include <QVBoxLayout>
#ifdef WITH_TESTS
# include <QTest>
# include "projectexplorer.h"
# include "outputparser_test.h"
#endif
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
ProjectExplorer: Remove unneeded qualifications Mostly done using the following ruby script: Dir.glob('**/*.cpp').each { |file| next if file =~ %r{src/shared/qbs|/qmljs/} s = File.read(file) s.scan(/^using namespace (.*);$/) { ns = $1 t = s.gsub(/^(.*)\b#{ns}::((?!Const)[A-Z])/) { |m| before = $1 char = $2 if before =~ /"|\/\/|\\|using|SIGNAL|SLOT|Q_/ m else before + char end } if t != s puts file File.open(file, 'w').write(t) end } } Change-Id: I1d05d48b23f44e3d589cc2a790803714786b57d2 Reviewed-by: Christian Kandeler <christian.kandeler@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2015-02-03 23:59:04 +02:00
using namespace Utils;
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
const char idKey[] = "Id";
const char nameKey[] = "Name";
const char errorKey[] = "Error";
const char warningKey[] = "Warning";
const char patternKey[] = "Pattern";
const char lineNumberCapKey[] = "LineNumberCap";
const char fileNameCapKey[] = "FileNameCap";
const char messageCapKey[] = "MessageCap";
const char channelKey[] = "Channel";
const char exampleKey[] = "Example";
namespace ProjectExplorer {
namespace Internal {
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
bool CustomParserExpression::operator ==(const CustomParserExpression &other) const
{
return pattern() == other.pattern() && fileNameCap() == other.fileNameCap()
&& lineNumberCap() == other.lineNumberCap() && messageCap() == other.messageCap()
&& channel() == other.channel() && example() == other.example();
}
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QString CustomParserExpression::pattern() const
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
return m_regExp.pattern();
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
void CustomParserExpression::setPattern(const QString &pattern)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
m_regExp.setPattern(pattern);
QTC_CHECK(m_regExp.isValid());
}
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
CustomParserExpression::CustomParserChannel CustomParserExpression::channel() const
{
return m_channel;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
void CustomParserExpression::setChannel(CustomParserExpression::CustomParserChannel channel)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTC_ASSERT(channel > ParseNoChannel && channel <= ParseBothChannels,
channel = ParseBothChannels);
m_channel = channel;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QString CustomParserExpression::example() const
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
return m_example;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
void CustomParserExpression::setExample(const QString &example)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
m_example = example;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
int CustomParserExpression::messageCap() const
{
return m_messageCap;
}
void CustomParserExpression::setMessageCap(int messageCap)
{
m_messageCap = messageCap;
}
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
QVariantMap CustomParserExpression::toMap() const
{
QVariantMap map;
map.insert(patternKey, pattern());
map.insert(messageCapKey, messageCap());
map.insert(fileNameCapKey, fileNameCap());
map.insert(lineNumberCapKey, lineNumberCap());
map.insert(exampleKey, example());
map.insert(channelKey, channel());
return map;
}
void CustomParserExpression::fromMap(const QVariantMap &map)
{
setPattern(map.value(patternKey).toString());
setMessageCap(map.value(messageCapKey).toInt());
setFileNameCap(map.value(fileNameCapKey).toInt());
setLineNumberCap(map.value(lineNumberCapKey).toInt());
setExample(map.value(exampleKey).toString());
int channel = map.value(channelKey).toInt();
if (channel == ParseNoChannel || channel > ParseBothChannels)
channel = ParseStdErrChannel;
setChannel(static_cast<CustomParserChannel>(channel));
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
int CustomParserExpression::lineNumberCap() const
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
return m_lineNumberCap;
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
void CustomParserExpression::setLineNumberCap(int lineNumberCap)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
m_lineNumberCap = lineNumberCap;
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
int CustomParserExpression::fileNameCap() const
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
return m_fileNameCap;
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
void CustomParserExpression::setFileNameCap(int fileNameCap)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
m_fileNameCap = fileNameCap;
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
bool CustomParserSettings::operator ==(const CustomParserSettings &other) const
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
return id == other.id && displayName == other.displayName
&& error == other.error && warning == other.warning;
}
QVariantMap CustomParserSettings::toMap() const
{
QVariantMap map;
map.insert(idKey, id.toSetting());
map.insert(nameKey, displayName);
map.insert(errorKey, error.toMap());
map.insert(warningKey, warning.toMap());
return map;
}
void CustomParserSettings::fromMap(const QVariantMap &map)
{
id = Core::Id::fromSetting(map.value(idKey));
displayName = map.value(nameKey).toString();
error.fromMap(map.value(errorKey).toMap());
warning.fromMap(map.value(warningKey).toMap());
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
CustomParser::CustomParser(const CustomParserSettings &settings)
{
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
setObjectName("CustomParser");
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
setSettings(settings);
}
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
void CustomParser::setSettings(const CustomParserSettings &settings)
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
m_error = settings.error;
m_warning = settings.warning;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
CustomParser *CustomParser::createFromId(Core::Id id)
{
const Internal::CustomParserSettings parser = findOrDefault(ProjectExplorerPlugin::customParsers(),
[id](const Internal::CustomParserSettings &p) { return p.id == id; });
if (parser.id.isValid())
return new CustomParser(parser);
return nullptr;
}
CustomToolChain: Allow MSVC output parser on non-Windows systems To do that, move the existing enumeration-based system to a string base. MSVC/Windows and Custom/Unix shared the same enumeration value (3), so we must provide an operating system aware upgrade path. Task-number: QTCREATORBUG-16247 Change-Id: I8beeeabc09119fc501933a7287f2f982195363a2 Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
2017-04-14 21:45:41 +02:00
Core::Id CustomParser::id()
{
return Core::Id("ProjectExplorer.OutputParser.Custom");
}
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
OutputLineParser::Result CustomParser::handleLine(const QString &line, OutputFormat type)
IOutputParser: Replace std{Out,Err} with a single parameterized function Another step towards parser/formatter unification. Task-number: QTCREATORBUG-22665 Change-Id: I6de86b3aee2c54585cdd4b06d21b0ea67300aeac Reviewed-by: hjk <hjk@qt.io>
2020-04-08 09:42:51 +02:00
{
const CustomParserExpression::CustomParserChannel channel = type == StdErrFormat
? CustomParserExpression::ParseStdErrChannel
: CustomParserExpression::ParseStdOutChannel;
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
return parseLine(line, channel);
IOutputParser: Replace std{Out,Err} with a single parameterized function Another step towards parser/formatter unification. Task-number: QTCREATORBUG-22665 Change-Id: I6de86b3aee2c54585cdd4b06d21b0ea67300aeac Reviewed-by: hjk <hjk@qt.io>
2020-04-08 09:42:51 +02:00
}
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
OutputLineParser::Result CustomParser::hasMatch(
const QString &line,
CustomParserExpression::CustomParserChannel channel,
const CustomParserExpression &expression,
Task::TaskType taskType
)
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
{
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
if (!(channel & expression.channel()))
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
return Status::NotHandled;
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
if (expression.pattern().isEmpty())
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
return Status::NotHandled;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
const QRegularExpressionMatch match = expression.match(line);
CustomParser: Use QRegularExpression instead of QRegExp Change-Id: I952f61a30435b26bf5c77f0b219ddc3b17b0c2e4 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 18:51:32 +01:00
if (!match.hasMatch())
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
return Status::NotHandled;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
Output parsers: Generalize the search directory concept All parsers can now have search directories, not just the GnuMakeParser. This allows us to get rid of the "task mangling", removing another instance where the order of parsers in the chain mattered. Task-number: QTCREATORBUG-22665 Change-Id: Id0d55522ae6800afd9f50ff36546224b0d8bb382 Reviewed-by: hjk <hjk@qt.io>
2020-04-07 13:49:34 +02:00
const FilePath fileName = absoluteFilePath(FilePath::fromString(
match.captured(expression.fileNameCap())));
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
const int lineNumber = match.captured(expression.lineNumberCap()).toInt();
const QString message = match.captured(expression.messageCap());
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
LinkSpecs linkSpecs;
addLinkSpecForAbsoluteFilePath(linkSpecs, fileName, lineNumber, match,
expression.fileNameCap());
scheduleTask(CompileTask(taskType, message, fileName, lineNumber), 1);
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
return {Status::Done, linkSpecs};
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
}
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
OutputLineParser::Result CustomParser::parseLine(
const QString &rawLine,
CustomParserExpression::CustomParserChannel channel
)
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
{
const QString line = rawLine.trimmed();
Merge output formatters and output parsers Now only one piece of code needs to be written to both linkify output in an output pane and create tasks for it in the issues pane. The calling sites are also simplified. For instance, until now, build steps had to feed their output parsers manually and then push the created tasks up the signal stack in parallel with the actual output, which the build manager relied upon for cross-linking the output pane content. Afterwards, the output would get forwarded to the formatter (and parsed for ANSI escape codes a second time). In contrast, a build step now just forwards the process output, and task parsing as well as output formatting is done centrally further up the stack. Concrete user-visible improvements so far: - File paths in compiler/linker messages are clickable links now. - QtTest applications now create clickable links also when run as part of a build step, not just in the app output pane. Task-number: QTCREATORBUG-22665 Change-Id: Ic9fb95b2d97f2520ab3ec653315e9219466ec08d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2020-04-16 13:53:05 +02:00
const Result res = hasMatch(line, channel, m_error, Task::Error);
if (res.status != Status::NotHandled)
return res;
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
return hasMatch(line, channel, m_warning, Task::Warning);
}
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
namespace {
class SelectionWidget : public QWidget
{
Q_OBJECT
public:
SelectionWidget(QWidget *parent = nullptr) : QWidget(parent)
{
const auto layout = new QVBoxLayout(this);
const auto explanatoryLabel = new QLabel(tr(
"Custom output parsers scan command line output for user-provided error patterns<br>"
"in order to create entries in the issues pane.<br>"
"The parsers can be configured <a href=\"dummy\">here</a>."));
layout->addWidget(explanatoryLabel);
connect(explanatoryLabel, &QLabel::linkActivated, [] {
Core::ICore::showOptionsDialog(Constants::CUSTOM_PARSERS_SETTINGS_PAGE_ID);
});
updateUi();
connect(ProjectExplorerPlugin::instance(), &ProjectExplorerPlugin::customParsersChanged,
this, &SelectionWidget::updateUi);
}
void setSelectedParsers(const QList<Core::Id> &parsers)
{
for (const auto &p : qAsConst(parserCheckBoxes))
p.first->setChecked(parsers.contains(p.second));
emit selectionChanged();
}
QList<Core::Id> selectedParsers() const
{
QList<Core::Id> parsers;
for (const auto &p : qAsConst(parserCheckBoxes)) {
if (p.first->isChecked())
parsers << p.second;
}
return parsers;
}
signals:
void selectionChanged();
private:
void updateUi()
{
const auto layout = qobject_cast<QVBoxLayout *>(this->layout());
QTC_ASSERT(layout, return);
const QList<Core::Id> parsers = selectedParsers();
for (const auto &p : qAsConst(parserCheckBoxes))
delete p.first;
parserCheckBoxes.clear();
for (const CustomParserSettings &s : ProjectExplorerPlugin::customParsers()) {
const auto checkBox = new QCheckBox(s.displayName, this);
connect(checkBox, &QCheckBox::stateChanged,
this, &SelectionWidget::selectionChanged);
parserCheckBoxes << qMakePair(checkBox, s.id);
layout->addWidget(checkBox);
}
setSelectedParsers(parsers);
}
QList<QPair<QCheckBox *, Core::Id>> parserCheckBoxes;
};
} // anonymous namespace
CustomParsersSelectionWidget::CustomParsersSelectionWidget(QWidget *parent) : DetailsWidget(parent)
{
const auto widget = new SelectionWidget(this);
connect(widget, &SelectionWidget::selectionChanged, [this] {
updateSummary();
emit selectionChanged();
});
setWidget(widget);
updateSummary();
}
void CustomParsersSelectionWidget::setSelectedParsers(const QList<Core::Id> &parsers)
{
qobject_cast<SelectionWidget *>(widget())->setSelectedParsers(parsers);
}
QList<Core::Id> CustomParsersSelectionWidget::selectedParsers() const
{
return qobject_cast<SelectionWidget *>(widget())->selectedParsers();
}
void CustomParsersSelectionWidget::updateSummary()
{
const QList<Core::Id> parsers
= qobject_cast<SelectionWidget *>(widget())->selectedParsers();
if (parsers.isEmpty())
setSummaryText(tr("There are no custom parsers active"));
else
setSummaryText(tr("There are %n custom parsers active", nullptr, parsers.count()));
}
CustomParsersAspect::CustomParsersAspect(Target *target)
{
Q_UNUSED(target)
setId("CustomOutputParsers");
setSettingsKey("CustomOutputParsers");
setDisplayName(tr("Custom Output Parsers"));
setConfigWidgetCreator([this] {
const auto widget = new CustomParsersSelectionWidget;
widget->setSelectedParsers(m_parsers);
connect(widget, &CustomParsersSelectionWidget::selectionChanged,
this, [this, widget] { m_parsers = widget->selectedParsers(); });
return widget;
});
}
void CustomParsersAspect::fromMap(const QVariantMap &map)
{
m_parsers = transform(map.value(settingsKey()).toList(), &Core::Id::fromSetting);
}
void CustomParsersAspect::toMap(QVariantMap &map) const
{
map.insert(settingsKey(), transform(m_parsers, &Core::Id::toSetting));
}
} // namespace Internal
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
// Unit tests:
#ifdef WITH_TESTS
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
using namespace Internal;
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
void ProjectExplorerPlugin::testCustomOutputParsers_data()
{
QTest::addColumn<QString>("input");
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
QTest::addColumn<QString>("workDir");
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QTest::addColumn<OutputParserTester::Channel>("inputChannel");
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTest::addColumn<CustomParserExpression::CustomParserChannel>("filterErrorChannel");
QTest::addColumn<CustomParserExpression::CustomParserChannel>("filterWarningChannel");
QTest::addColumn<QString>("errorPattern");
QTest::addColumn<int>("errorFileNameCap");
QTest::addColumn<int>("errorLineNumberCap");
QTest::addColumn<int>("errorMessageCap");
QTest::addColumn<QString>("warningPattern");
QTest::addColumn<int>("warningFileNameCap");
QTest::addColumn<int>("warningLineNumberCap");
QTest::addColumn<int>("warningMessageCap");
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QTest::addColumn<QString>("childStdOutLines");
QTest::addColumn<QString>("childStdErrLines");
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
QTest::addColumn<Tasks >("tasks");
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QTest::addColumn<QString>("outputLines");
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString simplePattern = "^([a-z]+\\.[a-z]+):(\\d+): error: ([^\\s].+)$";
Utils: Rename FileName to FilePath More in line with QFileInfo terminonlogy which appears to be best-of-breed within Qt. Change-Id: I1d051ff1c8363ebd4ee56376451df45216c4c9ab Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-28 13:49:26 +02:00
const FilePath fileName = FilePath::fromUserInput("main.c");
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTest::newRow("empty patterns")
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString::fromLatin1("Sometext")
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDOUT
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< QString() << 1 << 2 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString::fromLatin1("Sometext\n") << QString()
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
QTest::newRow("pass-through stdout")
<< QString::fromLatin1("Sometext")
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDOUT
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString::fromLatin1("Sometext\n") << QString()
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
QTest::newRow("pass-through stderr")
<< QString::fromLatin1("Sometext")
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDERR
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString() << QString::fromLatin1("Sometext\n")
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString simpleError = "main.c:9: error: `sfasdf' undeclared (first use this function)";
const QString simpleErrorPassThrough = simpleError + '\n';
const QString message = "`sfasdf' undeclared (first use this function)";
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QTest::newRow("simple error")
<< simpleError
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDERR
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, fileName, 9)})
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
const QString pathPattern = "^([a-z\\./]+):(\\d+): error: ([^\\s].+)$";
QString workingDir = "/home/src/project";
Utils: Rename FileName to FilePath More in line with QFileInfo terminonlogy which appears to be best-of-breed within Qt. Change-Id: I1d051ff1c8363ebd4ee56376451df45216c4c9ab Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-28 13:49:26 +02:00
FilePath expandedFileName = FilePath::fromString("/home/src/project/main.c");
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
QTest::newRow("simple error with expanded path")
<< "main.c:9: error: `sfasdf' undeclared (first use this function)"
<< workingDir
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< pathPattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, expandedFileName, 9)})
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString();
Utils: Rename FileName to FilePath More in line with QFileInfo terminonlogy which appears to be best-of-breed within Qt. Change-Id: I1d051ff1c8363ebd4ee56376451df45216c4c9ab Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-28 13:49:26 +02:00
expandedFileName = FilePath::fromString("/home/src/project/subdir/main.c");
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
QTest::newRow("simple error with subdir path")
<< "subdir/main.c:9: error: `sfasdf' undeclared (first use this function)"
<< workingDir
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< pathPattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, expandedFileName, 9)})
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString();
workingDir = "/home/src/build-project";
QTest::newRow("simple error with buildir path")
<< "../project/subdir/main.c:9: error: `sfasdf' undeclared (first use this function)"
<< workingDir
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< pathPattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, expandedFileName, 9)})
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString();
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTest::newRow("simple error on wrong channel")
<< simpleError
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDOUT
<< CustomParserExpression::ParseStdErrChannel << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
<< simpleErrorPassThrough << QString()
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
QTest::newRow("simple error on other wrong channel")
<< simpleError
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseStdOutChannel << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< QString() << 0 << 0 << 0
<< QString() << simpleErrorPassThrough
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString simpleError2 = "Error: Line 19 in main.c: `sfasdf' undeclared (first use this function)";
const QString simplePattern2 = "^Error: Line (\\d+) in ([a-z]+\\.[a-z]+): ([^\\s].+)$";
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
const int lineNumber2 = 19;
QTest::newRow("another simple error on stderr")
<< simpleError2
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDERR
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern2 << 2 << 1 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, fileName, lineNumber2)})
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
QTest::newRow("another simple error on stdout")
<< simpleError2
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDOUT
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern2 << 2 << 1 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, fileName, lineNumber2)})
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString simpleWarningPattern = "^([a-z]+\\.[a-z]+):(\\d+): warning: ([^\\s].+)$";
const QString simpleWarning = "main.c:1234: warning: `helloWorld' declared but not used";
const QString warningMessage = "`helloWorld' declared but not used";
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTest::newRow("simple warning")
<< simpleWarning
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< QString() << 1 << 2 << 3
<< simpleWarningPattern << 1 << 2 << 3
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Warning, warningMessage, fileName, 1234)})
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString simpleWarning2 = "Warning: `helloWorld' declared but not used (main.c:19)";
const QString simpleWarningPassThrough2 = simpleWarning2 + '\n';
const QString simpleWarningPattern2 = "^Warning: (.*) \\(([a-z]+\\.[a-z]+):(\\d+)\\)$";
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QTest::newRow("another simple warning on stdout")
<< simpleWarning2
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDOUT
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseStdOutChannel
<< simplePattern2 << 1 << 2 << 3
<< simpleWarningPattern2 << 2 << 3 << 1
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Warning, warningMessage, fileName, lineNumber2)})
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
QTest::newRow("warning on wrong channel")
<< simpleWarning2
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDOUT
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseStdErrChannel
<< QString() << 1 << 2 << 3
<< simpleWarningPattern2 << 2 << 3 << 1
<< simpleWarningPassThrough2 << QString()
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
QTest::newRow("warning on other wrong channel")
<< simpleWarning2
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseStdOutChannel
<< QString() << 1 << 2 << 3
<< simpleWarningPattern2 << 2 << 3 << 1
<< QString() << simpleWarningPassThrough2
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
<< Tasks()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
QTest::newRow("error and *warning*")
<< simpleWarning
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< simpleWarningPattern << 1 << 2 << 3
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Warning, warningMessage, fileName, 1234)})
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
QTest::newRow("*error* when equal pattern")
<< simpleError
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< OutputParserTester::STDERR
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< simplePattern << 1 << 2 << 3
<< simplePattern << 1 << 2 << 3
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, message, fileName, 9)})
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< QString();
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString unitTestError = "../LedDriver/LedDriverTest.c:63: FAIL: Expected 0x0080 Was 0xffff";
Utils: Rename FileName to FilePath More in line with QFileInfo terminonlogy which appears to be best-of-breed within Qt. Change-Id: I1d051ff1c8363ebd4ee56376451df45216c4c9ab Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-28 13:49:26 +02:00
const FilePath unitTestFileName = FilePath::fromUserInput("../LedDriver/LedDriverTest.c");
CustomParser: Modernize Change-Id: I07b512ac1ecb3c07c33859892d06f4b1bbc0b69f Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-06-14 21:10:02 +02:00
const QString unitTestMessage = "Expected 0x0080 Was 0xffff";
const QString unitTestPattern = "^([^:]+):(\\d+): FAIL: ([^\\s].+)$";
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
const int unitTestLineNumber = 63;
QTest::newRow("unit test error")
<< unitTestError
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
<< QString()
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< OutputParserTester::STDOUT
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
<< CustomParserExpression::ParseBothChannels << CustomParserExpression::ParseBothChannels
<< unitTestPattern << 1 << 2 << 3
<< QString() << 1 << 2 << 3
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString() << QString()
ProjectManager: Add convenience Task subclasses For Compile, BuildSystem and Deployment. Unclutters user code and reduces binary size. Change-Id: Ia18e917bb411754162e9f4ec6056d752a020bb50 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2020-01-15 08:56:11 +01:00
<< Tasks({CompileTask(Task::Error, unitTestMessage, unitTestFileName, unitTestLineNumber)})
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
<< QString();
}
void ProjectExplorerPlugin::testCustomOutputParsers()
{
QFETCH(QString, input);
CustomParser: Improve relative file path resolving By building an absolute path from the relative path, relating from the build directory. Task-number: QTCREATORBUG-20605 Change-Id: If76578d2ee01567a9c72f3fc63a773ea2901a545 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2018-03-07 18:44:28 +01:00
QFETCH(QString, workDir);
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QFETCH(OutputParserTester::Channel, inputChannel);
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
QFETCH(CustomParserExpression::CustomParserChannel, filterErrorChannel);
QFETCH(CustomParserExpression::CustomParserChannel, filterWarningChannel);
QFETCH(QString, errorPattern);
QFETCH(int, errorFileNameCap);
QFETCH(int, errorLineNumberCap);
QFETCH(int, errorMessageCap);
QFETCH(QString, warningPattern);
QFETCH(int, warningFileNameCap);
QFETCH(int, warningLineNumberCap);
QFETCH(int, warningMessageCap);
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QFETCH(QString, childStdOutLines);
QFETCH(QString, childStdErrLines);
ProjectExplorer: Introduce a alias for QList<Tasks> Change-Id: I91391ad22b420926b0f512cac23cfe009048b218 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2019-05-27 16:09:44 +02:00
QFETCH(Tasks, tasks);
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
QFETCH(QString, outputLines);
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
CustomParserSettings settings;
settings.error.setPattern(errorPattern);
settings.error.setFileNameCap(errorFileNameCap);
settings.error.setLineNumberCap(errorLineNumberCap);
settings.error.setMessageCap(errorMessageCap);
settings.error.setChannel(filterErrorChannel);
settings.warning.setPattern(warningPattern);
settings.warning.setFileNameCap(warningFileNameCap);
settings.warning.setLineNumberCap(warningLineNumberCap);
settings.warning.setMessageCap(warningMessageCap);
settings.warning.setChannel(filterWarningChannel);
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
CustomParser *parser = new CustomParser;
CustomParser: Add warning parser and output channel filter There have been several requests on the mailing list or the bug tracker to support parsing warnings for alien compilers (sometimes slightly modified GCC). Instead of natively supporting every compiler, users of less frequently used compilers should use the custom parser to parse errors and warnings. The output channel filter for error and warning parser allows to scan standard output, standard error or both channels. Also added tests for twisted capture positions. Task-number: QTCREATORBUG-11003 Change-Id: I5a5bd6f88cf21cde1c74962225067d4543693678 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2015-12-16 21:04:45 +01:00
parser->setSettings(settings);
Output parsers: Generalize the search directory concept All parsers can now have search directories, not just the GnuMakeParser. This allows us to get rid of the "task mangling", removing another instance where the order of parsers in the chain mattered. Task-number: QTCREATORBUG-22665 Change-Id: Id0d55522ae6800afd9f50ff36546224b0d8bb382 Reviewed-by: hjk <hjk@qt.io>
2020-04-07 13:49:34 +02:00
parser->addSearchDir(FilePath::fromString(workDir));
parser->skipFileExistsCheck();
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
OutputParserTester testbench;
Output parsers: Replace the chaining approach Use "flat" aggregation instead. This is another step towards the formatter/parser merger. Along the way, also fix some some subclasses (mostly in BareMetal) that erroneously forwarded handled output to other parsers. Task-number: QTCREATORBUG-22665 Change-Id: I12947349ca663d2e6bbfc99efd069d69e2b54969 Reviewed-by: hjk <hjk@qt.io>
2020-04-08 17:45:39 +02:00
testbench.addLineParser(parser);
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
testbench.testParsing(input, inputChannel,
tasks, childStdOutLines, childStdErrLines,
outputLines);
}
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
Custom Error Parser Allow setting the following items from outside: * capture regular expression, * file name, line number and message capture position and * whether to parse stdout, stderr or both The parser functions can be unit-tested by running (Debug build of Qt Creator needed): qtcreator -test ProjectExplorer,testCustomOutputParsers The data is passed to the custom parser in CustomToolChain::outputParser(). The parser information is stored in toolchains.xml together with the custom toolchain. A configuration widget is provided to set up and test the regular expression against a sample error message. Change-Id: I6191df3c44432943e0aeb16c48d8e79d35845d2e Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
2013-08-05 21:30:41 +03:00
#endif
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
ProjectExplorer: Fix release build And compile on macOS. Amends c15e09e0fe880c5. Change-Id: I39395f341e8590104dd96348aa8fc12d437dbd28 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2020-05-12 08:32:38 +02:00
} // namespace ProjectExplorer
ProjectExplorer: Generalize the concept of custom output parsers They can now be created independently of any toolchains, and we expose them in the build and run configurations, so that users can easily get tasks for output that comes from custom tools or is otherwise specific to the user's environment. Fixes: QTCREATORBUG-23993 Change-Id: I405753b9b68508ffe5deb4fcac08d6b213c7554d Reviewed-by: André Hartmann <aha_1980@gmx.de> Reviewed-by: hjk <hjk@qt.io>
2020-05-06 12:51:08 +02:00
#include <customparser.moc>
Copy Permalink