Fix for (re-seq #"^$" "")

.gitignore

@@ -8,6 +8,8 @@ closure
 /coreadvanced.js
 /coresimple.js
 /out
+/web/out
+/node/out
 .repl
 *.swp
 *.zip

README.md

@@ -1,3 +1,112 @@
+## ClojureScript Compiler Compiled with ClojureScript? ##
+
+This is a **patched version of the ClojureScript compiler** that
+compiles to ClojureScript. Normally, the ClojureScript compiler is
+a pure Clojure program that runs on the JVM. This patched version runs
+from the compiled JavaScript. This project was kicked off by
+[kanaka](https://github.com/kanaka) and
+[chouser](https://github.com/chouser) during some intense hacking at
+Clojure/conj 2012. Kanaka continues to develop the fork towards the
+goal of being fully self-hosting (i.e. ClojureScript-in-ClojureScript).
+
+### Why?
+
+* Why not?
+* Compilers are only cool once they are self-hosting (can compile
+  their own code). This fork is not self-hosting yet, but that is the
+  goal.
+* You can use ClojureScript without a JVM.
+* You can have a [ClojureScript REPL web
+  app](http://kanaka.github.com/clojurescript/web/jsrepl.html) that
+  runs locally in your browser (no server involved after loading the
+  page).
+
+### Current Caveats
+
+* JavaScript output is not optimized by the Google Closure Compiler
+  (which is a Java program).
+* The code changes are not all compatible with the normal Clojure
+  ClojureScript (JVM based) compiler. To make it compatible we really
+  need [Feature Expressions in Clojure](http://dev.clojure.org/display/design/Feature+Expressions)
+* The :nodejs compilation target is currently broken. However, the
+  `node/run.js` bootstrap script enables compiled CLJS code to be
+  invoked that was not compiled with a :target.
+* Other miscellaneous broken things that have not been tracked down
+  yet.
+
+### Bugs
+
+- no division ("/" symbol in general is problematic)
+- use of certain regexex causes hard hangs
+- escaping in regexes is broken
+- numeric keywords are broken
+- anonymous functions do not warn about arity
+- non-unicode symbol breakage
+- warnings during compile about *unchecked-if*
+
+
+### TODOs
+
+- update to upstream ClojureScript
+- file I/O (at least on the node.js side)
+- misc functionality: require, use, var metadata, :private def check
+- self-hosting (compile ClojureScript compiler using node.js hosted ClojureScript compiler)
+- optional optimizations (single JS file output, etc)
+
+### Build
+
+You can build the ClojureScript analyzer and compiler with
+ClojureScript like this:
+
+```
+bin/cljsc src/cljs/cljs/compiler.cljs > compiler.cljs
+```
+
+However, that is not all that useful because it  does not have all the pieces
+necessary to run it under a JavaScript engine (e.g. browser or node.js).
+
+You can rebuild the ClojureScript analyzer, compiler, reader and
+browser/node.js bootstrap pieces with a web REPL like this:
+
+```
+cd web
+../bin/cljsc ../src/cljs/webrepl.cljs > webrepl.js
+```
+Now load the `web/jsrepl.html` file in a browser.
+
+For a REPL in nodejs, build the `src/cljs/noderepl.cljs` code:
+
+```
+cd node
+../bin/cljsc ../src/cljs/noderepl.cljs > noderepl.js
+cp ../src/cljs/goog.js out/
+```
+
+Now use the `run.js` bootstrap code to launch the repl:
+
+```
+./run.js noderepl.js
+```
+
+For direct *.cljs file compilation/evaluation, build the nodecljs.cljs compiler:
+
+```
+cd node
+../bin/cljsc ../src/cljs/nodecljs.cljs > nodecljs.js
+cp ../src/cljs/goog.js out/
+```
+
+You can now use a combination of the `run.js` bootstrap code and
+`nodecljs.js` to compile/evaluate the `hello.cljs` file:
+
+```
+./run.js nodecljs.js hello.cljs
+```
+
+
+
+--------
+
 ## What is ClojureScript? ##
 
 ClojureScript is a new compiler for [Clojure](http://clojure.org) that targets JavaScript. It is designed to emit JavaScript code which is compatible with the advanced compilation mode of the [Google Closure](http://code.google.com/closure/) optimizing compiler.

node/hello.cljs

@@ -0,0 +1,3 @@
+(def sqr (fn* [x] (* x x)))
+
+(println "hello world" (sqr 16))

node/run.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+// Launch a CLJS compiled program using node
+// - First argument is the path to the compiled *.js file
+// - Rest of the arguments are passed to the *main-cli*
+
+(function() {
+    var path = require("path"),
+        targ = process.argv[2],
+        ns = path.basename(targ).replace(/[.]js$/, ""),
+        jsfile = path.resolve("./", targ);
+
+    // Load the Closure Library wrapper
+    require('./out/goog.js');
+
+    // Load the initial compiled file
+    require(jsfile);
+    goog.require(ns);
+
+    // Setup the print function
+    cljs.core._STAR_print_fn_STAR_ = require("util").print;
+
+    // Bootstrap an empty version of the cljs.user namespace
+    cljs.core.swap_BANG_.call(null,cljs.compiler._STAR_emitted_provides_STAR_,cljs.core.conj,(new cljs.core.Symbol(null,"cljs.user")));
+    goog.provide('cljs.user');
+    cljs.core._STAR_ns_sym_STAR_ = cljs.core.symbol.call(null,"cljs.user");
+})();
+
+// Call the users's main function
+cljs.core.apply.call(null,cljs.core._STAR_main_cli_fn_STAR_,cljs.core.drop.call(null,3,process.argv));
+

src/clj/cljs/analyzer.clj

@@ -128,7 +128,7 @@
            {:name (symbol (str full-ns) (str (name sym)))
             :ns full-ns}))
 
-       (.contains s ".")
+       (and (not= ".." s) (>= (.indexOf s ".") 0))
        (let [idx (.indexOf s ".")
              prefix (symbol (subs s 0 idx))
              suffix (subs s (inc idx))
@@ -173,7 +173,7 @@
              ns (if (= "clojure.core" ns) "cljs.core" ns)]
          {:name (symbol (str (resolve-ns-alias env ns)) (name sym))})
 
-       (.contains s ".")
+       (and (not= ".." s) (>= (.indexOf s ".") 0))
        (let [idx (.indexOf s ".")
              prefix (symbol (subs s 0 idx))
              suffix (subs s idx)

src/clj/cljs/compiler.clj

@@ -59,7 +59,8 @@
           munged-name
           (symbol (str munged-name "__$" depth))))
       ; String munging
-      (let [ss (string/replace (str s) #"\/(.)" ".$1") ; Division is special
+      (let [ss (string/replace (str s) #"[.][.]" "_DOTDOT_") ; .. is special
+            ss (string/replace ss #"\/(.)" ".$1") ; Division is special
             ss (apply str (map #(if (reserved %) (str % "$") %)
                                (string/split ss #"(?<=\.)|(?=\.)")))
             ms (clojure.lang.Compiler/munge ss)]
@@ -158,11 +159,14 @@
                   \"))
 
 (defmethod emit-constant clojure.lang.Symbol [x]
-           (emits \" "\\uFDD1" \'
-                  (if (namespace x)
-                    (str (namespace x) "/") "")
-                  (name x)
-                  \"))
+            (emits "(new cljs.core.Symbol("  
+                  (if (meta x)
+                    (emit-constant (meta x))
+                    "null")
+                  ","
+                  (str "\"" x "\"")
+                  "))"))
+
 
 (defn- emit-meta-constant [x & body]
   (if (meta x)
@@ -778,6 +782,15 @@
          (ana/analyze-file "cljs/core.cljs"))
        ~@body))
 
+(defn ns-snap [ns]
+  (let [nss1 (dissoc (get @ana/namespaces ns) :requires-macros)
+        nss2 (read-string (pr-str (update-in nss1
+                                             [:defs] dissoc '/)))]
+    (apply str
+      (emit (ana/analyze (ana/empty-env)
+        (list 'swap! 'cljs.core/namespaces 'assoc (list 'quote ns) (list 'quote nss2)))))))
+
+
 (defn compile-file* [src dest]
   (with-core-cljs
     (with-open [out ^java.io.Writer (io/make-writer dest {})]
@@ -797,10 +810,13 @@
                   (if (= (:op ast) :ns)
                     (recur (rest forms) (:name ast) (merge (:uses ast) (:requires ast)))
                     (recur (rest forms) ns-name deps))))
-            {:ns (or ns-name 'cljs.user)
-             :provides [ns-name]
-             :requires (if (= ns-name 'cljs.core) (set (vals deps)) (conj (set (vals deps)) 'cljs.core))
-             :file dest}))))))
+            (do
+              (println "\n// Analyzer namespace snapshot:")
+              (ns-snap ns-name)
+              {:ns (or ns-name 'cljs.user)
+               :provides [ns-name]
+               :requires (if (= ns-name 'cljs.core) (set (vals deps)) (conj (set (vals deps)) 'cljs.core))
+               :file dest})))))))
 
 (defn requires-compilation?
   "Return true if the src file requires compilation."