lisp_eval_should_be '(shellquote "foo")' '"'\''foo'\''"' 'shellquote, trivial'
lisp_eval_should_be '(shellquote "foo'\''s")' '"'\''foo'\'\\\'\''s'\''"' 'shellquote, single single quote'
lisp_eval_should_be '(shellquote "c d")' '"'\''c d'\''"' 'shellquote, space'
lisp_eval_should_be '(shellquote "$foo")' '"'\''$foo'\''"' 'shellquote, dollarsign'
lisp_eval_should_be '(shellquote "a\\nb")' '"'\''a\nb'\''"' 'shellquote, newline'
lisp_eval_should_be '(unsafe-system "echo hi; echo ho")' 'hi
ho' 'unsafe-system vulnerable to command injection'
lisp_eval_should_be '(system "echo" "hi;" "echo" "ho")' 'hi; echo ho' 'system properly escapes arguments'
lisp_eval_should_be '(let ((a '\''(1 2 3))) (apply + 6 a))' '12' 'apply'

    if(car == _symbol("system"))
        return _system(_eval3(_cadr(form), env, env, d+1))

    if(car == _symbol("shellquote"))
        return _shellquote(_eval3(_cadr(form), env, env, d+1))
    if(car == _symbol("unsafe-system"))
        return _unsafe_system(_eval3(_cadr(form), env, env, d+1))

function _system(s) {

function _shellquote(s,   subber) {

        return _system(_STRING[s])

        subber = _STRING[s]
        # This lisp is aimed at system administration, where it might
        # run as root, and unquoted control characters output to a
        # terminal may have ill effects. Rather nerf the control
        # characters than pass them through. But we'll let \011, HT;
        # \012, LF; and \015, CR, through.
        gsub(/[\001-\010\013-\014\016-\037]/, "[GlotawkNerfedCtrl]", subber)
        gsub(/'/, "'\\''", subber)
        sub(/^/, "'", subber)
        sub(/$/, "'", subber)
        return _string(subber)

        logg_err("_system", "non-string operand " _repr(s))

        logg_err("_shellquote", "non-string operand " _repr(s))
        return _nil()
    }
}
# This is unsafe because you pass in a single string, which is passed
# straight to the shell. If the string contains any user-controlled
# input, calling unsafe-system with it introduces a command injection
# vulnerability, CWE-78.
function _unsafe_system(s) {
    if(_TYPE[s] == "s") {
        return system(_STRING[s])
    } else {
        logg_err("_unsafe_system", "non-string operand " _repr(s))

            logg_dbg("_printf", "printfing " fmt)

(setq apply (lambda xs (apply xs)))            \

(setq system (lambda (x) (system x))) \

(setq unsafe-system (lambda (x) (system x))) \
(setq shellquote (lambda (x) (shellquote x))) \
(setq intercalate (lambda (it them) \
                          (cond ((null them)) \
                                ((null (cdr them)) them) \
                                (true (cons (car them) \
                                            (cons it \
                                                  (intercalate it (cdr them)))))))) \
(setq string-join (lambda args (apply strcat (intercalate (car args) (cdr args))))) \
(setq system (lambda argv (unsafe-system (apply string-join \" \" (mapcar shellquote argv)))))\

    _GLOBALS = _cons(_cons(_symbol("a-newline"), _cons(_string("\n"), _nil())),
                     _GLOBALS)

    _symbol("apply")

    _symbol("system")

    _symbol("shellquote")
    _symbol("unsafe-system")

    _symbol("intercalate")
    _symbol("string-join")
    _symbol("system")

function _apply(args, env, depth,      last, butlast) {
#    logg_dbg("apply", _repr(args), depth)
    if(_is_null(args)) # (apply)
        return _nil()
    else if(_is_null(_cdr(args))) # (apply just-a-function-no-args)
        return _eval3(args, env, env, depth)
    else {
        butlast = _nil()
        for(last=args; !_is_null(_cdr(last)); last=_cdr(last)) {
            butlast = _cons(_car(last), butlast)
        }
        # now, butlast is a reversed copy of everything but the last.
        # last is the (unevaluated) last cdr in args. is last a list?
#        logg_dbg("apply", "butlast is " butlast " with " _repr(butlast), depth)
#        logg_dbg("apply", "last is    " last " with " _repr(last) ". evalling", depth)
        last = _eval3(_car(last), env, env, depth+1)
#        logg_dbg("apply", "last is now " last " with " _repr(last), depth)
        if(_TYPE[last] == "(") {
            args = _nconc(_nreverse(butlast), last)
#            logg_dbg("apply", "now we shall evaluate " _repr(args), depth)
            return _eval3(args, env, env, depth)
        } else {
            # last is an atom. why'd you use apply? oh well.
#            logg_dbg("apply", "last is not a list. oh well, evaluating " _repr(args), depth)
            return _eval3(args, env, env, depth)
        }
    }
}

    else if(car == _symbol("apply"))
        return _apply(_cdr(form), env, d+1)

    gsub(/\n/, "\\n", string)

        awkescape(v)

        v = awkescape(v)

            awkescape(v)

            v = awkescape(v)

            awkescape(v)

            v = awkescape(v)