bash/step7_quote.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 EVAL_AST () {
  54     local ast="${1}" env="${2}"
  55     #_pr_str "${ast}"; echo "EVAL_AST '${ast}:${r} / ${env}'"
  56     _obj_type "${ast}"; local ot="${r}"
  57     case "${ot}" in
  58     symbol)
  59         local val="${ANON["${ast}"]}"
  60         ENV_GET "${env}" "${val}"
  61         return ;;
  62     list)
  63         _map_with_type _list EVAL "${ast}" "${env}" ;;
  64     vector)
  65         _map_with_type _vector EVAL "${ast}" "${env}" ;;
  66     hash_map)
  67         local res="" val="" hm="${ANON["${ast}"]}"
  68         _hash_map; local new_hm="${r}"
  69         eval local keys="\${!${hm}[@]}"
  70         for key in ${keys}; do
  71             eval val="\${${hm}[\"${key}\"]}"
  72             EVAL "${val}" "${env}"
  73             _assoc! "${new_hm}" "${key}" "${r}"
  74         done
  75         r="${new_hm}" ;;
  76     *)
  77         r="${ast}" ;;
  78     esac
  79 }
  80
  81 EVAL () {
  82     local ast="${1}" env="${2}"
  83     while true; do
  84     r=
  85     [[ "${__ERROR}" ]] && return 1
  86     #_pr_str "${ast}"; echo "EVAL '${r} / ${env}'"
  87     _obj_type "${ast}"; local ot="${r}"
  88     if [[ "${ot}" != "list" ]]; then
  89         EVAL_AST "${ast}" "${env}"
  90         return
  91     fi
  92
  93     # apply list
  94     _nth "${ast}" 0; local a0="${r}"
  95     _nth "${ast}" 1; local a1="${r}"
  96     _nth "${ast}" 2; local a2="${r}"
  97     case "${ANON["${a0}"]}" in
  98         def!) local k="${ANON["${a1}"]}"
  99               #echo "def! ${k} to ${a2} in ${env}"
 100               EVAL "${a2}" "${env}"
 101               ENV_SET "${env}" "${k}" "${r}"
 102               return ;;
 103         let*) ENV "${env}"; local let_env="${r}"
 104               local let_pairs=(${ANON["${a1}"]})
 105               local idx=0
 106               #echo "let: [${let_pairs[*]}] for ${a2}"
 107               while [[ "${let_pairs["${idx}"]}" ]]; do
 108                   EVAL "${let_pairs[$(( idx + 1))]}" "${let_env}"
 109                   ENV_SET "${let_env}" "${ANON["${let_pairs[${idx}]}"]}" "${r}"
 110                   idx=$(( idx + 2))
 111               done
 112               ast="${a2}"
 113               env="${let_env}"
 114               # Continue loop
 115               ;;
 116         quote)
 117               r="${a1}"
 118               return ;;
 119         quasiquote)
 120               QUASIQUOTE "${a1}"
 121               ast="${r}"
 122               # Continue loop
 123               ;;
 124         do)   _count "${ast}"
 125               _slice "${ast}" 1 $(( ${r} - 2 ))
 126               EVAL_AST "${r}" "${env}"
 127               [[ "${__ERROR}" ]] && r= && return 1
 128               _last "${ast}"
 129               ast="${r}"
 130               # Continue loop
 131               ;;
 132         if)   EVAL "${a1}" "${env}"
 133               if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]]; then
 134                   # eval false form
 135                   _nth "${ast}" 3; local a3="${r}"
 136                   if [[ "${a3}" ]]; then
 137                       ast="${a3}"
 138                   else
 139                       r="${__nil}"
 140                       return
 141                   fi
 142               else
 143                   # eval true condition
 144                   ast="${a2}"
 145               fi
 146               # Continue loop
 147               ;;
 148         fn*)  _function "ENV \"${env}\" \"${a1}\" \"\${@}\"; \
 149                          EVAL \"${a2}\" \"\${r}\"" \
 150                         "${a2}" "${env}" "${a1}"
 151               return ;;
 152         *)    EVAL_AST "${ast}" "${env}"
 153               [[ "${__ERROR}" ]] && r= && return 1
 154               local el="${r}"
 155               _first "${el}"; local f="${ANON["${r}"]}"
 156               _rest "${el}"; local args="${ANON["${r}"]}"
 157               #echo "invoke: [${f}] ${args}"
 158               if [[ "${f//@/ }" != "${f}" ]]; then
 159                   set -- ${f//@/ }
 160                   ast="${2}"
 161                   ENV "${3}" "${4}" ${args}
 162                   env="${r}"
 163               else
 164                   eval ${f%%@*} ${args}
 165                   return
 166               fi
 167               # Continue loop
 168               ;;
 169     esac
 170     done
 171 }
 172
 173 # print
 174 PRINT () {
 175     if [[ "${__ERROR}" ]]; then
 176         _pr_str "${__ERROR}" yes
 177         r="Error: ${r}"
 178         __ERROR=
 179     else
 180         _pr_str "${1}" yes
 181     fi
 182 }
 183
 184 # repl
 185 ENV; REPL_ENV="${r}"
 186 REP () {
 187     r=
 188     READ "${1}" || return 1
 189     EVAL "${r}" "${REPL_ENV}"
 190     PRINT "${r}"
 191 }
 192
 193 # core.sh: defined using bash
 194 _fref () { _function "${2} \"\${@}\""; ENV_SET "${REPL_ENV}" "${1}" "${r}"; }
 195 for n in "${!core_ns[@]}"; do _fref "${n}" "${core_ns["${n}"]}"; done
 196 _eval () { EVAL "${1}" "${REPL_ENV}"; }
 197 _fref "eval" _eval
 198 _list; argv="${r}"
 199 for _arg in "${@:2}"; do _string "${_arg}"; _conj! "${argv}" "${r}"; done
 200 ENV_SET "${REPL_ENV}" "__STAR__ARGV__STAR__" "${argv}";
 201
 202 # core.mal: defined using the language itself
 203 REP "(def! not (fn* (a) (if a false true)))"
 204 REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
 205
 206 # load/run file from command line (then exit)
 207 if [[ "${1}" ]]; then
 208     REP "(load-file \"${1}\")"
 209     exit 0
 210 fi
 211
 212 # repl loop
 213 while true; do
 214     READLINE "user> " || exit "$?"
 215     [[ "${r}" ]] && REP "${r}" && echo "${r}"
 216 done