core/core.cpp

@@ -3,20 +3,4 @@
 
 extern "C" void lib(jk::Loader& loader)
 {
-  loader.declare("dump", [](auto args){
-    std::string sep;
-
-    for (auto arg: args)
-      {
-        std::cout << sep << arg->string();
-        sep = " ";
-      }
-
-    if (args.empty() == false)
-      {
-        std::cout << std::endl;
-      }
-
-    return jk::Value::make_nil();
-  });
 }

doc/grammar.bnf

@@ -1,12 +1,4 @@
 PROG ::= FUNCALL*
-EXPR ::=
-LITERAL
-| FUNCALL
-| VARDECL
-| LAMBDA
-LAMBDA ::= opar rarrow opar PARAMS cpar BODY cpar
-PARAMS ::= ident*
-BODY ::= expr*
-VARDECL ::= opar decl ident EXPR cpar
+EXPR ::=  LITERAL | FUNCALL
 FUNCALL ::= opar ident EXPR* cpar
 LITERAL ::= int | ident

lib/Code.cpp

@@ -7,11 +7,6 @@ namespace jk
   {
   }
 
-  /*explicit*/ Code::Code(std::shared_ptr<Program> program)
-    : m_program { program }
-  {
-  }
-
   /*virtual*/ Code::~Code()
   {
   }

lib/Code.hpp

@@ -10,15 +10,12 @@ namespace jk
   {
   public:
     explicit Code(foreign_t foreign);
-    explicit Code(std::shared_ptr<Program> program);
     virtual ~Code();
 
     foreign_t foreign() const { return m_foreign; }
-    std::shared_ptr<Program> program() const { return m_program; }
 
   private:
     foreign_t m_foreign;
-    std::shared_ptr<Program> m_program;
   };
 }
 

lib/Compiler.cpp

@@ -4,8 +4,10 @@
 
 namespace jk
 {
-  /*explicit*/ Compiler::Compiler(Logger& logger)
-    : m_logger(logger)
+  /*explicit*/ Compiler::Compiler(std::shared_ptr<SymTable> sym,
+                                  Logger& logger)
+    : m_sym { sym }
+    , m_logger(logger)
   {
   }
 
@@ -14,74 +16,50 @@ namespace jk
   }
 
   void Compiler::compile(std::shared_ptr<Node> node,
-                         std::shared_ptr<Program> program,
-                         std::shared_ptr<SymTable> sym)
+                         std::shared_ptr<Program> program)
   {
     switch (node->type())
       {
-      case NODE_PROG:
-      case NODE_BODY: {
+      case NODE_PROG: {
         for (size_t i=0; i<node->size(); i++)
           {
-            compile(node->child(i).lock(), program, sym);
+            compile(node->child(i).lock(), program);
           }
       } break;
 
       case NODE_FUNCALL: {
         for (size_t i=0; i<node->size(); i++)
           {
-            compile(node->child(i).lock(), program, sym);
+            compile(node->child(i).lock(), program);
           }
 
         program->push_instr(OPCODE_CALL, node->size() - 1);
       } break;
 
-      case NODE_VARDECL: {
-        std::string ident = node->child(0).lock()->repr();
-        auto entry = sym->find(ident);
-        assert(entry);
-
-        compile(node->child(1).lock(), program, sym);
-        program->push_instr(OPCODE_STORE, entry->addr);
-      } break;
-
-      case NODE_LAMBDA: {
-        auto params = node->child(0).lock();
-        auto body = node->child(1).lock();
-        auto prog = std::make_shared<Program>();
-        auto fun_sym = std::make_shared<SymTable>(m_logger, sym);
-
-        for (size_t i=0; i<params->size(); i++)
-          {
-            std::string param = params->child(i).lock()->repr();
-            fun_sym->declare(param,
-                         std::make_shared<Type>(TYPE_NIL),
-                         node->loc());
-          }
-
-        compile(body, prog, fun_sym);
-        prog->push_instr(OPCODE_RET);
-
-        auto code = std::make_shared<Code>(prog);
-        size_t addr = program->push_constant(Value::make_code(code));
-        program->push_instr(OPCODE_PUSH_CONST, addr);
-        program->push_instr(OPCODE_MK_FUNCTION);
-        //program->push_instr(OpcodeType opcode)
-      } break;
-
       case NODE_IDENT: {
         std::string ident = node->repr();
-        auto mysym = sym->find(ident);
-        assert(sym);
+        auto sym = m_sym->find(ident);
+
+        if (!sym)
+          {
+            m_logger.log<compile_error>(LOG_ERROR, node->loc(),
+                                        std::string()
+                                        + "'"
+                                        + ident
+                                        + "' is undefined");
+          }
 
         OpcodeType op_load = OPCODE_LOAD;
 
-        if (mysym->is_global)
+        if (sym->is_global)
           {
             op_load = OPCODE_LOAD_GLOBAL;
           }
 
-        program->push_instr(op_load, mysym->addr);
+        if (sym->type->type() == TYPE_FUNCTION)
+          {
+            program->push_instr(op_load, sym->addr);
+          }
 
       } break;
 

lib/Compiler.hpp

@@ -15,14 +15,15 @@ namespace jk
   class Compiler
   {
   public:
-    explicit Compiler(Logger& logger);
+    explicit Compiler(std::shared_ptr<SymTable> sym,
+                      Logger& logger);
     virtual ~Compiler();
 
     void compile(std::shared_ptr<Node> node,
-                 std::shared_ptr<Program> program,
-                 std::shared_ptr<SymTable> sym);
+                 std::shared_ptr<Program> program);
 
   private:
+    std::shared_ptr<SymTable> m_sym;
     Logger& m_logger;
   };
 }

lib/Function.cpp

@@ -8,22 +8,12 @@ namespace jk
   {
   }
 
-  /*explicit*/ Function::Function(std::shared_ptr<Program> program)
-    : m_program { program }
-  {
-  }
-
   /*virtual*/ Function::~Function()
   {
   }
 
   value_t Function::call(std::vector<value_t> const& args)
   {
-    if (m_foreign)
-      {
-        return m_foreign(args);
-      }
-
-    return Value::make_nil();
+    return m_foreign(args);
   }
 }

