# we shall not compare the contents of secret strings: they shall
    # only be equal if they are eq. and encrypted strings made from
    # the same source will likely always differ in their contents even
    # if we compared their contents - if we have used a cipher mode
    # with a nonce.
    #

    _symbol("with-encrypted-input-from")

BEGIN {
    delete _CLOSE_INSTEAD[1]
}

    else if(car == _symbol("with-encrypted-input-from"))
        return _with_encrypted_input_from(\
            _eval3(_cadr(form), env, env, d+1, hdlrs, st, errp),
            _eval3(_caddr(form), env, env, d+1, hdlrs, st, errp),
            _cdddr(form), env, d+1, hdlrs, st, errp) # to be evprogged

    if(secretp[1]) # the thing to be output is secret

    if(secretp[1]) # the thing to be output is secret. (if redacted, it is not!)

    return _cons(_string(a), _cons(_number(rv), _nil()))

    if(_INPUT_SECRET) {
        return _cons(_secret_string(a), _cons(_number(rv), _nil()))
    } else {
        return _cons(_string(a), _cons(_number(rv), _nil()))
    }

function _with_output_to(redir_kind, name, secretp, forms, env, d, hdlrs, st, errp,       old_redir_kind, old_name, rv) {

function _with_output_to(redir_kind, name, secretp, forms, env, d, hdlrs, st, errp,       old_redir_kind, old_name, old_secret, rv) {

function _with_input_from(redir_kind, name, forms, env, d, hdlrs, st, errp,       old_redir_kind, old_name, rv) {

function _with_input_from(redir_kind, name, forms, env, d, hdlrs, st, errp,       old_redir_kind, old_name, old_secret, rv) {

    old_secret     = _INPUT_SECRET

            _INPUT_SECRET     = 0

            _INPUT_SECRET     = old_secret

function _with_encrypted_input_from(redir_kind, name, forms, env, d, hdlrs, st, errp,     old_redir_kind, old_name, old_secret, rv) {
    old_redir_kind = _INPUT_REDIR_KIND
    old_name       = _INPUT_NAME
    old_secret     = _INPUT_SECRET
    if(_TYPE[redir_kind] == "s") {
        if(_TYPE[name] == "s") {
            if(_STRING[redir_kind] == "<") {
                _INPUT_REDIR_KIND = "|"
                _INPUT_REDIR_NAME = DECRYPT_COMMAND " < " _STRING[name]
            } else if(_STRING[redir_kind] == "|") {
                _INPUT_REDIR_KIND = "|"
                _INPUT_REDIR_NAME = _STRING[name] " | " DECRYPT_COMMAND
            } else {
                logg_err("_with_encrypted_input_from", "unknown redir kind " _STRING[redir_kind] " - use \"<\" or \"|\"", d)
                return _nil()
            }
            # we have lied about what is being opened; we must keep
            # track of our lie in order to close the right thing.
            _CLOSE_INSTEAD[name] = _INPUT_REDIR_NAME
            _INPUT_SECRET = 1
            rv = _evprog(forms, env, env, d, hdlrs, st, errp)
            _INPUT_REDIR_KIND = old_redir_kind
            _INPUT_REDIR_NAME = old_name
            _INPUT_SECRET     = old_secret
            return rv
        } else {
            logg_err("_with_encrypted_input_from", "file or command should be a string", d)
            return _nil()
        }
    } else {
        logg_err("_with_encrypted_input_from", "redir kind should be a string: \"<\" or \"|\"", d)
        return _nil()
    }
}
                

function _close(thing) {

function _close(thing,        s, instead) {

        close(_STRING[thing])

        s = _STRING[thing]
        if(s in _CLOSE_INSTEAD) { # see with-encrypted-input-from
            instead = _CLOSE_INSTEAD[s]
            delete _CLOSE_INSTEAD[s]
            s = instead
        }
        close(s)

(setq with-encrypted-input-from nil)

EXTRA_AWK_ARGS="-v KEY_FILE=keyfile" lisp_eval_should_be '(with-output-to ">>" "shh-secret" (printf "%s\n" (reveal-encrypted (encrypt "foo"))))' '()' 'secret output to file'
if grep -q foo shh-secret; then
    tap_fail "encrypted string output to file"
else
    tap_pass "encrypted string output to file"
fi
EXTRA_AWK_ARGS="-v KEY_FILE=keyfile" lisp_eval_should_be '(with-encrypted-input-from "<" "shh-secret" (car (getline)))' 'S"(redacted)"' 'getline from an encrypted file produces a secret string'
rm -f shh-secret