Implement user-interatction part of k_prime in new_kraken.kp, moved from load_test.kp

k_prime.krak

@@ -657,6 +657,7 @@ fun main(argc: int, argv: **char): int {
     var ret_nil_term: fun(ref KPValue, ref str, int, int): KPResult = fun(_: ref KPValue, input: ref str, l: int, r: int): KPResult { return KPResult::Ok(kpNil()); }
     var ret_nil_sym: fun(ref KPValue, ref vec<KPResult>): KPResult = fun(_: ref KPValue, x: ref vec<KPResult>): KPResult { return KPResult::Ok(kpNil()); }
     var ret_0_sym: fun(ref KPValue, ref vec<KPResult>): KPResult = fun(_: ref KPValue, x: ref vec<KPResult>): KPResult { return x[0]; }
+    var ret_1_sym: fun(ref KPValue, ref vec<KPResult>): KPResult = fun(_: ref KPValue, x: ref vec<KPResult>): KPResult { return x[1]; }
 
     var WS = grammar.add_new_nonterminal("WS", vec(grammar.add_terminal("( |	|
 |(;[ -~]*
@@ -730,7 +731,9 @@ fun main(argc: int, argv: **char): int {
     grammar.add_to_nonterminal(form, vec(call_form), kpNil(), fun(_: ref KPValue, x: ref vec<KPResult>): KPResult {
         return x[0];
     })
-    grammar.set_start_symbol(form)
+    var start_symbol = grammar.add_new_nonterminal("start_symbol", vec(optional_WS, form, optional_WS), kpNil(), ret_1_sym)
+    grammar.set_start_symbol(start_symbol)
+    //grammar.set_start_symbol(form)
 
 
     var env = new<KPEnv>()->construct()
@@ -1194,66 +1197,6 @@ fun main(argc: int, argv: **char): int {
             }))
         }
     }));
-    var ERS = fun(params: vec<KPValue>, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> {
-        if params.size == 0 || params.size > 2 {
-            return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("eval-read-string with not a single string and optional env"))))
-        } else {
-            if !params[0].is_string() {
-                return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("first param to eval-read-string s not a string"))))
-            }
-            var input = params[0].get_string()
-            if params.size == 2 && !params[1].is_env() {
-                return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("second param to eval-read-string is not a env"))))
-            }
-            var eval_env = dynamic_env
-            if params.size == 2 {
-                eval_env = params[1].get_env()
-            }
-            var i = 0
-            var current_ret = KPResult::Ok(kpNil())
-            if i < input.length() {
-                // initial handle whitespace
-                var BSR = fungll(grammar, optional_WS, input.slice(i, -1))
-                var longest = -1
-                for (var j = 0; j < BSR.data.size; j++;) {
-                    if BSR.data[j].nonterminal == optional_WS && BSR.data[j].left == 0 {
-                        if BSR.data[j].right > longest {
-                            longest = BSR.data[j].right
-                        }
-                    }
-                }
-                if longest > 0 {
-                    i += longest
-                }
-            }
-            while i < input.length() {
-                var r = read_str(grammar, input.slice(i, -1))
-                i += r.first
-                if is_err(r.second) {
-                    return make_pair(null<KPEnv>(), r.second)
-                }
-                current_ret = EVAL(eval_env, get_value(r.second))
-                if is_err(current_ret) {
-                    return make_pair(null<KPEnv>(), current_ret)
-                }
-                // handle whitespace again
-                var BSR = fungll(grammar, optional_WS, input.slice(i, -1))
-                var longest = -1
-                for (var j = 0; j < BSR.data.size; j++;) {
-                    if BSR.data[j].nonterminal == optional_WS && BSR.data[j].left == 0 {
-                        if BSR.data[j].right > longest {
-                            longest = BSR.data[j].right
-                        }
-                    }
-                }
-                if longest > 0 {
-                    i += longest
-                }
-            }
-            return make_pair(null<KPEnv>(), current_ret)
-        }
-    }
-    env->set(str("eval-read-string"), make_builtin_combiner(str("eval-read-string"), 1, false, ERS));
 
     env->set(str("read-string"), make_builtin_combiner(str("read-string"), 1, false, fun(params: vec<KPValue>, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> {
         if params.size != 1 {
@@ -1331,42 +1274,12 @@ fun main(argc: int, argv: **char): int {
         return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("unwrap called with not combiner ") + pr_str(params[0], true))))
     }));
 
