summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/boot.clj195
-rw-r--r--src/jvm/clojure/lang/RT.java75
2 files changed, 148 insertions, 122 deletions
diff --git a/src/boot.clj b/src/boot.clj
index 6ab0474c..5c65577c 100644
--- a/src/boot.clj
+++ b/src/boot.clj
@@ -9,8 +9,8 @@
(in-namespace 'clojure)
(def list (fn [& args] args))
-(def cons (fn [x seq] (. RT (cons x seq))))
-(def conj (fn [coll x] (. RT (conj coll x))))
+(def cons (fn [x seq] (. clojure.lang.RT (cons x seq))))
+(def conj (fn [coll x] (. clojure.lang.RT (conj coll x))))
(def defn (fn [name & fdecl]
(list 'def name (cons 'fn fdecl))))
@@ -35,10 +35,10 @@
([comparator & args]
(. clojure.lang.PersistentTreeMap (create comparator args))))
-(defn meta [#^IObj x]
+(defn meta [#^clojure.lang.IObj x]
(. x (meta)))
-(defn with-meta [#^IObj x m]
+(defn with-meta [#^clojure.lang.IObj x m]
(. x (withMeta m)))
(def defmacro (fn [name & args]
@@ -54,19 +54,24 @@
(defmacro when-not [test & body]
(list 'if test nil (cons 'do body)))
-(def t (. RT T))
+(def t (. clojure.lang.RT T))
(defn nil? [x] (if x nil t))
(defn not [x] (nil? x))
-(defn first [x] (. RT (first x)))
+(defn first [x] (. clojure.lang.RT (first x)))
-(defn rest [x] (. RT (rest x)))
+(defn rest [x] (. clojure.lang.RT (rest x)))
-(defn second [x] (. RT (second x)))
+(defn second [x] (. clojure.lang.RT (second x)))
-(defn eql? [x y] (. RT (equal x y)))
+(defn ffirst [x] (first (first x)))
+(defn rfirst [x] (rest (first x)))
+(defn frest [x] (first (rest x)))
+(defn rrest [x] (rest (rest x)))
+
+(defn eql? [x y] (. clojure.lang.RT (equal x y)))
(defn str [#^Object x] (. x (toString)))
@@ -76,9 +81,13 @@
(recur (. s (concat (str (first ys)))) (rest ys))
s)))
+(defn sym
+ ([name] (. clojure.lang.Symbol (intern name)))
+ ([ns name] (. clojure.lang.Symbol (intern ns name))))
+
(defn gensym
([] (thisfn "G__"))
- ([prefix-string] (. Symbol (intern (strcat prefix-string (str (. RT (nextID))))))))
+ ([prefix-string] (. clojure.lang.Symbol (intern (strcat prefix-string (str (. clojure.lang.RT (nextID))))))))
(defmacro cond [& clauses]
(when clauses
@@ -92,7 +101,7 @@
(nil? (rest arglist)) (first arglist)
:else (cons (first arglist) (thisfn (rest arglist)))))
-(defn apply [#^IFn f & args]
+(defn apply [#^clojure.lang.IFn f & args]
(. f (applyTo (spread args))))
(defn list* [& args]
@@ -130,73 +139,73 @@
(defn +
([] 0)
([x] x)
- ([x y] (. Num (add x y)))
+ ([x y] (. clojure.lang.Num (add x y)))
([x y & more]
(apply thisfn (thisfn x y) more)))
(defn *
([] 1)
([x] x)
- ([x y] (. Num (multiply x y)))
+ ([x y] (. clojure.lang.Num (multiply x y)))
([x y & rest]
(apply thisfn (thisfn x y) rest)))
(defn /
([x] (thisfn 1 x))
- ([x y] (. Num (divide x y)))
+ ([x y] (. clojure.lang.Num (divide x y)))
([x y & rest]
(apply thisfn (thisfn x y) rest)))
(defn -
- ([x] (. Num (negate x)))
- ([x y] (. Num (subtract x y)))
+ ([x] (. clojure.lang.Num (negate x)))
+ ([x y] (. clojure.lang.Num (subtract x y)))
([x y & rest]
(apply thisfn (thisfn x y) rest)))
(defn <
([x] t)
- ([x y] (. Num (lt x y)))
+ ([x y] (. clojure.lang.Num (lt x y)))
([x y & rest]
(and (thisfn x y) (apply thisfn y rest))))
(defn <=
([x] t)
- ([x y] (. Num (lte x y)))
+ ([x y] (. clojure.lang.Num (lte x y)))
([x y & rest]
(and (thisfn x y) (apply thisfn y rest))))
(defn >
([x] t)
- ([x y] (. Num (gt x y)))
+ ([x y] (. clojure.lang.Num (gt x y)))
([x y & rest]
(and (thisfn x y) (apply thisfn y rest))))
(defn >=
([x] t)
- ([x y] (. Num (gte x y)))
+ ([x y] (. clojure.lang.Num (gte x y)))
([x y & rest]
(and (thisfn x y) (apply thisfn y rest))))
(defn ==
([x] t)
- ([x y] (. Num (equiv x y)))
+ ([x y] (. clojure.lang.Num (equiv x y)))
([x y & rest]
(and (thisfn x y) (apply thisfn y rest))))
(defn inc [x]
- (. Num (inc x)))
+ (. clojure.lang.Num (inc x)))
(defn dec [x]
- (. Num (dec x)))
+ (. clojure.lang.Num (dec x)))
(defn pos? [x]
- (. Num (posPred x)))
+ (. clojure.lang.Num (posPred x)))
(defn neg? [x]
- (. Num (negPred x)))
+ (. clojure.lang.Num (negPred x)))
(defn zero? [x]
- (. Num (zeroPred x)))
+ (. clojure.lang.Num (zeroPred x)))
(defn complement [f]
(fn [& args]
@@ -210,42 +219,42 @@
;;Collection stuff
(defn seq [coll]
- (. RT (seq coll)))
+ (. clojure.lang.RT (seq coll)))
(defn count [coll]
- (. RT (count coll)))
+ (. clojure.lang.RT (count coll)))
;;list stuff
(defn peek [list]
- (. RT (peek list)))
+ (. clojure.lang.RT (peek list)))
(defn pop [list]
- (. RT (pop list)))
+ (. clojure.lang.RT (pop list)))
(defn nth [coll index]
- (. RT (nth coll index)))
+ (. clojure.lang.RT (nth coll index)))
;;map stuff
(defn contains [map key]
- (. RT (contains map key)))
+ (. clojure.lang.RT (contains map key)))
(defn get [map key]
- (. RT (get map key)))
+ (. clojure.lang.RT (get map key)))
(defn assoc [map key val]
- (. RT (assoc map key val)))
+ (. clojure.lang.RT (assoc map key val)))
(defn dissoc [map key]
- (. RT (dissoc map key)))
+ (. clojure.lang.RT (dissoc map key)))
(defn find [map key]
- (. RT (find map key)))
+ (. clojure.lang.RT (find map key)))
(defn select [map keyseq]
(loop [ret {} keys (seq keyseq)]
(if keys
- (let [entry (. RT (find map (first keys)))]
+ (let [entry (. clojure.lang.RT (find map (first keys)))]
(recur
(if entry
(conj ret entry)
@@ -254,10 +263,10 @@
ret)))
(defn keys [map]
- (. RT (keys map)))
+ (. clojure.lang.RT (keys map)))
(defn vals [map]
- (. RT (vals map)))
+ (. clojure.lang.RT (vals map)))
(defn rseq [smap]
(. smap (rseq)))
@@ -307,31 +316,31 @@
(seq ret))))]
`(try-finally
(do
- (. Var (pushThreadBindings (hash-map ~@(var-ize bindings))))
+ (. clojure.lang.Var (pushThreadBindings (hash-map ~@(var-ize bindings))))
~@body)
- (. Var (popThreadBindings)))))
+ (. clojure.lang.Var (popThreadBindings)))))
(defn find-var [sym]
- (. Var (find sym)))
+ (. clojure.lang.Var (find sym)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Refs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defn ref [x]
- (new Ref x))
+ (new clojure.lang.Ref x))
-(defn deref [#^Ref ref]
+(defn deref [#^clojure.lang.Ref ref]
(. ref (get)))
-(defn deref! [#^Ref ref]
+(defn deref! [#^clojure.lang.Ref ref]
(. ref (currentVal)))
-(defn commute [#^Ref ref fun]
+(defn commute [#^clojure.lang.Ref ref fun]
(. ref (commute fun)))
(defn set
- ([#^Ref ref]
+ ([#^clojure.lang.Ref ref]
(. ref (touch))
(. ref (get)))
- ([#^Ref ref val]
+ ([#^clojure.lang.Ref ref val]
(. ref (set val))))
(defmacro sync [flags-ignored-for-now & body]
@@ -458,51 +467,59 @@
(reduce conj maps))
;; evaluation
+
(defn eval [form]
(. clojure.lang.Compiler (eval form)))
-
-(defmacro import [pkg & class-names]
- (loop [ret () classes class-names]
- (if classes
- (let [c (first classes)]
- (recur (conj ret
- (if (instance? c Symbol)
- `(set! *imports* (assoc *imports* '~c ~(strcat pkg "." c)))
- `(set! *imports* (assoc *imports* '~(second c) ~(strcat pkg "." (first c))))))
- (rest classes)))
- (cons `do ret))))
-
-;(defmacro refer-to [ns & names]
-; (loop [ret () names names]
-; (if names
-; (let [v (first names)]
-; (recur (conj ret
-; (if (instance? v Symbol)
-; `(set! *refers* (assoc *refers* '~v (the-var ~(. Symbol (intern (str ns) (str v))))))
-; `(set! *refers* (assoc *refers* '~(second v) (the-var ~(. Symbol (intern (str ns) (str (first v)))))))))
-; (rest names)))
-; (cons `do ret))))
-
-(defn refer-to [& export-maps]
- (set! *refers* (apply merge export-maps)))
-
-(defn make-export-map [var-syms]
- (loop [ret {}
- vs (seq var-syms)]
- (if vs
- (let [s (first vs) v (find-var s)]
- (if v
- (recur (assoc ret (. Symbol (intern (name s))) v) (rest vs))
- (throw (new Exception (strcat "Can't find Var: " s)))))
- ret)))
+
+(defn defimports [& imports-maps]
+ (def *imports* (apply merge imports-maps)))
+
+(defmacro dolist [item list & body]
+ `(loop [list# (seq ~list)]
+ (when list#
+ (let [~item (first list#)]
+ ~@body)
+ (recur (rest list#)))))
+
+(defn import [& import-lists]
+ (when import-lists
+ (let [#^clojure.lang.Var imps *ns-imports*
+ pkg (ffirst import-lists)
+ classes (rfirst import-lists)]
+ (dolist c classes
+ (. imps (bindRoot (assoc (. imps (get)) c (strcat pkg "." c))))))
+ (apply thisfn (rest import-lists))))
+
+(defn unimport [names]
+ (let [#^clojure.lang.Var imps *ns-imports*]
+ (dolist name names
+ (. imps (bindRoot (dissoc (. imps (get)) name))))))
+
+(defn refer [& refer-lists]
+ (dolist rlist refer-lists
+ (let [#^clojure.lang.Var refers *ns-refers*
+ ns (first rlist)
+ names (rest rlist)]
+ (dolist name names
+ (let [varsym (sym (str ns) (str name))
+ var (. clojure.lang.Var (find varsym))]
+ (if var
+ (. refers (bindRoot (assoc (. refers (get)) name var)))
+ (throw (new Exception (strcat "Can't find Var: " varsym)))))))))
+
+(defn unrefer [names]
+ (let [#^clojure.lang.Var refers *ns-refers*]
+ (dolist name names
+ (. refers (bindRoot (dissoc (. refers (get)) name))))))
(def *exports*
- (make-export-map
- `( load-file eql-ref?
+ '(clojure
+ load-file eql-ref?
list cons conj defn
vector hash-map sorted-map sorted-map-by
meta with-meta defmacro when when-not
nil? not first rest second
+ ffirst frest rfirst rrest
eql? str strcat gensym cond
apply list* delay lazy-cons concat
and or + * / - == < <= > >=
@@ -510,12 +527,14 @@
complement constantly identity seq count
peek pop nth contains get
assoc dissoc find keys vals merge
- rseq name namespace locking ..
+ rseq sym name namespace locking ..
defpolyfn defmethod binding find-var
ref deref deref! commute set sync
reduce reverse comp appl
every not-every any not-any
map mapcat filter take take-while drop drop-while
cycle split-at split-with repeat replicate iterate
- eval import refer-to in-namespace
- ))) \ No newline at end of file
+ dolist
+ eval import unimport refer unrefer in-namespace
+ ))
+
diff --git a/src/jvm/clojure/lang/RT.java b/src/jvm/clojure/lang/RT.java
index 40bdb854..8c421e44 100644
--- a/src/jvm/clojure/lang/RT.java
+++ b/src/jvm/clojure/lang/RT.java
@@ -35,20 +35,21 @@ final static Symbol EQL_REF = Symbol.create("clojure", "eql-ref?");
//symbol
final static Var CURRENT_NS_SYM = Var.intern(Symbol.create("clojure", "*current-namespace*"), Symbol.create("clojure"));
//simple-symbol->fully-qualified-class-name-string
-final static IPersistentMap DEFAULT_IMPORTS = map(Symbol.create("RT"), "clojure.lang.RT",
- Symbol.create("Num"), "clojure.lang.Num",
- Symbol.create("Symbol"), "clojure.lang.Symbol",
- Symbol.create("Keyword"), "clojure.lang.Keyword",
- Symbol.create("Var"), "clojure.lang.Var",
- Symbol.create("Ref"), "clojure.lang.Ref",
- Symbol.create("IFn"), "clojure.lang.IFn",
- Symbol.create("IObj"), "clojure.lang.IObj",
- Symbol.create("ISeq"), "clojure.lang.ISeq",
- Symbol.create("IPersistentCollection"),
- "clojure.lang.IPersistentCollection",
- Symbol.create("IPersistentMap"), "clojure.lang.IPersistentMap",
- Symbol.create("IPersistentList"), "clojure.lang.IPersistentList",
- Symbol.create("IPersistentVector"), "clojure.lang.IPersistentVector",
+final static IPersistentMap DEFAULT_IMPORTS = map(
+// Symbol.create("RT"), "clojure.lang.RT",
+// Symbol.create("Num"), "clojure.lang.Num",
+// Symbol.create("Symbol"), "clojure.lang.Symbol",
+// Symbol.create("Keyword"), "clojure.lang.Keyword",
+// Symbol.create("Var"), "clojure.lang.Var",
+// Symbol.create("Ref"), "clojure.lang.Ref",
+// Symbol.create("IFn"), "clojure.lang.IFn",
+// Symbol.create("IObj"), "clojure.lang.IObj",
+// Symbol.create("ISeq"), "clojure.lang.ISeq",
+// Symbol.create("IPersistentCollection"),
+// "clojure.lang.IPersistentCollection",
+// Symbol.create("IPersistentMap"), "clojure.lang.IPersistentMap",
+// Symbol.create("IPersistentList"), "clojure.lang.IPersistentList",
+// Symbol.create("IPersistentVector"), "clojure.lang.IPersistentVector",
Symbol.create("Boolean"), "java.lang.Boolean",
Symbol.create("Byte"), "java.lang.Byte",
Symbol.create("Character"), "java.lang.Character",
@@ -89,23 +90,23 @@ final static IPersistentMap DEFAULT_IMPORTS = map(Symbol.create("RT"), "clojure.
Symbol.create("Iterable"), "java.lang.Iterable",
Symbol.create("Readable"), "java.lang.Readable",
Symbol.create("Runnable"), "java.lang.Runnable",
- Symbol.create("Exception"), "java.lang.Exception",
- Symbol.create("Collection"), "java.util.Collection",
- Symbol.create("Comparator"), "java.util.Comparator",
- Symbol.create("Enumeration"), "java.util.Enumeration",
- Symbol.create("EventListener"), "java.util.EventListener",
- Symbol.create("Formattable"), "java.util.Formattable",
- Symbol.create("Iterator"), "java.util.Iterator",
- Symbol.create("List"), "java.util.List",
- Symbol.create("ListIterator"), "java.util.ListIterator",
- Symbol.create("Map"), "java.util.Map",
- Symbol.create("Map$Entry"), "java.util.Map$Entry",
- Symbol.create("Observer"), "java.util.Observer",
- Symbol.create("Queue"), "java.util.Queue",
- Symbol.create("RandomAccess"), "java.util.RandomAccess",
- Symbol.create("Set"), "java.util.Set",
- Symbol.create("SortedMap"), "java.util.SortedMap",
- Symbol.create("SortedSet"), "java.util.SortedSet"
+ Symbol.create("Exception"), "java.lang.Exception"
+// Symbol.create("Collection"), "java.util.Collection",
+// Symbol.create("Comparator"), "java.util.Comparator",
+// Symbol.create("Enumeration"), "java.util.Enumeration",
+// Symbol.create("EventListener"), "java.util.EventListener",
+// Symbol.create("Formattable"), "java.util.Formattable",
+// Symbol.create("Iterator"), "java.util.Iterator",
+// Symbol.create("List"), "java.util.List",
+// Symbol.create("ListIterator"), "java.util.ListIterator",
+// Symbol.create("Map"), "java.util.Map",
+// Symbol.create("Map$Entry"), "java.util.Map$Entry",
+// Symbol.create("Observer"), "java.util.Observer",
+// Symbol.create("Queue"), "java.util.Queue",
+// Symbol.create("RandomAccess"), "java.util.RandomAccess",
+// Symbol.create("Set"), "java.util.Set",
+// Symbol.create("SortedMap"), "java.util.SortedMap",
+// Symbol.create("SortedSet"), "java.util.SortedSet"
);
final static Var IMPORTS = Var.intern(Symbol.create("clojure", "*imports*"), DEFAULT_IMPORTS);
@@ -113,10 +114,16 @@ final static IFn inNamespace = new AFn(){
public Object invoke(Object arg1) throws Exception{
Symbol ns = (Symbol) arg1;
CURRENT_NS_SYM.set(ns);
- Var refers = Var.intern(Symbol.intern(ns.name, "*refers*"), EXPORTS_VAR.get());
- Var imports = Var.intern(Symbol.intern(ns.name, "*imports*"), DEFAULT_IMPORTS);
+ Var refers = Var.intern(Symbol.intern(ns.name, "*refers*"));
+
+ Var imports = Var.intern(Symbol.intern(ns.name, "*imports*"), DEFAULT_IMPORTS,false);
NS_REFERS.set(refers);
NS_IMPORTS.set(imports);
+ if(!refers.isBound())
+ {
+ refers.bindRoot(PersistentHashMap.EMPTY);
+ Compiler.eval(list(Symbol.create("clojure","refer"),EXPORTS));
+ }
return RT.T;
}
};
@@ -337,7 +344,7 @@ static public ISeq findKey(Keyword key, ISeq keyvals) throws Exception{
return null;
}
-static public Object dissoc(Object key, Object coll){
+static public Object dissoc(Object coll, Object key){
if(coll == null)
return null;
return ((IPersistentMap) coll).without(key);
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-07-17 13:58:56 +0000