FIX: nested lambdas closures.

examples/array.fk

@@ -17,4 +17,14 @@
 (assert= 4 (second (produce)))
 
 ($ arr [2 'bim' produce false])
-(assert= 6 (ref ((ref arr 2)) 2))
+(assert= 6 (ref ((ref arr 2)) 2))
+
+($ hello [2 4 6])
+(assert= 4 (ref hello 1))
+(ref! hello 1 12)
+(assert= 12 (ref hello 1))
+
+($ hello2 [[5 7][9 2]])
+(assert= 9 (ref hello2 1 0))
+(ref! (ref hello2 1) 0 34)
+(assert= 34 (ref hello2 1 0))

examples/cast.fk

@@ -0,0 +1 @@
+(assert= 8 (trunc 8.71))

examples/closure.fk

@@ -13,4 +13,33 @@
 (assert= 33 (b))
 (assert= 6 (a))
 (assert= 7 (a))
-(assert= 34 (b))
+(assert= 34 (b))
+
+($ (c) 42)
+
+($ (d)
+   (+ (c) 1))
+
+(assert= 43 (d))
+
+
+($ hello 34)
+
+($ (i)
+   ($ (j)
+      ($ (k)
+         (println hello))))
+
+(((i)))
+
+($ @m './mod2')
+
+($ (u)
+   ($ (v)
+      ($ (w)
+         (assert= 42 m::var)
+         (assert= 14 (m::fun 7))
+         259 )))
+
+(assert= 42 ((-> () m::var)))
+(assert= 259 (((u))))

libstd/commons.hpp

@@ -2,16 +2,13 @@
 #define fkstd_COMMONS_HPP
 
 #include <cmath>
+#include "../src/commons.hpp"
 #include "../src/Module.hpp"
 #include "../src/Constant.hpp"
 #include "../src/SymTable.hpp"
 
 using namespace fk;
 
-#define STDARGS std::vector<std::shared_ptr<Constant>>
-#define STDRET std::shared_ptr<Constant>
-#define STDSYM std::shared_ptr<SymTable>
-
 FK_ERROR(assert_error);
 
 #endif

libstd/fun.cpp

@@ -278,6 +278,13 @@ namespace fkstd
     return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
   }
 
+  STDRET trunc(Loc loc, Module&, STDARGS args)
+  {
+    float val = std::get<float>(args[0]->value());
+    int res = val;
+    return std::make_shared<Constant>(TYPE_INT, res, loc);
+  }
+
   STDRET lt(Loc loc, Module&, STDARGS args)
   {
     NUM_BINOP(<);
@@ -339,6 +346,20 @@ namespace fkstd
     return val->at(std::get<int>(args.back()->value()));
   }
 
