formatted with astyle

src/libutil/error.cc

@@ -3,18 +3,16 @@
 #include <iostream>
 #include <optional>
 
-namespace nix {
+namespace nix
+{
 
 std::optional<string> ErrorInfo::programName = std::nullopt;
 
 string showErrLine(ErrLine &errLine)
 {
-    if (errLine.columnRange.has_value()) 
-    {
+    if (errLine.columnRange.has_value()) {
         return (format("(%1%:%2%)") % errLine.lineNumber % errLine.columnRange->start).str();
-    }
-    else
-    {
+    } else {
         return (format("(%1%)") % errLine.lineNumber).str();
     };
 }
@@ -22,42 +20,38 @@ string showErrLine(ErrLine &errLine)
 void printCodeLines(string &prefix, NixCode &nixCode)
 {
 
-  if (nixCode.errLine.has_value()) 
-    {
+    if (nixCode.errLine.has_value()) {
         // previous line of code.
         if (nixCode.errLine->prevLineOfCode.has_value()) {
             std::cout << format("%1% %|2$5d|| %3%")
-                %    prefix
-                % (nixCode.errLine->lineNumber - 1)
-                % *nixCode.errLine->prevLineOfCode
-                << std::endl;
+                      %    prefix
+                      % (nixCode.errLine->lineNumber - 1)
+                      % *nixCode.errLine->prevLineOfCode
+                      << std::endl;
         }
 
         // line of code containing the error.%2$+5d%
         std::cout << format("%1% %|2$5d|| %3%")
-            %    prefix
-            % (nixCode.errLine->lineNumber)
-            % nixCode.errLine->errLineOfCode
-            << std::endl;
+                  %    prefix
+                  % (nixCode.errLine->lineNumber)
+                  % nixCode.errLine->errLineOfCode
+                  << std::endl;
 
-      // error arrows for the column range.
-        if (nixCode.errLine->columnRange.has_value()) 
-        {
+        // error arrows for the column range.
+        if (nixCode.errLine->columnRange.has_value()) {
             int start = nixCode.errLine->columnRange->start;
             std::string spaces;
-            for (int i = 0; i < start; ++i)
-            {
+            for (int i = 0; i < start; ++i) {
                 spaces.append(" ");
             }
 
             int len = nixCode.errLine->columnRange->len;
             std::string arrows;
-            for (int i = 0; i < len; ++i)
-            {
+            for (int i = 0; i < len; ++i) {
                 arrows.append("^");
             }
 
-          std::cout << format("%1%      |%2%" ANSI_RED "%3%" ANSI_NORMAL) % prefix % spaces % arrows << std::endl;
+            std::cout << format("%1%      |%2%" ANSI_RED "%3%" ANSI_NORMAL) % prefix % spaces % arrows << std::endl;
         }
 
 
@@ -65,10 +59,10 @@ void printCodeLines(string &prefix, NixCode &nixCode)
         // next line of code.
         if (nixCode.errLine->nextLineOfCode.has_value()) {
             std::cout << format("%1% %|2$5d|| %3%")
-            %    prefix
-            % (nixCode.errLine->lineNumber + 1)
-            % *nixCode.errLine->nextLineOfCode
-            << std::endl;
+                      %    prefix
+                      % (nixCode.errLine->lineNumber + 1)
+                      % *nixCode.errLine->nextLineOfCode
+                      << std::endl;
         }
 
     }
@@ -81,27 +75,23 @@ void printErrorInfo(ErrorInfo &einfo)
     string prefix = "    ";
 
     string levelString;
-    switch (einfo.level) 
-    {
-        case ErrLevel::elError: 
-            {
-                levelString = ANSI_RED;
-                levelString += "error:";
-                levelString += ANSI_NORMAL;
-                break;
-            }
-        case ErrLevel::elWarning: 
-            {
-                levelString = ANSI_YELLOW;
-                levelString += "warning:";    
-                levelString += ANSI_NORMAL;
-                break;
-            }
-        default: 
-            {
-                levelString = (format("invalid error level: %1%") % einfo.level).str();    
-                break;
-            }
+    switch (einfo.level) {
+    case ErrLevel::elError: {
+        levelString = ANSI_RED;
+        levelString += "error:";
+        levelString += ANSI_NORMAL;
+        break;
+    }
+    case ErrLevel::elWarning: {
+        levelString = ANSI_YELLOW;
+        levelString += "warning:";
+        levelString += ANSI_NORMAL;
+        break;
+    }
+    default: {
+        levelString = (format("invalid error level: %1%") % einfo.level).str();
+        break;
+    }
     }
 
     int ndl = prefix.length() + levelString.length() + 3 + einfo.name.length() + einfo.programName.value_or("").length();
@@ -113,29 +103,25 @@ void printErrorInfo(ErrorInfo &einfo)
 
     // divider.
     std::cout << format("%1%%2%" ANSI_BLUE " %3% %4% %5% %6%" ANSI_NORMAL)
-        % prefix
-        % levelString
-        % "---"
-        % einfo.name
-        % dashes
-        % einfo.programName.value_or("")
-        << std::endl;
+              % prefix
+              % levelString
+              % "---"
+              % einfo.name
+              % dashes
+              % einfo.programName.value_or("")
+              << std::endl;
 
     // filename.
-    if (einfo.nixCode.has_value()) 
-    {
-        if (einfo.nixCode->nixFile.has_value()) 
-        {
+    if (einfo.nixCode.has_value()) {
+        if (einfo.nixCode->nixFile.has_value()) {
             string eline = einfo.nixCode->errLine.has_value()
-                ? string(" ") + showErrLine(*einfo.nixCode->errLine)
-                : "";
+                           ? string(" ") + showErrLine(*einfo.nixCode->errLine)
+                           : "";
 
             std::cout << format("%1%in file: " ANSI_BLUE "%2%%3%" ANSI_NORMAL)
-                % prefix % *einfo.nixCode->nixFile % eline << std::endl;
+                      % prefix % *einfo.nixCode->nixFile % eline << std::endl;
             std::cout << prefix << std::endl;
-        }
-        else
-        {
+        } else {
             std::cout << format("%1%from command line argument") % prefix << std::endl;
             std::cout << prefix << std::endl;
         }
@@ -146,15 +132,13 @@ void printErrorInfo(ErrorInfo &einfo)
     std::cout << prefix << std::endl;
 
     // lines of code.
-    if (einfo.nixCode.has_value())
-    {
+    if (einfo.nixCode.has_value()) {
         printCodeLines(prefix, *einfo.nixCode);
         std::cout << prefix << std::endl;
     }
 
     // hint
-    if (einfo.hint.has_value()) 
-    {
+    if (einfo.hint.has_value()) {
         std::cout << prefix << *einfo.hint << std::endl;
         std::cout << prefix << std::endl;
     }

src/libutil/error.hh

@@ -9,41 +9,45 @@
 
 #include <boost/format.hpp>
 
-namespace nix {
+namespace nix
+{
 
 typedef enum {
     elWarning,
     elError
 } ErrLevel;
 
-class ColumnRange { 
-    public:
-        unsigned int start;
-        unsigned int len;
+class ColumnRange
+{
+public:
+    unsigned int start;
+    unsigned int len;
 };
 
 class ErrorInfo;
 
-class ErrLine { 
-    public:
-        int lineNumber;
-        std::optional<ColumnRange> columnRange;
-        std::optional<string> prevLineOfCode;
-        string errLineOfCode;
-        std::optional<string> nextLineOfCode;
+class ErrLine
+{
+public:
+    int lineNumber;
+    std::optional<ColumnRange> columnRange;
+    std::optional<string> prevLineOfCode;
+    string errLineOfCode;
+    std::optional<string> nextLineOfCode;
 };
 
-class NixCode { 
-    public:
-        std::optional<string> nixFile;
-        std::optional<ErrLine> errLine;
+class NixCode
+{
+public:
+    std::optional<string> nixFile;
+    std::optional<ErrLine> errLine;
 
-        ErrLine& ensureErrLine() 
-        { 
-            if (!this->errLine.has_value())
-                 this->errLine = std::optional(ErrLine());
-            return *this->errLine; 
-        }
+    ErrLine& ensureErrLine()
+    {
+        if (!this->errLine.has_value())
+            this->errLine = std::optional(ErrLine());
+        return *this->errLine;
+    }
 };
 
 // -------------------------------------------------
@@ -75,126 +79,157 @@ template <class T>
 class AddLOC;
 
 // The error info class itself.
-class ErrorInfo { 
-    public:
-        ErrLevel level;
-        string name;
-        string description;
-        std::optional<NixCode> nixCode;
-        std::optional<string> hint;
-        ErrorInfo& GetEI() { return *this; }
+class ErrorInfo
+{
+public:
+    ErrLevel level;
+    string name;
+    string description;
+    std::optional<NixCode> nixCode;
+    std::optional<string> hint;
+    ErrorInfo& GetEI()
+    {
+        return *this;
+    }
 
-        static std::optional<string> programName;
+    static std::optional<string> programName;
 
-        // give these access to the private constructor, 
-        // when they are direct descendants (children but not grandchildren).
-        friend AddName<ErrorInfo>;
-        friend AddDescription<ErrorInfo>;
-        friend AddNixCode<ErrorInfo>;
-        friend AddNixFile<ErrorInfo>;
-        friend AddErrLine<ErrorInfo>;
-        friend AddLineNumber<ErrorInfo>;
-        friend AddColumnRange<ErrorInfo>;
-        friend AddLOC<ErrorInfo>;
+    // give these access to the private constructor,
+    // when they are direct descendants (children but not grandchildren).
+    friend AddName<ErrorInfo>;
+    friend AddDescription<ErrorInfo>;
+    friend AddNixCode<ErrorInfo>;
+    friend AddNixFile<ErrorInfo>;
+    friend AddErrLine<ErrorInfo>;
+    friend AddLineNumber<ErrorInfo>;
+    friend AddColumnRange<ErrorInfo>;
+    friend AddLOC<ErrorInfo>;
 
-        NixCode& ensureNixCode() 
-        { 
-            if (!this->nixCode.has_value())
-                 this->nixCode = std::optional(NixCode());
-            return *this->nixCode; 
-        }
-    protected:
-        // constructor is protected, so only the builder classes can create an ErrorInfo.
-        ErrorInfo(ErrLevel level) { this->level = level; }
+    NixCode& ensureNixCode()
+    {
+        if (!this->nixCode.has_value())
+            this->nixCode = std::optional(NixCode());
+        return *this->nixCode;
+    }
+protected:
+    // constructor is protected, so only the builder classes can create an ErrorInfo.
+    ErrorInfo(ErrLevel level)
+    {
+        this->level = level;
+    }
 };
 
 // Init as error
 class EIError : public ErrorInfo
 {
-    protected:
-        EIError() : ErrorInfo(elError) {}
+protected:
+    EIError() : ErrorInfo(elError) {}
 };
 
 // Init as warning
 class EIWarning : public ErrorInfo
 {
-    protected:
-        EIWarning() : ErrorInfo(elWarning) {}
+protected:
+    EIWarning() : ErrorInfo(elWarning) {}
 };
 
 // Builder class definitions.
 template <class T>
 class AddName : private T
 {
-    public:
-        T& name(const std::string &name){
-            GetEI().name = name;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& name(const std::string &name)
+    {
+        GetEI().name = name;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 template <class T>
 class AddDescription : private T
 {
-    public:
-        T& description(const std::string &description){
-            GetEI().description = description;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& description(const std::string &description)
+    {
+        GetEI().description = description;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 template <class T>
 class AddNixFile : private T
 {
-    public:
-        T& nixFile(string filename) { 
-            GetEI().ensureNixCode().nixFile = filename;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& nixFile(string filename)
+    {
+        GetEI().ensureNixCode().nixFile = filename;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 template <class T>
 class AddLineNumber : private T
 {
-    public:
-        T& lineNumber(int lineNumber) { 
-            GetEI().ensureNixCode().ensureErrLine().lineNumber = lineNumber;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& lineNumber(int lineNumber)
+    {
+        GetEI().ensureNixCode().ensureErrLine().lineNumber = lineNumber;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 template <class T>
 class AddColumnRange : private T
 {
-    public:
-        T& columnRange(unsigned int start, unsigned int len) { 
-            GetEI().ensureNixCode().ensureErrLine().columnRange = { start, len };
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& columnRange(unsigned int start, unsigned int len)
+    {
+        GetEI().ensureNixCode().ensureErrLine().columnRange = { start, len };
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 template <class T>
 class AddLOC : private T
 {
-    public:
-        T& linesOfCode(std::optional<string> prevloc, string loc, std::optional<string> nextloc) { 
-            GetEI().ensureNixCode().ensureErrLine().prevLineOfCode = prevloc;
-            GetEI().ensureNixCode().ensureErrLine().errLineOfCode = loc;
-            GetEI().ensureNixCode().ensureErrLine().nextLineOfCode = nextloc;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& linesOfCode(std::optional<string> prevloc, string loc, std::optional<string> nextloc)
+    {
+        GetEI().ensureNixCode().ensureErrLine().prevLineOfCode = prevloc;
+        GetEI().ensureNixCode().ensureErrLine().errLineOfCode = loc;
+        GetEI().ensureNixCode().ensureErrLine().nextLineOfCode = nextloc;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 
@@ -206,8 +241,8 @@ template <class T>
 class yellowify
 {
 public:
-        yellowify(T &s) : value(s) {}
-        T &value;
+    yellowify(T &s) : value(s) {}
+    T &value;
 };
 
 template <class T>
@@ -218,17 +253,22 @@ std::ostream& operator<<(std::ostream &out, const yellowify<T> &y)
 
 class hintfmt
 {
-    public:
-        hintfmt(string format) :fmt(format) {
-            fmt.exceptions(boost::io::all_error_bits ^ boost::io::too_many_args_bit);
-          }
-        template<class T>
-            hintfmt& operator%(const T &value) { fmt % yellowify(value); return *this; }
+public:
+    hintfmt(string format) :fmt(format)
+    {
+        fmt.exceptions(boost::io::all_error_bits ^ boost::io::too_many_args_bit);
+    }
+    template<class T>
+    hintfmt& operator%(const T &value)
+    {
+        fmt % yellowify(value);
+        return *this;
+    }
 
-        template <typename U>
-        friend class AddHint;
-    private:
-        format fmt;
+    template <typename U>
+    friend class AddHint;
+private:
+    format fmt;
 
 };
 
@@ -236,49 +276,54 @@ class hintfmt
 template <class T>
 class AddHint : private T
 {
-    public:
-        T& hint(hintfmt &hfmt) {
-            GetEI().hint = std::optional(hfmt.fmt.str());
-            return *this;
-        }
-        T& nohint() {
-            GetEI().hint = std::nullopt;
-            return *this;
-        }
-    protected:
-        ErrorInfo& GetEI() { return T::GetEI(); }
+public:
+    T& hint(hintfmt &hfmt)
+    {
+        GetEI().hint = std::optional(hfmt.fmt.str());
+        return *this;
+    }
+    T& nohint()
+    {
+        GetEI().hint = std::nullopt;
+        return *this;
+    }
+protected:
+    ErrorInfo& GetEI()
+    {
+        return T::GetEI();
+    }
 };
 
 // --------------------------------------------------------
 // error types
 
 typedef AddName<
-        AddDescription<
-        AddHint<
-        EIError>>> ProgramError;
+AddDescription<
+AddHint<
+EIError>>> ProgramError;
 
 typedef AddName<
-        AddDescription<
-        AddHint<
-        EIWarning>>> ProgramWarning;
+AddDescription<
+AddHint<
+EIWarning>>> ProgramWarning;
 
 typedef AddName<
-        AddDescription<
-        AddNixFile<
-        AddLineNumber<
-        AddColumnRange<
-        AddLOC<
-        AddHint<
-        EIError>>>>>>> NixLangError;
+AddDescription<
+AddNixFile<
+AddLineNumber<
+AddColumnRange<
+AddLOC<
+AddHint<
+EIError>>>>>>> NixLangError;
 
 typedef AddName<
-        AddDescription<
-        AddNixFile<
-        AddLineNumber<
-        AddColumnRange<
-        AddLOC<
-        AddHint<
-        EIWarning>>>>>>> NixLangWarning;
+AddDescription<
+AddNixFile<
+AddLineNumber<
+AddColumnRange<
+AddLOC<
+AddHint<
+EIWarning>>>>>>> NixLangWarning;
 
 
 // --------------------------------------------------------

tests/errors/main.cc

@@ -1,7 +1,7 @@
 #include "../../src/libutil/error.hh"
 
-#include <optional>
 #include <iostream>
+#include <optional>
 
 int main()
 {
@@ -16,26 +16,26 @@ int main()
     //
     // Each error type is created with a specific sequence of builder functions.
     // Unlike with a constructor, each parameter is clearly named.
-    // If the sequence of function calls isn't followed, then there's a type error.
-    // This should make for a consistent look in the code when errors are created.
+    // If the sequence of function calls isn't followed, then there's a type
+    // error. This should make for a consistent look in the code when errors are
+    // created.
 
     // ProgramError takes name, description, and an optional hint.
-    printErrorInfo(
-        ProgramError()
-            .name("name")
-            .description("error description")
-            .nohint()
-            );
+    printErrorInfo( ProgramError()
+                    .name("name")
+                    .description("error description")
+                    .nohint()
+                  );
 
     // ProgramWarning takes name, description, and an optional hint.
-    // The hint is in the form of a hintfmt class, which wraps boost::format(), and 
-    // makes all the substituted text yellow.
-    printErrorInfo(
-        ProgramWarning()
-            .name("warning name")
-            .description("warning description")
-            .hint(hintfmt("there was a %1%") % "warning") // 'warning' will be yellow.
-            );
+    // The hint is in the form of a hintfmt class, which wraps boost::format(),
+    // and makes all the substituted text yellow.
+    printErrorInfo( ProgramWarning()
+                    .name("warning name")
+                    .description("warning description")
+                    .hint(hintfmt("there was a %1%") %
+                          "warning") // 'warning' will be yellow.
+                  );
 
     /*
       // some invalid errors:
@@ -51,41 +51,38 @@ int main()
         .name("name")
         .nohint();
 
-      // type error: hint function with regular boost format, not special hintfmt.
-      ProgramError()
-        .description("error description")
-        .name("name")
+      // type error: hint function with regular boost format, not special
+      hintfmt. ProgramError() .description("error description") .name("name")
         .hint(format("there was a %1%") % "warning");
     */
 
-    // NixLangWarning adds nix file, line number, column range, and the lines of code 
-    // where a warning occurred.
-    printErrorInfo(
-        NixLangWarning()
-            .name("warning name")
-            .description("warning description")
-            .nixFile("myfile.nix")
-            .lineNumber(40)
-            .columnRange(13,7)
-            .linesOfCode(std::nullopt
-                        ,"this is the problem line of code"
-                        ,std::nullopt)
-            .hint(hintfmt("this hint has %1% templated %2%!!") % "yellow" % "values")
-            );
+    // NixLangWarning adds nix file, line number, column range, and the lines of
+    // code where a warning occurred.
+    printErrorInfo(NixLangWarning()
+                   .name("warning name")
+                   .description("warning description")
+                   .nixFile("myfile.nix")
+                   .lineNumber(40)
+                   .columnRange(13, 7)
+                   .linesOfCode(std::nullopt,
+                                "this is the problem line of code",
+                                std::nullopt)
+                   .hint(hintfmt("this hint has %1% templated %2%!!") %
+                         "yellow" % "values"));
 
-    // NixLangError is just the same as NixLangWarning, except for the Error flag.
-    printErrorInfo(
-        NixLangError()
-            .name("error name")
-            .description("error description")
-            .nixFile("myfile.nix")
-            .lineNumber(40)
-            .columnRange(13,7)
-            .linesOfCode(std::optional("previous line of code")
-                        ,"this is the problem line of code"
-                        ,std::optional("next line of code"))
-            .hint(hintfmt("this hint has %1% templated %2%!!") % "yellow" % "values")
-            );
+    // NixLangError is just the same as NixLangWarning, except for the Error
+    // flag.
+    printErrorInfo(NixLangError()
+                   .name("error name")
+                   .description("error description")
+                   .nixFile("myfile.nix")
+                   .lineNumber(40)
+                   .columnRange(13, 7)
+                   .linesOfCode(std::optional("previous line of code"),
+                                "this is the problem line of code",
+                                std::optional("next line of code"))
+                   .hint(hintfmt("this hint has %1% templated %2%!!") %
+                         "yellow" % "values"));
 
     return 0;
 }