-    // a tiny bit of self-implementation fun
+    // Launch into new kraken for interface and self-hosting features
-    println(rep(grammar, env, str("(set! load-file (vau de (f) (eval-read-string (slurp (eval f de)) de)))")))
+    var params = vec<KPValue>()
-
+    for (var i = 0; i < argc; i++;) {
-    if argc == 3 && str(argv[1]) == "-C" {
+        params.add(kpString(str(argv[i])))
-        env->set(str("*ARGV*"), kpNil())
-        var evaled = ERS(vec(kpString(str(argv[2])), kpEnv(env)), env)
-        if is_err(evaled.second) {
-            printlnerr(str("Exception: ") + pr_str(get_err(evaled.second), true))
-        } else {
-            println("Result: " + pr_str(get_value(evaled.second), true))
-        }
-    } else if argc >= 2 {
-        var params = vec<KPValue>()
-        for (var i = 2; i < argc; i++;) {
-            params.add(kpString(str(argv[i])))
-        }
-        env->set(str("*ARGV*"), kpArray(params))
-        var eval_result_str = rep(grammar, env, str("(load-file \"") + argv[1] + "\")")
-        println(eval_result_str)
-        if eval_result_str.length() >= 11 && eval_result_str.slice(0,11) == "Exception: " {
-            error("aborting compile")
-        }
-        // check for compile
-        var main = env->get(str("main"))
-        if !is_err(main) {
-            println("Starting compile!")
-            error("Compiler not implemented")
-        } else {
-            println("No main function to compile, exiting")
-        }
-    } else {
-        while (true) {
-            var line = get_line(str("user> "), 1024)
-            if (line == "***EOF***")
-                break
-            println(rep(grammar, env, line))
-        }
     }
+    env->set(str("*ARGV*"), kpArray(params))
+    println(rep(grammar, env, str("(eval (read-string (slurp \"./new_kraken.kp\")))")))
+    return 0
 }

new_kraken.kp

@@ -1,12 +1,9 @@
-(vau de (code)
 
 ((wrap (vau _ (quote)
 ((wrap (vau _ (let1)
 
 (let1 lambda (vau se (p b) (wrap (eval (array vau (quote _) p b) se)))
 
-
-
 (let1 do_helper (lambda (recurse s i se) (cond (= i (len s)) nil
                                                (= i (- (len s) 1)) (eval (idx s i) se)
                                                (eval (idx s i) se) (recurse recurse s (+ i 1) se)
@@ -31,13 +28,24 @@
 (let1 let (vY (lambda (recurse) (vau de (vs b) (cond (= (len vs) 0) (eval b de)
                                                      true (vapply let1 (array (idx vs 0) (idx vs 1) (array recurse (slice vs 2 -1) b)) de)))))
 
-(let1 rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b)))))
+(let (
+        rec-lambda (vau se (p b) (eval (array Y (array lambda (quote (recurse)) (array lambda p b)))))
+        rep (Y (lambda (recurse) (wrap (vau de () (do (println (eval (read-string (get_line "> ")) de))
+                                                      (recurse))))))
+    )
 
-(eval code)
+    (do
-
+        (println "Welcome to Kraken! Parameters were" *ARGV*)
-))))))))))))
+        (cond (and (>= (len *ARGV*) 3) (= "-C" (idx *ARGV* 1))) (eval (read-string (idx *ARGV* 2)))
+              (> (len *ARGV*) 1)                                (eval (read-string (slurp (idx *ARGV* 1))))
+              true                                              (rep)
+        )
+    )
+)
+))))))))))) ; end of all the let1's
 
+; impl of let1
 )) (vau de (s v b) (eval (array (array vau (quote _) (array s) b) (eval v de)) de)))
+; impl of quote
 )) (vau _ (x) x))
 
-)