bash/stepA_more.sh

   1 #!/bin/bash
   2
   3 source $(dirname $0)/reader.sh
   4 source $(dirname $0)/printer.sh
   5 source $(dirname $0)/env.sh
   6 source $(dirname $0)/core.sh
   7
   8 # read
   9 READ () {
  10     [ "${1}" ] && r="${1}" || READLINE
  11     READ_STR "${r}"
  12 }
  13
  14 # eval
  15 IS_PAIR () {
  16     if _sequential? "${1}"; then
  17         _count "${1}"
  18         [[ "${r}" > 0 ]] && return 0
  19     fi
  20     return 1
  21 }
  22
  23 QUASIQUOTE () {
  24     if ! IS_PAIR "${1}"; then
  25         _symbol quote
  26         _list "${r}" "${1}"
  27         return
  28     else
  29         _nth "${1}" 0; local a0="${r}"
  30         if [[ "${ANON["${a0}"]}" == "unquote" ]]; then
  31             _nth "${1}" 1
  32             return
  33         elif IS_PAIR "${a0}"; then
  34             _nth "${a0}" 0; local a00="${r}"
  35             if [[ "${ANON["${a00}"]}" == "splice-unquote" ]]; then
  36                 _symbol concat; local a="${r}"
  37                 _nth "${a0}" 1; local b="${r}"
  38                 _rest "${1}"
  39                 QUASIQUOTE "${r}"; local c="${r}"
  40                 _list "${a}" "${b}" "${c}"
  41                 return
  42             fi
  43         fi
  44     fi
  45     _symbol cons; local a="${r}"
  46     QUASIQUOTE "${a0}"; local b="${r}"
  47     _rest "${1}"
  48     QUASIQUOTE "${r}"; local c="${r}"
  49     _list "${a}" "${b}" "${c}"
  50     return
  51 }
  52
  53 IS_MACRO_CALL () {
  54     if ! _list? "${1}"; then return 1; fi
  55     _nth "${1}" 0; local a0="${r}"
  56     if _symbol? "${a0}"; then
  57         ENV_FIND "${2}" "${ANON["${a0}"]}_ismacro_"
  58         if [[ "${r}" ]]; then
  59             return 0
  60         fi
  61     fi
  62     return 1
  63 }
  64
  65 MACROEXPAND () {
  66     local ast="${1}" env="${2}"
  67     while IS_MACRO_CALL "${ast}" "${env}"; do
  68         _nth "${ast}" 0; local a0="${r}"
  69         ENV_GET "${env}" "${ANON["${a0}"]}"; local mac="${ANON["${r}"]}"
  70         _rest "${ast}"
  71         ${mac%%@*} ${ANON["${r}"]}
  72         ast="${r}"
  73     done
  74     r="${ast}"
  75 }
  76
  77
  78 EVAL_AST () {
  79     local ast="${1}" env="${2}"
  80     #_pr_str "${ast}"; echo "EVAL_AST '${ast}:${r} / ${env}'"
  81     _obj_type "${ast}"; local ot="${r}"
  82     case "${ot}" in
  83     symbol)
  84         local val="${ANON["${ast}"]}"
  85         ENV_GET "${env}" "${val}"
  86         return ;;
  87     list)
  88         _map_with_type _list EVAL "${ast}" "${env}" ;;
  89     vector)
  90         _map_with_type _vector EVAL "${ast}" "${env}" ;;
  91     hash_map)
  92         local res="" val="" hm="${ANON["${ast}"]}"
  93         _hash_map; local new_hm="${r}"
  94         eval local keys="\${!${hm}[@]}"
  95         for key in ${keys}; do
  96             eval val="\${${hm}[\"${key}\"]}"
  97             EVAL "${val}" "${env}"
  98             _assoc! "${new_hm}" "${key}" "${r}"
  99         done
 100         r="${new_hm}" ;;
 101     *)
 102         r="${ast}" ;;
 103     esac
 104 }
 105
 106 EVAL () {
 107     local ast="${1}" env="${2}"
 108     while true; do
 109     r=
 110     [[ "${__ERROR}" ]] && return 1
 111     #_pr_str "${ast}"; echo "EVAL '${r} / ${env}'"
 112     if ! _list? "${ast}"; then
 113         EVAL_AST "${ast}" "${env}"
 114         return
 115     fi
 116
 117     # apply list
 118     MACROEXPAND "${ast}" "${env}"
 119     ast="${r}"
 120     if ! _list? "${ast}"; then return; fi
 121     _nth "${ast}" 0; local a0="${r}"
 122     _nth "${ast}" 1; local a1="${r}"
 123     _nth "${ast}" 2; local a2="${r}"
 124     case "${ANON["${a0}"]}" in
 125         def!) local k="${ANON["${a1}"]}"
 126               #echo "def! ${k} to ${a2} in ${env}"
 127               EVAL "${a2}" "${env}"
 128               ENV_SET "${env}" "${k}" "${r}"
 129               return ;;
 130         let*) ENV "${env}"; local let_env="${r}"
 131               local let_pairs=(${ANON["${a1}"]})
 132               local idx=0
 133               #echo "let: [${let_pairs[*]}] for ${a2}"
 134               while [[ "${let_pairs["${idx}"]}" ]]; do
 135                   EVAL "${let_pairs[$(( idx + 1))]}" "${let_env}"
 136                   ENV_SET "${let_env}" "${ANON["${let_pairs[${idx}]}"]}" "${r}"
 137                   idx=$(( idx + 2))
 138               done
 139               ast="${a2}"
 140               env="${let_env}"
 141               # Continue loop
 142               ;;
 143         quote)
 144               r="${a1}"
 145               return ;;
 146         quasiquote)
 147               QUASIQUOTE "${a1}"
 148               ast="${r}"
 149               # Continue loop
 150               ;;
 151         defmacro!)
 152               local k="${ANON["${a1}"]}"
 153               EVAL "${a2}" "${env}"
 154               ENV_SET "${env}" "${k}" "${r}"
 155               ENV_SET "${env}" "${k}_ismacro_" "yes"
 156               return ;;
 157         macroexpand)
 158               MACROEXPAND "${a1}" "${env}"
 159               return ;;
 160         sh*)  MACROEXPAND "${a1}" "${env}"
 161               EVAL "${r}" "${env}"
 162               local output=""
 163               local line=""
 164               while read line; do
 165                   output="${output}${line}\n"
 166               done < <(eval ${ANON["${r}"]})
 167               _string "${output%\\n}"
 168               return ;;
 169         try*) MACROEXPAND "${a1}" "${env}"
 170               EVAL "${r}" "${env}"
 171               [[ -z "${__ERROR}" ]] && return
 172               _nth "${a2}" 0; local a20="${r}"
 173               if [ "${ANON["${a20}"]}" == "catch__STAR__" ]; then
 174                   _nth "${a2}" 1; local a21="${r}"
 175                   _nth "${a2}" 2; local a22="${r}"
 176                   _list "${a21}"; local binds="${r}"
 177                   ENV "${env}" "${binds}" "${__ERROR}"
 178                   local try_env="${r}"
 179                   __ERROR=
 180                   MACROEXPAND "${a22}" "${try_env}"
 181                   EVAL "${r}" "${try_env}"
 182               fi  # if no catch* clause, just propagate __ERROR
 183               return ;;
 184         do)   _count "${ast}"
 185               _slice "${ast}" 1 $(( ${r} - 2 ))
 186               EVAL_AST "${r}" "${env}"
 187               [[ "${__ERROR}" ]] && r= && return 1
 188               _last "${ast}"
 189               ast="${r}"
 190               # Continue loop
 191               ;;
 192         if)   EVAL "${a1}" "${env}"
 193               if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]]; then
 194                   # eval false form
 195                   _nth "${ast}" 3; local a3="${r}"
 196                   if [[ "${a3}" ]]; then
 197                       ast="${a3}"
 198                   else
 199                       r="${__nil}"
 200                       return
 201                   fi
 202               else
 203                   # eval true condition
 204                   ast="${a2}"
 205               fi
 206               # Continue loop
 207               ;;
 208         fn*)  _function "ENV \"${env}\" \"${a1}\" \"\${@}\"; \
 209                          EVAL \"${a2}\" \"\${r}\"" \
 210                         "${a2}" "${env}" "${a1}"
 211               return ;;
 212         *)    EVAL_AST "${ast}" "${env}"
 213               [[ "${__ERROR}" ]] && r= && return 1
 214               local el="${r}"
 215               _first "${el}"; local f="${ANON["${r}"]}"
 216               _rest "${el}"; local args="${ANON["${r}"]}"
 217               #echo "invoke: [${f}] ${args}"
 218               if [[ "${f//@/ }" != "${f}" ]]; then
 219                   set -- ${f//@/ }
 220                   ast="${2}"
 221                   ENV "${3}" "${4}" ${args}
 222                   env="${r}"
 223               else
 224                   eval ${f%%@*} ${args}
 225                   return
 226               fi
 227               # Continue loop
 228               ;;
 229     esac
 230     done
 231 }
 232
 233 # print
 234 PRINT () {
 235     if [[ "${__ERROR}" ]]; then
 236         _pr_str "${__ERROR}" yes
 237         r="Error: ${r}"
 238         __ERROR=
 239     else
 240         _pr_str "${1}" yes
 241     fi
 242 }
 243
 244 # repl
 245 ENV; REPL_ENV="${r}"
 246 REP () {
 247     r=
 248     READ "${1}" || return 1
 249     EVAL "${r}" "${REPL_ENV}"
 250     PRINT "${r}"
 251 }
 252
 253 # core.sh: defined using bash
 254 _fref () { _function "${2} \"\${@}\""; ENV_SET "${REPL_ENV}" "${1}" "${r}"; }
 255 for n in "${!core_ns[@]}"; do _fref "${n}" "${core_ns["${n}"]}"; done
 256 _eval () { EVAL "${1}" "${REPL_ENV}"; }
 257 _fref "eval" _eval
 258 _list; argv="${r}"
 259 for _arg in "${@:2}"; do _string "${_arg}"; _conj! "${argv}" "${r}"; done
 260 ENV_SET "${REPL_ENV}" "__STAR__ARGV__STAR__" "${argv}";
 261
 262 # core.mal: defined using the language itself
 263 REP "(def! *host-language* \"bash\")"
 264 REP "(def! not (fn* (a) (if a false true)))"
 265 REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
 266 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)))))))"
 267 REP "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) \`(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
 268
 269 # load/run file from command line (then exit)
 270 if [[ "${1}" ]]; then
 271     REP "(load-file \"${1}\")"
 272     exit 0
 273 fi
 274
 275 # repl loop
 276 REP "(println (str \"Mal [\" *host-language* \"]\"))"
 277 while true; do
 278     READLINE "user> " || exit "$?"
 279     [[ "${r}" ]] && REP "${r}" && echo "${r}"
 280 done