lib/Function.hpp

@@ -2,7 +2,6 @@
 #define jk_FUNCTION_HPP
 
 #include "commons.hpp"
-#include "Program.hpp"
 
 namespace jk
 {
@@ -15,17 +14,12 @@ namespace jk
   {
   public:
     explicit Function(foreign_t foreign);
-    explicit Function(std::shared_ptr<Program> program);
-
     virtual ~Function();
 
-    std::shared_ptr<Program> program() const { return m_program; }
-
     value_t call(std::vector<value_t> const& args);
 
   private:
     foreign_t m_foreign;
-    std::shared_ptr<Program> m_program;
   };
 }
 

lib/Lexer.cpp

@@ -7,8 +7,6 @@ namespace jk
     , m_loc { loc }
   {
     std::vector<std::tuple<NodeType, std::string, bool>> texts = {
-      {NODE_RARROW, "->", false},
-      {NODE_DECL, "$", false},
       {NODE_OPAR, "(", false},
       {NODE_CPAR, ")", false}
     };

lib/Node.hpp

@@ -10,14 +10,7 @@
     G(NODE_OPAR),                               \
     G(NODE_CPAR),                               \
     G(NODE_IDENT),                              \
-    G(NODE_DECL),                               \
-    G(NODE_FUNCALL),                            \
-    G(NODE_VARDECL),                            \
-    G(NODE_RARROW),                             \
-    G(NODE_LAMBDA),                             \
-    G(NODE_PARAMS),                             \
-    G(NODE_BODY),
-
+    G(NODE_FUNCALL),
 
 
 namespace jk

lib/Opcodes.hpp

@@ -9,7 +9,6 @@
     G(OPCODE_LOAD),                             \
     G(OPCODE_STORE),                            \
     G(OPCODE_LOAD_GLOBAL),                      \
-    G(OPCODE_RET),                              \
     G(OPCODE_MK_FUNCTION)
 
 namespace jk

lib/Parser.cpp

@@ -91,7 +91,7 @@ namespace jk
 
     while (m_cursor < m_tokens.size())
       {
-        root->add_child(parse_expr());
+        root->add_child(parse_funcall());
       }
 
     return root;
@@ -99,77 +99,14 @@ namespace jk
 
   std::shared_ptr<Node> Parser::parse_expr()
   {
-    if (type_is(NODE_OPAR)
-        && type_is(NODE_IDENT, 1))
+    if (type_is(NODE_OPAR))
       {
         return parse_funcall();
       }
 
-    if (type_is(NODE_OPAR)
-        && type_is(NODE_DECL, 1))
-      {
-        return parse_vardecl();
-      }
-
-    if (type_is(NODE_OPAR)
-        && type_is(NODE_RARROW, 1))
-      {
-        return parse_lambda();
-      }
-
     return parse_literal();
   }
 
-  std::shared_ptr<Node> Parser::parse_vardecl()
-  {
-    auto root = std::make_shared<Node>(NODE_VARDECL, "", loc());
-    consume(NODE_OPAR);
-    consume(NODE_DECL);
-    root->add_child(consume(NODE_IDENT));
-    root->add_child(parse_expr());
-    consume(NODE_CPAR);
-
-    return root;
-  }
-
-  std::shared_ptr<Node> Parser::parse_lambda()
-  {
-    auto root = std::make_shared<Node>(NODE_LAMBDA, "", loc());
-    consume(NODE_OPAR);
-    consume(NODE_RARROW);
-    consume(NODE_OPAR);
-    root->add_child(parse_params());
-    consume(NODE_CPAR);
-    root->add_child(parse_body());
-    consume(NODE_CPAR);
-
-    return root;
-  }
-
-  std::shared_ptr<Node> Parser::parse_params()
-  {
-    auto root = std::make_shared<Node>(NODE_PARAMS, "", loc());
-
-    while (!type_is(NODE_CPAR))
-      {
-        root->add_child(consume(NODE_IDENT));
-      }
-
-    return root;
-  }
-
-  std::shared_ptr<Node> Parser::parse_body()
-  {
-    auto root = std::make_shared<Node>(NODE_BODY, "", loc());
-
-    while (!type_is(NODE_CPAR))
-      {
-        root->add_child(parse_expr());
-      }
-
-    return root;
-  }
-
   std::shared_ptr<Node> Parser::parse_funcall()
   {
     auto root = std::make_shared<Node>(NODE_FUNCALL, "", loc());
@@ -197,10 +134,8 @@ namespace jk
                                loc(),
                                std::string()
                                + "unexpected token '"
-                               + NodeTypeStr[current()->type()]
-                               + "' ('"
                                + current()->repr()
-                               + "')");
+                               + "'");
 
     abort();
   }

