bash/reader.sh

   1 #
   2 # mal (Make Lisp) Parser/Reader
   3 #
   4
   5 if [ -z "${__mal_readerr_included__}" ]; then
   6 __mal_readerr_included=true
   7
   8 source $(dirname $0)/types.sh
   9
  10 READ_ATOM () {
  11     local token=${__reader_tokens[${__reader_idx}]}
  12     __reader_idx=$(( __reader_idx + 1 ))
  13     case "${token}" in
  14         [0-9]*)  _number "${token}" ;;
  15         -[0-9]*) _number "${token}" ;;
  16         \"*)    if [[ ! "${token}" =~ ^\"(\\.|[^\\\"])*\"$ ]]; then
  17                     _error "expected '\"', got EOF"
  18                     return
  19                 fi
  20                 token="${token:1:-1}"
  21                 token="${token//\\\\/${__keyw}}"
  22                 token="${token//\\\"/\"}"
  23                 token="${token//\\n/$'\n'}"
  24                 token="${token//${__keyw}/\\}"
  25                 _string "${token}" ;;
  26         :*)     _keyword "${token:1}" ;;
  27         nil)    r="${__nil}" ;;
  28         true)   r="${__true}" ;;
  29         false)  r="${__false}" ;;
  30         *)      _symbol "${token}" ;;
  31     esac
  32 }
  33
  34 # Return seqence of tokens into r.
  35 #   ${1}: Type of r (vector, list)
  36 #   ${2}: starting symbol
  37 #   ${3}: ending symbol
  38 READ_SEQ () {
  39     local start="${1}"
  40     local end="${2}"
  41     local items=""
  42     local token=${__reader_tokens[${__reader_idx}]}
  43     __reader_idx=$(( __reader_idx + 1 ))
  44     if [[ "${token}" != "${start}" ]]; then
  45         r=
  46         _error "expected '${start}'"
  47         return
  48     fi
  49     token=${__reader_tokens[${__reader_idx}]}
  50     while [[ "${token}" != "${end}" ]]; do
  51         if [[ ! "${token}" ]]; then
  52             r=
  53             _error "expected '${end}', got EOF"
  54             return
  55         fi
  56         READ_FORM
  57         items="${items} ${r}"
  58         token=${__reader_tokens[${__reader_idx}]}
  59     done
  60     __reader_idx=$(( __reader_idx + 1 ))
  61     r="${items:1}"
  62 }
  63
  64 # Return form in r
  65 READ_FORM () {
  66     local token=${__reader_tokens[${__reader_idx}]}
  67     case "${token}" in
  68         \')     __reader_idx=$(( __reader_idx + 1 ))
  69                 _symbol quote; local q="${r}"
  70                 READ_FORM; local f="${r}"
  71                 _list "${q}" "${f}" ;;
  72         \`)     __reader_idx=$(( __reader_idx + 1 ))
  73                 _symbol quasiquote; local q="${r}"
  74                 READ_FORM; local f="${r}"
  75                 _list "${q}" "${f}" ;;
  76         \~)     __reader_idx=$(( __reader_idx + 1 ))
  77                 _symbol unquote; local q="${r}"
  78                 READ_FORM; local f="${r}"
  79                 _list "${q}" "${f}" ;;
  80         \~\@)   __reader_idx=$(( __reader_idx + 1 ))
  81                 _symbol splice-unquote; local q="${r}"
  82                 READ_FORM; local f="${r}"
  83                 _list "${q}" "${f}" ;;
  84         ^)      __reader_idx=$(( __reader_idx + 1 ))
  85                 _symbol with-meta; local wm="${r}"
  86                 READ_FORM; local meta="${r}"
  87                 READ_FORM; local obj="${r}"
  88                 _list "${wm}" "${obj}" "${meta}" ;;
  89         @)     __reader_idx=$(( __reader_idx + 1 ))
  90                 _symbol deref; local d="${r}"
  91                 READ_FORM; local f="${r}"
  92                 _list "${d}" "${f}" ;;
  93         \))     _error "unexpected ')'" ;;
  94         \()     READ_SEQ "(" ")"
  95                 _list ${r} ;;
  96         \])     _error "unexpected ']'" ;;
  97         \[)     READ_SEQ "[" "]"
  98                 _vector ${r} ;;
  99         \})     _error "unexpected '}'" ;;
 100         \{)     READ_SEQ "{" "}"
 101                 _hash_map ${r} ;;
 102         *)      READ_ATOM
 103     esac
 104 }
 105
 106 # Returns __reader_tokens as an indexed array of tokens
 107 TOKENIZE () {
 108     local data="${*}"
 109     local datalen=${#data}
 110     local idx=0
 111     local chunk=0
 112     local chunksz=500
 113     local match=
 114     local token=
 115     local str=
 116
 117     __reader_idx=0
 118     __reader_tokens=
 119     while true; do
 120         if (( ${#str} < ( chunksz / 2) )) && (( chunk < datalen )); then
 121             str="${str}${data:${chunk}:${chunksz}}"
 122             chunk=$(( chunk + ${chunksz} ))
 123         fi
 124         (( ${#str} == 0 )) && break
 125         [[ "${str}" =~ ^^([][{}\(\)^@])|^(~@)|(\"(\\.|[^\\\"])*\"?)|^(;[^$'\n']*)|^([~\'\`])|^([^][ ~\`\'\";{}\(\)^@\,]+)|^[,]|^[[:space:]]+ ]]
 126         match=${BASH_REMATCH[0]}
 127         str="${str:${#match}}"
 128         token="${match//$'\n'/}"
 129         #echo "MATCH: '${token}' / [${str}]"
 130         if ! [[ "${token}" =~ (^[,]$|^[[:space:]]*;.*$|^[[:space:]]*$) ]]; then
 131             __reader_tokens[${idx}]="${token}"
 132             idx=$(( idx + 1 ))
 133         fi
 134         if [ -z "${match}" ]; then
 135             _error "Tokenizing error at: ${str:0:50}"
 136             return 1
 137         fi
 138     done
 139 }
 140
 141 # read-str from a raw "string" or from a string object. Retruns object
 142 # read in r.
 143 READ_STR () {
 144     declare -a __reader_tokens
 145     TOKENIZE "${*}" || return 1  # sets __reader_tokens
 146     #set | grep ^__reader_tokens
 147     if [ -z "${__reader_tokens[0]}" ]; then
 148         r=
 149         return 1  # No tokens
 150     fi
 151     READ_FORM
 152     #echo "Token: ${r}: <${ANON["${r}"]}>"
 153     return
 154 }
 155
 156 # Call readline and save the history. Returns the string read in r.
 157 READLINE_EOF=
 158 READLINE_HISTORY_FILE=${HOME}/.mal-history
 159 READLINE () {
 160     history -r "${READLINE_HISTORY_FILE}" 2>/dev/null || true
 161     read -r -e -p "${1}" r || return "$?"
 162     history -s -- "${r}"
 163     history -a "${READLINE_HISTORY_FILE}" 2>/dev/null || true
 164 }
 165
 166 fi