Line data    Source code

       1              : #ifndef NICOLE_ERRORS_H
       2              : #define NICOLE_ERRORS_H
       3              : 
       4              : #include <expected>
       5              : #include <ostream>
       6              : 
       7              : namespace nicole {
       8              : 
       9              : enum class ERROR_TYPE {
      10              :   // Options
      11              :   MISSING_ARGUMENTS,
      12              :   MISSING_BINARY_NAME,
      13              :   MISSING_ENTRY_FILE,
      14              :   ENTRY_FILE_NOT_FOUND,
      15              :   UNKOWN_ARGUMENT,
      16              : 
      17              :   // Lexer
      18              :   CHECK_UNMATCHED,
      19              :   FILE_EXTENSION,
      20              :   FILE_NOT_OPEN,
      21              : 
      22              :   // TokeStream
      23              :   EAT,
      24              :   CURRENT,
      25              :   LOOK_AHEAD,
      26              :   LAST_READ,
      27              :   IS_CURRENT_TOKEN_TYPE,
      28              :   INSERT_AFTER,
      29              : 
      30              :   BUILDER,
      31              : 
      32              :   SINTAX,
      33              : 
      34              :   NULL_NODE,
      35              : 
      36              :   ENUM,
      37              :   VARIABLE,
      38              :   TYPE,
      39              :   FUNCTION,
      40              :   METHOD,
      41              :   ATTR,
      42              : 
      43              :   PRINT_TREE,
      44              :   VALIDATE_TREE
      45              : };
      46              : 
      47           63 : [[nodiscard]] inline std::string errorToStr(const ERROR_TYPE type) noexcept {
      48           63 :   switch (type) {
      49              :   // Options
      50            9 :   case ERROR_TYPE::MISSING_ARGUMENTS:
      51            9 :     return "MISSING_ARGUMENTS";
      52            9 :   case ERROR_TYPE::MISSING_BINARY_NAME:
      53            9 :     return "MISSING_BINARY_NAME";
      54            0 :   case ERROR_TYPE::MISSING_ENTRY_FILE:
      55            0 :     return "MISSING_ENTRY_FILE";
      56            9 :   case ERROR_TYPE::ENTRY_FILE_NOT_FOUND:
      57            9 :     return "ENTRY_FILE_NOT_FOUND";
      58            0 :   case ERROR_TYPE::UNKOWN_ARGUMENT:
      59            0 :     return "UNKOWN_ARGUMENT";
      60              : 
      61              :   // Lexer
      62            9 :   case ERROR_TYPE::CHECK_UNMATCHED:
      63            9 :     return "CHECK_UNMATCHED";
      64            9 :   case ERROR_TYPE::FILE_EXTENSION:
      65            9 :     return "FILE_EXTENSION";
      66            0 :   case ERROR_TYPE::FILE_NOT_OPEN:
      67            0 :     return "FILE_NOT_OPEN";
      68              : 
      69              :   // TokeStream
      70            9 :   case ERROR_TYPE::EAT:
      71            9 :     return "EAT";
      72            0 :   case ERROR_TYPE::CURRENT:
      73            0 :     return "CURRENT";
      74            9 :   case ERROR_TYPE::LOOK_AHEAD:
      75            9 :     return "LOOK_AHEAD";
      76            0 :   case ERROR_TYPE::LAST_READ:
      77            0 :     return "LAST_READ";
      78            0 :   case ERROR_TYPE::IS_CURRENT_TOKEN_TYPE:
      79            0 :     return "IS_CURRENT_TOKEN_TYPE";
      80            0 :   case ERROR_TYPE::INSERT_AFTER:
      81            0 :     return "INSERT_AFTER";
      82              : 
      83            0 :   case ERROR_TYPE::BUILDER:
      84            0 :     return "BUILDER";
      85              : 
      86            0 :   case ERROR_TYPE::SINTAX:
      87            0 :     return "SINTAX";
      88              : 
      89            0 :   case ERROR_TYPE::NULL_NODE:
      90            0 :     return "NULL_NODE";
      91              : 
      92            0 :   case ERROR_TYPE::ENUM:
      93            0 :     return "ENUM";
      94              : 
      95            0 :   case ERROR_TYPE::TYPE:
      96            0 :     return "TYPE";
      97              : 
      98            0 :   case ERROR_TYPE::VARIABLE:
      99            0 :     return "VARIABLE";
     100              : 
     101            0 :   case ERROR_TYPE::FUNCTION:
     102            0 :     return "FUNCTION";
     103              : 
     104            0 :   case ERROR_TYPE::METHOD:
     105            0 :     return "METHOD";
     106              : 
     107            0 :   case ERROR_TYPE::ATTR:
     108            0 :     return "ATTR";
     109              : 
     110            0 :   case ERROR_TYPE::PRINT_TREE:
     111            0 :     return "PRINT_TREE";
     112              : 
     113            0 :   case ERROR_TYPE::VALIDATE_TREE:
     114            0 :     return "VALIDATE_TREE";
     115           63 :   }
     116           63 : }
     117              : 
     118              : class Error final {
     119              : private:
     120              :   ERROR_TYPE type_;
     121              :   std::string info_;
     122              : 
     123              : public:
     124              :   explicit Error(const ERROR_TYPE type, const std::string &info) noexcept
     125          198 :       : type_{type}, info_{info} {}
     126              : 
     127          135 :   [[nodiscard]] ERROR_TYPE type() const noexcept { return type_; }
     128              : 
     129           63 :   [[nodiscard]] const std::string &info() const noexcept { return info_; }
     130              : 
     131              :   friend std::ostream &operator<<(std::ostream &os,
     132           63 :                                   const Error &error) noexcept {
     133           63 :     return os << "Error " << errorToStr(error.type_) << ": " << error.info_;
     134           63 :   }
     135              : };
     136              : 
     137              : [[nodiscard]] inline std::unexpected<Error> createError(const ERROR_TYPE type,
     138          135 :                                 const std::string &info) noexcept {
     139          135 :   return std::unexpected{Error{type, info}};
     140          135 : }
     141              : 
     142           27 : [[nodiscard]] inline std::unexpected<Error> createError(const Error &error) noexcept {
     143           27 :   return std::unexpected{error};
     144           27 : }
     145              : 
     146              : } // namespace nicole
     147              : 
     148              : #endif