2020-05-09 00:18:28 +00:00
|
|
|
#include "error.hh"
|
2020-03-22 18:25:47 +00:00
|
|
|
|
|
|
|
#include <iostream>
|
2020-03-25 16:52:03 +00:00
|
|
|
#include <optional>
|
2020-04-17 21:07:44 +00:00
|
|
|
#include "serialise.hh"
|
2020-05-14 18:28:18 +00:00
|
|
|
#include <sstream>
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-04-29 03:06:08 +00:00
|
|
|
namespace nix {
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-04-24 20:57:51 +00:00
|
|
|
|
|
|
|
const std::string nativeSystem = SYSTEM;
|
|
|
|
|
|
|
|
|
|
|
|
BaseError & BaseError::addPrefix(const FormatOrString & fs)
|
|
|
|
{
|
|
|
|
prefix_ = fs.s + prefix_;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
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_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-02 03:30:19 +00:00
|
|
|
std::optional<string> ErrorInfo::programName = std::nullopt;
|
2020-03-22 18:25:47 +00:00
|
|
|
|
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)
|
2020-03-22 18:25:47 +00:00
|
|
|
{
|
2020-05-09 00:18:28 +00:00
|
|
|
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-03-22 18:25:47 +00:00
|
|
|
}
|
|
|
|
|
2020-05-20 23:25:02 +00:00
|
|
|
void getCodeLines(NixCode &nixCode)
|
|
|
|
{
|
|
|
|
if (nixCode.errPos.line <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// check this magic value!
|
|
|
|
if (nixCode.errPos.file == "(string)")
|
|
|
|
return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
AutoCloseFD fd = open(nixCode.errPos.file.c_str(), O_RDONLY | O_CLOEXEC);
|
|
|
|
if (!fd)
|
|
|
|
throw SysError("opening file '%1%'", nixCode.errPos.file);
|
|
|
|
|
|
|
|
// count the newlines.
|
|
|
|
|
|
|
|
int count = 0;
|
|
|
|
string line;
|
|
|
|
int pl = nixCode.errPos.line - 1;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
line = readLine(fd.get());
|
|
|
|
++count;
|
|
|
|
if (count < pl)
|
|
|
|
{
|
|
|
|
;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
catch (EndOfFile &eof) {
|
|
|
|
;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
printError("error reading nix file: %s\n%s", nixCode.errPos.file, e.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-09 00:18:28 +00:00
|
|
|
void printCodeLines(std::ostream &out, const string &prefix, const NixCode &nixCode)
|
2020-03-22 18:25:47 +00:00
|
|
|
{
|
2020-04-08 15:48:21 +00:00
|
|
|
// previous line of code.
|
|
|
|
if (nixCode.prevLineOfCode.has_value()) {
|
2020-05-09 00:18:28 +00:00
|
|
|
out << fmt("%1% %|2$5d|| %3%",
|
2020-04-29 16:14:32 +00:00
|
|
|
prefix,
|
|
|
|
(nixCode.errPos.line - 1),
|
|
|
|
*nixCode.prevLineOfCode)
|
2020-05-09 00:18:28 +00:00
|
|
|
<< std::endl;
|
2020-04-08 15:48:21 +00:00
|
|
|
}
|
2020-04-02 22:02:40 +00:00
|
|
|
|
2020-05-09 00:18:28 +00:00
|
|
|
if (nixCode.errLineOfCode.has_value()) {
|
|
|
|
// line of code containing the error.
|
|
|
|
out << fmt("%1% %|2$5d|| %3%",
|
|
|
|
prefix,
|
|
|
|
(nixCode.errPos.line),
|
|
|
|
*nixCode.errLineOfCode)
|
|
|
|
<< std::endl;
|
|
|
|
// 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(" ");
|
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-05-09 00:18:28 +00:00
|
|
|
std::string arrows("^");
|
2020-04-01 22:20:20 +00:00
|
|
|
|
2020-05-09 00:18:28 +00:00
|
|
|
out << fmt("%1% |%2%" ANSI_RED "%3%" ANSI_NORMAL,
|
|
|
|
prefix,
|
|
|
|
spaces,
|
|
|
|
arrows) << std::endl;
|
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
}
|
|
|
|
|
2020-04-08 15:48:21 +00:00
|
|
|
// next line of code.
|
|
|
|
if (nixCode.nextLineOfCode.has_value()) {
|
2020-05-09 00:18:28 +00:00
|
|
|
out << fmt("%1% %|2$5d|| %3%",
|
2020-04-29 16:14:32 +00:00
|
|
|
prefix,
|
|
|
|
(nixCode.errPos.line + 1),
|
|
|
|
*nixCode.nextLineOfCode)
|
2020-05-09 00:18:28 +00:00
|
|
|
<< std::endl;
|
2020-04-08 15:48:21 +00:00
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
}
|
|
|
|
|
2020-04-17 21:07:44 +00:00
|
|
|
std::ostream& operator<<(std::ostream &out, const ErrorInfo &einfo)
|
2020-03-22 18:25:47 +00:00
|
|
|
{
|
2020-04-01 22:20:20 +00:00
|
|
|
int errwidth = 80;
|
2020-04-25 03:40:13 +00:00
|
|
|
string prefix = "";
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-04-01 22:20:20 +00:00
|
|
|
string levelString;
|
2020-04-02 22:02:40 +00:00
|
|
|
switch (einfo.level) {
|
2020-05-09 00:18:28 +00:00
|
|
|
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-03-22 18:25:47 +00:00
|
|
|
}
|
|
|
|
|
2020-04-01 22:20:20 +00:00
|
|
|
int ndl = prefix.length() + levelString.length() + 3 + einfo.name.length() + einfo.programName.value_or("").length();
|
2020-04-02 22:02:40 +00:00
|
|
|
int dashwidth = ndl > (errwidth - 3) ? 3 : errwidth - ndl;
|
2020-04-01 22:20:20 +00:00
|
|
|
|
|
|
|
string dashes;
|
|
|
|
for (int i = 0; i < dashwidth; ++i)
|
|
|
|
dashes.append("-");
|
|
|
|
|
|
|
|
// divider.
|
2020-04-25 18:05:26 +00:00
|
|
|
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(""))
|
2020-04-29 03:06:08 +00:00
|
|
|
<< std::endl;
|
2020-04-25 18:05:26 +00:00
|
|
|
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(""))
|
2020-04-29 03:06:08 +00:00
|
|
|
<< std::endl;
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-05-11 19:02:16 +00:00
|
|
|
// filename, line, column.
|
2020-04-02 22:02:40 +00:00
|
|
|
if (einfo.nixCode.has_value()) {
|
2020-04-17 21:50:46 +00:00
|
|
|
if (einfo.nixCode->errPos.file != "") {
|
2020-05-09 00:18:28 +00:00
|
|
|
out << fmt("%1%in file: " ANSI_BLUE "%2% %3%" ANSI_NORMAL,
|
2020-04-29 16:14:32 +00:00
|
|
|
prefix,
|
|
|
|
einfo.nixCode->errPos.file,
|
2020-05-09 00:18:28 +00:00
|
|
|
showErrPos(einfo.nixCode->errPos)) << std::endl;
|
2020-04-17 21:07:44 +00:00
|
|
|
out << prefix << std::endl;
|
2020-04-02 22:02:40 +00:00
|
|
|
} else {
|
2020-04-17 21:07:44 +00:00
|
|
|
out << fmt("%1%from command line argument", prefix) << std::endl;
|
|
|
|
out << prefix << std::endl;
|
2020-04-01 22:20:20 +00:00
|
|
|
}
|
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-04-01 22:20:20 +00:00
|
|
|
// description
|
2020-04-25 03:40:13 +00:00
|
|
|
if (einfo.description != "") {
|
|
|
|
out << prefix << einfo.description << std::endl;
|
|
|
|
out << prefix << std::endl;
|
|
|
|
}
|
2020-04-01 22:20:20 +00:00
|
|
|
|
|
|
|
|
2020-05-20 23:25:02 +00:00
|
|
|
if (einfo.nixCode.has_value()) {
|
|
|
|
NixCode nixcode = *einfo.nixCode;
|
|
|
|
getCodeLines(nixcode);
|
|
|
|
|
|
|
|
// lines of code.
|
|
|
|
if (nixcode.errLineOfCode.has_value()) {
|
|
|
|
printCodeLines(out, prefix, nixcode);
|
|
|
|
out << prefix << std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
// hint
|
|
|
|
out << prefix << *einfo.hint << std::endl;
|
|
|
|
out << prefix << std::endl;
|
|
|
|
|
2020-04-01 22:20:20 +00:00
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
|
2020-04-17 21:07:44 +00:00
|
|
|
return out;
|
|
|
|
}
|
2020-03-22 18:25:47 +00:00
|
|
|
}
|