clojure 1.0.0

data/src/clj/clojure/core_print.clj

@@ -0,0 +1,317 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(in-ns 'clojure.core)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; printing ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(import '(java.io Writer))
+
+(def
+ #^{:doc "*print-length* controls how many items of each collection the
+  printer will print. If it is bound to logical false, there is no
+  limit. Otherwise, it must be bound to an integer indicating the maximum
+  number of items of each collection to print. If a collection contains
+  more items, the printer will print items up to the limit followed by
+  '...' to represent the remaining items. The root binding is nil
+  indicating no limit."}
+ *print-length* nil)
+
+(def
+ #^{:doc "*print-level* controls how many levels deep the printer will
+  print nested objects. If it is bound to logical false, there is no
+  limit. Otherwise, it must be bound to an integer indicating the maximum
+  level to print. Each argument to print is at level 0; if an argument is a
+  collection, its items are at level 1; and so on. If an object is a
+  collection and is at a level greater than or equal to the value bound to
+  *print-level*, the printer prints '#' to represent it. The root binding
+  is nil indicating no limit."}
+*print-level* nil)
+
+(defn- print-sequential [#^String begin, print-one, #^String sep, #^String end, sequence, #^Writer w]
+  (binding [*print-level* (and (not *print-dup*) *print-level* (dec *print-level*))]
+    (if (and *print-level* (neg? *print-level*))
+      (.write w "#")
+      (do
+        (.write w begin)
+        (when-let [xs (seq sequence)]
+          (if (and (not *print-dup*) *print-length*)
+            (loop [[x & xs] xs
+                   print-length *print-length*]
+              (if (zero? print-length)
+                (.write w "...")
+                (do
+                  (print-one x w)
+                  (when xs
+                    (.write w sep)
+                    (recur xs (dec print-length))))))
+            (loop [[x & xs] xs]
+              (print-one x w)
+              (when xs
+                (.write w sep)
+                (recur xs)))))
+        (.write w end)))))
+
+(defn- print-meta [o, #^Writer w]
+  (when-let [m (meta o)]
+    (when (and (pos? (count m))
+               (or *print-dup*
+                   (and *print-meta* *print-readably*)))
+      (.write w "#^")
+      (if (and (= (count m) 1) (:tag m))
+          (pr-on (:tag m) w)
+          (pr-on m w))
+      (.write w " "))))
+
+(defmethod print-method :default [o, #^Writer w]
+  (print-method (vary-meta o #(dissoc % :type)) w))
+
+(defmethod print-method nil [o, #^Writer w]
+  (.write w "nil"))
+
+(defmethod print-dup nil [o w] (print-method o w))
+
+(defn print-ctor [o print-args #^Writer w]
+  (.write w "#=(")
+  (.write w (.getName #^Class (class o)))
+  (.write w ". ")
+  (print-args o w)
+  (.write w ")"))
+
+(defmethod print-method Object [o, #^Writer w]
+  (.write w "#<")
+  (.write w (.getSimpleName (class o)))
+  (.write w " ")
+  (.write w (str o))
+  (.write w ">"))
+
+(defmethod print-method clojure.lang.Keyword [o, #^Writer w]
+  (.write w (str o)))
+
+(defmethod print-dup clojure.lang.Keyword [o w] (print-method o w))
+
+(defmethod print-method Number [o, #^Writer w]
+  (.write w (str o)))
+
+(defmethod print-dup Number [o, #^Writer w]
+  (print-ctor o
+              (fn [o w]
+                  (print-dup (str o) w))
+              w))
+
+(defmethod print-dup clojure.lang.Fn [o, #^Writer w]
+  (print-ctor o (fn [o w]) w))
+
+(prefer-method print-dup clojure.lang.IPersistentCollection clojure.lang.Fn)
+(prefer-method print-dup java.util.Map clojure.lang.Fn)
+(prefer-method print-dup java.util.Collection clojure.lang.Fn)
+
+(defmethod print-method Boolean [o, #^Writer w]
+  (.write w (str o)))
+
+(defmethod print-dup Boolean [o w] (print-method o w))
+
+(defn print-simple [o, #^Writer w]
+  (print-meta o w)
+  (.write w (str o)))
+
+(defmethod print-method clojure.lang.Symbol [o, #^Writer w]
+  (print-simple o w))
+
+(defmethod print-dup clojure.lang.Symbol [o w] (print-method o w))
+
+(defmethod print-method clojure.lang.Var [o, #^Writer w]
+  (print-simple o w))
+
+(defmethod print-dup clojure.lang.Var [#^clojure.lang.Var o, #^Writer w]
+  (.write w (str "#=(var " (.name (.ns o)) "/" (.sym o) ")")))
+
+(defmethod print-method clojure.lang.ISeq [o, #^Writer w]
+  (print-meta o w)
+  (print-sequential "(" pr-on " " ")" o w))
+
+(defmethod print-dup clojure.lang.ISeq [o w] (print-method o w))
+(defmethod print-dup clojure.lang.IPersistentList [o w] (print-method o w))
+(prefer-method print-method clojure.lang.IPersistentList clojure.lang.ISeq)
+(prefer-method print-dup clojure.lang.IPersistentList clojure.lang.ISeq)
+(prefer-method print-method clojure.lang.ISeq clojure.lang.IPersistentCollection)
+(prefer-method print-dup clojure.lang.ISeq clojure.lang.IPersistentCollection)
+(prefer-method print-method clojure.lang.ISeq java.util.Collection)
+(prefer-method print-dup clojure.lang.ISeq java.util.Collection)
+
+(defmethod print-method clojure.lang.IPersistentList [o, #^Writer w]
+  (print-meta o w)
+  (print-sequential "(" print-method " " ")" o w))
+
+
+(defmethod print-dup java.util.Collection [o, #^Writer w]
+ (print-ctor o #(print-sequential "[" print-dup " " "]" %1 %2) w))
+
+(defmethod print-dup clojure.lang.IPersistentCollection [o, #^Writer w]
+  (print-meta o w)
+  (.write w "#=(")
+  (.write w (.getName #^Class (class o)))
+  (.write w "/create ")
+  (print-sequential "[" print-dup " " "]" o w)
+  (.write w ")"))
+
+(prefer-method print-dup clojure.lang.IPersistentCollection java.util.Collection)
+
+(def #^{:tag String 
+        :doc "Returns escape string for char or nil if none"}
+  char-escape-string
+    {\newline "\\n"
+     \tab  "\\t"
+     \return "\\r"
+     \" "\\\""
+     \\  "\\\\"
+     \formfeed "\\f"
+     \backspace "\\b"})
+
+(defmethod print-method String [#^String s, #^Writer w]
+  (if (or *print-dup* *print-readably*)
+    (do (.append w \")
+      (dotimes [n (count s)]
+        (let [c (.charAt s n)
+              e (char-escape-string c)]
+          (if e (.write w e) (.append w c))))
+      (.append w \"))
+    (.write w s))
+  nil)
+
+(defmethod print-dup String [s w] (print-method s w))
+
+(defmethod print-method clojure.lang.IPersistentVector [v, #^Writer w]
+  (print-meta v w)
+  (print-sequential "[" pr-on " " "]" v w))
+
+(defn- print-map [m print-one w]
+  (print-sequential 
+   "{"
+   (fn [e  #^Writer w] 
+     (do (print-one (key e) w) (.append w \space) (print-one (val e) w)))
+   ", "
+   "}"
+   (seq m) w))
+
+(defmethod print-method clojure.lang.IPersistentMap [m, #^Writer w]
+  (print-meta m w)
+  (print-map m pr-on w))
+
+(defmethod print-dup java.util.Map [m, #^Writer w]
+  (print-ctor m #(print-map (seq %1) print-dup %2) w))
+
+(defmethod print-dup clojure.lang.IPersistentMap [m, #^Writer w]
+  (print-meta m w)
+  (.write w "#=(")
+  (.write w (.getName (class m)))
+  (.write w "/create ")
+  (print-map m print-dup w)
+  (.write w ")"))
+
+(prefer-method print-dup clojure.lang.IPersistentCollection java.util.Map)
+
+(defmethod print-method clojure.lang.IPersistentSet [s, #^Writer w]
+  (print-meta s w)
+  (print-sequential "#{" pr-on " " "}" (seq s) w))
+
+(def #^{:tag String 
+        :doc "Returns name string for char or nil if none"} 
+ char-name-string
+   {\newline "newline"
+    \tab "tab"
+    \space "space"
+    \backspace "backspace"
+    \formfeed "formfeed"
+    \return "return"})
+
+(defmethod print-method java.lang.Character [#^Character c, #^Writer w]
+  (if (or *print-dup* *print-readably*)
+    (do (.append w \\)
+        (let [n (char-name-string c)]
+          (if n (.write w n) (.append w c))))
+    (.append w c))
+  nil)
+
+(defmethod print-dup java.lang.Character [c w] (print-method c w))
+(defmethod print-dup java.lang.Integer [o w] (print-method o w))
+(defmethod print-dup java.lang.Double [o w] (print-method o w))
+(defmethod print-dup clojure.lang.Ratio [o w] (print-method o w))
+(defmethod print-dup java.math.BigDecimal [o w] (print-method o w))
+(defmethod print-dup clojure.lang.PersistentHashMap [o w] (print-method o w))
+(defmethod print-dup clojure.lang.PersistentHashSet [o w] (print-method o w))
+(defmethod print-dup clojure.lang.PersistentVector [o w] (print-method o w))
+(defmethod print-dup clojure.lang.LazilyPersistentVector [o w] (print-method o w))
+
+(def primitives-classnames
+  {Float/TYPE "Float/TYPE"
+   Integer/TYPE "Integer/TYPE"
+   Long/TYPE "Long/TYPE"
+   Boolean/TYPE "Boolean/TYPE"
+   Character/TYPE "Character/TYPE"
+   Double/TYPE "Double/TYPE"
+   Byte/TYPE "Byte/TYPE"
+   Short/TYPE "Short/TYPE"})
+
+(defmethod print-method Class [#^Class c, #^Writer w]
+  (.write w (.getName c)))
+
+(defmethod print-dup Class [#^Class c, #^Writer w]
+  (cond
+    (.isPrimitive c) (do
+                       (.write w "#=(identity ")
+                       (.write w #^String (primitives-classnames c))
+                       (.write w ")"))
+    (.isArray c) (do
+                   (.write w "#=(java.lang.Class/forName \"")
+                   (.write w (.getName c))
+                   (.write w "\")"))
+    :else (do
+            (.write w "#=")
+            (.write w (.getName c)))))
+
+(defmethod print-method java.math.BigDecimal [b, #^Writer w]
+  (.write w (str b))
+  (.write w "M"))
+
+(defmethod print-method java.util.regex.Pattern [p #^Writer w]
+  (.write w "#\"")
+  (loop [[#^Character c & r :as s] (seq (.pattern #^java.util.regex.Pattern p))
+         qmode false]
+    (when s
+      (cond
+        (= c \\) (let [[#^Character c2 & r2] r]
+                   (.append w \\)
+                   (.append w c2)
+                   (if qmode
+                      (recur r2 (not= c2 \E))
+                      (recur r2 (= c2 \Q))))
+        (= c \") (do
+                   (if qmode
+                     (.write w "\\E\\\"\\Q")
+                     (.write w "\\\""))
+                   (recur r qmode))
+        :else    (do
+                   (.append w c)
+                   (recur r qmode)))))
+  (.append w \"))
+
+(defmethod print-dup java.util.regex.Pattern [p #^Writer w] (print-method p w))
+
+(defmethod print-dup clojure.lang.Namespace [#^clojure.lang.Namespace n #^Writer w]
+  (.write w "#=(find-ns ")
+  (print-dup (.name n) w)
+  (.write w ")"))
+
+(defmethod print-method clojure.lang.IDeref [o #^Writer w]
+  (print-sequential (format "#<%s@%x: "
+                            (.getSimpleName (class o))
+                            (System/identityHashCode o))
+                    pr-on, "", ">", (list @o), w))
+
+(def #^{:private true} print-initialized true)

data/src/clj/clojure/core_proxy.clj

@@ -0,0 +1,394 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(in-ns 'clojure.core)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;; proxy ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(import
+ '(clojure.asm ClassWriter ClassVisitor Opcodes Type) 
+ '(java.lang.reflect Modifier Constructor)
+ '(clojure.asm.commons Method GeneratorAdapter)
+ '(clojure.lang IProxy Reflector DynamicClassLoader IPersistentMap PersistentHashMap RT))
+
+(defn method-sig [#^java.lang.reflect.Method meth]
+  [(. meth (getName)) (seq (. meth (getParameterTypes))) (. meth getReturnType)])
+
+(defn- most-specific [rtypes]
+  (or (some (fn [t] (when (every? #(isa? t %) rtypes) t)) rtypes)
+    (throw (Exception. "Incompatible return types"))))
+
+(defn- group-by-sig [coll]
+ "takes a collection of [msig meth] and returns a seq of maps from return-types to meths."
+  (vals (reduce (fn [m [msig meth]]
+                  (let [rtype (peek msig)
+                        argsig (pop msig)]
+                    (assoc m argsig (assoc (m argsig {}) rtype meth))))
+          {} coll)))
+
+(defn proxy-name
+ {:tag String} 
+ [#^Class super interfaces]
+  (apply str "clojure.proxy."
+         (.getName super)
+         (interleave (repeat "$")
+                     (sort (map #(.getSimpleName #^Class %) interfaces)))))
+
+(defn- generate-proxy [#^Class super interfaces]
+  (let [cv (new ClassWriter (. ClassWriter COMPUTE_MAXS))
+        cname (.replace (proxy-name super interfaces) \. \/) ;(str "clojure/lang/" (gensym "Proxy__"))
+        ctype (. Type (getObjectType cname))
+        iname (fn [#^Class c] (.. Type (getType c) (getInternalName)))
+        fmap "__clojureFnMap"
+        totype (fn [#^Class c] (. Type (getType c)))
+        to-types (fn [cs] (if (pos? (count cs))
+                            (into-array (map totype cs))
+                            (make-array Type 0)))
+        super-type #^Type (totype super)
+        imap-type #^Type (totype IPersistentMap)
+        ifn-type (totype clojure.lang.IFn)
+        obj-type (totype Object)
+        sym-type (totype clojure.lang.Symbol)
+        rt-type  (totype clojure.lang.RT)
+        ex-type  (totype java.lang.UnsupportedOperationException)
+        gen-bridge 
+        (fn [#^java.lang.reflect.Method meth #^java.lang.reflect.Method dest]
+            (let [pclasses (. meth (getParameterTypes))
+                  ptypes (to-types pclasses)
+                  rtype #^Type (totype (. meth (getReturnType)))
+                  m (new Method (. meth (getName)) rtype ptypes)
+                  dtype (totype (.getDeclaringClass dest))
+                  dm (new Method (. dest (getName)) (totype (. dest (getReturnType))) (to-types (. dest (getParameterTypes))))
+                  gen (new GeneratorAdapter (bit-or (. Opcodes ACC_PUBLIC) (. Opcodes ACC_BRIDGE)) m nil nil cv)]
+              (. gen (visitCode))
+              (. gen (loadThis))
+              (dotimes [i (count ptypes)]
+                  (. gen (loadArg i)))
+              (if (-> dest .getDeclaringClass .isInterface)
+                (. gen (invokeInterface dtype dm))
+                (. gen (invokeVirtual dtype dm)))
+              (. gen (returnValue))
+              (. gen (endMethod))))
+        gen-method
+        (fn [#^java.lang.reflect.Method meth else-gen]
+            (let [pclasses (. meth (getParameterTypes))
+                  ptypes (to-types pclasses)
+                  rtype #^Type (totype (. meth (getReturnType)))
+                  m (new Method (. meth (getName)) rtype ptypes)
+                  gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)
+                  else-label (. gen (newLabel))
+                  end-label (. gen (newLabel))
+                  decl-type (. Type (getType (. meth (getDeclaringClass))))]
+              (. gen (visitCode))
+              (if (> (count pclasses) 18)
+                (else-gen gen m)
+                (do
+                  (. gen (loadThis))
+                  (. gen (getField ctype fmap imap-type))
+                  
+                  (. gen (push (. meth (getName))))
+                                        ;lookup fn in map
+                  (. gen (invokeStatic rt-type (. Method (getMethod "Object get(Object, Object)"))))
+                  (. gen (dup))
+                  (. gen (ifNull else-label))
+                                        ;if found
+                  (.checkCast gen ifn-type)
+                  (. gen (loadThis))
+                                        ;box args
+                  (dotimes [i (count ptypes)]
+                      (. gen (loadArg i))
+                    (. clojure.lang.Compiler$HostExpr (emitBoxReturn nil gen (nth pclasses i))))
+                                        ;call fn
+                  (. gen (invokeInterface ifn-type (new Method "invoke" obj-type 
+                                                        (into-array (cons obj-type 
+                                                                          (replicate (count ptypes) obj-type))))))
+                                        ;unbox return
+                  (. gen (unbox rtype))
+                  (when (= (. rtype (getSort)) (. Type VOID))
+                    (. gen (pop)))
+                  (. gen (goTo end-label))
+                  
+                                        ;else call supplied alternative generator
+                  (. gen (mark else-label))
+                  (. gen (pop))
+                  
+                  (else-gen gen m)
+                  
+                  (. gen (mark end-label))))
+              (. gen (returnValue))
+              (. gen (endMethod))))]
+    
+                                        ;start class definition
+    (. cv (visit (. Opcodes V1_5) (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_SUPER))
+                 cname nil (iname super) 
+                 (into-array (map iname (cons IProxy interfaces)))))
+                                        ;add field for fn mappings
+    (. cv (visitField (+ (. Opcodes ACC_PRIVATE) (. Opcodes ACC_VOLATILE))
+                      fmap (. imap-type (getDescriptor)) nil nil))          
+                                        ;add ctors matching/calling super's
+    (doseq [#^Constructor ctor (. super (getDeclaredConstructors))]
+        (when-not (. Modifier (isPrivate (. ctor (getModifiers))))
+          (let [ptypes (to-types (. ctor (getParameterTypes)))
+                m (new Method "<init>" (. Type VOID_TYPE) ptypes)
+                gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
+            (. gen (visitCode))
+                                        ;call super ctor
+            (. gen (loadThis))
+            (. gen (dup))
+            (. gen (loadArgs))
+            (. gen (invokeConstructor super-type m))
+            
+            (. gen (returnValue))
+            (. gen (endMethod)))))
+                                        ;add IProxy methods
+    (let [m (. Method (getMethod "void __initClojureFnMappings(clojure.lang.IPersistentMap)"))
+          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
+      (. gen (visitCode))
+      (. gen (loadThis))
+      (. gen (loadArgs))
+      (. gen (putField ctype fmap imap-type))
+      
+      (. gen (returnValue))
+      (. gen (endMethod)))
+    (let [m (. Method (getMethod "void __updateClojureFnMappings(clojure.lang.IPersistentMap)"))
+          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
+      (. gen (visitCode))
+      (. gen (loadThis))
+      (. gen (dup))
+      (. gen (getField ctype fmap imap-type))
+      (.checkCast gen (totype clojure.lang.IPersistentCollection))
+      (. gen (loadArgs))
+      (. gen (invokeInterface (totype clojure.lang.IPersistentCollection)
+                              (. Method (getMethod "clojure.lang.IPersistentCollection cons(Object)"))))
+      (. gen (checkCast imap-type))
+      (. gen (putField ctype fmap imap-type))
+      
+      (. gen (returnValue))
+      (. gen (endMethod)))
+    (let [m (. Method (getMethod "clojure.lang.IPersistentMap __getClojureFnMappings()"))
+          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
+      (. gen (visitCode))
+      (. gen (loadThis))
+      (. gen (getField ctype fmap imap-type))
+      (. gen (returnValue))
+      (. gen (endMethod)))
+    
+                                        ;calc set of supers' non-private instance methods
+    (let [[mm considered]
+            (loop [mm {} considered #{} c super]
+              (if c
+                (let [[mm considered]
+                      (loop [mm mm 
+                             considered considered 
+                             meths (concat 
+                                    (seq (. c (getDeclaredMethods)))
+                                    (seq (. c (getMethods))))]
+                        (if (seq meths)
+                          (let [#^java.lang.reflect.Method meth (first meths)
+                                mods (. meth (getModifiers))
+                                mk (method-sig meth)]
+                            (if (or (considered mk)
+                                    (not (or (Modifier/isPublic mods) (Modifier/isProtected mods)))
+                                    ;(. Modifier (isPrivate mods)) 
+                                    (. Modifier (isStatic mods))
+                                    (. Modifier (isFinal mods))
+                                    (= "finalize" (.getName meth)))
+                              (recur mm (conj considered mk) (next meths))
+                              (recur (assoc mm mk meth) (conj considered mk) (next meths))))
+                          [mm considered]))]
+                  (recur mm considered (. c (getSuperclass))))
+                [mm considered]))
+          ifaces-meths (into {} 
+                         (for [#^Class iface interfaces meth (. iface (getMethods))
+                               :let [msig (method-sig meth)] :when (not (considered msig))]
+                           {msig meth}))
+          mgroups (group-by-sig (concat mm ifaces-meths))
+          rtypes (map #(most-specific (keys %)) mgroups)
+          mb (map #(vector (%1 %2) (vals (dissoc %1 %2))) mgroups rtypes)
+          bridge? (reduce into #{} (map second mb))
+          ifaces-meths (remove bridge? (vals ifaces-meths))
+          mm (remove bridge? (vals mm))]
+                                        ;add methods matching supers', if no mapping -> call super
+      (doseq [[#^java.lang.reflect.Method dest bridges] mb
+              #^java.lang.reflect.Method meth bridges]
+          (gen-bridge meth dest))
+      (doseq [#^java.lang.reflect.Method meth mm]
+          (gen-method meth 
+                      (fn [#^GeneratorAdapter gen #^Method m]
+                          (. gen (loadThis))
+                                        ;push args
+                        (. gen (loadArgs))
+                                        ;call super
+                        (. gen (visitMethodInsn (. Opcodes INVOKESPECIAL) 
+                                                (. super-type (getInternalName))
+                                                (. m (getName))
+                                                (. m (getDescriptor)))))))
+      
+                                        ;add methods matching interfaces', if no mapping -> throw
+      (doseq [#^java.lang.reflect.Method meth ifaces-meths]
+                (gen-method meth 
+                            (fn [#^GeneratorAdapter gen #^Method m]
+                                (. gen (throwException ex-type (. m (getName))))))))
+    
+                                        ;finish class def
+    (. cv (visitEnd))
+    [cname (. cv toByteArray)]))
+
+(defn- get-super-and-interfaces [bases]
+  (if (. #^Class (first bases) (isInterface))
+    [Object bases]
+    [(first bases) (next bases)]))
+
+(defn get-proxy-class 
+  "Takes an optional single class followed by zero or more
+  interfaces. If not supplied class defaults to Object.  Creates an
+  returns an instance of a proxy class derived from the supplied
+  classes. The resulting value is cached and used for any subsequent
+  requests for the same class set. Returns a Class object."  
+  [& bases]
+    (let [[super interfaces] (get-super-and-interfaces bases)
+          pname (proxy-name super interfaces)]
+      (or (RT/loadClassForName pname)
+          (let [[cname bytecode] (generate-proxy super interfaces)]
+            (. (RT/getRootClassLoader) (defineClass pname bytecode))))))
+
+(defn construct-proxy
+  "Takes a proxy class and any arguments for its superclass ctor and
+  creates and returns an instance of the proxy."  
+  [c & ctor-args]
+    (. Reflector (invokeConstructor c (to-array ctor-args))))
+
+(defn init-proxy
+  "Takes a proxy instance and a map of strings (which must
+  correspond to methods of the proxy superclass/superinterfaces) to
+  fns (which must take arguments matching the corresponding method,
+  plus an additional (explicit) first arg corresponding to this, and
+  sets the proxy's fn map."
+  [#^IProxy proxy mappings]
+    (. proxy (__initClojureFnMappings mappings)))
+
+(defn update-proxy
+  "Takes a proxy instance and a map of strings (which must
+  correspond to methods of the proxy superclass/superinterfaces) to
+  fns (which must take arguments matching the corresponding method,
+  plus an additional (explicit) first arg corresponding to this, and
+  updates (via assoc) the proxy's fn map. nil can be passed instead of
+  a fn, in which case the corresponding method will revert to the
+  default behavior. Note that this function can be used to update the
+  behavior of an existing instance without changing its identity."
+  [#^IProxy proxy mappings]
+    (. proxy (__updateClojureFnMappings mappings)))
+
+(defn proxy-mappings
+  "Takes a proxy instance and returns the proxy's fn map."
+  [#^IProxy proxy]
+    (. proxy (__getClojureFnMappings)))
+
+(defmacro proxy
+  "class-and-interfaces - a vector of class names
+
+  args - a (possibly empty) vector of arguments to the superclass
+  constructor.
+
+  f => (name [params*] body) or
+  (name ([params*] body) ([params+] body) ...)
+
+  Expands to code which creates a instance of a proxy class that
+  implements the named class/interface(s) by calling the supplied
+  fns. A single class, if provided, must be first. If not provided it
+  defaults to Object.
+
+  The interfaces names must be valid interface types. If a method fn
+  is not provided for a class method, the superclass methd will be
+  called. If a method fn is not provided for an interface method, an
+  UnsupportedOperationException will be thrown should it be
+  called. Method fns are closures and can capture the environment in
+  which proxy is called. Each method fn takes an additional implicit
+  first arg, which is bound to 'this. Note that while method fns can
+  be provided to override protected methods, they have no other access
+  to protected members, nor to super, as these capabilities cannot be
+  proxied."
+  [class-and-interfaces args & fs]
+   (let [bases (map #(or (resolve %) (throw (Exception. (str "Can't resolve: " %)))) 
+                    class-and-interfaces)
+         [super interfaces] (get-super-and-interfaces bases)
+         compile-effect (when *compile-files*
+                          (let [[cname bytecode] (generate-proxy super interfaces)]
+                            (clojure.lang.Compiler/writeClassFile cname bytecode)))
+         pc-effect (apply get-proxy-class bases)
+         pname (proxy-name super interfaces)]
+     `(let [;pc# (get-proxy-class ~@class-and-interfaces)
+            p# (new ~(symbol pname) ~@args)] ;(construct-proxy pc# ~@args)]   
+        (init-proxy p#
+         ~(loop [fmap {} fs fs]
+            (if fs
+              (let [[sym & meths] (first fs)
+                    meths (if (vector? (first meths))
+                            (list meths)
+                            meths)
+                    meths (map (fn [[params & body]]
+                                   (cons (apply vector 'this params) body))
+                               meths)]
+                (if-not (contains? fmap (name sym))		  
+                (recur (assoc fmap (name sym) (cons `fn meths)) (next fs))
+		           (throw (IllegalArgumentException.
+			              (str "Method '" (name sym) "' redefined")))))
+              fmap)))
+        p#)))
+
+(defn proxy-call-with-super [call this meth]
+ (let [m (proxy-mappings this)]
+    (update-proxy this (assoc m meth nil))
+    (let [ret (call)]
+      (update-proxy this m)
+      ret)))
+
+(defmacro proxy-super 
+  "Use to call a superclass method in the body of a proxy method. 
+  Note, expansion captures 'this"
+  [meth & args]
+ `(proxy-call-with-super (fn [] (. ~'this ~meth ~@args))  ~'this ~(name meth)))
+
+(defn bean
+  "Takes a Java object and returns a read-only implementation of the
+  map abstraction based upon its JavaBean properties."
+  [#^Object x]
+  (let [c (. x (getClass))
+	pmap (reduce (fn [m #^java.beans.PropertyDescriptor pd]
+			 (let [name (. pd (getName))
+			       method (. pd (getReadMethod))]
+			   (if (and method (zero? (alength (. method (getParameterTypes)))))
+			     (assoc m (keyword name) (fn [] (clojure.lang.Reflector/prepRet (. method (invoke x nil)))))
+			     m)))
+		     {}
+		     (seq (.. java.beans.Introspector
+			      (getBeanInfo c)
+			      (getPropertyDescriptors))))
+	v (fn [k] ((pmap k)))
+        snapshot (fn []
+                   (reduce (fn [m e]
+                             (assoc m (key e) ((val e))))
+                           {} (seq pmap)))]
+    (proxy [clojure.lang.APersistentMap]
+           []
+      (containsKey [k] (contains? pmap k))
+      (entryAt [k] (when (contains? pmap k) (new clojure.lang.MapEntry k (v k))))
+      (valAt ([k] (v k))
+	     ([k default] (if (contains? pmap k) (v k) default)))
+      (cons [m] (conj (snapshot) m))
+      (count [] (count pmap))
+      (assoc [k v] (assoc (snapshot) k v))
+      (without [k] (dissoc (snapshot) k))
+      (seq [] ((fn thisfn [plseq]
+		  (lazy-seq
+                   (when-let [pseq (seq plseq)]
+                     (cons (new clojure.lang.MapEntry (first pseq) (v (first pseq)))
+                           (thisfn (rest pseq)))))) (keys pmap))))))
+
+
+