/^@shebang/ {
    awk_executable = "/usr/bin/original-awk"

BEGIN {
    AWK = "/usr/bin/original-awk"

        awk_executable = "/usr/bin/awk"

        AWK = "/usr/bin/awk"

        # not recognize this switch.
        if(0 == system(awk_executable " -c " trivial_program no_output)) {

        # not recognize this switch, and will exit with an error when
        # it is provided.
        if(0 == system(AWK " -c " trivial_program no_output)) {

    print "#!" awk_executable awk_switches

}
/^@target/ {
    next
}
/^@shebang/ {
    print "#!" AWK awk_switches

    while((getline < fn) > 0)

    while((AWK " -f tmpl.awk " fn | getline) > 0)

BEGIN {
    if(!AWK)
        AWK = "awk"
}
/^@shebang/ {}
/^@target/ {
    TARGET = $2
    print TARGET " : tmpl.awk " FILENAME
}
/^@include/ {
    fn = $2
    print TARGET " : " fn
    while((AWK " -f tmpl-depends.awk -v TARGET=\"" fn "\" " fn | getline) > 0)
        print
    next
}

    # make definition searches happen in the order the definitions are
    # written above
    _GLOBALS = _nreverse(_GLOBALS)

@include logging.awk
@include data.awk
@include eval.awk
@include reader.awk
@include printer.awk
@include repl.awk
@include gc.awk
@include dump.awk
#@include image.awk
#@include lib.awk

@target glotawk
@include glotawk-common.awk
# When we build image.awk, this include is replaced with lib-eval.awk;
# see Makefile
@include image.awk

@include logging.awk
@include data.awk
@include eval.awk
@include reader.awk
@include printer.awk
@include repl.awk
@include gc.awk
@include dump.awk

@shebang
# -*- coding: utf-8-unix; mode: awk; -*-
@target glotawk-build.awk
@include glotawk-common.awk
@include lib-eval.awk

Like perhaps any Lisp, the build process for glotawk is slightly
convoluted.
First, the code is split into several AWK files, but for ease of
execution, glotawk should be a single file. This is why tmpl.awk was
first made, and supports @include directives.
Second, the built glotawk file should be executable, and should run
with the correct awk implementation; thence the @shebang directive.
There are many special forms; these are only treated specially when
they occur in operator position. To use them as higher-order
functions, they must be bound as values. The most concise and
maintainable way to do this is to write trivial definitions in glotawk
Lisp (lib-eval.awk); but that makes startup time unbearably slow. So
dump.awk supports dumping the AWK data structures that are built up
when things are defined, out to (inscrutable) AWK code that directly
(and quickly) reconstitutes them. We construct glotawk-build.awk
including that slow code, then dump an image using ~(dump
"image.awk")~, then build the glotawk intended to be run including
that image rather than lib-eval.awk. The two are quite similar, and
will need to remain so through many changes yet to come; and this is
why the multi-level includes and glotawk-common.awk were added.
Finally, when any source file is changed, the things that should be
built are the things that included it, but the means of inclusion is
tmpl.awk, of my own devising; therefore the means of turning those
includes into statements to make of dependencies must also be of my
own devising. And that's why the @target directive exists, and the
reason for tmpl-depends.awk. This constructs a .depends file which
make reads.

AWK = awk
all: depend glotawk check
depend:
	rm -f .depend
	awk -f tmpl-depends.awk *.tmpl.awk > .depend
glotawk-build.awk:
	$(AWK) -f tmpl.awk glotawk-build.tmpl.awk > $@

all: glotawk

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

INCLUDES != grep '^@include' glotawk.tmpl.awk | awk '{print $$2}'
glotawk: tmpl.awk glotawk.tmpl.awk $(INCLUDES)
	awk -f tmpl.awk glotawk.tmpl.awk > $@

glotawk: glotawk-build.awk
	$(AWK) -f tmpl.awk glotawk-run.tmpl.awk > $@

	rm -f glotawk

	rm -f glotawk glotawk-build.awk .depend

.PHONY: all check test clean

.PHONY: all depend check test clean

image.awk
.depend
glotawk-build.awk