lix/src/libutil/error.cc

332 lines
9.4 KiB
C++
Raw Normal View History

#include "error.hh"
#include <iostream>
2020-03-25 16:52:03 +00:00
#include <optional>
#include "serialise.hh"
2020-05-14 18:28:18 +00:00
#include <sstream>
2020-04-29 03:06:08 +00:00
namespace nix {
2020-04-24 20:57:51 +00:00
const std::string nativeSystem = SYSTEM;
// Traces show the chain of calls in nix code. If an ErrPos is included the surrounding
// lines of code will print.
2020-06-19 19:44:08 +00:00
BaseError & BaseError::addTrace(std::optional<ErrPos> e, hintformat hint)
2020-06-18 21:25:26 +00:00
{
err.traces.push_front(Trace { .pos = e, .hint = hint});
return *this;
}
2020-06-04 17:53:19 +00:00
// c++ std::exception descendants must have a 'const char* what()' function.
// This stringifies the error and caches it for use by what(), or similarly by msg().
2020-05-14 18:28:18 +00:00
const string& BaseError::calcWhat() const
{
if (what_.has_value())
return *what_;
else {
err.name = sname();
std::ostringstream oss;
oss << err;
what_ = oss.str();
return *what_;
}
}
std::optional<string> ErrorInfo::programName = std::nullopt;
2020-04-15 16:09:43 +00:00
std::ostream& operator<<(std::ostream &os, const hintformat &hf)
{
return os << hf.str();
}
2020-04-08 15:07:58 +00:00
string showErrPos(const ErrPos &errPos)
{
if (errPos.line > 0) {
if (errPos.column > 0) {
return fmt("(%1%:%2%)", errPos.line, errPos.column);
} else {
return fmt("(%1%)", errPos.line);
}
}
else {
return "";
}
}
2020-05-20 23:25:02 +00:00
void getCodeLines(NixCode &nixCode)
{
2020-06-18 21:25:26 +00:00
if (nixCode.errPos.line <= 0)
2020-05-20 23:25:02 +00:00
return;
2020-05-21 04:18:26 +00:00
if (nixCode.errPos.origin == foFile) {
try {
AutoCloseFD fd = open(nixCode.errPos.file.c_str(), O_RDONLY | O_CLOEXEC);
if (!fd)
logError(SysError("opening file '%1%'", nixCode.errPos.file).info());
else
2020-05-21 04:18:26 +00:00
{
// count the newlines.
int count = 0;
string line;
int pl = nixCode.errPos.line - 1;
2020-06-18 21:25:26 +00:00
do
2020-05-21 04:18:26 +00:00
{
line = readLine(fd.get());
++count;
2020-06-18 21:25:26 +00:00
if (count < pl)
{
2020-06-18 21:25:26 +00:00
;
}
else if (count == pl) {
nixCode.prevLineOfCode = line;
} else if (count == pl + 1) {
nixCode.errLineOfCode = line;
} else if (count == pl + 2) {
nixCode.nextLineOfCode = line;
break;
}
} while (true);
2020-06-18 21:25:26 +00:00
}
2020-05-21 04:18:26 +00:00
}
catch (EndOfFile &eof) {
;
}
catch (std::exception &e) {
printError("error reading nix file: %s\n%s", nixCode.errPos.file, e.what());
}
2020-06-18 21:25:26 +00:00
} else {
2020-05-21 04:18:26 +00:00
std::istringstream iss(nixCode.errPos.file);
2020-05-20 23:25:02 +00:00
// count the newlines.
int count = 0;
string line;
int pl = nixCode.errPos.line - 1;
2020-05-21 04:18:26 +00:00
2020-06-18 21:25:26 +00:00
do
2020-05-20 23:25:02 +00:00
{
2020-05-21 04:18:26 +00:00
std::getline(iss, line);
2020-05-20 23:25:02 +00:00
++count;
2020-06-18 21:25:26 +00:00
if (count < pl)
2020-05-20 23:25:02 +00:00
{
2020-06-18 21:25:26 +00:00
;
2020-05-20 23:25:02 +00:00
}
else if (count == pl) {
nixCode.prevLineOfCode = line;
} else if (count == pl + 1) {
nixCode.errLineOfCode = line;
} else if (count == pl + 2) {
nixCode.nextLineOfCode = line;
break;
}
2020-05-21 04:18:26 +00:00
if (!iss.good())
break;
2020-05-20 23:25:02 +00:00
} while (true);
}
}
2020-06-04 17:53:19 +00:00
// if nixCode contains lines of code, print them to the ostream, indicating the error column.
void printCodeLines(std::ostream &out, const string &prefix, const NixCode &nixCode)
{
2020-04-08 15:48:21 +00:00
// previous line of code.
if (nixCode.prevLineOfCode.has_value()) {
2020-06-15 12:12:39 +00:00
out << std::endl
<< fmt("%1% %|2$5d|| %3%",
2020-06-18 21:25:26 +00:00
prefix,
(nixCode.errPos.line - 1),
*nixCode.prevLineOfCode);
2020-04-08 15:48:21 +00:00
}
2020-04-02 22:02:40 +00:00
if (nixCode.errLineOfCode.has_value()) {
// line of code containing the error.
out << std::endl
<< fmt("%1% %|2$5d|| %3%",
2020-06-18 21:25:26 +00:00
prefix,
(nixCode.errPos.line),
*nixCode.errLineOfCode);
// error arrows for the column range.
if (nixCode.errPos.column > 0) {
int start = nixCode.errPos.column;
std::string spaces;
for (int i = 0; i < start; ++i) {
spaces.append(" ");
}
std::string arrows("^");
2020-04-01 22:20:20 +00:00
out << std::endl
<< fmt("%1% |%2%" ANSI_RED "%3%" ANSI_NORMAL,
2020-06-18 21:25:26 +00:00
prefix,
spaces,
arrows);
}
}
2020-04-08 15:48:21 +00:00
// next line of code.
if (nixCode.nextLineOfCode.has_value()) {
out << std::endl
<< fmt("%1% %|2$5d|| %3%",
2020-06-18 21:25:26 +00:00
prefix,
(nixCode.errPos.line + 1),
*nixCode.nextLineOfCode);
2020-04-08 15:48:21 +00:00
}
}
std::ostream& operator<<(std::ostream &out, const ErrorInfo &einfo)
{
auto errwidth = std::max<size_t>(getWindowSize().second, 20);
string prefix = "";
2020-04-01 22:20:20 +00:00
string levelString;
2020-04-02 22:02:40 +00:00
switch (einfo.level) {
case Verbosity::lvlError: {
levelString = ANSI_RED;
levelString += "error:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlWarn: {
levelString = ANSI_YELLOW;
levelString += "warning:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlInfo: {
levelString = ANSI_GREEN;
levelString += "info:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlTalkative: {
levelString = ANSI_GREEN;
levelString += "talk:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlChatty: {
levelString = ANSI_GREEN;
levelString += "chat:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlVomit: {
levelString = ANSI_GREEN;
levelString += "vomit:";
levelString += ANSI_NORMAL;
break;
}
case Verbosity::lvlDebug: {
levelString = ANSI_YELLOW;
levelString += "debug:";
levelString += ANSI_NORMAL;
break;
}
default: {
levelString = fmt("invalid error level: %1%", einfo.level);
break;
}
}
2020-06-15 16:16:03 +00:00
auto ndl = prefix.length() + levelString.length() + 3 + einfo.name.length() + einfo.programName.value_or("").length();
auto dashwidth = ndl > (errwidth - 3) ? 3 : errwidth - ndl;
2020-04-01 22:20:20 +00:00
2020-06-15 16:16:03 +00:00
std::string dashes(dashwidth, '-');
2020-04-01 22:20:20 +00:00
// divider.
if (einfo.name != "")
2020-04-29 03:06:08 +00:00
out << fmt("%1%%2%" ANSI_BLUE " --- %3% %4% %5%" ANSI_NORMAL,
2020-04-29 16:14:32 +00:00
prefix,
levelString,
einfo.name,
dashes,
einfo.programName.value_or(""));
else
2020-04-29 03:06:08 +00:00
out << fmt("%1%%2%" ANSI_BLUE " -----%3% %4%" ANSI_NORMAL,
2020-04-29 16:14:32 +00:00
prefix,
levelString,
dashes,
einfo.programName.value_or(""));
bool nl = false; // intersperse newline between sections.
if (einfo.errPos.has_value()) {
switch (einfo.errPos->origin) {
2020-05-21 04:18:26 +00:00
case foFile: {
out << prefix << std::endl;
auto &pos = *einfo.errPos;
out << prefix << ANSI_BLUE << "at: " << ANSI_YELLOW << showErrPos(pos) <<
ANSI_BLUE << " in file: " << ANSI_NORMAL << pos.file;
2020-05-21 04:18:26 +00:00
break;
}
case foString: {
out << prefix << std::endl;
out << prefix << ANSI_BLUE << "at: " << ANSI_YELLOW << showErrPos(*einfo.errPos) <<
ANSI_BLUE << " from command line argument" << ANSI_NORMAL;
2020-05-21 04:18:26 +00:00
break;
}
case foStdin: {
out << prefix << std::endl;
out << prefix << ANSI_BLUE << "at: " << ANSI_YELLOW << showErrPos(*einfo.errPos) <<
ANSI_BLUE << " from stdin" << ANSI_NORMAL;
2020-05-21 04:18:26 +00:00
break;
}
default:
throw Error("invalid FileOrigin in errPos");
2020-04-01 22:20:20 +00:00
}
nl = true;
2020-04-01 22:20:20 +00:00
}
2020-04-01 22:20:20 +00:00
// description
if (einfo.description != "") {
if (nl)
out << std::endl << prefix;
out << std::endl << prefix << einfo.description;
nl = true;
}
2020-04-01 22:20:20 +00:00
if (einfo.errPos.has_value()) {
NixCode nixcode { .errPos = *einfo.errPos };
2020-05-20 23:25:02 +00:00
getCodeLines(nixcode);
2020-06-18 21:25:26 +00:00
2020-05-20 23:25:02 +00:00
// lines of code.
if (nixcode.errLineOfCode.has_value()) {
if (nl)
out << std::endl << prefix;
2020-05-20 23:25:02 +00:00
printCodeLines(out, prefix, nixcode);
nl = true;
2020-05-20 23:25:02 +00:00
}
}
2020-05-20 23:25:02 +00:00
// hint
if (einfo.hint.has_value()) {
if (nl)
out << std::endl << prefix;
out << std::endl << prefix << *einfo.hint;
nl = true;
2020-04-01 22:20:20 +00:00
}
2020-06-23 15:36:58 +00:00
// traces
for (auto iter = einfo.traces.rbegin(); iter != einfo.traces.rend(); ++iter)
{
try {
auto pos = *iter->pos;
if (nl)
out << std::endl << prefix;
out << std::endl << prefix;
out << iter->hint.str() << std::endl;
out << ANSI_BLUE << "at: " << ANSI_YELLOW << showErrPos(pos) <<
ANSI_BLUE << " in file: " << ANSI_NORMAL << pos.file << std::endl;
nl = true;
NixCode nc { .errPos = pos };
getCodeLines(nc);
printCodeLines(out, prefix, nc);
} catch(const std::bad_optional_access& e) {
out << iter->hint.str() << std::endl;
}
}
return out;
}
}