function _dump(filename, append, main,   i, t, v, s, line) {

function _dump(filename, append, main,   i, t, v, s, line, errp) {

            i = _encrypt_secret_string(i)

            errp[1] = 0
            i = _encrypt_secret_string(i, _nil(), 0, _nil(), _nil(), errp)
            # ^ since we passed in a nil list of handlers, if an error
            # happened, we have now aborted and are gone.
            #
            # dumping is supposed to save things, not destroy them. if
            # you've been working on an image for hours or days and
            # you dump it, you don't expect to lose everything
            # instantly because the dump crashed glotawk.
            #
            # but also dumping is supposed to dependably save
            # everything, not everything but a few things that didn't
            # work. If a dump is automated, an error message that
            # doesn't cause a failure exit may be entirely missed.

            return _decrypt_encrypted_string(form)

            return _decrypt_encrypted_string(form, env, d+1, hdlrs, st, errp)

    gsub(/[^a-zA-Z0-9\/+=]/, "_", s)

    gsub(/[^a-zA-Z0-9\/+= \n]/, "_", s)

EXTRA_AWK_ARGS="-v KEY_FILE=._-NONEXISTENT-_." lisp_eval_should_be '(encrypt "foo")' '' 'cryptography without keyfile throws error' 87

EXTRA_AWK_ARGS="-v KEY_FILE=._-NONEXISTENT-_." lisp_eval_should_be '(setq x S"woyfutnwyu") (dump "test-dump-file-2")' 'S"(redacted)"' 'dumping secrets with no key aborts' 87

function _decrypt_encrypted_string(n, env, d, hdlrs, st, errp,    line, out, status, dcmd, tfn, oors) {

function _assert_key_readable(env, d, hdlrs, st, errp,   n_exitcode) {
    # use glotawk's system function, not awk's, because the KEY_FILE
    # variable is a user input, we wouldn't want to allow shell
    # command injection, and glotawk's system function is shown by
    # testing to disallow shell injection.
    n_exitcode = _eval3(_cons(_symbol("system"),
                              _cons(_string("/bin/test"),
                                    _cons(_string("-r"),
                                          _cons(_string(KEY_FILE),
                                                _nil())))),
                      env, env, d+1, hdlrs, st, errp)
    if(_eq_awk(n_exitcode, _number(0))) {
        return _true()
    } else {
        return _error(_cons(_string("cryptography attempted but KEY_FILE not readable: %s"),
                            _cons(_string(KEY_FILE),
                                  _nil())),
                      env, d, hdlrs, st, errp)
    }
}
function _decrypt_encrypted_string(n, env, d, hdlrs, st, errp,    line, out, status, dcmd, tfn, oors, akr) {
    akr = _assert_key_readable(env, d, hdlrs, st, errp)
    if(!_eq_awk(_true(), akr))
        return akr

        return _error(_cons(_string("could not mktemp"),_nil()))

        return _error(_cons(_string("could not mktemp"),_nil()),
                      env, d, hdlrs, st, errp)

        out = out line

        out = out line RS

    gsub((RS "$"), "", out)  # deal with single line hopefully ok

    akr = _assert_key_readable(env, d, hdlrs, st, errp)
    if(!_eq_awk(_true(), akr))
        return akr

                return _encrypt_secret_string(n)

                return _encrypt_secret_string(n, env, d, hdlrs, st, errp)

                return _encrypt_string(n)

                return _encrypt_string(n, env, d, hdlrs, st, errp)

                return _unsafe_reveal(_decrypt(n), env, d, hdlrs, st, errp)

                return _unsafe_reveal(_decrypt(n, env, d, hdlrs, st, errp),
                                      env, d, hdlrs, st, errp)