v0.5.0 - module system

Signed-off-by: Nick Wanninger <[email protected]>

Author: nickwanninger

core/core.cdr renamed to core/main.cdr

@@ -146,6 +146,9 @@
                           (str self other))))
 
 
+(. Module (add-field 'str (fn (self) (str "<Module " self.*name* ">"))))
+(. Module (add-field 'repr (fn (self) (str "<Module " self.*name* ">"))))
+
 (defmacro catch (id expr body)
   (list 'catch* (list 'fn nil expr) (list 'fn (list id) body)))
 
@@ -518,11 +521,18 @@
 
 
 
+(def (import-opt-expand name opts)
+  (when opts
+    (let [opt (first opts)
+          t (type (first opts))]
+      (cons (cond (= Vector t) (cons 'do (map (fn (x) `(def ~x (. ~name ~x)))
+                                           opt))
+                  true 1)
+            (import-opt-expand name (rest opts))))))
 
-
-(defmacro case (dispatch & cases)
-  (let []))
-
+(defmacro import (name & opts)
+  `(do (def ~name (require ~(str name)))
+     ~@(import-opt-expand name opts)))
 
 
 (defmacro while (test & body)
@@ -670,28 +680,6 @@
 
 
 
-;; the Module type that represents the current module
-;; and what gets returned from (import)
-(deftype Module)
-
-
-(def *imported* {})
-
-(def (import path)
-  (let (qualified (path-resolve path *file*)
-        *old-file* *file*
-        *old-module* nil
-        *new-module* nil)
-    (if (not (get *imported* qualified false))
-      (do (eval-file-in-module qualified *new-module*)
-          (set *imported* qualified *new-module*)
-          (def *file* *old-file*)
-          *new-module*)
-      (get *imported* qualified))))
-
-
-
-
 
 (defmacro do-global (& globs)
   (let [old-mod-name (gensym)
@@ -704,10 +692,6 @@
        ~return-sym)))
 
 
-
-
-
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Base Exceptions
@@ -930,10 +914,12 @@
 (def (unlock! m) (. m (unlock!)))
 
 
+
+(import _mutex)
 ;; define an event-loop safe wrapper around a kernel mutex
 (deftype Mutex
   (def (new self)
-    (. self _mut := (KernelMutex)))
+    (. self _mut := (_mutex.KernelMutex)))
   (def (locked? self)
     (locked? self._mut))
   (def (lock! self)
@@ -965,4 +951,3 @@
                   (join files " ")))))
 
 
-

example/main.cdr

@@ -53,6 +53,7 @@
 
 
 
+
 (def (vrange n)
   (let (i 0
         v [])

include/cedar/builtin_types.h

@@ -22,5 +22,7 @@ BUILTIN_TYPE(dict, "Dict")
 BUILTIN_TYPE(symbol, "Symbol")
 BUILTIN_TYPE(keyword, "Keyword")
 BUILTIN_TYPE(fiber, "Fiber")
+BUILTIN_TYPE(module, "Module")
+
 
 #endif

include/cedar/globals.h

@@ -33,6 +33,10 @@
 
 namespace cedar {
 
+  class module;
+
+  extern module *core_mod;
+
   void def_global(int, ref);
   void def_global(ref, ref);
   void def_global(runes, ref);

include/cedar/modules.h

@@ -30,11 +30,17 @@
 #define _MODULES_H
 
 #include <string>
+#include <cedar/runes.h>
+#include <cedar/ref.h>
 
 namespace cedar {
   class module;
   // primary module require system
   module *require(std::string);
+
+  void define_builtin_module(std::string, module*);
+
+  ref eval_string_in_module(cedar::runes, module*);
 };
 
 #endif

include/cedar/object/module.h

@@ -31,8 +31,12 @@ namespace cedar {
 
   class module : public object {
    public:
-    module();
+    module(void);
+    module(std::string);
     ~module(void);
+
+    void def(std::string, ref);
+    void def(std::string, bound_function);
   };
 
 }  // namespace cedar

include/cedar/ref.h

@@ -74,7 +74,6 @@ namespace cedar {
       f64 m_flt;
       object *m_obj;
       void *m_ptr;
-
       fractional m_frac;
     };
 

include/cedar/version.h

@@ -22,4 +22,4 @@
  * SOFTWARE.
  */
 
-#define CEDAR_VERSION "0.4.1"
+#define CEDAR_VERSION "0.5.0"

include/cedar/vm/opcode.h

@@ -32,6 +32,7 @@
 #define OP_DEF_MACRO                0x19
 #define OP_EVAL                     0x1a
 #define OP_SLEEP                    0x1b
+#define OP_GET_MODULE               0x1c
 
 /* Instruction opcode foreach macro for code generation */
 /* Arg order: (name, bytecode, type, stack effect */
@@ -63,6 +64,7 @@
   V(SET_ATTR, OP_SET_ATTR, imm_int, 0) \
   V(DEF_MACRO, OP_DEF_MACRO, imm_int, 0) \
   V(EVAL, OP_EVAL, no_arg, 0) \
-  V(SLEEP, OP_SLEEP, no_arg, -1)
+  V(SLEEP, OP_SLEEP, no_arg, -1) \
+  V(GET_MODULE, OP_GET_MODULE, no_arg, 1)
 
 #endif

src/cedar/bindings/mutex.cpp

@@ -24,6 +24,9 @@
 
 #include <cedar/globals.h>
 #include <cedar/objtype.h>
+#include <cedar/modules.h>
+#include <cedar/object/string.h>
+#include <cedar/object/module.h>
 #include <cedar/vm/binding.h>
 #include <stdio.h>
 #include <mutex>
@@ -40,6 +43,11 @@ class mutex_obj : public object {
 
 
 void bind_mutex(void) {
+
+
+  module *mod = new module("_mutex");
+
+
   mutex_type = new type("KernelMutex");
   type_init_default_bindings(mutex_type);
 
@@ -70,4 +78,7 @@ void bind_mutex(void) {
   });
 
   def_global(new symbol("KernelMutex"), mutex_type);
+
+  mod->def("KernelMutex", mutex_type);
+  define_builtin_module("_mutex", mod);
 }

src/cedar/bindings/os.cpp

@@ -27,6 +27,8 @@
 #include <cedar/object/keyword.h>
 #include <cedar/object/string.h>
 #include <cedar/object/vector.h>
+#include <cedar/object/module.h>
+#include <cedar/modules.h>
 #include <cedar/objtype.h>
 #include <cedar/vm/binding.h>
 #include <dirent.h>
@@ -57,10 +59,10 @@ static cedar_binding(os_which) {
 static cedar_binding(os_fork) { return fork(); }
 
 static cedar_binding(os_shell) {
-  if (argc != 1) throw cedar::make_exception("os/shell requires 1 argument");
+  if (argc != 1) throw cedar::make_exception("os.shell requires 1 argument");
 
   if (argv[0].get_type() != string_type) {
-    throw cedar::make_exception("os/shell requires a string as an argument");
+    throw cedar::make_exception("os.shell requires a string as an argument");
   }
 
   std::string cmd = argv[0].to_string(true);
@@ -71,9 +73,9 @@ static cedar_binding(os_shell) {
 
 
 static cedar_binding(os_stat) {
-  if (argc != 1) throw cedar::make_exception("os/stat requires 1 argument");
+  if (argc != 1) throw cedar::make_exception("os.stat requires 1 argument");
   if (argv[0].get_type() != string_type) {
-    throw cedar::make_exception("os/stat requires a string path as an argument");
+    throw cedar::make_exception("os.stat requires a string path as an argument");
   }
   std::string path = argv[0].to_string(true);
   struct stat s;
@@ -115,7 +117,7 @@ static cedar_binding(os_listdir) {
 
   if (argc == 1) {
     if (argv[0].get_type() != string_type) {
-      throw cedar::make_exception("os/listdir requires a string path as an argument");
+      throw cedar::make_exception("os.listdir requires a string path as an argument");
     }
     path = argv[0].to_string(true);
   }
@@ -135,9 +137,9 @@ static cedar_binding(os_listdir) {
 static cedar_binding(os_rm) {
   static ref _true = new symbol("true");
   static ref _false = new symbol("false");
-  if (argc != 1) throw cedar::make_exception("os/rm requires 1 argument");
+  if (argc != 1) throw cedar::make_exception("os.rm requires 1 argument");
   if (argv[0].get_type() != string_type) {
-    throw cedar::make_exception("os/rm requires a string path as an argument");
+    throw cedar::make_exception("os.rm requires a string path as an argument");
   }
   std::string path = argv[0].to_string(true);
   return remove(path.c_str()) == 0 ? _true : _false;
@@ -147,10 +149,10 @@ static cedar_binding(os_rm) {
 
 typedef void(init_func)(void);
 static cedar_binding(os_import_so) {
-  if (argc != 1) throw cedar::make_exception("os/import-so requires 1 argument");
+  if (argc != 1) throw cedar::make_exception("os.import-so requires 1 argument");
 
   if (argv[0].get_type() != string_type) {
-    throw cedar::make_exception("os/import-so requires a string as an argument");
+    throw cedar::make_exception("os.import-so requires a string as an argument");
   }
 
   std::string path = argv[0].to_string(true);
@@ -180,13 +182,19 @@ static cedar_binding(os_getppid) {
 }
 
 void bind_os(void) {
-  def_global("os/shell", os_shell);
-  def_global("os/fork", os_fork);
-  def_global("os/import-so", os_import_so);
-  def_global("os/which", os_which);
-  def_global("os/listdir", os_listdir);
-  def_global("os/stat", os_stat);
-  def_global("os/rm", os_rm);
-  def_global("os/getpid", os_getpid);
-  def_global("os/getppid", os_getppid);
+  module *mod = new module("os");
+
+  mod->def("shell", os_shell);
+  mod->def("fork", os_fork);
+  mod->def("shell", os_shell);
+  mod->def("fork", os_fork);
+  mod->def("import-so", os_import_so);
+  mod->def("which", os_which);
+  mod->def("listdir", os_listdir);
+  mod->def("stat", os_stat);
+  mod->def("rm", os_rm);
+  mod->def("getpid", os_getpid);
+  mod->def("getppid", os_getppid);
+
+  define_builtin_module("os", mod);
 }

src/cedar/globals.cpp

@@ -37,6 +37,10 @@ static std::mutex g_lock;
 static std::unordered_map<int, ref> globals;
 
 
+
+module *cedar::core_mod = nullptr;
+
+
 void cedar::def_global(int id, ref val) {
   g_lock.lock();
   globals[id] = val;

src/cedar/modules.cpp

@@ -27,6 +27,8 @@
 #include <cedar/vm/compiler.h>
 #include <cedar/object/lambda.h>
 #include <cedar/object/module.h>
+#include <cedar/object/string.h>
+#include <cedar/object/symbol.h>
 #include <unordered_map>
 #include <mutex>
 #include <stdio.h>
@@ -67,22 +69,13 @@ static module *require_file(apathy::Path p) {
   cedar::runes src = util::read_file(path.c_str());
 
 
-  module *mod = new module();
+  module *mod = new module(path);
 
-  reader reader;
-  reader.lex_source(src);
 
-  vm::compiler c;
-  bool valid = true;
+  static int file_id = get_symbol_intern_id("*file*");
+  mod->setattr_fast(file_id, new string(path));
 
-  while (true) {
-    ref obj = reader.read_one(&valid);
-    if (!valid) break;
-    ref compiled_lambda = c.compile(obj, nullptr);
-    lambda *raw_program = ref_cast<cedar::lambda>(compiled_lambda);
-    raw_program->mod = mod;
-    ref val = eval_lambda(raw_program);
-  }
+  eval_string_in_module(src, mod);
 
   modules[path] = mod;
 
@@ -92,8 +85,10 @@ static module *require_file(apathy::Path p) {
 
 
 module *cedar::require(std::string name) {
+  if (modules.count(name) != 0) {
+    return modules.at(name);
+  }
   auto path = get_path();
-  static std::string dir_file_name = "main.cdr";
 
   for (std::string p : path) {
     apathy::Path f = p;
@@ -115,4 +110,29 @@ module *cedar::require(std::string name) {
   return nullptr;
 }
 
+// simple function to allow modules to be added externally
+void cedar::define_builtin_module(std::string name, module *mod) {
+  modules[name] = mod;
+}
+
+
 
+ref cedar::eval_string_in_module(cedar::runes src, module *mod) {
+  reader reader;
+  reader.lex_source(src);
+
+  vm::compiler c;
+  bool valid = true;
+
+  ref val;
+  while (true) {
+    ref obj = reader.read_one(&valid);
+    if (!valid) break;
+    ref compiled_lambda = c.compile(obj, nullptr);
+    lambda *raw_program = ref_cast<cedar::lambda>(compiled_lambda);
+    raw_program->mod = mod;
+    val = eval_lambda(raw_program);
+  }
+
+  return val;
+}