From 1d97366933f3a7483a372bc9d44c5d04e561b52a Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Thu, 17 Sep 2020 23:28:45 -0400 Subject: [PATCH] Implement user-interatction part of k_prime in new_kraken.kp, moved from load_test.kp --- k_prime.krak | 109 ++++------------------------------ load_test.kp => new_kraken.kp | 24 +++++--- 2 files changed, 27 insertions(+), 106 deletions(-) rename load_test.kp => new_kraken.kp (70%) diff --git a/k_prime.krak b/k_prime.krak index bc738f4..d84b73a 100644 --- a/k_prime.krak +++ b/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 = fun(_: ref KPValue, x: ref vec): KPResult { return KPResult::Ok(kpNil()); } var ret_0_sym: fun(ref KPValue, ref vec): KPResult = fun(_: ref KPValue, x: ref vec): KPResult { return x[0]; } + var ret_1_sym: fun(ref KPValue, ref vec): KPResult = fun(_: ref KPValue, x: ref vec): 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 { 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()->construct() @@ -1194,66 +1197,6 @@ fun main(argc: int, argv: **char): int { })) } })); - var ERS = fun(params: vec, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> { - if params.size == 0 || params.size > 2 { - return make_pair(null(), 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(), 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(), 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(), r.second) - } - current_ret = EVAL(eval_env, get_value(r.second)) - if is_err(current_ret) { - return make_pair(null(), 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(), 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, 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(), KPResult::Err(kpString(str("unwrap called with not combiner ") + pr_str(params[0], true)))) })); - // a tiny bit of self-implementation fun - println(rep(grammar, env, str("(set! load-file (vau de (f) (eval-read-string (slurp (eval f de)) de)))"))) - - if argc == 3 && str(argv[1]) == "-C" { - 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() - 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)) - } + // Launch into new kraken for interface and self-hosting features + var params = vec() + for (var i = 0; i < argc; i++;) { + params.add(kpString(str(argv[i]))) } + env->set(str("*ARGV*"), kpArray(params)) + println(rep(grammar, env, str("(eval (read-string (slurp \"./new_kraken.kp\")))"))) + return 0 } diff --git a/load_test.kp b/new_kraken.kp similarity index 70% rename from load_test.kp rename to new_kraken.kp index 609a489..0505058 100644 --- a/load_test.kp +++ b/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)) -)