Clojure Реализация интерфейса Liscript интерпретатора

package com.company;
 
 
import java.util.HashMap;
 
public class Env {
    public HashMap<String, Object> map;
    public Env parent;
 
    Env (HashMap<String, Object> m, Env p) { map = m; parent = p; }
 
    public static void setVar(Env env, String var, Object value) {
        //if (env != null) {
        //    if (env.map.containsKey(var)) env.map.put(var, value);
        //    else setVar(env.parent, var, value);
        //}
 
        Env curenv = env;
        while (curenv != null) {
            if (curenv.map.containsKey(var)) {curenv.map.put(var, value); break;}
            curenv = curenv.parent;
        }
    }
 
    public static Object getVar(Env env, String var) {
        //return env == null ? var : env.map.containsKey(var) ? env.map.get(var) :
        // getVar(env.parent, var);
 
        Env curenv = env;
        while (curenv != null) {
            if (curenv.map.containsKey(var)) return curenv.map.get(var);
            curenv = curenv.parent;
        }
        return var;
    }
 
    public static void defVar(Env env, String var, Object value) {
        if (env != null) env.map.put(var, value);
    }
 
    public static boolean isBounded(Env env, String var) {
        Env curenv = env;
        while (curenv != null) {
            if (curenv.map.containsKey(var)) return true;
            curenv = curenv.parent;
        }
        return false;
    }
}

package com.company;
 
import com.company.Eval.ConsList;
 
import java.util.LinkedList;
 
public class Read {
 
    public static LinkedList<String> tokens_(String s) {
        LinkedList<String> r = new LinkedList<String>();
 
        String t = "";
        Integer lev = 0;
        boolean f = false;
        for (Character c : (s + " ").toCharArray()) {
            if (c.toString().trim().isEmpty()) {}//continue;
            else if (c == '(' && !f) lev += 1;
            else if (c == ')' && !f) lev -= 1;
            else if (c == '"') f = !f;
 
            t += c.toString();
            if (    lev == 0 &&
                    !t.trim().isEmpty() &&
                    (c.toString().trim().isEmpty() || c == ')') &&
                    !f) {
                if (!t.trim().isEmpty()) r.add(t.trim());
                t = "";
                f = false;
            }
        }
        return r;
    }
 
    public static void addToken(LinkedList<String> r, String s) {
        if(!r.isEmpty() && r.getLast().equals("\'")) {
            r.remove(r.size()-1);
            r.add("\'" + s);
        } else r.add(s);
    }
 
    public static LinkedList<String> tokens(String s) {
        LinkedList<String> r = new LinkedList<String>();
 
        int STATE_TOKEN = 0, STATE_STRING = 2, STATE_COMMENT = 3;
        int state = STATE_TOKEN;
        int ifrom = 0, ito = s.length(), ib = ifrom, lev = 0;
 
        for (int i = ifrom; i <= ito; ++i) {
            char c = i < ito ? s.charAt(i) : 0;
 
            if (state == STATE_STRING &&
                    //(c == '"' || c == '\n' || c == 0)) {
                    (c == '"' || c == 0)) {
                if (lev == 0) {
                    addToken(r, s.substring(ib, i + 1));
                    ib = i + 1;
                }
                state = STATE_TOKEN;
            }
            else if (state == STATE_COMMENT &&
                    //(c == ';' || c == '\n' || c == 0)) {
                    (c == ';' || c == 0)) {
                if (lev == 0) {
                    //r.add(s.substring(ib, i + 1));
                    ib = i + 1;
                }
                state = STATE_TOKEN;
            }
            else if (state == STATE_TOKEN) {
                if (c == ')') lev -= 1;
                if (lev == 0 &&
                        (Character.isWhitespace(c) || c == '(' || c == ')'
                                || c == '"' || c == ';' || c == 0) ) {
                    int ie = c == ')' ? i+1 : i;
                    if (ie>ib) addToken(r, s.substring(ib, ie));
                    ib = ie;
                    if (Character.isWhitespace(c)) ib += 1;
                }
                if (c == '(') lev += 1;
                else if (c == '"') state = STATE_STRING;
                else if (c == ';') state = STATE_COMMENT;
            }
        }
        return r;
    }
 
    private static Object readToken(String t) {
        int length = t.length();
        char fst = t.charAt(0), lst = t.charAt(length - 1);
        if (fst == '(' && lst == ')') {
            //return tokens2ConsList(tokens(t.substring(1, length - 1)));
 
            String subt = t.substring(1, length - 1);
            ConsList p = tokens2ConsList(tokens(subt));
            if (subt.contains("\n")) p.s = subt;
            return p;
        } else if (fst == '"' && lst == '"')
            //return t.substring(1, length - 1);
            return new Eval.RawString(t.substring(1, length - 1));
        else if (fst == '\'') {
            Object v = tokens2LispVal(tokens(t.substring(1, length)));
            return new ConsList("quote", new ConsList(v, Eval.emptyList)); }
        else if (t.equals("true")) return true;
        else if (t.equals("false")) return false;
        else
            try {return new Integer(t);}
            catch (NumberFormatException errorInteger) {
                try {return new Double(t);}
                catch (NumberFormatException errorDouble) {return t;}
            }
    }
 
    private static ConsList tokens2ConsList(LinkedList<String> ts) {
        if (ts.isEmpty()) return Eval.emptyList;
        else {
            String h = ts.removeFirst();
            return new ConsList(readToken(h), tokens2ConsList(ts));
        }
    }
 
    public static Object tokens2LispVal(LinkedList<String> ts) {
        if (ts.size()==1) return readToken(ts.getFirst());
        else return tokens2ConsList(ts);
    }
}

........
Object lv = Read.tokens2LispVal(Read.tokens(expression));
pane.out(true, Eval.eval(0, true, pane, globalEnv, lv).toString());