else if(car == _symbol("gc-dot"))
        # two filenames: one for marks and one for sweeps
        return _gc_dot(_cons(env,
                             _cons(_GLOBALS,
                                   _cons(_MACROS,
                                         _cons(_COMPARED_SYMBOLS,
                                               _nil())))),
                       _STRING[_cadr(form)],
                       _STRING[_caddr(form)])

        return _gc(_cons(env, _cons(outer_env, _cons(_GLOBALS, _nil()))))

        return _gc(_cons(env,
                         _cons(_GLOBALS,
                               _cons(_MACROS,
                                     _cons(_COMPARED_SYMBOLS,
                                           _nil())))))

    else if(car == _symbol("dump-dot"))
        return _dump_dot(_STRING[_cadr(form)])

\"lol\"                                        \
(setq setq nil)                                \

(setq string-length (lambda (s) (string-length s))) \
(setq print (lambda (a) (print a)))            \
\"you can't use progn as a function, because.\" \
(setq progn nil)                               \
(setq macro nil)                               \
(setq expand1 (lambda (a) (expand1 a)))        \
(setq eval (lambda (a) (eval a)))              \

(setq sub! (lambda (r t s) (sub! r t s))) \
(setq gsub! (lambda (r t s) (gsub! r t s))) \

(setq sub (lambda (r t s) (sub r t s))) \
(setq gsub (lambda (r t s) (gsub r t s))) \

(setq string-length (lambda (s) (string-length s))) \

(setq sprintf nil) \
(setq strcat (lambda xs (strcat xs))) \
(setq gc-dot nil) \
(setq gc nil) \
(setq dump-dot nil) \
(setq dump nil) \

