bash/step9_interop.sh

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