Implement REPL

Author: nos1dot618

CMakeLists.txt

@@ -24,6 +24,7 @@ add_library(intp STATIC
 add_executable(lbd
     ${CMAKE_SOURCE_DIR}/src/main.cpp
     ${CMAKE_SOURCE_DIR}/src/cmd.cpp
+    ${CMAKE_SOURCE_DIR}/src/repl.cpp
 )
 
 target_link_libraries(lbd PRIVATE fe intp)

include/lbd/fe/lexer.h

@@ -6,14 +6,22 @@
 #include <vector>
 
 namespace fe::lexer {
+    struct FromFile {
+    };
+
+    struct FromRepl {
+    };
+
     struct Lexer {
         std::string source;
         size_t pos = 0;
         size_t row = 1;
         size_t col = 1;
         std::string filepath;
 
-        explicit Lexer(const std::string &filepath);
+        explicit Lexer(const std::string &filepath, FromFile);
+
+        explicit Lexer(const std::string &str, FromRepl);
 
         token::Token next_token();
 

include/lbd/intp/interpreter.h

@@ -77,9 +77,10 @@ namespace intp::interp {
     /// Program Driver
     struct Result {
         std::shared_ptr<Env> global_env;
+        Value value;
     };
 
-    Result interpret(const fe::ast::Program &program);
+    Result interpret(const fe::ast::Program &program, std::optional<std::shared_ptr<Env> > global_env = std::nullopt);
 
     /// Add builtins Native Functions into Environment
     void install_builtins(const std::shared_ptr<Env> &env);

include/lbd/repl.h

@@ -0,0 +1,5 @@
+#pragma once
+
+namespace repl {
+    void loop(bool debug = false);
+}

src/fe/lexer.cpp

@@ -29,7 +29,7 @@ namespace fe::lexer {
         return {row, col, filepath};
     }
 
-    Lexer::Lexer(const std::string &filepath) : filepath(filepath) {
+    Lexer::Lexer(const std::string &filepath, FromFile) : filepath(filepath) {
         std::ifstream ifs(filepath);
         if (!ifs) {
             std::cerr << "error: could not open file "
@@ -42,6 +42,9 @@ namespace fe::lexer {
         source = ss.str();
     }
 
+    Lexer::Lexer(const std::string &str, FromRepl) : source(str) {
+    }
+
     token::Token Lexer::next_token() {
         char c = peek();
         // Skip whitespace

src/intp/interpreter.cpp

@@ -243,23 +243,25 @@ namespace intp::interp {
         thunk->set(&def_ast_node.expr, env, def_ast_node.expr.get_loc());
     }
 
-    Result interpret(const fe::ast::Program &program) {
-        const auto global_env = std::make_shared<Env>();
-        install_builtins(global_env);
+    Result interpret(const fe::ast::Program &program, std::optional<std::shared_ptr<Env> > global_env) {
+        if (!global_env) {
+            global_env = std::make_shared<Env>();
+        }
+        Value result_value;
+        install_builtins(*global_env);
         for (const auto &[value]: program.nodes) {
             std::visit([&]<typename T0>(T0 &&arg) {
                 using T = std::decay_t<T0>;
                 if constexpr (std::is_same_v<T, fe::ast::Expression>) {
-                    eval_expr(arg, global_env);
-                    // The top level Value returned by this is not needed
+                    result_value = eval_expr(arg, *global_env);
                 } else if constexpr (std::is_same_v<T, fe::ast::DefAstNode>) {
-                    bind_def_ast_node_lazy(arg, global_env);
+                    bind_def_ast_node_lazy(arg, *global_env);
                 } else {
                     STATIC_ASSERT_UNREACHABLE_T(T, "unhandled program node");
                 }
             }, value);
         }
-        return {global_env};
+        return {*global_env, result_value};
     }
 
     void install_builtins(const std::shared_ptr<Env> &env) {

src/main.cpp

@@ -4,6 +4,7 @@
 #include <lbd/fe/parser.h>
 #include <lbd/intp/interpreter.h>
 #include <lbd/cmd.h>
+#include <lbd/repl.h>
 #include <string>
 #include <vector>
 
@@ -13,27 +14,26 @@ int main(const int argc, char **argv) {
     const auto &[filepath, show_help, repl, debug] = cmd::parse_args(argc, argv, program_name);
     if (show_help) {
         cmd::print_help(std::cout, argv[0]);
-        return 0;
+        return EXIT_SUCCESS;
     }
     if (repl) {
-        std::cout << "entering REPL mode (not yet implemented)..." << std::endl;
-        // TODO: implement REPL
-        return 0;
-    }
-    // Lex
-    auto lexer_v = fe::lexer::Lexer(*filepath);
-    const std::vector<fe::token::Token> tokens = lexer_v.lex_all();
-    if (debug) {
-        for (const fe::token::Token &token: tokens) {
-            std::cout << token << std::endl;
+        repl::loop(debug);
+    } else {
+        // Lex
+        auto lexer_v = fe::lexer::Lexer(*filepath, fe::lexer::FromFile{});
+        const std::vector<fe::token::Token> tokens = lexer_v.lex_all();
+        if (debug) {
+            for (const fe::token::Token &token: tokens) {
+                std::cout << token << std::endl;
+            }
         }
+        // Parse
+        const auto parser = fe::parser::Parser(tokens);
+        if (debug) {
+            std::cout << parser.program << std::endl;
+        }
+        // Interpret
+        auto result = intp::interp::interpret(parser.program);
+        return EXIT_SUCCESS;
     }
-    // Parse
-    const auto parser = fe::parser::Parser(tokens);
-    if (debug) {
-        std::cout << parser.program << std::endl;
-    }
-    // Interpret
-    auto result = intp::interp::interpret(parser.program);
-    return EXIT_SUCCESS;
 }

src/repl.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include <lbd/repl.h>
+
+#include "lbd/fe/lexer.h"
+#include "lbd/fe/parser.h"
+#include "lbd/intp/interpreter.h"
+
+namespace repl {
+    void loop(const bool debug) {
+        std::cout << "Lambda Discipline REPL. Type :quit to exit." << std::endl;
+        std::string line;
+        std::optional<std::shared_ptr<intp::interp::Env> > shared_global_env = std::nullopt;
+        while (true) {
+            std::cout << "lbd> ";
+            if (!std::getline(std::cin, line)) {
+                break; // EOF (C-d / C-z)
+            }
+            if (line == ":quit" || line == ":q" || line == ":exit") {
+                std::cout << "Exiting REPL...\n";
+                break;
+            }
+            if (line.empty()) {
+                continue;
+            }
+            try {
+                // Lex
+                fe::lexer::Lexer lexer(line, fe::lexer::FromRepl{});
+                const std::vector<fe::token::Token> tokens = lexer.lex_all();
+                if (debug) {
+                    for (const auto &tok: tokens) {
+                        std::cout << tok << "\n";
+                    }
+                }
+                // Parse
+                fe::parser::Parser parser(tokens);
+                if (debug) {
+                    std::cout << parser.program << "\n";
+                }
+                // Interpret
+                const auto [global_env, value] = intp::interp::interpret(parser.program, shared_global_env);
+                std::cout << "=> " << value << "\n";
+                shared_global_env = global_env;
+            } catch (const std::exception &ex) {
+                std::cerr << "error: " << ex.what() << "\n";
+            }
+        }
+    }
+}