2015-02-10 23:59:50 +03:00
|
|
|
#!/usr/bin/env bash
|
2014-03-25 01:32:24 +04:00
|
|
|
|
|
|
|
source $(dirname $0)/reader.sh
|
2014-04-03 07:23:37 +04:00
|
|
|
source $(dirname $0)/printer.sh
|
|
|
|
source $(dirname $0)/env.sh
|
2014-04-17 08:57:50 +04:00
|
|
|
source $(dirname $0)/core.sh
|
2014-03-25 01:32:24 +04:00
|
|
|
|
2014-04-19 22:04:09 +04:00
|
|
|
# read
|
2014-03-25 01:32:24 +04:00
|
|
|
READ () {
|
2014-04-17 08:57:50 +04:00
|
|
|
[ "${1}" ] && r="${1}" || READLINE
|
2014-03-25 01:32:24 +04:00
|
|
|
READ_STR "${r}"
|
|
|
|
}
|
|
|
|
|
2014-04-19 22:04:09 +04:00
|
|
|
# eval
|
2020-07-21 19:01:48 +03:00
|
|
|
starts_with () {
|
|
|
|
_list? "$1" && _first "$1" && _symbol? "$r" && [ "${ANON[$r]}" = "$2" ]
|
2014-03-25 01:32:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
QUASIQUOTE () {
|
2020-07-21 19:01:48 +03:00
|
|
|
_obj_type "$1"
|
|
|
|
case "$r" in
|
|
|
|
list)
|
|
|
|
if starts_with "$1" unquote; then
|
|
|
|
_nth "$1" 1
|
|
|
|
else
|
|
|
|
qqIter "$1"
|
|
|
|
fi ;;
|
|
|
|
vector)
|
|
|
|
_symbol vec; local a="$r"
|
|
|
|
qqIter "$1"
|
|
|
|
_list "$a" "$r" ;;
|
|
|
|
symbol|hash_map)
|
|
|
|
_symbol quote
|
|
|
|
_list "$r" "$1" ;;
|
|
|
|
*)
|
|
|
|
r="$1" ;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
|
|
|
qqIter () {
|
|
|
|
if _empty? "$1"; then
|
|
|
|
_list
|
2014-03-25 01:32:24 +04:00
|
|
|
else
|
2020-07-21 19:01:48 +03:00
|
|
|
_nth "${1}" 0; local a0="$r"
|
|
|
|
if starts_with "$a0" splice-unquote; then
|
|
|
|
_symbol concat; local a="$r"
|
|
|
|
_nth "$a0" 1; local b="$r"
|
|
|
|
else
|
|
|
|
_symbol cons; local a="$r"
|
|
|
|
QUASIQUOTE "$a0"; local b="$r"
|
2014-03-25 01:32:24 +04:00
|
|
|
fi
|
2020-07-21 19:01:48 +03:00
|
|
|
_rest "$1"
|
|
|
|
qqIter "$r"
|
|
|
|
_list "$a" "$b" "$r"
|
2014-03-25 01:32:24 +04:00
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2022-01-10 02:15:40 +03:00
|
|
|
_symbol DEBUG-EVAL; debug_eval="$r"
|
2014-03-25 01:32:24 +04:00
|
|
|
|
2022-01-10 02:15:40 +03:00
|
|
|
EVAL () {
|
2014-03-25 01:32:24 +04:00
|
|
|
local ast="${1}" env="${2}"
|
2022-01-10 02:15:40 +03:00
|
|
|
while true; do
|
|
|
|
r=
|
2014-03-25 01:32:24 +04:00
|
|
|
|
2022-01-10 02:15:40 +03:00
|
|
|
ENV_GET "$env" "$debug_eval"
|
|
|
|
if [ -n "$__ERROR" ]; then
|
|
|
|
__ERROR=
|
|
|
|
elif [ "$r" != "$__false" -a "$r" != "$__nil" ]; then
|
|
|
|
_pr_str "$ast" yes; echo "EVAL: $r / $env"
|
|
|
|
fi
|
2014-03-25 01:32:24 +04:00
|
|
|
|
|
|
|
_obj_type "${ast}"; local ot="${r}"
|
|
|
|
case "${ot}" in
|
|
|
|
symbol)
|
2014-12-19 05:33:49 +03:00
|
|
|
ENV_GET "${env}" "${ast}"
|
2014-03-25 01:32:24 +04:00
|
|
|
return ;;
|
|
|
|
list)
|
2022-01-10 02:15:40 +03:00
|
|
|
;;
|
2014-03-25 01:32:24 +04:00
|
|
|
vector)
|
2022-01-10 02:15:40 +03:00
|
|
|
_map_with_type _vector EVAL "${ast}" "${env}"
|
|
|
|
return ;;
|
2014-03-25 01:32:24 +04:00
|
|
|
hash_map)
|
2015-12-04 01:19:22 +03:00
|
|
|
local res="" key= val="" hm="${ANON["${ast}"]}"
|
2014-04-03 07:23:37 +04:00
|
|
|
_hash_map; local new_hm="${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
eval local keys="\${!${hm}[@]}"
|
|
|
|
for key in ${keys}; do
|
|
|
|
eval val="\${${hm}[\"${key}\"]}"
|
|
|
|
EVAL "${val}" "${env}"
|
2014-04-03 07:23:37 +04:00
|
|
|
_assoc! "${new_hm}" "${key}" "${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
done
|
2022-01-10 02:15:40 +03:00
|
|
|
r="${new_hm}"
|
|
|
|
return ;;
|
2014-03-25 01:32:24 +04:00
|
|
|
*)
|
2022-01-10 02:15:40 +03:00
|
|
|
r="${ast}"
|
|
|
|
return ;;
|
2014-03-25 01:32:24 +04:00
|
|
|
esac
|
|
|
|
|
|
|
|
# apply list
|
2016-03-31 21:46:28 +03:00
|
|
|
_empty? "${ast}" && r="${ast}" && return
|
|
|
|
|
2014-03-25 01:32:24 +04:00
|
|
|
_nth "${ast}" 0; local a0="${r}"
|
|
|
|
_nth "${ast}" 1; local a1="${r}"
|
|
|
|
_nth "${ast}" 2; local a2="${r}"
|
|
|
|
case "${ANON["${a0}"]}" in
|
2014-12-19 05:33:49 +03:00
|
|
|
def!) EVAL "${a2}" "${env}"
|
|
|
|
[[ "${__ERROR}" ]] && return 1
|
|
|
|
ENV_SET "${env}" "${a1}" "${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
return ;;
|
2017-10-11 22:57:07 +03:00
|
|
|
let__STAR__) ENV "${env}"; local let_env="${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
local let_pairs=(${ANON["${a1}"]})
|
|
|
|
local idx=0
|
|
|
|
#echo "let: [${let_pairs[*]}] for ${a2}"
|
|
|
|
while [[ "${let_pairs["${idx}"]}" ]]; do
|
|
|
|
EVAL "${let_pairs[$(( idx + 1))]}" "${let_env}"
|
2014-12-19 05:33:49 +03:00
|
|
|
ENV_SET "${let_env}" "${let_pairs[${idx}]}" "${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
idx=$(( idx + 2))
|
|
|
|
done
|
2014-04-24 06:59:50 +04:00
|
|
|
ast="${a2}"
|
|
|
|
env="${let_env}"
|
|
|
|
# Continue loop
|
|
|
|
;;
|
2014-03-25 01:32:24 +04:00
|
|
|
quote)
|
|
|
|
r="${a1}"
|
|
|
|
return ;;
|
|
|
|
quasiquote)
|
|
|
|
QUASIQUOTE "${a1}"
|
2014-04-24 06:59:50 +04:00
|
|
|
ast="${r}"
|
|
|
|
# Continue loop
|
|
|
|
;;
|
2014-03-25 01:32:24 +04:00
|
|
|
defmacro!)
|
|
|
|
EVAL "${a2}" "${env}"
|
2014-12-19 05:33:49 +03:00
|
|
|
[[ "${__ERROR}" ]] && return 1
|
2021-08-04 08:42:50 +03:00
|
|
|
local func="${r}"
|
|
|
|
__new_obj_like "${func}"
|
|
|
|
ANON["${r}"]="${ANON["${func}"]}"
|
2014-12-19 05:33:49 +03:00
|
|
|
ANON["${r}_ismacro_"]="yes"
|
|
|
|
ENV_SET "${env}" "${a1}" "${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
return ;;
|
2017-10-11 22:57:07 +03:00
|
|
|
sh__STAR__) EVAL "${a1}" "${env}"
|
2014-03-25 01:32:24 +04:00
|
|
|
local output=""
|
|
|
|
local line=""
|
2019-12-02 13:08:24 +03:00
|
|
|
r="${ANON["${r}"]}"
|
|
|
|
r="${r//__STAR__/*}"
|
2019-12-01 09:23:08 +03:00
|
|
|
while read -r line || [ -n "${line}" ]; do
|
|
|
|
output="${output}${line}"$'\n'
|
2019-12-02 13:08:24 +03:00
|
|
|
done < <(eval "${r}")
|
2019-12-01 09:21:36 +03:00
|
|
|
_string "${output%$'\n'}"
|
2014-03-25 01:32:24 +04:00
|
|
|
return ;;
|
2017-10-11 22:57:07 +03:00
|
|
|
try__STAR__) EVAL "${a1}" "${env}"
|
2014-03-25 01:32:24 +04:00
|
|
|
[[ -z "${__ERROR}" ]] && return
|
|
|
|
_nth "${a2}" 0; local a20="${r}"
|
|
|
|
if [ "${ANON["${a20}"]}" == "catch__STAR__" ]; then
|
|
|
|
_nth "${a2}" 1; local a21="${r}"
|
|
|
|
_nth "${a2}" 2; local a22="${r}"
|
2014-04-03 07:23:37 +04:00
|
|
|
_list "${a21}"; local binds="${r}"
|
2014-03-25 01:32:24 +04:00
|
|
|
ENV "${env}" "${binds}" "${__ERROR}"
|
|
|
|
local try_env="${r}"
|
|
|
|
__ERROR=
|
2014-12-19 05:33:49 +03:00
|
|
|
EVAL "${a22}" "${try_env}"
|
2014-03-25 01:32:24 +04:00
|
|
|
fi # if no catch* clause, just propagate __ERROR
|
|
|
|
return ;;
|
|
|
|
do) _count "${ast}"
|
|
|
|
_slice "${ast}" 1 $(( ${r} - 2 ))
|
2022-01-10 02:15:40 +03:00
|
|
|
_map_with_type _list EVAL "${r}" "${env}"
|
2014-03-25 01:32:24 +04:00
|
|
|
[[ "${__ERROR}" ]] && r= && return 1
|
2014-04-17 08:57:50 +04:00
|
|
|
_last "${ast}"
|
2014-03-25 01:32:24 +04:00
|
|
|
ast="${r}"
|
|
|
|
# Continue loop
|
|
|
|
;;
|
|
|
|
if) EVAL "${a1}" "${env}"
|
2014-12-19 05:33:49 +03:00
|
|
|
[[ "${__ERROR}" ]] && return 1
|
2014-03-25 01:32:24 +04:00
|
|
|
if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]]; then
|
|
|
|
# eval false form
|
|
|
|
_nth "${ast}" 3; local a3="${r}"
|
|
|
|
if [[ "${a3}" ]]; then
|
|
|
|
ast="${a3}"
|
|
|
|
else
|
|
|
|
r="${__nil}"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
# eval true condition
|
|
|
|
ast="${a2}"
|
|
|
|
fi
|
|
|
|
# Continue loop
|
|
|
|
;;
|
2017-10-11 22:57:07 +03:00
|
|
|
fn__STAR__) _function "ENV \"${env}\" \"${a1}\" \"\${@}\"; \
|
2014-04-03 07:23:37 +04:00
|
|
|
EVAL \"${a2}\" \"\${r}\"" \
|
|
|
|
"${a2}" "${env}" "${a1}"
|
2014-03-25 01:32:24 +04:00
|
|
|
return ;;
|
2022-01-10 02:15:40 +03:00
|
|
|
*) EVAL "${a0}" "${env}"
|
|
|
|
[[ "${__ERROR}" ]] && return 1
|
|
|
|
local f="${r}"
|
|
|
|
|
|
|
|
_rest "${ast}"
|
|
|
|
# Should cause no error as ast is not empty.
|
|
|
|
local args="${r}"
|
|
|
|
|
|
|
|
if [ "${ANON["${f}_ismacro_"]}" ]; then
|
|
|
|
f="${ANON["${f}"]}"
|
|
|
|
${f%%@*} ${ANON["${args}"]}
|
|
|
|
ast="${r}"
|
|
|
|
continue
|
|
|
|
fi
|
|
|
|
|
|
|
|
f="${ANON["${f}"]}"
|
|
|
|
|
|
|
|
_map_with_type _list EVAL "${args}" "${env}"
|
2014-03-25 01:32:24 +04:00
|
|
|
[[ "${__ERROR}" ]] && r= && return 1
|
2022-01-10 02:15:40 +03:00
|
|
|
args="${ANON["${r}"]}"
|
|
|
|
|
2014-03-25 01:32:24 +04:00
|
|
|
#echo "invoke: [${f}] ${args}"
|
|
|
|
if [[ "${f//@/ }" != "${f}" ]]; then
|
|
|
|
set -- ${f//@/ }
|
|
|
|
ast="${2}"
|
|
|
|
ENV "${3}" "${4}" ${args}
|
|
|
|
env="${r}"
|
|
|
|
else
|
|
|
|
eval ${f%%@*} ${args}
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
# Continue loop
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
2014-04-03 07:23:37 +04:00
|
|
|
|
2014-04-19 22:04:09 +04:00
|
|
|
# print
|
2014-03-25 01:32:24 +04:00
|
|
|
PRINT () {
|
|
|
|
if [[ "${__ERROR}" ]]; then
|
|
|
|
_pr_str "${__ERROR}" yes
|
|
|
|
r="Error: ${r}"
|
|
|
|
__ERROR=
|
|
|
|
else
|
|
|
|
_pr_str "${1}" yes
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2014-04-19 22:04:09 +04:00
|
|
|
# repl
|
2014-03-25 01:32:24 +04:00
|
|
|
ENV; REPL_ENV="${r}"
|
|
|
|
REP () {
|
|
|
|
r=
|
2014-05-11 00:45:36 +04:00
|
|
|
READ "${1}"
|
2014-03-25 01:32:24 +04:00
|
|
|
EVAL "${r}" "${REPL_ENV}"
|
|
|
|
PRINT "${r}"
|
|
|
|
}
|
|
|
|
|
2014-04-17 08:57:50 +04:00
|
|
|
# core.sh: defined using bash
|
2014-12-19 05:33:49 +03:00
|
|
|
_fref () {
|
|
|
|
_symbol "${1}"; local sym="${r}"
|
|
|
|
_function "${2} \"\${@}\""
|
|
|
|
ENV_SET "${REPL_ENV}" "${sym}" "${r}"
|
|
|
|
}
|
2014-04-03 07:23:37 +04:00
|
|
|
for n in "${!core_ns[@]}"; do _fref "${n}" "${core_ns["${n}"]}"; done
|
|
|
|
_eval () { EVAL "${1}" "${REPL_ENV}"; }
|
2014-03-25 01:32:24 +04:00
|
|
|
_fref "eval" _eval
|
2014-04-19 22:04:09 +04:00
|
|
|
_list; argv="${r}"
|
|
|
|
for _arg in "${@:2}"; do _string "${_arg}"; _conj! "${argv}" "${r}"; done
|
2014-12-19 05:33:49 +03:00
|
|
|
_symbol "__STAR__ARGV__STAR__"
|
|
|
|
ENV_SET "${REPL_ENV}" "${r}" "${argv}";
|
2014-03-25 01:32:24 +04:00
|
|
|
|
2014-04-17 08:57:50 +04:00
|
|
|
# core.mal: defined using the language itself
|
2014-04-18 06:49:07 +04:00
|
|
|
REP "(def! *host-language* \"bash\")"
|
2014-03-25 01:32:24 +04:00
|
|
|
REP "(def! not (fn* (a) (if a false true)))"
|
2019-07-16 00:57:02 +03:00
|
|
|
REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \"\nnil)\")))))"
|
2014-03-25 01:32:24 +04:00
|
|
|
REP "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"
|
|
|
|
|
2014-04-19 22:04:09 +04:00
|
|
|
# load/run file from command line (then exit)
|
2014-03-25 01:32:24 +04:00
|
|
|
if [[ "${1}" ]]; then
|
2014-04-19 22:04:09 +04:00
|
|
|
REP "(load-file \"${1}\")"
|
|
|
|
exit 0
|
|
|
|
fi
|
|
|
|
|
|
|
|
# repl loop
|
|
|
|
REP "(println (str \"Mal [\" *host-language* \"]\"))"
|
|
|
|
while true; do
|
|
|
|
READLINE "user> " || exit "$?"
|
|
|
|
[[ "${r}" ]] && REP "${r}" && echo "${r}"
|
|
|
|
done
|