feat: add rudimentary for logging

Author: nos1dot618

README.md

@@ -43,7 +43,7 @@ if_then: Any = \condition: Any.
 ```
 
 ```console
-$ ./cmake-build-debug/lbd.exe -f ./examples/if_then.lbd
+$ ./cmake-build-debug/lbd -f ./examples/if_then.lbd
 True
 False
 ```

examples/shapes.lbd

@@ -13,5 +13,4 @@ volume_of_cylinder: Float -> Float -> Float = \r: Float.
 	\h: Float. (mul (area_of_circle r) h)
 
 -- Calculate the volume of a cylinder
-(print "Volume of cylinder is: ")
-(print (volume_of_cylinder 5.0 10.0))
+(print "Volume of cylinder is: " (volume_of_cylinder 5.0 10.0) "\n")

examples/std.lbd

@@ -28,4 +28,4 @@ lte: Float -> Float -> Bool = \x: Float. \y: Float.
     (if_zero (cmp x y) true (if_zero (cmp (cmp x y) -1) true false))
 
 gte: Float -> Float -> Bool = \x: Float. \y: Float.
-    (if_zero (cmp x y) true (if_zero (cmp (cmp x y) 1) true false))
+    (if_zero (cmp x y) true (if_zero (cmp (cmp x y) 1) true false))

include/lbd/error.h

@@ -25,4 +25,4 @@ inline constexpr bool always_false_v = false;
 #define UNREACHABLE_OP ((void)0)
 #endif
 
-#define UNREACHABLE(MSG) (assert(false && (MSG)), UNREACHABLE_OP)
+#define UNREACHABLE(MSG) (assert(false && (MSG)), UNREACHABLE_OP)

include/lbd/exceptions.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <exception>
+
+struct ControlledExit final : std::exception {
+    const char *what() const noexcept override {
+        return "Controlled non-fatal exit";
+    }
+};

include/lbd/fe/lexer.h

@@ -2,6 +2,7 @@
 
 #include <lbd/fe/loc.h>
 #include <lbd/fe/token.h>
+#include <lbd/options.h>
 #include <string>
 #include <vector>
 
@@ -19,9 +20,9 @@ namespace fe::lexer {
         size_t col = 1;
         std::string filepath;
 
-        explicit Lexer(const std::string &filepath, FromFile);
+        Lexer(const std::string &filepath, FromFile, options::Options options_ = {});
 
-        explicit Lexer(const std::string &str, FromRepl);
+        Lexer(std::string str, FromRepl, options::Options options_ = {});
 
         token::Token next_token();
 

include/lbd/fe/parser.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <lbd/options.h>
 #include <lbd/fe/ast.h>
 #include <lbd/fe/token.h>
 #include <lbd/intp/types.h>
@@ -9,7 +10,7 @@ namespace fe::parser {
     struct Parser {
         ast::Program program;
 
-        explicit Parser(const std::vector<token::Token> &tokens);
+        explicit Parser(const std::vector<token::Token> &tokens, options::Options options_ = {});
 
     private:
         // TODO: Add checks for T to be a variant of fe::token::TokenType

include/lbd/intp/builtins.h

@@ -1,7 +1,8 @@
 #pragma once
 
 #include <lbd/intp/interpreter.h>
+#include <lbd/options.h>
 
 namespace intp::interp {
-    std::vector<NativeFunction> get_builtins();
+    std::vector<NativeFunction> get_builtins(options::Options options_ = {});
 }

include/lbd/intp/interpreter.h

@@ -6,6 +6,7 @@
 #include <variant>
 #include <lbd/fe/ast.h>
 #include <lbd/fe/parser.h>
+#include <lbd/options.h>
 
 namespace intp::interp {
     struct NativeFunction;
@@ -54,7 +55,7 @@ namespace intp::interp {
         using Impl = std::function<Value(
             const std::vector<std::shared_ptr<Thunk> > &, const std::shared_ptr<Env> &)>;
 
-        std::size_t arity;
+        int arity;
         std::string name;
         Impl impl;
 
@@ -113,12 +114,8 @@ namespace intp::interp {
         Value value;
     };
 
-    struct Options {
-        bool own_expr = false;
-    };
-
     Result interpret(fe::ast::Program &program, std::optional<std::shared_ptr<Env> > global_env = std::nullopt,
-                     Options options = {});
+                     options::Options options_ = {});
 
     /// Add builtins Native Functions into Environment
     void install_builtins(const std::shared_ptr<Env> &env);

include/lbd/logs.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <optional>
+#include <lbd/fe/loc.h>
+#include <lbd/utils/term.h>
+#include <lbd/exceptions.h>
+
+namespace logs {
+    struct Logger {
+        bool exit_on_error = true;
+        bool use_color = false;
+        bool show_loc = true;
+
+        Logger() = default;
+
+        Logger(const bool exit_on_error, const bool use_color, const bool show_loc) : exit_on_error(exit_on_error),
+            use_color(use_color), show_loc(show_loc) {
+            if (use_color) {
+                enable_virtual_terminal();
+            }
+        }
+
+        template<typename... Args>
+        [[noreturn]] void error(const std::optional<fe::loc::Loc> &loc, Args &&... args) const {
+            if (use_color) {
+                std::cerr << colors::RED;
+            }
+            if (show_loc && loc.has_value()) {
+                std::cerr << loc.value() << ": ";
+            }
+            (std::cerr << ... << std::forward<Args>(args));
+            if (use_color) {
+                std::cerr << colors::RESET;
+            }
+            std::cerr << std::endl;
+            if (exit_on_error) {
+                exit(EXIT_FAILURE);
+            }
+            throw ControlledExit{};
+        }
+
+        template<typename... Args>
+        void info(Args &&... args) const {
+            log_impl(colors::BLUE, std::cout, std::forward<Args>(args)...);
+        }
+
+        template<typename... Args>
+        void debug(Args &&... args) const {
+            log_impl(colors::YELLOW, std::cout, std::forward<Args>(args)...);
+        }
+
+    private:
+        template<typename... Args>
+        void log_impl(const std::string &color, std::ostream &os, Args &&... args) const {
+            if (use_color) {
+                os << color;
+            }
+            (os << ... << std::forward<Args>(args));
+            if (use_color) {
+                os << colors::RESET;
+            }
+            os << std::endl;
+        }
+    };
+}