+  STDRET array_set(Loc, Module& mod, STDARGS args)
+  {
+    auto ref_val = args[0]->value();
+    size_t ref = std::get<size_t>(ref_val);
+
+    int index = std::get<int>(args[1]->value());
+
+    std::shared_ptr<Array> val =
+      std::get<std::shared_ptr<Array>>(mod.vm()->load_global(ref));
+
+    val->set(index, args[2]);
+    return args[2];
+  }
+
   STDRET string_cat(Loc loc, Module&, STDARGS args)
   {
     if (args.empty())

libstd/fun.hpp

@@ -20,6 +20,7 @@ namespace fkstd
   STDRET div_float(Loc loc, Module& mod, STDARGS args);
   STDRET mod_float(Loc loc, Module& mod, STDARGS args);
   STDRET pow_float(Loc loc, Module& mod, STDARGS args);
+  STDRET trunc(Loc loc, Module& mod, STDARGS args);
 
   STDRET lt(Loc loc, Module& mod, STDARGS args);
   STDRET le(Loc loc, Module& mod, STDARGS args);
@@ -30,6 +31,7 @@ namespace fkstd
 
   STDRET bool_not(Loc loc, Module& mod, STDARGS args);
   STDRET array_ref(Loc loc, Module& mod, STDARGS args);
+  STDRET array_set(Loc loc, Module& mod, STDARGS args);
 
   STDRET string_cat(Loc loc, Module& mod, STDARGS args);
   STDRET string_dup(Loc loc, Module& mod, STDARGS args);

libstd/lib.cpp

@@ -20,6 +20,8 @@ extern "C" void lib(Module& mod)
   mod.register_function("%.", fkstd::mod_float);
   mod.register_function("^.", fkstd::pow_float);
 
+  mod.register_function("trunc", fkstd::trunc);
+
   mod.register_function("<", fkstd::lt);
   mod.register_function("<=", fkstd::le);
   mod.register_function(">", fkstd::gt);
@@ -29,6 +31,7 @@ extern "C" void lib(Module& mod)
 
   mod.register_function("not", fkstd::bool_not);
   mod.register_function("ref", fkstd::array_ref);
+  mod.register_function("ref!", fkstd::array_set);
   mod.register_function("cat", fkstd::string_cat);
   mod.register_function("dup", fkstd::string_dup);
   mod.register_function("char-at", fkstd::char_at);

libstd/macro.cpp

@@ -9,7 +9,7 @@ namespace fkstd
   {
     auto ident = node->child(1)->repr();
     compiler.compile_prog(node->child(2), program);
-    std::cout << "push " << node->child(2)->string() << std::endl;
+
     auto entry = compiler.sym()->find(ident);
 
     if (entry)
@@ -59,11 +59,10 @@ namespace fkstd
     compiler.pop_decl();
 
     auto entry = compiler.sym()->declare_local(ident,
-                                               addr,
                                                node->loc())
       .set_node(rhs);
 
-    program->add(OP_STORE_LOCAL, addr);
+    program->add(OP_STORE_LOCAL, entry.addr());
   }
 
   void block(Compiler& compiler,

meson.build

@@ -63,10 +63,14 @@ fakir_hpp = [
   'src/types.hpp',
 ]
 
+pkg = import('pkgconfig')
+
 fakir_lib = shared_library('fakir',
                            sources: fakir_cpp,
                            install: true)
 
+pkg.generate(fakir_lib, subdirs: ['fakir'])
+
 install_headers(fakir_hpp, subdir: 'fakir')
 
 fakir_dep = declare_dependency(

src/Array.cpp

@@ -22,6 +22,12 @@ namespace fk
     return m_data.at(index);
   }
 
+  void Array::set(size_t index, std::shared_ptr<Constant> value)
+  {
+    assert(index < size());
+    m_data[index] = value;
+  }
+
   std::shared_ptr<Constant> Array::pop()
   {
     assert(size() > 0);

src/Array.hpp

@@ -17,6 +17,7 @@ namespace fk
 
     void push(std::shared_ptr<Constant> constant);
     std::shared_ptr<Constant> at(size_t index) const;
+    void set(size_t index, std::shared_ptr<Constant> value);
     std::shared_ptr<Constant> pop();
 
     std::string string() const;

src/Compiler.cpp

@@ -74,23 +74,19 @@ namespace fk
       } break;
 
       case NODE_VARDECL: {
-        m_addr++;
-
         std::string ident = node->child(0)->repr();
         auto rhs = node->child(1);
-
         push_decl(ident);
         compile_prog(rhs, prog);
         pop_decl();
 
         auto entry = sym()->declare_local(ident,
-                                          m_addr,
                                           node->loc())
+
           .set_is_array(rhs->type() == NODE_ARRAY)
           .set_node(rhs);
 
-        prog->add(OP_STORE_LOCAL, m_addr);
+        prog->add(OP_STORE_LOCAL, entry.addr());
-
       } break;
 
       case NODE_ARRAY: {
@@ -114,9 +110,7 @@ namespace fk
         prog->load_const(std::make_shared<Constant>(TYPE_STRING,
                                                     var->repr(),
                                                     node->loc()));
-
         compile_prog(mod, prog);
-
         prog->add(OP_LOAD_MOD);
 
       } break;
@@ -162,14 +156,15 @@ namespace fk
 
         m_sym->enter_scope(node);
 
+        int base_addr = m_sym->addr();
+
         for (size_t i=0; i<params->size(); i++)
           {
             std::string ident = params->child(i)->repr();
-            m_sym->declare_local(ident, i, node->loc());
+            auto entry = m_sym->declare_local(ident, node->loc());
           }
 
-        m_sym->declare_local(func_name, params->size(),
+        m_sym->declare_local(func_name, node->loc());
-                             node->loc());
 
         Compiler compiler {m_mod, m_sym};
         for (auto e: m_macros)
@@ -187,6 +182,10 @@ namespace fk
                                                    program,
                                                    node->loc());
         prog->load_const(constant);
+
+        prog->load_const(std::make_shared<Constant>(TYPE_INT,
+                                                    base_addr,
+                                                    constant->loc()));
         prog->add(OP_MAKE_FUNCTION, params->size());
       } break;
 
