Here's a summary of most of the major dependencies in the build system. There
are lots of others, of course.  Most minor auxiliary tools (convickt, bin2c,
etc.) are left out of this, and it doesn't even attempt to track the
documentation or test system.

Most of the parts of the build system that actually ship in a distribution
tarball are stored in the "buildaux" directory; a few files (like
configure.ac) have to be in the root of the tree, so that they can tell the
user (and autoconf) where the others are.  The directories "build" and "prefix"
represent the build and installation directories respectively.

There are several major steps to the C-INTERCAL build:

* First, the build system itself has to be generated from its source files.
  The build system actually handles dependencies all the way back into the
  build system itself; if the build system source files are changed, it will
  rebuild itself.  Regenerating it is thus rarely necessary in normal
  operation; however, the build process has to start somewhere, and a file
  'regenerate-build-system.sh' will run the steps necessary to start the
  rebuild loop off.  This step thus only ever needs to be run once, and only
  if you obtained C-INTERCAL from a version control repository (the
  distribution tarballs have this step pre-performed).

* Next, the build system needs configuration for each individual machine
  ('./configure'); this has to be done in each build directory you want to
  use.

* Optionally, you can combine C-INTERCAL with add-on packages (currently only
  'cfunge', to provide Befunge-98 support). This is done in a separate stage
  before the main build.

* Then comes the main build: the source files for the compiler are compiled
  (either via a C compiler, or with each other), producing the executables and
  libraries needed for C-INTERCAL to work.

* Finally, the compiler is installed in a directory of the user's choice.

After the five steps that make up the build system, this file also lists what
compiles and interprets what at runtime, so that it is possible to chart the
entire lifecycle of a resulting binary all the way through all the compilers
involved.

Hopefully someone (maybe me) will make a nice flowchart out of this some day.
The major purpose of this is to create pretty pictures, not really for the tiny
chance it might actually be useful information.

== Building C-INTERCAL ==

=== Regenerating the build system ===
    sh interprets buildaux/regenerate-build-system.sh:
        autoreconf:
            autoconf compiles configure.ac to configure
            automake compiles buildaux/Makefile.am to buildaux/Makefile.in
            autoheader compiles configure.ac to buildaux/configh.in
            automake creates buildaux/install-sh
            [also aclocal, --install-missing, etc, but who cares...]
        [stuff that only comes up when cross-compiling]    

=== Configuring a build directory ===
    sh interprets configure:
        creates build/config.status
        sh interprets build/config.status:
            compiles buildaux/Makefile.in to build/Makefile
            compiles buildaux/configh.in to build/config.h
            compiles src/abcessh.in to build/abcess.h
            [stuff related to -F]
        [stuff that only comes up when cross-compiling]

=== Building external libraries ===
    sh interprets cftoec.sh:
        cp compiles $CFUNGE_PATH/*, etc/IFFI/* to etc/cftoec_temp/*.[ch], etc/cftoec_temp/tools/gen_fprint_list.sh
        cp compiles etc/IFFI.spec to etc/cftoec_temp/src/fingerprints/IFFI.spec
        sh interprets etc/cftoec_temp/tools/gen_fprint_list.sh compiles etc/cftoec_temp/src/fingerprints/IFFI.spec to etc/cftoec_temp/src/fingerprints.h
        [this omits the other fingerprints, but that's cfunge internal bookkeeping that C-INTERCAL doesn't care about]
        find:
            gcc compiles etc/cftoec_temp/*.[ch], etc/cftoec_temp/src/fingerprints.h to etc/cftoec_temp/*.o
        ar compiles etc/cftoec_temp/*.o to etc/libick_ecto_b98.a

=== Building C-INTERCAL ===
    make interprets build/Makefile:
        [actually this can go back to the start, because the build system can recursively rebuild itself...]
        ln compiles pit/lib/syslib.i to build/syslib.i [ditto other INTERCAL libraries]
        ln compiles src/ick-wrap.c to build/ick-wrap.c
        ln compiles src/*.h to build/*.h
        ln compiles etc/libick_ecto_b98.a to build/libick_ecto_b98.a
        bison compiles src/oil.y to build/oil-oil.c
        gcc compiles build/oil-oil.c to build/oil
        build/oil compiles src/idiotism.oil to build/oilout*.c
        gcc compiles build/oilout*.c to build/oilout*.o
        ar compiles build/oilout*.o to build/libidiot.a
        [stuff to do with character sets]
        flex compiles src/lexer.l to build/lexer.c [headers omitted]
        bison compiles src/parser.y to build/parser.c
        gcc compiles src/*.c, build/lexer.c, build/parser.c to build/*.o
        ar compiles build/*.o to build/libick.a [some of them, anyway]
        gcc:
            ld compiles build/*.o, build/libidiot.a to ick

=== Installing C-INTERCAL ===
    make interprets build/Makefile:
        sh interprets install-sh compiles build/libick.a to prefix/lib/libick.a [likewise, other libs]
        sh interprets install-sh compiles build/libick_ecto_b98.a to prefix/lib/libick_ecto_b98.a
        sh interprets install-sh compiles build/syslib.i, build/ick-wrap.c to prefix/share/ick-0.29/*
        sh interprets install-sh compiles build/ick to prefix/bin/ick
        sh interprets install-sh compiles build/*.h, build/abcess.h to prefix/include/*.h

== Using C-INTERCAL ==

=== Compiling INTERCAL with C-INTERCAL ===
    prefix/bin/ick:
        compiles program.i, prefix/share/ick-0.29/* to program.c
        gcc compiles program.c, prefix/include/*.h, prefix/lib/libick.a to program

=== Compiling INTERCAL that uses external calls with C-INTERCAL ===
    prefix/bin/ick:
        compiles program.i, prefix/share/ick-0.29/* to program.c
        cpp compiles program.c to program.cio
        cpp compiles program2.c to program2.cio [likewise]
        compiles program3.b98 to program3.cio [yep, ick does this one not cpp]
        ick compiles program.cio,program2.cio,program3.cio to *.cio ["interprocessing"/"prelinking"]
        gcc:
            compiles *.cio to /tmp/some-meaningless-name.o
            [separating compile and link here, because ick screws with linker command-line options]
            ld compiles /tmp/some-meaningless-name.o to program
