forked from qt-creator/qt-creator
1c6e4fbd32
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>
332 lines
14 KiB
C++
332 lines
14 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 Axonian LLC.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** 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
|
|
** 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.
|
|
**
|
|
** 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.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "cmakeparser.h"
|
|
|
|
#include <utils/qtcassert.h>
|
|
|
|
#include <projectexplorer/projectexplorerconstants.h>
|
|
|
|
using namespace ProjectExplorer;
|
|
using namespace Utils;
|
|
|
|
namespace CMakeProjectManager {
|
|
|
|
const char COMMON_ERROR_PATTERN[] = "^CMake Error at (.*):([0-9]*)( \\((.*)\\))?:";
|
|
const char NEXT_SUBERROR_PATTERN[] = "^CMake Error in (.*):";
|
|
const char LOCATION_LINE_PATTERN[] = ":(\\d+):(?:(\\d+))?$";
|
|
|
|
CMakeParser::CMakeParser()
|
|
{
|
|
m_commonError.setPattern(QLatin1String(COMMON_ERROR_PATTERN));
|
|
m_commonError.setMinimal(true);
|
|
QTC_CHECK(m_commonError.isValid());
|
|
|
|
m_nextSubError.setPattern(QLatin1String(NEXT_SUBERROR_PATTERN));
|
|
m_nextSubError.setMinimal(true);
|
|
QTC_CHECK(m_nextSubError.isValid());
|
|
|
|
m_locationLine.setPattern(QLatin1String(LOCATION_LINE_PATTERN));
|
|
QTC_CHECK(m_locationLine.isValid());
|
|
}
|
|
|
|
void CMakeParser::setSourceDirectory(const QString &sourceDir)
|
|
{
|
|
if (m_sourceDirectory)
|
|
emit searchDirExpired(FilePath::fromString(m_sourceDirectory.value().path()));
|
|
m_sourceDirectory = QDir(sourceDir);
|
|
emit addSearchDir(FilePath::fromString(sourceDir));
|
|
}
|
|
|
|
OutputLineParser::Result CMakeParser::handleLine(const QString &line, OutputFormat type)
|
|
{
|
|
if (type != StdErrFormat)
|
|
return Status::NotHandled;
|
|
|
|
QString trimmedLine = rightTrimmed(line);
|
|
switch (m_expectTripleLineErrorData) {
|
|
case NONE:
|
|
if (trimmedLine.isEmpty() && !m_lastTask.isNull()) {
|
|
if (m_skippedFirstEmptyLine) {
|
|
flush();
|
|
return Status::InProgress;
|
|
}
|
|
m_skippedFirstEmptyLine = true;
|
|
return Status::InProgress;
|
|
}
|
|
if (m_skippedFirstEmptyLine)
|
|
m_skippedFirstEmptyLine = false;
|
|
|
|
if (m_commonError.indexIn(trimmedLine) != -1) {
|
|
QString path = m_sourceDirectory ? m_sourceDirectory->absoluteFilePath(
|
|
QDir::fromNativeSeparators(m_commonError.cap(1)))
|
|
: QDir::fromNativeSeparators(m_commonError.cap(1));
|
|
m_lastTask = BuildSystemTask(Task::Error,
|
|
QString(),
|
|
absoluteFilePath(FilePath::fromUserInput(path)),
|
|
m_commonError.cap(2).toInt());
|
|
m_lines = 1;
|
|
LinkSpecs linkSpecs;
|
|
addLinkSpecForAbsoluteFilePath(linkSpecs, m_lastTask.file, m_lastTask.line,
|
|
m_commonError, 1);
|
|
return {Status::InProgress, linkSpecs};
|
|
} else if (m_nextSubError.indexIn(trimmedLine) != -1) {
|
|
m_lastTask = BuildSystemTask(Task::Error, QString(),
|
|
absoluteFilePath(FilePath::fromUserInput(m_nextSubError.cap(1))));
|
|
LinkSpecs linkSpecs;
|
|
addLinkSpecForAbsoluteFilePath(linkSpecs, m_lastTask.file, m_lastTask.line,
|
|
m_nextSubError, 1);
|
|
m_lines = 1;
|
|
return {Status::InProgress, linkSpecs};
|
|
} else if (trimmedLine.startsWith(QLatin1String(" ")) && !m_lastTask.isNull()) {
|
|
if (!m_lastTask.description.isEmpty())
|
|
m_lastTask.description.append(QLatin1Char(' '));
|
|
m_lastTask.description.append(trimmedLine.trimmed());
|
|
++m_lines;
|
|
return Status::InProgress;
|
|
} else if (trimmedLine.endsWith(QLatin1String("in cmake code at"))) {
|
|
m_expectTripleLineErrorData = LINE_LOCATION;
|
|
flush();
|
|
const Task::TaskType type =
|
|
trimmedLine.contains(QLatin1String("Error")) ? Task::Error : Task::Warning;
|
|
m_lastTask = BuildSystemTask(type, QString());
|
|
return Status::InProgress;
|
|
} else if (trimmedLine.startsWith("CMake Error: ")) {
|
|
m_lastTask = BuildSystemTask(Task::Error, trimmedLine.mid(13));
|
|
m_lines = 1;
|
|
return Status::InProgress;
|
|
} else if (trimmedLine.startsWith("-- ") || trimmedLine.startsWith(" * ")) {
|
|
// Do not pass on lines starting with "-- " or "* ". Those are typical CMake output
|
|
return Status::InProgress;
|
|
}
|
|
return Status::NotHandled;
|
|
case LINE_LOCATION:
|
|
{
|
|
QRegularExpressionMatch m = m_locationLine.match(trimmedLine);
|
|
QTC_CHECK(m.hasMatch());
|
|
m_lastTask.file = absoluteFilePath(FilePath::fromUserInput(
|
|
trimmedLine.mid(0, m.capturedStart())));
|
|
m_lastTask.line = m.captured(1).toInt();
|
|
m_expectTripleLineErrorData = LINE_DESCRIPTION;
|
|
LinkSpecs linkSpecs;
|
|
addLinkSpecForAbsoluteFilePath(linkSpecs, m_lastTask.file, m_lastTask.line, 0,
|
|
m.capturedStart());
|
|
return {Status::InProgress, linkSpecs};
|
|
}
|
|
case LINE_DESCRIPTION:
|
|
m_lastTask.description = trimmedLine;
|
|
if (trimmedLine.endsWith(QLatin1Char('\"')))
|
|
m_expectTripleLineErrorData = LINE_DESCRIPTION2;
|
|
else {
|
|
m_expectTripleLineErrorData = NONE;
|
|
flush();
|
|
return Status::Done;
|
|
}
|
|
return Status::InProgress;
|
|
case LINE_DESCRIPTION2:
|
|
m_lastTask.description.append(QLatin1Char('\n'));
|
|
m_lastTask.description.append(trimmedLine);
|
|
m_expectTripleLineErrorData = NONE;
|
|
flush();
|
|
return Status::Done;
|
|
}
|
|
return Status::NotHandled;
|
|
}
|
|
|
|
void CMakeParser::flush()
|
|
{
|
|
if (m_lastTask.isNull())
|
|
return;
|
|
Task t = m_lastTask;
|
|
m_lastTask.clear();
|
|
scheduleTask(t, m_lines, 1);
|
|
m_lines = 0;
|
|
}
|
|
|
|
} // CMakeProjectManager
|
|
|
|
#ifdef WITH_TESTS
|
|
#include "cmakeprojectplugin.h"
|
|
|
|
#include <projectexplorer/outputparser_test.h>
|
|
|
|
#include <QTest>
|
|
|
|
namespace CMakeProjectManager {
|
|
|
|
void Internal::CMakeProjectPlugin::testCMakeParser_data()
|
|
{
|
|
QTest::addColumn<QString>("input");
|
|
QTest::addColumn<OutputParserTester::Channel>("inputChannel");
|
|
QTest::addColumn<QString>("childStdOutLines");
|
|
QTest::addColumn<QString>("childStdErrLines");
|
|
QTest::addColumn<Tasks>("tasks");
|
|
QTest::addColumn<QString>("outputLines");
|
|
|
|
// negative tests
|
|
QTest::newRow("pass-through stdout")
|
|
<< QString::fromLatin1("Sometext") << OutputParserTester::STDOUT
|
|
<< QString::fromLatin1("Sometext\n") << QString()
|
|
<< Tasks()
|
|
<< QString();
|
|
QTest::newRow("pass-through stderr")
|
|
<< QString::fromLatin1("Sometext") << OutputParserTester::STDERR
|
|
<< QString() << QString::fromLatin1("Sometext\n")
|
|
<< Tasks()
|
|
<< QString();
|
|
|
|
// positive tests
|
|
QTest::newRow("add custom target")
|
|
<< QString::fromLatin1("CMake Error at src/1/app/CMakeLists.txt:70 (add_custom_target):\n"
|
|
" Cannot find source file:\n\n"
|
|
" unknownFile.qml\n\n"
|
|
" Tried extensions .c .C .c++ .cc .cpp .cxx .m .M .mm .h .hh .h++ .hm .hpp\n"
|
|
" .hxx .in .txx\n\n\n"
|
|
"CMake Error in src/1/app/CMakeLists.txt:\n"
|
|
" Cannot find source file:\n\n"
|
|
" CMakeLists.txt2\n\n"
|
|
" Tried extensions .c .C .c++ .cc .cpp .cxx .m .M .mm .h .hh .h++ .hm .hpp\n"
|
|
" .hxx .in .txx\n\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"Cannot find source file: unknownFile.qml Tried extensions "
|
|
".c .C .c++ .cc .cpp .cxx .m .M .mm .h .hh .h++ .hm .hpp .hxx .in .txx",
|
|
FilePath::fromUserInput("src/1/app/CMakeLists.txt"), 70)
|
|
<< BuildSystemTask(Task::Error,
|
|
"Cannot find source file: CMakeLists.txt2 Tried extensions "
|
|
".c .C .c++ .cc .cpp .cxx .m .M .mm .h .hh .h++ .hm .hpp .hxx .in .txx",
|
|
FilePath::fromUserInput("src/1/app/CMakeLists.txt"), -1))
|
|
<< QString();
|
|
|
|
QTest::newRow("add subdirectory")
|
|
<< QString::fromLatin1("CMake Error at src/1/CMakeLists.txt:8 (add_subdirectory):\n"
|
|
" add_subdirectory given source \"app1\" which is not an existing directory.\n\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"add_subdirectory given source \"app1\" which is not an existing directory.",
|
|
FilePath::fromUserInput("src/1/CMakeLists.txt"), 8))
|
|
<< QString();
|
|
|
|
QTest::newRow("unknown command")
|
|
<< QString::fromLatin1("CMake Error at src/1/CMakeLists.txt:8 (i_am_wrong_command):\n"
|
|
" Unknown CMake command \"i_am_wrong_command\".\n\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"Unknown CMake command \"i_am_wrong_command\".",
|
|
FilePath::fromUserInput("src/1/CMakeLists.txt"), 8))
|
|
<< QString();
|
|
|
|
QTest::newRow("incorrect arguments")
|
|
<< QString::fromLatin1("CMake Error at src/1/CMakeLists.txt:8 (message):\n"
|
|
" message called with incorrect number of arguments\n\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"message called with incorrect number of arguments",
|
|
FilePath::fromUserInput("src/1/CMakeLists.txt"), 8))
|
|
<< QString();
|
|
|
|
QTest::newRow("cmake error")
|
|
<< QString::fromLatin1("CMake Error: Error in cmake code at\n"
|
|
"/test/path/CMakeLists.txt:9:\n"
|
|
"Parse error. Expected \"(\", got newline with text \"\n"
|
|
"\".")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"Parse error. Expected \"(\", got newline with text \"\n\".",
|
|
FilePath::fromUserInput("/test/path/CMakeLists.txt"), 9))
|
|
<< QString();
|
|
|
|
QTest::newRow("cmake error2")
|
|
<< QString::fromLatin1("CMake Error: Error required internal CMake variable not set, cmake may be not be built correctly.\n"
|
|
"Missing variable is:\n"
|
|
"CMAKE_MAKE_PROGRAM\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString("Missing variable is:\nCMAKE_MAKE_PROGRAM\n")
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"Error required internal CMake variable not set, "
|
|
"cmake may be not be built correctly."))
|
|
<< QString();
|
|
|
|
QTest::newRow("cmake error at")
|
|
<< QString::fromLatin1("CMake Error at CMakeLists.txt:4:\n"
|
|
" Parse error. Expected \"(\", got newline with text \"\n"
|
|
"\n"
|
|
" \".\n")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Error,
|
|
"Parse error. Expected \"(\", got newline with text \" \".",
|
|
FilePath::fromUserInput("CMakeLists.txt"), 4))
|
|
<< QString();
|
|
|
|
QTest::newRow("cmake warning")
|
|
<< QString::fromLatin1("Syntax Warning in cmake code at\n"
|
|
"/test/path/CMakeLists.txt:9:15\n"
|
|
"Argument not separated from preceding token by whitespace.")
|
|
<< OutputParserTester::STDERR
|
|
<< QString() << QString()
|
|
<< (Tasks()
|
|
<< BuildSystemTask(Task::Warning,
|
|
"Argument not separated from preceding token by whitespace.",
|
|
FilePath::fromUserInput("/test/path/CMakeLists.txt"), 9))
|
|
<< QString();
|
|
QTest::newRow("eat normal CMake output")
|
|
<< QString::fromLatin1("-- Qt5 install prefix: /usr/lib\n"
|
|
" * Plugin componentsplugin, with CONDITION TARGET QmlDesigner")
|
|
<< OutputParserTester::STDERR << QString() << QString() << (Tasks()) << QString();
|
|
}
|
|
|
|
void Internal::CMakeProjectPlugin::testCMakeParser()
|
|
{
|
|
OutputParserTester testbench;
|
|
testbench.addLineParser(new CMakeParser);
|
|
QFETCH(QString, input);
|
|
QFETCH(OutputParserTester::Channel, inputChannel);
|
|
QFETCH(Tasks, tasks);
|
|
QFETCH(QString, childStdOutLines);
|
|
QFETCH(QString, childStdErrLines);
|
|
QFETCH(QString, outputLines);
|
|
|
|
testbench.testParsing(input, inputChannel,
|
|
tasks, childStdOutLines, childStdErrLines,
|
|
outputLines);
|
|
}
|
|
|
|
} // CMakeProjectManager
|
|
|
|
#endif
|