First of all, have you noticed that CLC-INTERCAL is now a significant fraction
of the size of egcs, or perl? Must be doing something wrong, compilers should
always be small enough to fit in one page [well, iacc.iacc *does* fit in one
A4 page, and with a relatively readable 4 point font too]

The following files are intended to be in the distribution but have not
been included in this pre-escape:

    Language/INTERCAL.pm (no longer needed, but useful for compatibility)
    bin/oo,\ ick (ditto -- use bin/sick)
    Language/INTERCAL.pod (the documentation -- but see doc/html)
    Language/INTERCAL/Interface/Line.pm
    Language/INTERCAL/Backend/Uncompile.pm - attempt to get INTERCAL source
	by any means possible: if the object has some source code, it is
	extracted; any compiled code without a source is disassembled.
    doc/html/* -- the documentation has been updated but not quite proofread
    doc/intercal-manual.pod
    doc/intercal-tutorial.pod
    doc/sickrc.pod -- read the comments in Include/system.sickrc instead
    examples/computed-labels.li (try "(.1) DO .1 <- #1 ... PLEASE COME FROM (1)")
    examples/next-from.i (if you never used NEXT FROM do it now!)
    examples/quantum/next-from.i
    more examples/*.i
    some of the test scripts (which will say "Skipped: not implemented"
	or words to that effect during "make test"); also, some of the
	ones provided could do with more tests

The following problem afflict the current release:

    The sick compiler is rather slow. This is due to the lack of optimisation
	when generating a parser from a grammar, and I plan to do something
	about it one of these years. Some source programs suffer more than other.
	For example, the horrible computed COME FROMs in examples/hello.i are
	particularly bad.

The following functionality is missing:

    The documentation is not currently installed by "make install"
    Politesse checking
    The user interfaces work with intercalc but are not yet powerful enough
	for use with sick - but see the next point as well.
    Executing a "WRITE IN" statement in intercalc only works when operating
	in batch mode; with an interactive interface it always returns an
	end of file condition because the interfaces don't yet have text
	input dialogs (the calculator's command line is implemented in
	a rather different way).
    Intercalc defaults to --language=ick rather than --language=sick as one
	would expect. The "sick" functionality is present, but at the moment
	is very slow - I know how to fix that, but I haven't had time to do it.
	On the other hand, using "intercalc -msick --batch" is a useful way to
	have an INTERCAL interpreter which does not suffer from the slowness
	of intercalc with an interactive user interface.
    The optimiser (optimise.iacc is provided, empty, as a placeholder)
	Additionally, "iacc.iacc" (and "iacc.io") do not currently provide
	syntax to create optimisers (you can, of course, use "INTERNAL")
    Interface-specific configuration in sickrc
    The system call interface is provided, but only codes #0 (NOP), #1
	(return version of CLC-INTERCAL), #2 (return name of compiler) and
	#3 (open file) work. And the interface to system call #3 is currently
	undocumented, but see examples/syscall3.si (note that t/21syscall.t
	does not test for syscall#3 yet)
    The Curses interface requires some sort of scrollbars. It works fine if
	the top window fits in the screen, but makes a mess if it doesn't.
	In a standard 80x25 terminal this means: oic yes, anything else no.
    The compiler could be made to do a lot more work at compile time, leaving
	less for the runtime. For example, if a program contains CREATE
	statements, it is possible to avoid recompilation at runtime in most 
	cases, by recompiling the program with the extended grammar but
	recording that the new rules introduced are not enabled. See function
	find_code in Language::INTERCAL::Object to see why this would work.
	Maybe this could be enabled only if optimisation is requested.
    Related to the previous point, the compiler compiler just stores the list
	of CREATE statements necessary to recreate the compiler when a user
	program is compiled. This could be improved by running the code
	generated by the compiler compiler and storing the completed grammar.
	This should greatly reduce the compile time.