function _gc_mark_list(lis,    car, tv, t, v, i) {
    logg_dbg("_gc_mark_list", "cons number " lis)
    i = 0

function _gc_mark_cell(n, dot_filename, d) {
    logg_dbg("_gc_mark_cell", n, d)
    _MARK[n] = 1
    if(dot_filename)
        print " n" n " [fillcolor=green];" >>dot_filename
    return 1
}
function _gc_mark_list(lis, dot_filename, d,    i) {

        car = _car(lis)
        lis = _cdr(lis)
        if(_falsy(car)) continue
        t = _TYPE[car]
        _MARK[car] = 1
        if(t == "(") {
            i += _gc_mark_list(car)

        i += _gc_mark_cell(lis, dot_filename, d)
        if(!_is_literal(_car(lis))) {
            if(_TYPE[_car(lis)] == "(") {
                i += _gc_mark_list(_car(lis), dot_filename, d+1)
            } else {
                i += _gc_mark_cell(_car(lis), dot_filename, d)
            }

        i += 1
    }

        if(_is_literal(_cdr(lis))) {
            if(_is_null(_cdr(lis))) {
                lis = _nil()
            } else {
                # pair
                logg_dbg("_gc_mark_list", "cdr is a literal. pair?", d)
                i += _gc_mark_cell(_cdr(lis), dot_filename, d)
                lis = _nil()
            }
        } else {
            if(_TYPE[_cdr(lis)] == "(") {
                # move along lis
                lis = _cdr(lis)
            } else {
                # a pair with a non-literal
                logg_dbg("_gc_mark_list",
                         "cdr " _cdr(lis) " is not a cons. pair?", d)
                i += _gc_mark_cell(_cdr(lis), dot_filename, d)
            }
        }
    }    

function _gc(envs,    i, t, name, ngcd, nmarks) {
    # y'know... the envs given had better add up to everything, not
    # just globals and not just one stack of envs. hmm
    delete _MARK
    ngcd = 0
    logg_dbg("_gc", "marking")
    nmarks = _gc_mark_list(envs)
    logg_dbg("_gc", "sweeping")

function _gc_sweep(dot_filename,    ngcd) {

        if(i+0!=i) continue # no string keys please

                if(dot_filename)
                    print "    n" i " [fillcolor=lightpink]" >>dot_filename

                if(dot_filename)
                    print "    n" i " [fillcolor=lightcyan2]" >>dot_filename

            } else { # 

                if(dot_filename) 
                    print "    n" i " [fillcolor=orange1]" >>dot_filename
            } else {
                if(dot_filename)
                    print "    n" i " [fillcolor=oldlace]" >>dot_filename

    }

    }    
}
function _gc_dot(envs, mark_filename, sweep_filename,    i, t, name, ngcd, nmarks) {
    # y'know... the envs given had better add up to everything, not
    # just globals and not just one stack of envs. hmm
    delete _MARK
    ngcd = 0
    logg_dbg("_gc", "marking")
    if(mark_filename) print "" >mark_filename
    if(sweep_filename) print "" >sweep_filename
    nmarks = _gc_mark_list(envs, mark_filename, 0)
    logg_dbg("_gc", "sweeping")
    ngcd = _gc_sweep(sweep_filename)
#    _dump("post-gc")

function _gc(envs) {
    return _gc_dot(envs)
}

    _symbol("gc-dot")

    _symbol("dump-dot")

    # make list of these percent symbols because _eval3 compares the
    # address of the operator being eval'd against them, in order to
    # reduce the number of if-elseif-elseif-elseif... cases if the
    # operator isn't one of the most common ones.
    _COMPARED_SYMBOLS = _cons(_symbol("%other-lispy%"),
                              _cons(_symbol("%math%"),
                                    _cons(_symbol("%last-special-form%"),
                                          _nil())))
                                                  

    _logg_err(where, "builtin mischaracterization for symbol " what)

    logg_err(where, "builtin mischaracterization for symbol " what)

    if(N > (N_at_last_gc + GC_EVERY)) {
        logg_dbg("_eval3", "auto-gc at N " N)
        _gc(_cons(env,
                  _cons(outer_env,
                        _cons(_GLOBALS,
                              _cons(_MACROS,
                                    _cons(_COMPARED_SYMBOLS,
                                          _nil()))))))
    }

    logg_dbg("_dump", "dumping to " filename)

    print "    N_at_last_gc = " N_at_last_gc >> filename

        # i is not a number but a string. somewhere in the code we
        # ask if _TYPE[something] == bla, where something may be
        # true, or false, or nil, or a literal number ("# 123");
        # and by asking about _TYPE[something], we make
        # _TYPE[something] exist, and be "". we don't want to dump
        # those here because _TYPE[# 123] is not valid awk syntax.
        if((i+0)!=i) continue

    print "    _COMPARED_SYMBOLS = " _COMPARED_SYMBOLS >>filename

}
function dotescape(string) {
    gsub(/\\/, "\\\\", string)
    gsub(/"/,  "\\\"", string)
    return string
}
function dotrepr(v) {
    if(v == _nil())
        return _nil()
    else if(v == _true())
        return _true()
    else if(v == _false())
        return _false()
    else if(v+0 == v)
        return v
    else {
        dotescape(v)
        return v
    }

function _dump_dot(filename,    i, t, v, s, n, node, edge, edge2) {
    logg_dbg("_dump_dot", "dumping Graphviz to " filename)
    print "digraph g {" >filename
    print "    rankdir=LR" >>filename
    print "    overlap=false" >>filename
    print "    node [style=filled]" >>filename
    for(i in _TYPE) {
        # i is not a number but a string. somewhere in the code we
        # ask if _TYPE[something] == bla, where something may be
        # true, or false, or nil, or a literal number ("# 123");
        # and by asking about _TYPE[something], we make
        # _TYPE[something] exist, and be "". we don't want to dump
        # those here.
        if((i+0)!=i) continue
        t = _TYPE[i]
        print "/*  " i " is a " _TYPE[i] " : " _repr(i) " */" >>filename
        if(t == "(") {
            print "/*  -- " _CAR[i] " is a " _TYPE[_CAR[i]] " : " _repr(_CAR[i]) "  */" >>filename
            t = _TYPE[_CAR[i]]
            node = "    n" i " [shape=record,label=\"{<n> " i "|"
            edge = ""
            edge2 = ""
            if(t == "(") {
                node = node "<car> ·|"
                edge = "    n" i ":car -> n" _CAR[i] ":n;"
            } else if(t == "'") {
                v = _SYM_NUMBERS[_CAR[i]]
                dotescape(v)
                node = node v "|"
                #edge ="    n" i ":car -> n" _CAR[i] ";"
            } else if(t == "s") {
                v = _STRING[_CAR[i]]
                dotescape(v)
                node = node "\\\"" v "\\\"|"
            } else {
                node = node dotrepr(_CAR[i]) "|"
            }
            if(_is_null(_CDR[i])) {
                node = node "<cdr> X}\"];"
            } else {
                node = node "<cdr> ·}\"];"
                edge2 = "    n" i ":cdr -> n" _CDR[i] ":n;"
            }
            print node >>filename
            print edge >>filename
            print edge2 >>filename
        } else if(t == "'") {
            #print "    n" i " [shape=record,label=\"{<n> " i "|" _SYM_NUMBERS[i] "}\"];" >>filename
        } else if(t == "s") {
            print "    n" i " [shape=record,label=\"{<n> " i "|" _STRING[i] "}\"];" >>filename
        }
    }
    print "    nGlobals [label=\"_GLOBALS\"];" >>filename
    print "    nGlobals -> n" _GLOBALS ";" >>filename
    print "    nMacros [label=\"_MACROS\"];" >>filename
    print "    nMacros -> n" _MACROS ";" >>filename
    print "    nCompared [label=\"_COMPARED_SYMBOLS\"];" >>filename
    print "    nCompared -> n" _COMPARED_SYMBOLS ";" >>filename
    print "/*sweep colors*/" >>filename
    print "/*mark colors*/" >>filename
    print "}" >>filename
    close(filename)
    return _true()
}

    N_at_last_gc = 0
    GC_EVERY = 16384

    max_n += 1

help = "\n\
Targets:\n\
        glotawk:       build the interpreter, a single large\n\
                       executable AWK script\n\
        check:         run tests\n\
        benchmark:     run a few benchmarks\n\
        all (default): glotawk, check, and benchmark\n\
        clean:         get rid of build products\n\
        heapviz:       fancy Graphviz view of initial heap and GC\n\
"
help:
	@echo ${help} >&2

	echo "(dump \"$@\")" | $(AWK) -f glotawk-build.awk

	(echo "(gc)"; echo "(dump \"$@\")") | $(AWK) -f glotawk-build.awk

	rm -f glotawk glotawk-build.awk image.awk .depend

	rm -f glotawk glotawk-build.awk image.awk heap-nomarks.dot gc-marks.dot gc-sweeps.dot heap.dot .depend

.PHONY: all depend check test clean benchmark

heap-nomarks.dot: glotawk
	echo "(dump-dot \"$@\")" | ./glotawk
gc-marks.dot gc-sweeps.dot: glotawk
	echo "(gc-dot \"gc-marks.dot\" \"gc-sweeps.dot\")" | ./glotawk -v LOG_LEVEL=3
heap.dot: glotawk heap-nomarks.dot gc-marks.dot gc-sweeps.dot
	cat heap-nomarks.dot | \
		sed -e '/^\/\*mark colors\*\/$$/r gc-marks.dot' | \
		sed -e '/^\/\*sweep colors\*\/$$/r gc-sweeps.dot' > $@
heapviz: heap.dot
	dot -Tx11 heap.dot
.PHONY: all depend check test clean benchmark heapviz