# FILENAME is a builtin variable containing the name of awk's
    # current input file

    while((AWK " -f tmpl-depends.awk -v TARGET=\"" fn "\" " fn | getline) > 0)
        print

    # When we are trying to find dependencies, image.awk may well not
    # exist, and in any case it will never @include anything; so avoid
    # a fatal error by ignoring it.
    if(fn != "image.awk")
        while((AWK " -f tmpl-depends.awk -v TARGET=\"" TARGET "\" " fn | getline) > 0)
            print

(setq mapcar                                    \
      (lambda (f a)                            \
        (label                                  \
         ((map (lambda (a r)                     \
                 (cond ((eq a nil) (nreverse r)) \
                       (true (map (cdr a)           \
                                  (cons (f (car a)) \
                                        r))))))) \
         (map a nil))))                          \

(setq mapcar (lambda (a b) (mapcar a b)))      \

# (setq mapcar                                    \
#       (lambda (f a)                            \
#         (label                                  \
#          ((map (lambda (a r)                     \
#                  (cond ((eq a nil) (nreverse r)) \
#                        (true (map (cdr a)           \
#                                   (cons (f (car a)) \
#                                         r))))))) \
#          (map a nil))))                                 

function _assoc(sym, alis) {
    logg_dbg("_assoc", "looking for " sym)
    # _car(alis) is the first pair; _caar(alis) is the name
    for(; !_is_null(alis) && _falsy(_eq(_caar(alis), sym));
        alis=_cdr(alis)) {
        logg_dbg("_assoc", "is it " _repr(_car(alis)) "?")
    }
    if(_is_null(alis)) # we did not find sym.
        return _nil()
    else {
        logg_dbg("_assoc", "found: " _car(alis) " containing " _repr(_car(alis)))
        return _car(alis)
    }
}

function _expand(form,     car, mpair, app, acc) {
    if(_truthy(_atom(form))) {
        # "atoms cannot be macro applications," LFN p.168
        return form
    } else {
        car = _car(form)
        if(car == _symbol("quote")) {
            # don't expand macros inside quote calls
            return form
        } else {
            mpair = _assoc(car, _MACROS)
            if(_is_null(mpair)) {
                # expand everything in form. don't worry, form is a
                # list (see first case).
                
                for(acc=_nil(); !_is_null(form); form=_cdr(form)) {
# TODO                    
#                    acc=_cons(acc)
                }
                return _nreverse(acc)
            } else {
                # a macro call!
                return _expand(_eval(_cons(_cadr(mpair))))
            }}}}
          

                else if(car == _symbol("mapcar"))
                    return _mapcar(_eval3(_cadr(form), env, env),
                                   _eval3(_caddr(form), env, env),
                                   env)
                else if(car == _symbol("macro"))
                    # don't eval. hope the name is a symbol!
                    return _addmacro(_cadr(form), _caddr(form))

                    # the first argument is a filename

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

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

    _MACROS = _nil()

}
function _assoc(sym, alis) {
    logg_dbg("_assoc", "looking for " sym)
    # _car(alis) is the first pair; _caar(alis) is the name
    for(; !_is_null(alis) && _falsy(_eq(_caar(alis), sym));
        alis=_cdr(alis)) {
        logg_dbg("_assoc", "is it " _repr(_car(alis)) "?")
    }
    if(_is_null(alis)) # we did not find sym.
        return _nil()
    else {
        logg_dbg("_assoc", "found: " _car(alis) " containing " _repr(_car(alis)))
        return _car(alis)
    }
}
function _addmacro(name, fun,    existing, a) {
    existing = _assoc(name, _MACROS)
    if(_is_null(existing)) {
        _MACROS = _cons(_cons(name, _cons(fun, _nil())), _MACROS)
    } else {
        # replace existing definition
        _set_cdr(existing, _cons(fun, _nil()))
    }
    return name

function _mapcar(fun, lis, env,   app, acc) {
    if(_is_null(lis)) {
        return lis
    } else {
        for(acc=_nil(); !_is_null(lis); lis = _cdr(lis)) {
            app = _cons(fun, _cons(_car(lis), _nil()))
            acc = _cons(_eval3(app, env, env), acc)
        }
        return _nreverse(acc)
    }
}
    

Run ~make~. It will build all the source into one file, ~glotawk~. You
can run that one, ~./glotawk~, and it'll show you a REPL prompt.

- When under a BSD: Run ~make depend~, then ~make~.
- When using GNU make: Just run ~make~.
It will build all the source into one file, ~glotawk~, and run the
tests. Then you can run that file, ~./glotawk~, and it'll show you a
REPL prompt.

AWK = awk

AWK = original-awk

all: depend glotawk check

all: glotawk check
depend: .depend
	:

depend:
	rm -f .depend

.depend:

	if ./sane_lisp; then echo --pass--; else echo --FAIL--; fi

	./sane_lisp; x=$$?; if [ $$x -eq 0 ]; then echo --pass--; else echo --FAIL--; fi; return $$x

	rm -f glotawk glotawk-build.awk .depend

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

.MAKE: .depend

# SPDX-License-Identifier: BSD-2-Clause
include Makefile
GNUmakefile: .depend
-include .depend