f=$(mktemp)
lisp_eval_should_be "(progn (with-output-to \">\" \"${f}\" (print \"foo\") (print 3) (fflush)) (close \"${f}\"))" '()' 'with-output-to print close'
lisp_eval_should_be "(with-input-from \"<\" \"${f}\" (print (getline)) (print (getline)))" '(""foo"" 1)
("3" 1)
()' 'with-input-from getline'

    print _repr(x)

    if(_OUTPUT_REDIR_NAME) {
        if(_OUTPUT_REDIR_KIND == ">") {
            print _repr(x) > _OUTPUT_REDIR_NAME
            _OUTPUT_REDIR_KIND = ">>"
        } else if(_OUTPUT_REDIR_KIND == ">>") {
            print _repr(x) >> _OUTPUT_REDIR_NAME
        } else if(_OUTPUT_REDIR_KIND == "|") {
            print _repr(x) | _OUTPUT_REDIR_NAME
        }
    } else {
        print _repr(x)
    }

    else if(car == _symbol("with-rs"))
        return _with_rs(_eval3(_cadr(form), env, env, d+1),
                        _cddr(form), env, d+1) # to be evaluated using evprog
    else if(car == _symbol("with-fs"))
        return _with_fs(_eval3(_cadr(form), env, env, d+1),
                        _cddr(form), env, d+1) # to be evaluated using evprog

    else if(car == _symbol("with-input-from"))
        return _with_input_from(_eval3(_cadr(form), env, env, d+1),
                                _eval3(_caddr(form), env, env, d+1),
                                _cdddr(form), env, d+1) # to be evprogged
    else if(car == _symbol("fflush"))
        return _fflush()
    else if(car == _symbol("close"))
        return _close(_eval3(_cadr(form), env, env, d+1))

    rv = getline a

    if(_INPUT_REDIR_NAME) {
        if(_INPUT_REDIR_KIND == "<") {
            rv = getline a < _INPUT_REDIR_NAME
        } else if(_INPUT_REDIR_KIND == "|") {
            rv = _INPUT_REDIR_NAME | getline a
        }
    } else {
        rv = getline a
    }

        return _nil()
    }
}
function _with_rs(new_rs, forms, env, d,       old_rs, rv) {
    old_rs = RS
    if(_TYPE[new_rs] == "s") {
        RS = _STRING[new_rs]
        rv = _evprog(forms, env, env, d)
        RS = old_rs
        return rv
    } else {
        logg_err("_with_rs", "with-rs needs a string")
        return _nil()
    }
}
function _with_fs(new_fs, forms, env, d,       old_fs, rv) {
    old_fs = FS
    if(_TYPE[new_fs] == "s") {
        FS = _STRING[new_fs]
        rv = _evprog(forms, env, env, d)
        FS = old_fs
        return rv
    } else {
        logg_err("_with_fs", "with-fs needs a string")

        return _nil()
    }
}
# same as above. every function that consumes input, check these
# globals. they are only set within the body of with-output-to. note:
# (with-input-from "|" "echo foo" (getline)) in glotawk corresponds
# with "echo foo" | getline in awk.
function _with_input_from(redir_kind, name, forms, env, d,       old_redir_kind, old_name, rv) {
    old_redir_kind = _INPUT_REDIR_KIND
    old_name       = _INPUT_NAME
    if(_TYPE[redir_kind] == "s") {
        if(_TYPE[name] == "s") {
            _INPUT_REDIR_KIND = _STRING[redir_kind]
            _INPUT_REDIR_NAME = _STRING[name]
            rv = _evprog(forms, env, env, d)
            _INPUT_REDIR_KIND = old_redir_kind
            _INPUT_REDIR_NAME = old_name
            return rv
        } else {
            logg_err("_with_input_from", "file or command should be a string")
            return _nil()
        }
    } else {
        logg_err("_with_input_from", "redir kind should be a string: \"<\" or \"|\"")

    }
}
function _fflush() {
    if(_OUTPUT_REDIR_NAME) {
        fflush(_OUTPUT_REDIR_NAME)
    } else {
        fflush("/dev/stdout")
    }
    return _nil()
}
function _close(thing) {
    if(_TYPE[thing] == "s") {
        close(_STRING[thing])
    } else {
        logg_err("_close", "file or command to close should be a string")

    return _nil()

(setq with-input-from nil) \
(setq fflush nil) \
(setq close nil) \

    # at one point i had a more generic fix for this, but then it
    # unaccountably broke? this will work.

    _symbol("with-rs")
    _symbol("with-fs")

    _symbol("with-input-from")
    _symbol("fflush")
    _symbol("close")