lib/Parser.hpp

@@ -31,10 +31,6 @@ namespace jk
 
     std::shared_ptr<Node> parse_prog();
     std::shared_ptr<Node> parse_expr();
-    std::shared_ptr<Node> parse_vardecl();
-    std::shared_ptr<Node> parse_lambda();
-    std::shared_ptr<Node> parse_params();
-    std::shared_ptr<Node> parse_body();
     std::shared_ptr<Node> parse_funcall();
     std::shared_ptr<Node> parse_literal();
   };

lib/Program.cpp

@@ -48,7 +48,6 @@ namespace jk
 
   size_t Program::push_constant(std::shared_ptr<Value> value)
   {
-    assert(value);
     m_constants.push_back(value);
     return m_constants.size() - 1;
   }

lib/StaticPass.cpp

@@ -17,69 +17,15 @@ namespace jk
   {
     switch (node->type())
       {
-      case NODE_PROG:
-      case NODE_BODY: {
+      case NODE_PROG: {
         for (size_t i=0; i<node->size(); i++)
           {
             pass(node->child(i).lock());
-            pop();
           }
       } break;
 
-      case NODE_LAMBDA: {
-        auto params = node->child(0).lock();
-        auto body = node->child(1).lock();
-
-        for (size_t i=0; i<params->size(); i++)
-          {
-            auto param = params->child(i).lock();
-            std::string ident = params->child(i).lock()->repr();
-            m_sym->declare(ident,
-                           std::make_shared<Type>(TYPE_NIL),
-                           param->loc());
-          }
-
-        pass(body);
-
-        push(std::make_shared<Type>(TYPE_FUNCTION));
-      } break;
-
-      case NODE_INT: {
-        push(std::make_shared<Type>(TYPE_INT));
-      } break;
-
-      case NODE_IDENT: {
-        std::string ident = node->repr();
-        auto entry = m_sym->find(ident);
-
-        if (!entry)
-          {
-            m_logger.log<symbolic_error>(LOG_ERROR, node->loc(),
-                                         std::string()
-                                         + "'"
-                                         + ident
-                                         + "' is undefined");
-          }
-
-        push(entry->type);
-      } break;
-
-      case NODE_VARDECL: {
-        std::string ident = node->child(0).lock()->repr();
-        pass(node->child(1).lock());
-        auto type = pop();
-        m_sym->declare(ident, type, node->loc());
-        push(type);
-      } break;
-
       case NODE_FUNCALL: {
-        for (size_t i=0; i<node->size(); i++)
-          {
-            pass(node->child(i).lock());
-            pop();
-          }
-        // TODO find actual returned type
-        push(std::make_shared<Type>(TYPE_NIL));
+
       } break;
 
       default:
@@ -88,17 +34,4 @@ namespace jk
         abort();
       }
   }
-
-  void StaticPass::push(std::shared_ptr<Type> type)
-  {
-    m_types.push_back(type);
-  }
-
-  std::shared_ptr<Type> StaticPass::pop()
-  {
-    auto type = m_types.back();
-    m_types.pop_back();
-
-    return type;
-  }
 }

