lisp_eval_should_be '(printf "%03d%%03d%s" 5 "foo")' \
                    '005%03dfoo()' 'printf'
lisp_eval_should_be '(with-output-to ">>" "/dev/null" (printf "%03d%%03d%s" 5 "foo"))' \
                    '()' 'with-output-to'

    else if(car == _symbol("printf"))
        # oo tricky, varargs. note we are sending the cddr in unevaluated.
        return _printf(_eval3(_cadr(form), env, env, d+1),
                       _cddr(form))

        # oo tricky, varargs. note we are sending the cddr in unevaluated.

        # same

    else if(car == _symbol("with-output-to"))
        return _with_output_to(_eval3(_cadr(form), env, env, d+1),
                               _eval3(_caddr(form), env, env, d+1),
                               _cdddr(form), env, d+1) # to be evprogged

}
function _printf(fmt, unevald, env, d,      dlave, evald, s, a, i, p) {
    # mostly like _sprintf above
    n = 1
    dlave = _nil()
    for(; !_is_null(unevald); unevald=_cdr(unevald)) {
        dlave = _cons(_eval3(_car(unevald), env, env, d+1), dlave)
    }
    evald = _nreverse(dlave)
    _list_to_flat_awk_array_of_any(evald, a)
    i = 1
    s = ""
    fmt = _STRING[fmt]
    while(fmt != "") {
        if(match(fmt, /%/)) {
            # vv printf the bit before the %
            if(_OUTPUT_REDIR_NAME) {
                if(_OUTPUT_REDIR_KIND == ">") {
                    printf substr(fmt, 1, RSTART-1) > _OUTPUT_REDIR_NAME
                    # don't re-overwrite the file with the next bit
                    _OUTPUT_REDIR_KIND = ">>"
                } else if(_OUTPUT_REDIR_KIND == ">>") {
                    printf substr(fmt, 1, RSTART-1) >> _OUTPUT_REDIR_NAME
                } else if(_OUTPUT_REDIR_KIND == "|") {
                    printf substr(fmt, 1, RSTART-1) | _OUTPUT_REDIR_NAME
                }
            } else {
                printf substr(fmt, 1, RSTART-1)
            }
            # ^^
            fmt = substr(fmt, RSTART)
            # now do the %
            if(match(fmt, /^%%/)) {
                # vv printf a percent character
                if(_OUTPUT_REDIR_NAME) {
                    if(_OUTPUT_REDIR_KIND == ">") { # shouldn't be, by now
                        printf "%%" > _OUTPUT_REDIR_NAME
                        _OUTPUT_REDIR_KIND = ">>"
                    } else if(_OUTPUT_REDIR_KIND == ">>") {
                        printf "%%" >> _OUTPUT_REDIR_NAME
                    } else if(_OUTPUT_REDIR_KIND == "|") {
                        printf "%%" | _OUTPUT_REDIR_NAME
                    }
                } else {
                    printf "%%"
                }
                # ^^
                fmt = substr(fmt, 3)
                continue
            }
            # now the %-thing is at the beginning of fmt. how long is
            # it? (grammar derived from FreeBSD printf(3); your libc
            # may vary)
            match(fmt,/^%[*#+ 0-9.'-]*[diouxXfFeEgGaAcsb]/);
            if(i > length(a)) {
                logg_err("_printf", "not enough values for printf!")
                return _nil()
            } else {
                p = a[i++]
            }
            # RLENGTH is the length of the format specifier
            # vv printf %omgwtfbbq, p
            if(_OUTPUT_REDIR_NAME) {
                if(_OUTPUT_REDIR_KIND == ">") {
                    printf substr(fmt,1,RLENGTH), p > _OUTPUT_REDIR_NAME
                    _OUTPUT_REDIR_KIND = ">>"
                } else if(_OUTPUT_REDIR_KIND == ">>") {
                    printf substr(fmt,1,RLENGTH), p >> _OUTPUT_REDIR_NAME
                } else if(_OUTPUT_REDIR_KIND == "|") {
                    printf substr(fmt,1,RLENGTH), p | _OUTPUT_REDIR_NAME
                }
            } else {
                printf substr(fmt,1,RLENGTH), p
            }
            # ^^
            fmt = substr(fmt, RLENGTH+1)
        } else {
            # vv no more %, printf the rest
            if(_OUTPUT_REDIR_NAME) {
                if(_OUTPUT_REDIR_KIND == ">") {
                    printf fmt > _OUTPUT_REDIR_NAME
                    _OUTPUT_REDIR_KIND = ">>"
                } else if(_OUTPUT_REDIR_KIND == ">>") {
                    printf fmt >> _OUTPUT_REDIR_NAME
                } else if(_OUTPUT_REDIR_KIND == "|") {
                    printf fmt | _OUTPUT_REDIR_NAME
                }
            } else {
                printf fmt
            }
            # ^^
            fmt = ""
        }
    }
    return _nil()

        return _nil()
    }
}
# it is up to every function that produces output under programmatic
# control to check these globals. they start out uninitialized and
# are only set within the body of with-output-to.
function _with_output_to(redir_kind, name, forms, env, d,       old_redir_kind, old_name, rv) {
    old_redir_kind = _OUTPUT_REDIR_KIND
    old_name       = _OUTPUT_NAME
    if(_TYPE[redir_kind] == "s") {
        if(_TYPE[name] == "s") {
            _OUTPUT_REDIR_KIND = _STRING[redir_kind]
            _OUTPUT_REDIR_NAME = _STRING[name]
            rv = _evprog(forms, env, env, d)
            _OUTPUT_REDIR_KIND = old_redir_kind
            _OUTPUT_REDIR_NAME = old_name
            return rv
        } else {
            logg_err("_with_output_to", "file or command should be a string")
            return _nil()
        }
    } else {
        logg_err("_with_output_to", "redir kind should be a string: \">\", \">>\" or \"|\"")

\"no sprintf function value, varargs are too tricky\" \

\"no printf/sprintf function values, i've got no apply\" \

(setq printf nil) \

(setq with-output-to nil) \

    _symbol("printf")

    _symbol("with-output-to")