Brand new approach
.
Strengthen assertion in buf.c
Parse lambda expressions.  Add the query combinator.
Don't bother expanding combine inline in type_query.
I did that to avoid the extra hold and drop on x, but that's just silly.
Keep it clear.
Wrote the "resolve" function which resolves any symbols in a form with a given
context.

Change symbol structure so we don't have to copy the name if it's a literal
string (line < 0).

Use -Wl,--gc-sections to prune any unused code.  For example, str_common is a
potentially useful routine but it's not actually used yet.
Fully automated build script.
The build script now updates caches in the most intelligent way possible.

You can rename, move, or delete a source file, or even change a source file
to a main program or vice-versa, and the build script tracks it perfectly,
exactly as if it were not caching at all.

This extra power actually shortened and simplified the build script.

I also simplified the clean script.
New "options" file provides a way to link to external objects in build script.
Add the bracketed list syntax to parse.c.
Fixed the combine routine to hold the result before dropping the operands, and
added a test for it.

Changed the resolve routine to make it responsible for holding and dropping f.
I did this because I could create a case where the symbol x went on the free
list before calling context on it.  By holding f itself, the symbol x is
guaranteed to stay live because it's a child of f.  Also, the resolve routine
can now call "abstract" directly instead of "lam".

Changed the erase routine in the build script so that it stops when the first
rmdir fails.  The old behavior of going all the way up the path was harmless,
but the new behavior is more efficient and also makes the code smaller.
Rename type.* to base.*.
Go back to the original way of implementing type functions, with a single
argument.  It's much cleaner and simpler.
Optimized combinators by using eager "apply".

This avoids creating extra A-forms and running extra eval cycles.  Also note
how type_A becomes a one-line function which just calls apply.

I also eliminated one optimization in parse.c.  Formerly if you said
"\x=def body", it would optimize that to simply "body", because the def is not
used.  However we really shouldn't do that because if def has any undefined
symbols, we want those reported as errors.  In many cases when coding we start
off with definitions that aren't yet used, and we definitely want those to be
checked.
Made a fexl executable.

Added parsing of symbolic forms enclosed in braces.

Simplified the show routine and how it can be extended.

Added many extensive tests, including syntax errors, undefined symbols, and
pathological run-time behavior such as exceeding limits on time, memory, and
stack.

Renamed "atom_" routines to "get_".

Include directives now alphabetized, except where something needs to be pulled
ahead of the others.

Eliminated separate "atom" routine.  It's just clearer to use the V-form
directly.

Added type_long.
Merging in all the pieces from previous versions.
Enabled more pieces from previous versions.
Defined setrlimit and the RLIMIT constants in Fexl.

Eliminated fexl.h and moved those declarations to system.h.  We don't want to
have a .h file which corresponds to a main .c program because if you include
that .h file from a different main program, the build system would link in the
.o and give you multiple definitions of "main".

Enhanced the build script to notice when a cache/o entry is older than any of
the .o files it contains.
Made Fexl highly portable and lean (under 32K now).

Added full-fledged arithmetic and comparison operators.

New values are created with reference count 1 instead of 0, which gives the
code some reassuring properties when returning a value that is under another
value.

Removed the free list.  Unused values are completely freed now.

Eliminated the use of printf and stdarg.

The new approach in Fexl is *not* to make the raw machine details visible to
the Fexl programmer, but rather to insulate the programmer from such details.
"Don't master complexity, avoid it."