lib/StaticPass.hpp

@@ -18,10 +18,6 @@ namespace jk
   private:
     std::shared_ptr<SymTable> m_sym;
     Logger& m_logger;
-    std::vector<std::shared_ptr<Type>> m_types;
-
-    void push(std::shared_ptr<Type> type);
-    std::shared_ptr<Type> pop();
   };
 }
 

lib/SymTable.cpp

@@ -2,10 +2,8 @@
 
 namespace jk
 {
-  /*explicit*/ SymTable::SymTable(Logger& logger,
-                                  std::shared_ptr<SymTable> parent)
+  /*explicit*/ SymTable::SymTable(Logger& logger)
     : m_logger { logger }
-    , m_parent { parent }
   {
   }
 
@@ -18,7 +16,7 @@ namespace jk
                     std::shared_ptr<Type> type,
                     Loc const& loc)
   {
-    if (find_local(name))
+    if (find(name))
       {
         m_logger.log<symbolic_error>(LOG_ERROR,
                                      loc,
@@ -51,7 +49,7 @@ namespace jk
     return addr;
   }
 
-  std::optional<Sym> SymTable::find_local(std::string const& name) const
+  std::optional<Sym> SymTable::find(std::string const& name) const
   {
     for (auto const& sym: m_syms)
       {
@@ -63,17 +61,4 @@ namespace jk
 
     return std::nullopt;
   }
-
-  std::optional<Sym> SymTable::find(std::string const& name) const
-  {
-    auto entry = find_local(name);
-    if (entry) { return entry; }
-
-    if (m_parent)
-      {
-        return m_parent->find(name);
-      }
-
-    return std::nullopt;
-  }
 }

lib/SymTable.hpp

@@ -20,9 +20,7 @@ namespace jk
   class SymTable
   {
   public:
-    explicit SymTable(Logger& logger,
-                      std::shared_ptr<SymTable> parent=nullptr);
-
+    explicit SymTable(Logger& logger);
     virtual ~SymTable();
 
     size_t declare(std::string const& name,
@@ -34,11 +32,9 @@ namespace jk
                           Loc const& loc);
 
     std::optional<Sym> find(std::string const& name) const;
-    std::optional<Sym> find_local(std::string const& name) const;
 
   private:
     Logger& m_logger;
-    std::shared_ptr<SymTable> m_parent;
     std::vector<Sym> m_syms;
     size_t m_addr = 0;
   };

lib/VM.cpp

@@ -18,11 +18,7 @@ namespace jk
     Frame frame;
     frame.program = program;
     m_frames.push_back(frame);
-    execute();
-  }
 
-  void VM::execute()
-  {
     while (m_pc < m_frames.back().program->size())
       {
         Instr instr = m_frames.back().program->get(m_pc);
@@ -30,28 +26,17 @@ namespace jk
         switch (instr.opcode)
           {
           case OPCODE_MK_FUNCTION: {
-            auto code = program()->constant(pop());
+            auto code = program->constant(pop());
 
-            auto prog = code->as_code()->program();
-
-            std::shared_ptr<Function> function;
-
-            if (prog)
-              {
-                function = std::make_shared<Function>(prog);
-              }
-            else
-              {
-                 function = std::make_shared<Function>
-                  (code->as_code()->foreign());
-              }
+            auto function = std::make_shared<Function>
+              (code->as_code()->foreign());
 
             auto value = Value::make_function(function);
 
             size_t addr = push_heap(value);
             auto ref = Value::make_ref(addr);
 
-            push(program()->push_constant(ref));
+            push(program->push_constant(ref));
 
             m_pc++;
 
@@ -64,7 +49,7 @@ namespace jk
 
           case OPCODE_LOAD: {
             auto value = m_frames.back().locals[*instr.param];
-            push(program()->push_constant(value));
+            push(program->push_constant(value));
             m_pc++;
           } break;
 
@@ -72,73 +57,35 @@ namespace jk
             auto idx = pop();
 
             m_frames.back().locals[*instr.param] =
-              program()->constant(idx);
+              program->constant(idx);
 
             m_pc++;
           } break;
 
           case OPCODE_LOAD_GLOBAL: {
             auto value = m_globals[*instr.param];
-            push(program()->push_constant(value));
+            push(program->push_constant(value));
             m_pc++;
           } break;
 
-          case OPCODE_RET: {
-            size_t pc = m_frames.back().ret_addr;
-            size_t stack_sz = m_frames.back().stack_sz;
-            auto prog = m_frames.back().program;
-
-            param_t ret = pop();
-            auto ret_val = prog->constant(ret);
-            assert(ret_val);
-
-            while (m_stack.size() > stack_sz)
-              {
-                pop();
-              }
-
-            m_frames.pop_back();
-
-            push(program()->push_constant(ret_val));
-
-            m_pc = pc + 1;
-          } break;
-
           case OPCODE_CALL: {
             std::vector<std::shared_ptr<Value>> args;
 
             for (size_t i=0; i<*instr.param; i++)
               {
-                args.insert(std::begin(args), program()->constant(pop()));
+                args.insert(std::begin(args), program->constant(pop()));
               }
 
-            auto ref_val = program()->constant(pop());
+            auto ref_val = program->constant(pop());
             auto ref = ref_val->as_ref();
             auto fun_val = heap(ref);
             auto fun = fun_val->as_function();
 
-            if (auto prog = fun->program();
-                prog)
-              {
-                Frame frame;
-                frame.program = prog;
-                frame.ret_addr = m_pc;
-                frame.stack_sz = m_stack.size();
-                m_pc = 0;
+            auto result = fun->call(args);
 
-                for (size_t i=0; i<args.size(); i++)
-                  {
-                    frame.locals[i] = args[i];
-                  }
+            push(program->push_constant(result));
 
-                m_frames.push_back(frame);
-              }
-            else
-              {
-                auto result = fun->call(args);
-                push(program()->push_constant(result));
-                m_pc++;
-              }
+            m_pc++;
           } break;
 
           default:
@@ -191,8 +138,4 @@ namespace jk
     return param;
   }
 
-  std::shared_ptr<Program> VM::program() const
-  {
-    return m_frames.back().program;
-  }
 }

lib/VM.hpp

@@ -9,8 +9,6 @@ namespace jk
   struct Frame {
     std::shared_ptr<Program> program;
     std::unordered_map<int, std::shared_ptr<Value>> locals;
-    size_t ret_addr;
-    size_t stack_sz;
   };
 
   class VM
@@ -20,7 +18,6 @@ namespace jk
     virtual ~VM();
 
     void execute(std::shared_ptr<Program> program);
-    void execute();
 
     std::string string() const;
 
@@ -38,8 +35,6 @@ namespace jk
 
     void push(param_t param);
     param_t pop();
-
-    std::shared_ptr<Program> program() const;
   };
 }
 

