            reader (readers/indexing-push-back-reader file 1 p)]
        (binding [*ns*                 *ns*
                  *file*               p
-                 *load-configuration* options
-                 clojure.core/load    oxcart/load
-                 clojure.core/eval    oxcart/eval]
-         (loop []
-           (let [form (r/read reader false eof)]
-             (when (not= eof form)
-               (eval form options)
-               (recur))))))
+                 *load-configuration* options]
+         (with-redefs [clojure.core/load    oxcart/load
+                       clojure.core/eval    oxcart/eval]
+           (loop []
+             (let [form (r/read reader false eof)]
+               (when (not= eof form)
+                 (eval form options)
+                 (recur)))))))
      nil))
 
 

         ;;   ana.jvm/analyze invocation is required? I think the
         ;;   answer is no, but it'd be nice.

         ;; FIXME: Closed over defs
         ;;   This is gonna be invalid for a whole lot of code. Lambda
         ;;   lifting is gonna come into play here methinks. I have to
         ;;   get this working so that closed over defs are supported,
         ;;   eg:
         ;;
         ;;   (let [x 3]
         ;;     (def foo [y]
         ;;          (+ x y)))
         ;;
         ;; This issue also impacts multimethods which are implemented
         ;; with closed over defs.

         (do (let [ast (binding [ana/macroexpand-1 ana.jvm/macroexpand-1
                                 ana/create-var    ana.jvm/create-var
                                 ana/parse         ana.jvm/parse
                                 ana/var?          var?]
                         (ana.jvm/analyze mform
                                          (or env (ana.jvm/empty-env))))]

               ;; the accumulator for the whole read program
               (when (and forms
                          (atom? forms))
                 (swap! forms conj ast)))

             ;; and run the code for side-effects.
             (let [r     (-> `(^:once fn* [] ~mform)
                             (ana.jvm/analyze (or env (ana.jvm/empty-env)))
                             (e/emit {:debug?       debug?
                                      :class-loader (or classloader
                                                        (clojure.lang.RT/makeClassLoader))}))
                   class (-> r meta :class)]
               (.invoke ^IFn (.newInstance ^Class class))))))))


(defn load

       ;; to generate the forms and defs structures.
       (load res config)

       (let [settings (:passes settings)]
         (doseq [pass passes]
           (swap! forms pass settings)))

       ;; Having taken an O(Nᵏ) compile operation to the face we now
       ;; run the emitter and call it quits.