@@ -271,7 +270,17 @@ namespace fk
 
         if (!entry)
           {
-            auto entry = m_sym->find_global(node->repr());
+            auto entries = m_sym->find_all(node->repr());
+            std::optional<SymEntry> entry;
+
+            for (SymEntry const& e: entries)
+              {
+                if (e.scope() <= m_sym->scope()
+                    && (!entry || e.scope() < entry->scope()))
+                  {
+                    entry = e;
+                  }
+              }
 
             if (entry)
               {
@@ -293,12 +302,13 @@ namespace fk
         if (!entry->is_global())
           {
             prog->add(OP_LOAD_LOCAL, entry->addr());
+            break;
           }
         else
           {
             prog->add(OP_LOAD_GLOBAL, entry->addr());
+            break;
           }
-
       } break;
 
       case NODE_INT: {
@@ -347,5 +357,4 @@ namespace fk
     assert(m_decl_stack.empty() == false);
     m_decl_stack.pop_back();
   }
-
 }

src/Compiler.hpp

@@ -46,7 +46,6 @@ namespace fk
 
   private:
     Module& m_mod;
-    addr_t m_addr = 0;
     std::shared_ptr<SymTable> m_sym;
     std::vector<std::string> m_decl_stack;
     std::unordered_map<std::string,

src/Constant.cpp

@@ -30,6 +30,7 @@ namespace fk
       case TYPE_STRING: return std::get<std::string>(m_value);
       case TYPE_REF: return std::to_string(std::get<size_t>(m_value));
       case TYPE_PROGRAM: return "<program>";
+      case TYPE_CUSTOM: return "<custom>";
       case TYPE_ARRAY: return std::get<std::shared_ptr<Array>>
           (m_value)->string();
 

src/Constant.hpp

@@ -15,6 +15,7 @@ namespace fk
   using constant_t = std::variant<int,
                                   float,
                                   bool,
+                                  void*,
                                   std::string,
                                   size_t,
                                   std::shared_ptr<Program>,

src/Lambda.hpp

@@ -14,20 +14,31 @@ namespace fk
     explicit Lambda(std::shared_ptr<Program> program, size_t arity);
     virtual ~Lambda();
 
+    std::unordered_map<addr_t, std::shared_ptr<Constant>>
+    get_all_env() const { return m_env; }
+
     size_t arity() const { return m_arity; }
 
+    addr_t base_addr() const { return m_base_addr; }
+    void set_base_addr(addr_t base) { m_base_addr = base; }
+
     std::shared_ptr<Program> program() const { return m_program; }
-    std::shared_ptr<SymTable> sym() const { return m_sym; }
 
     bool has_env(addr_t addr) const;
+
+
     std::shared_ptr<Constant> get_env(addr_t addr) const;
     void add_env(addr_t addr, std::shared_ptr<Constant> constant);
+    size_t env_size() const { return m_env.size(); }
+
 
   private:
     std::shared_ptr<Program> m_program;
     std::unordered_map<addr_t, std::shared_ptr<Constant>> m_env;
     size_t m_arity;
-    std::shared_ptr<SymTable> m_sym = std::make_shared<SymTable>();
+    addr_t m_base_addr = 0;
+
+    //std::shared_ptr<SymTable> m_sym = std::make_shared<SymTable>();
   };
 }
 

src/Module.cpp

@@ -17,10 +17,15 @@ namespace fk
 
   std::shared_ptr<Module> Module::get_mod(std::string const& name)
   {
-    assert(m_native_modules.find(name) != std::end(m_native_modules));
+    assert(has_mod(name));
     return m_native_modules[name];
   }
 
+  bool Module::has_mod(std::string const& name)
+  {
+    return m_native_modules.find(name) != std::end(m_native_modules);
+  }
+
   void Module::build()
   {
     import_std();

src/Module.hpp

@@ -24,6 +24,7 @@ namespace fk
     std::shared_ptr<VM> vm() const { return m_vm; }
 
     std::shared_ptr<Module> get_mod(std::string const& name);
+    bool has_mod(std::string const& name);
 
     void build();
 

src/SymTable.cpp

@@ -13,7 +13,6 @@ namespace fk
   }
 
   SymEntry& SymTable::declare_local(std::string const& name,
-                                    addr_t addr,
                                     Loc const& loc)
   {
     auto entry = find(name);
@@ -31,13 +30,13 @@ namespace fk
       }
 
     SymEntry e {name,
-                addr,
+                m_addr,
                 false,
                 m_scope,
                 m_parents.empty() ?
                 nullptr : m_parents.back(),
                 loc};
-
+    m_addr++;
     m_entries.push_back(e);
 
     return m_entries.back();
