local exitcode=$?
    if [ "$exitcode" -ne 0 ] ; then
        tap_fail "$3 - nonzero exit code"
    else
        tap_cmp "$output" "$2" "$3"
    fi
}
lisp_eval_should_be_tricky_output () {
    [ $LOG_LEVEL -ge 2 ] && echo "INF ---- test $(($TAP_TEST_COUNT + 1)) ---------"
    lisp_with_string "$1" >/dev/null 2>&1

        local output="$(lisp_with_string "$1" | od -A n -t x1 -w999)"

lisp_eval_should_be "(with-input-from \"<\" \"${f}\" (print (getline)) (print (getline)))" '(""foo"" 1)

lisp_eval_should_be "(with-input-from \"<\" \"${f}\" (print (getline)) (print (getline)))" '("\"foo\"" 1)

# a double-quoted string, with a single quote, the word foo, and a single quote

lisp_eval_should_be '(shellquote "foo'\''s")' '"'\''foo'\'\\\'\''s'\''"' 'shellquote, single single quote'

lisp_eval_should_be '(shellquote "foo'\''s")' '"'\''foo'\'\\\\\'\''s'\''"' 'shellquote, single single quote'

lisp_eval_should_be '(shellquote "a
b")' '"'\''a
b'\''"' 'shellquote, newline'

lisp_eval_should_be '(shellquote "a\\nb")' '"'\''a\nb'\''"' 'shellquote, newline'

# woo, tricky quoting inside this very script, before it gets to glotawk
lisp_eval_should_be '(string-length ".\\a.\\b.\\f.\\n.\\r.\\t.\\v.\\\\.\\".")' '19' 'string read backslash escapes'
lisp_eval_should_be_tricky_output '(mapcar (lambda (x) (substr ".\\a.\\b.\\f.\\n.\\r.\\t.\\v.\\\\.\\"." x 1)) '\''(2 4 6 8 10 12 14 16 18))' ' 28 22 5c 61 22 20 22 5c 62 22 20 22 5c 66 22 20 22 5c 6e 22 20 22 5c 72 22 20 22 5c 74 22 20 22 5c 76 22 20 22 5c 5c 22 20 22 5c 22 22 29 0a' 'string print backslash escapes'

BEGIN {
    _string_unescapes["a"] = "\a"
    _string_unescapes["b"] = "\b"
    _string_unescapes["f"] = "\f"
    _string_unescapes["n"] = "\n"
    _string_unescapes["r"] = "\r"
    _string_unescapes["t"] = "\t"
    _string_unescapes["v"] = "\v"
    _string_unescapes["\\"] = "\\"
    _string_unescapes["\""] = "\""
}

function read_atom(a, quote,  this, ans, self_quoting) {

function read_atom(a, quote,  this, ans, self_quoting, ch) {

            ans = _string(substr(this, 2, length(this)-2))

            ans = substr(this, 2, length(this)-2)
            # effectuate backslash-escapes. note we are only
            # supporting single-letter escapes, not \012 style octal
            # escapes.
            #
#            logg_dbg("read_atom", "string before backslash escapes: " ans)
            while(match(ans, /\\[abfnrtv"\\]/)) {
                ch = _string_unescapes[substr(ans, RSTART+1, 1)]
                ans = substr(ans, 1, RSTART-1) ch substr(ans, RSTART+RLENGTH)
            }
# careful.
#            logg_dbg("read_atom", "string after backslash escapes: " ans)
            # ok.
            ans = _string(ans)

BEGIN {
    _string_reescapes["\a"] = "\\a"
    _string_reescapes["\b"] = "\\b"
    _string_reescapes["\f"] = "\\f"
    _string_reescapes["\n"] = "\\n"
    _string_reescapes["\r"] = "\\r"
    _string_reescapes["\t"] = "\\t"
    _string_reescapes["\v"] = "\\v"
    _string_reescapes["\\"] = "\\\\"
    _string_reescapes["\""] = "\\\""
}

function _repr_string(n) {
    return "\"" _STRING[n] "\""

function _repr_string(n,      s, chs) {
    s = _STRING[n]
    gsub(/\\/, "\\\\", s)
    gsub(/"/,  "\\\"", s)
    while(match(s, /[\a\b\f\n\r\t\v]/)) {
#        logg_dbg("_repr_string", "reescaping " s)
        chs = _string_reescapes[substr(s, RSTART, 1)]
        s = substr(s, 1, RSTART-1) chs substr(s, RSTART+1)
#        logg_dbg("_repr_string", "now it is " s)
    }
    return "\"" s "\""

            logg_dbg("_printf", "printfing " fmt)

#            logg_dbg("_printf", "printfing " fmt)