     :else (match-int s (doto (.matcher int-pattern s) .matches))))
 
 (defn- parse-symbol [^String token]
-  (when (not (= "" token))
+  (when-not (= "" token)
     (let [ns-idx (.indexOf token "/")
           ns (if-not (== -1 ns-idx) (.substring token 0 ns-idx))]
       (if (nil? ns)

      (let [token (read-token rdr ch)]
        (cond

          (= 1 (.length token))  (Character/valueOf (.charAt token 0))

          (= token "newline") \newline
          (= token "space") \space

(defn read-unicode-char
  ([^String token offset length base]
     (let [l (+ offset length)]
       (when-not (== (.length token) l)
         (throw (IllegalArgumentException. (str "Invalid unicode character: \\" token))))
       (loop [uc 0 i offset]
         (if (== i l)
           (char uc)
           (let [d (Character/digit (.charAt token i) ^int base)]
             (if (== d -1)
               (throw (IllegalArgumentException. (str "Invalid digit: " (.charAt token i))))
               (recur (long (* uc (+ base d))) (inc i))))))))

  ([rdr initch base length exact?]
     (let [uc (Character/digit ^char initch ^int base)]
       (if (== uc -1)
         (throw (IllegalArgumentException. (str "Invalid digit: " initch))))
       (loop [i 1 uc uc]
         (if-not (== i length)
           (let [ch (peek-char rdr)]
             (if (or (nil? ch)
                     (whitespace? ch)
                     (macros ch))
               (if exact?
                 (throw (IllegalArgumentException.
                         (str "Invalid character length: " i ", should be: " length)))
                 (char uc))
               (let [d (Character/digit ^char ch ^int base)]
                 (read-char rdr)
                 (if (== d -1)
                   (throw (IllegalArgumentException. (str "Invalid digit: " (char ch))))
                   (recur (inc i) (long (* uc (+ base d))))))))
           (char uc))))))