@@ -47,7 +46,7 @@ namespace fk
                                      addr_t addr,
                                      Loc const& loc)
   {
-    return declare_local(name, addr, loc).set_global(true);
+    return declare_local(name, loc).set_global(true).set_addr(addr);
   }
 
   std::optional<SymEntry> SymTable::find(std::string const& name)
@@ -126,6 +125,22 @@ namespace fk
     return idx;
   }
 
+  std::vector<SymEntry> SymTable::find_all(std::string const& name)
+  {
+
+    std::vector<SymEntry> res;
+
+    for (auto e: m_entries)
+      {
+        if (e.name() == name)
+          {
+            res.push_back(e);
+          }
+      }
+
+    return res;
+  }
+
   void SymTable::set(std::string const& name, addr_t addr)
   {
     if (auto idx = find_idx(name);

src/SymTable.hpp

@@ -14,10 +14,10 @@ namespace fk
     explicit SymTable();
     virtual ~SymTable();
 
+    size_t addr() const { return m_addr; }
     int scope() const { return m_scope; }
 
     SymEntry& declare_local(std::string const& name,
-                            addr_t addr,
                             Loc const& loc);
 
     SymEntry& declare_global(std::string const& name,
@@ -30,6 +30,8 @@ namespace fk
     std::optional<SymEntry> find_global(std::string const& name);
     std::optional<size_t> find_idx_global(std::string const& name);
 
+    std::vector<SymEntry> find_all(std::string const& name);
+
     void set(std::string const& name, addr_t addr);
 
     std::string string() const;
@@ -40,6 +42,7 @@ namespace fk
   private:
     std::vector<SymEntry> m_entries;
     int m_scope;
+    size_t m_addr = 12;
     std::vector<std::shared_ptr<Node>> m_parents;
   };
 }

src/VM.cpp

@@ -31,41 +31,6 @@ namespace fk
 
         switch (instr.opcode)
           {
-            /*case OP_DEREF: {
-            std::vector<int> indexes;
-
-            for (size_t i=0; i<instr.param; i++)
-              {
-                auto index_val = frame().program->get_const(pop());
-                int index = std::get<int>(index_val->value());
-                indexes.insert(std::begin(indexes), index);
-              }
-
-            size_t ref =
-              std::get<size_t>(frame().program
-                               ->get_const(pop())->value());
-
-            std::shared_ptr<Array> val =
-              std::get<std::shared_ptr<Array>>(load_global(ref));
-
-            for (size_t i=0; i<indexes.size() - 1; i++)
-              {
-                auto ref_val = val->at(indexes[i])->value();
-
-                size_t ref = std::get<size_t>(ref_val);
-
-                auto arr =
-                  std::get<std::shared_ptr<Array>>(load_global(ref));
-
-                val = arr;
-
-              }
-
-            push(frame().program->add(val->at(indexes.back())));
-
-            m_pc++;
-            } break;*/
-
           case OP_MAKE_ARRAY: {
             std::vector<std::shared_ptr<Constant>> data;
 
@@ -116,7 +81,24 @@ namespace fk
             std::filesystem::path path =
               std::get<std::string>(path_val->value());
 
-            auto mod = m_mod.get_mod(path);
+            auto alt_path = std::filesystem::path("/")
+              / "usr" / "lib" / ("lib"
+                                 + path.filename().string()
+                                 + ".so" );
+
+            std::shared_ptr<Module> mod;
+
+            if (m_mod.has_mod(path))
+              {
+                mod = m_mod.get_mod(path);
+
+              }
+            else if (std::filesystem::exists(alt_path))
+              {
+                mod = std::make_shared<Module>(alt_path);
+                mod->import_std();
+                mod->import_library(alt_path);
+              }
 
             addr_t addr = store_global(mod);
             auto res = std::make_shared<Constant>(TYPE_REF, addr,
@@ -129,6 +111,7 @@ namespace fk
           case OP_LOAD_MOD: {
             addr_t mod_addr = pop();
             auto mod_val = frame().program->get_const(mod_addr);
+
             size_t mod_ref =
               std::get<size_t>(mod_val->value());
 
@@ -199,17 +182,33 @@ namespace fk
           } break;
 
           case OP_LOAD_CLOSURE: {
-            if (frame().lambda && frame().lambda->has_env(instr.param))
+            std::shared_ptr<Lambda> lambda;
-              {
-                auto val = frame().lambda->get_env(instr.param);
-                addr_t addr = frame().program->add(val);
 
+            for (size_t i=0; i<m_frames.size(); i++)
+              {
+                size_t k = m_frames.size() - 1 - i;
+
+                if (m_frames[k].lambda->has_env(instr.param))
+                  {
+                    lambda = m_frames[k].lambda;
+                    break;
+                  }
+              }
+
+            if (lambda)
+              {
+                auto val = lambda->get_env(instr.param);
+                addr_t addr = frame().program->add(val);
                 push(addr);
+
                 m_pc++;
                 break;
               }
 
-            m_pc++;
+            std::cerr << "cannot find addr '"
+                      << instr.param
+                      << "'" << std::endl;
+            abort();
           } break;
 
           case OP_NOT: {
@@ -242,19 +241,30 @@ namespace fk
           } break;
 
           case OP_MAKE_FUNCTION: {
+            int base_addr =
+              std::get<int>(frame().program->get_const(pop())->value());
+
             auto p = frame().program->get_const(pop());
             auto prog = std::get<std::shared_ptr<Program>>(p->value());
             auto lambda = std::make_shared<Lambda>(prog, instr.param);
-
+            lambda->set_base_addr(base_addr);
             addr_t addr = store_global(lambda);
             auto ref = std::make_shared<Constant>(TYPE_REF, addr, p->loc());
 
-            if (m_frames.size() > 1)
+            for (auto const& f: m_frames)
               {
-                for (auto e: m_frames.back().locals)
+                for (auto e: f.locals)
                   {
                     lambda->add_env(e.first, e.second);
                   }
+
+                if (f.lambda)
+                  {
+                    for (auto e: f.lambda->get_all_env())
+                      {
+                        lambda->add_env(e.first, e.second);
+                      }
+                  }
               }
 
             push(frame().program->add(ref));
@@ -315,8 +325,9 @@ namespace fk
               auto fun = std::get<std::shared_ptr<NativeFunction>>
                 (load_global(ref));
 
-              push(frame().program->add(fun->call(ref_val->loc(),
+              auto res = fun->call(ref_val->loc(), m_mod, args);
-                                                  m_mod, args)));
+
+              push(frame().program->add(res));
               m_pc++;
               break;
             }
@@ -336,10 +347,10 @@ namespace fk
 
             for (size_t i=0; i<args.size(); i++)
               {
-                store_local(i, args[i]);
+                store_local(lambda->base_addr() + i, args[i]);
               }
 
-            store_local(args.size(), self);
+            store_local(lambda->base_addr() + args.size(), self);
 
             m_pc = 0;
           } break;
@@ -364,6 +375,7 @@ namespace fk
             auto value = frame().program->get_const(top());
             assert(value);
             frame().locals[instr.param] = value;
+
             m_pc++;
           } break;
 
@@ -410,13 +422,14 @@ namespace fk
 
     for (size_t i=0; i<args.size(); i++)
       {
-        store_local(i, args[i]);
+        store_local(lambda->base_addr() + i, args[i]);
       }
 
     auto self = std::make_shared<Constant>(TYPE_REF,
                                            static_cast<size_t>(ref),
                                            loc);
-    store_local(args.size(), self);
+
+    store_local(lambda->base_addr() + args.size(), self);
 
     m_pc = 0;
 
@@ -495,9 +508,12 @@ namespace fk
                  size_t ref,
                  Loc const& loc)
   {
-    for (auto entry: parent.m_globals)
+    if (&parent != this)
       {
-        store_global(entry.first, entry.second);
+        for (auto entry: parent.m_globals)
+          {
+            store_global(entry.first, entry.second);
+          }
       }
 
     auto self = std::make_shared<Constant>(TYPE_REF,
@@ -512,10 +528,10 @@ namespace fk
 
     for (size_t i=0; i<args.size(); i++)
       {
-        store_local(i, args[i]);
+        store_local(lambda->base_addr() + i, args[i]);
       }
 
-    store_local(args.size(), self);
+    store_local(lambda->base_addr() + args.size(), self);
 
     m_pc = 0;
 

src/commons.hpp

@@ -26,4 +26,8 @@ using addr_t = size_t;
     NAME (std::string const& what) : std::runtime_error(what ) {}       \
   }
 
+#define STDARGS std::vector<std::shared_ptr<Constant>>
+#define STDRET std::shared_ptr<Constant>
+#define STDSYM std::shared_ptr<SymTable>
+
 #endif

src/types.hpp

@@ -5,7 +5,7 @@
 
 #define TYPES(G) G(TYPE_INT), G(TYPE_FLOAT), G(TYPE_BOOL), G(TYPE_STRING), \
     G(TYPE_REF), G(TYPE_PROGRAM), G(TYPE_ARRAY), G(TYPE_NIL), \
-    G(TYPE_FUNCTION)
+    G(TYPE_FUNCTION), G(TYPE_CUSTOM)
 
 namespace fk
 {