merge master

Author: halgari

.gitignore

@@ -4,3 +4,4 @@ pixie-vm
 .idea
 lib
 include
+pixie/*.pxic

pixie/ffi-infer.pxi

@@ -62,6 +62,10 @@
   [{:keys [name]}]
   (str "PixieChecker::DumpType<__typeof__(" name ")>();"))
 
+(defmethod emit-infer-code :global
+  [_]
+  (str "std::cout <<\"[]\" << std::endl;"))
+
 
 (defn start-string []
   (str (apply str (map (fn [i]
@@ -80,6 +84,7 @@
 return 0;
       }")
 
+
 ;; To Ctype conversion
 
 (defmulti edn-to-ctype (fn [n _]
@@ -131,6 +136,10 @@ return 0;
   [{:keys [name]} {:keys [value type]}]
   `(def ~(symbol name) ~value))
 
+(defmethod generate-code :global
+  [{:keys [name]} _]
+  `(def ~(symbol name) (ffi-voidp *library* ~(str name))))
+
 
 
 (defmethod generate-code :function
@@ -228,6 +237,10 @@ return 0;
   `(swap! *bodies* conj (assoc {:op :callback}
                           :name ~(name nm))))
 
+(defmacro defglobal [nm]
+  `(swap! *bodies* conj (assoc {:op :global}
+                          :name ~(name nm))))
+
 
 (defn compile-library [{:keys [prefix includes]} & source]
   (let [c-name (str "/tmp/" prefix ".c")

pixie/repl.pxi

@@ -21,7 +21,10 @@
       (try (let [form (read rdr false)]
              (if (= form eof)
                (exit 0)
-               (println (eval form))))
+               (let [x (eval form)]
+                 (pixie.stdlib/-push-history x)
+                 (prn x))))
            (catch ex
-               (println "ERROR: \n" ex)))
+             (pixie.stdlib/-set-*e ex)
+             (println "ERROR: \n" ex)))
       (recur))))

pixie/stdlib.pxi

@@ -144,32 +144,22 @@
                   ([result] (xf result))
                   ([result item] (xf result (f item))))))
            ([f coll]
-              (let [i (iterator coll)]
-                (loop []
-                  (if (at-end? i)
-                    nil
-                    (do (yield (f (current i)))
-                        (move-next! i)
-                        (recur))))))
+            (lazy-seq*
+              (fn []
+                (let [s (seq coll)]
+                  (if s
+                    (cons (f (first s))
+                          (map f (rest s)))
+                    nil)))))
            ([f & colls]
-              (let [its (vec (map iterator colls))]
-                (loop []
-                  (let [args (if (at-end? (first its))
-                               nil
-                               (reduce
-                                (fn [acc i]
-                                  (if (at-end? i)
-                                    (reduced nil)
-                                    (let [new-acc (conj acc (current i))]
-                                      (move-next! i)
-                                      new-acc)))
-                                []
-                                its))]
-
-                    (if args
-                      (do (yield (apply f args))
-                          (recur)))))))))
-
+              (let [step (fn step [cs]
+                           (lazy-seq*
+                             (fn []
+                               (let [ss (map seq cs)]
+                                 (if (every? identity ss)
+                                   (cons (map first ss) (step (map rest ss)))
+                                   nil)))))]
+                (map (fn [args] (apply f args)) (step colls))))))
 
 (def reduce (fn [rf init col]
               (-reduce col rf init)))
@@ -812,6 +802,7 @@ If further arguments are passed, invokes the method named by symbol, passing the
 (defn keyword? [v] (instance? Keyword v))
 
 (defn list? [v] (instance? PersistentList v))
+(defn set? [v] (instance? PersistentHashSet v))
 (defn map? [v] (satisfies? IMap v))
 (defn fn? [v] (satisfies? IFn v))
 
@@ -2191,3 +2182,11 @@ Expands to calls to `extend-type`."
 (defn mapv
   ([f col]
    (transduce (map f) conj col)))
+
+(defn -push-history [x]
+  (def *3 *2)
+  (def *2 *1)
+  (def *1 x))
+
+(defn -set-*e [e]
+  (def *e e))

pixie/test.pxi

@@ -61,15 +61,25 @@
           yr# ~y]
      (assert (= xr# yr#) (str (show '~x xr#) " != " (show '~y yr#)))))
 
-(defmacro assert-throws? [klass msg body]
-     `(try 
-       ~body 
-       (assert false (str "Expected a " ~klass " exception: " ~msg))
-       (catch e#
-         (assert (= (type e#) ~klass) 
-                 (str "Expected exception of class " ~klass " but got " (type e#)))
-         (assert (= (ex-msg e#) ~msg) 
-                 (str "Expected message: " ~msg " but got " (ex-msg e#))))))
+(defmacro assert-throws?
+  ([body]
+   `(let [exn# (try (do ~body nil) (catch e# e#))]
+      (assert (not (nil? exn#))
+              (str "Expected " (pr-str (quote ~body)) " to throw an exception"))
+      exn#))
+  ([klass body]
+   `(let [exn# (assert-throws? ~body)]
+     (assert (= (type exn#) ~klass)
+             (str "Expected " (pr-str (quote ~body))
+                  " to throw exception of class " (pr-str ~klass)
+                  " but got " (pr-str (type exn#))))
+     exn#))
+  ([klass msg body]
+   `(let [exn# (assert-throws? ~klass ~body)]
+     (assert (= (ex-msg exn#) ~msg)
+             (str "Expected " (pr-str (quote ~body))
+                  " to throw exception with message " (pr-str ~msg)
+                  " but got " (pr-str (ex-msg exn#)))))))
 
 (defmacro assert [x]
   `(let [x# ~x]

pixie/vm/libs/ffi.py

@@ -196,6 +196,13 @@ def _ffi_fn__args(args):
     f = FFIFn(lib, rt.name(nm), new_args, ret_type, is_variadic)
     return f
 
+@as_var("ffi-voidp")
+def _ffi_voidp(lib, nm):
+    affirm(isinstance(lib, ExternalLib), u"First argument to ffi-voidp should be an external library")
+    name = rt.name(nm)
+    return VoidP(lib.get_fn_ptr(name))
+
+
 
 
 

pixie/vm/stdlib.py

@@ -420,7 +420,6 @@ def _load_file(filename, compile=False):
     import pixie.vm.reader as reader
     import pixie.vm.libs.pxic.writer as pxic_writer
     import os.path as path
-    from pixie.vm.persistent_vector import EMPTY as EMPTY_VECTOR
     import os
 
 

tests/pixie/tests/test-stdlib.pxi

@@ -6,6 +6,14 @@
     (doseq [v vs]
       (t/assert= (identity v) v))))
 
+(t/deftest test-map
+  (t/assert= (map inc [1 2 3]) [2 3 4])
+  (t/assert= (map + [1 2 3] [4 5 6]) [5 7 9])
+  (t/assert= (map + [1 2 3] [4 5 6] [7 8 9]) [12 15 18])
+  (let [value (map identity [1 2 3])]
+    (t/assert= (seq value) [1 2 3])
+    (t/assert= (seq value) [1 2 3])))
+
 (t/deftest test-mapcat
   (t/assert= (mapcat identity []) [])
   (t/assert= (mapcat first [[[1 2]] [[3] [:not :present]] [[4 5 6]]]) [1 2 3 4 5 6]))