lib/Value.cpp

@@ -68,7 +68,6 @@ namespace jk
       {
       case TYPE_NIL: return "<nil>";
       case TYPE_INT: return std::to_string(*m_int_val);
-      case TYPE_REF: return "<ref:" + std::to_string(*m_ref_val) + ">";
 
       default:
         std::cerr << "cannot stringify value '"

src/main.cpp

@@ -83,17 +83,16 @@ int main(int argc, char** argv)
 
       auto sym = std::make_shared<jk::SymTable>(logger);
 
+      auto static_pass = std::make_shared<jk::StaticPass>(sym, logger);
+      static_pass->pass(ast);
 
-      auto compiler = std::make_shared<jk::Compiler>(logger);
+      auto compiler = std::make_shared<jk::Compiler>(sym, logger);
       auto program = std::make_shared<jk::Program>();
       auto vm = std::make_shared<jk::VM>();
       auto loader = std::make_shared<jk::Loader>(vm, sym);
       loader->load();
 
-      auto static_pass = std::make_shared<jk::StaticPass>(sym, logger);
-      static_pass->pass(ast);
-
-      compiler->compile(ast, program, sym);
+      compiler->compile(ast, program);
 
       if (debug_mode)
         {

tests/Lexer.cpp

@@ -65,19 +65,3 @@ TEST_CASE_METHOD(LexerTest, "Lexer_funcall")
   test_next(*lexer, "IDENT[salut/monde]");
   test_end(*lexer);
 }
-
-TEST_CASE_METHOD(LexerTest, "Lexer_vardecl")
-{
-  auto lexer = jk::Factory(m_logger, "tests/lexer").make_lexer();
-  lexer->scan(" $ ");
-  test_next(*lexer, "DECL");
-  test_end(*lexer);
-}
-
-TEST_CASE_METHOD(LexerTest, "Lexer_lambda")
-{
-  auto lexer = jk::Factory(m_logger, "tests/lexer").make_lexer();
-  lexer->scan(" -> ");
-  test_next(*lexer, "RARROW");
-  test_end(*lexer);
-}

tests/Parser.cpp

@@ -34,30 +34,3 @@ TEST_CASE_METHOD(ParserTest, "Parser_funcall")
   test_parser("PROG(FUNCALL(IDENT[hello],INT[1],INT[2],IDENT[bim!]))",
               " (hello 1 2 bim!) ");
 }
-
-TEST_CASE_METHOD(ParserTest, "Parser_vardecl")
-{
-  test_parser("PROG(VARDECL(IDENT[hello],INT[4]))",
-              " ($ hello 4) ");
-
-  test_parser("PROG(VARDECL(IDENT[world],"
-              "FUNCALL(IDENT[f],INT[3],INT[2])))",
-              " ($ world (f 3 2)) ");
-}
-
-TEST_CASE_METHOD(ParserTest, "Parser_lambda")
-{
-  test_parser("PROG(LAMBDA(PARAMS("
-              "IDENT[x],IDENT[y]"
-              "),BODY("
-              "FUNCALL(IDENT[add],IDENT[y],IDENT[x])"
-              ")))",
-              " (-> (x y) (add y x)) ");
-
-    test_parser("PROG(LAMBDA(PARAMS("
-                "IDENT[x]"
-                "),BODY("
-                "IDENT[x]"
-                ")))",
-                " (-> (x) x)");
-}