 0.01 - This alpha version was rushed out of the doors because of I promised
	to release the compiler "first thing on April 1st 1999" - I released
	it at 1.01am BST (aka 0.01 GMT) on April 1st, so that does count
	as "first thing". There are six known bugs^H^H^H^H restrictions:

	1. Double-oh-seven is not supported (that's actually rather easy to
	   add, but it would have required five extra minutes and we had this
	   "first thing" deadline)
	2. The parser does not quite work with some of the compound gerunds
	   (READING OUT, WRITING IN  and COMING FROM - use READING, WRITING
	   and COMING for just now).
	3. It is possible to ABSTAIN FROM GIVING UP and REINSTATE GIVING UP
	   (both by gerund and by label). If you need a definite no-op,
	   use DO NOTHING or perhaps DON'T PANIC.
	4. Neither of the random compiler bugs has been implemented.
	5. We forgot to include this file in the distribution.
	6. The runtime does not check for array bounds when accessing
	   subscripts.

 0.02 - Fixed all bugs listed above:

	1. Double-oh-seven is now supported (and there's a test program to
	   test it).
	2. The parser has been changed to recognise compound gerunds with
	   or without the suffix (so you can write READING or READING OUT
	   and they both work). While doing this we found a bug - RESUMING
	   happened to be written RESUING in the parser's tables. Fixed.
	3. The runtime now refuses to alter the ABSTAIN status of a GIVE UP,
	   so this bug is also fixed.
	4. The reqired bugs have been added. The compiler will always add one
	   bug to each program. At runtime, the bug will be executed with
	   probability 5% (this can be reduced to 0%). However, whenever the
	   bug is skipped there is a 0.005% probability that it will
	   mysteriously executed anyway.
	5. If you are reading this, this bug must have been fixed.
	6. The runtime does now.

      - Added subscript checks for all array access (wasn't there before)
        (pity, it allowed the Turing Machine program to dynamically reallocate
	the tape array. Oh well)

      - Added some more test scripts

      - Fixed one bug in the unary operators, which shifted instead of
	rotating right their operand.

      - Documented the undocumented (and renamed it to "formerly undocumented")
	compiler directives

      - Added support for different compiler back ends, the default being the
	Perl back end (compile into a Perl subroutine). A C back end might
	be made available at some point (compile into a C program), as well
	as a PerlMod back end (create a Perl module).

      - Added support for a (not yet written) optimiser.

      - Added a standalone (command-line) compiler, 'oo, ick' (with embedded
	space and comma).

      - Changed the precedence rules in the parser to make it compatible
	with C-INTERCAL. This was not a bug as the specification is vague
	enough that almost anything is correct, but it makes it easier to
	adapt C-INTERCAL programs if they follow the same rules.

 0.03 - Added a mechanism to help using separate compilation units -- although
	they must arrive all together at the back ends. At execution time,
	they all run in sequence in the order they were linked, when one GIVEs
	UP the next one starts. The command-line compiler, 'oo, ick', now
	automatically links together all programs and parse trees it sees on
	the command line, in the order it sees them.
 
       Slightly changed the semantics of BELONGS TO when one register belongs
	to more than one other register. This was never documented anyway, as
	the documentation only says "this is confusing but not an error". Now
	the most recent buyer is the main owner.

      - Provided a new back end to the compiler, 'PerlText', which saves the
	perl code to a file instead of compiling it on the fly. It takes one
	argument, the name of the file to create. The command-line compiler,
	'oo, ick' defaults to create program.pl if the source is program.i
	or program.ipt and this back end is selected.

      - Written a bit of the optimiser:
	* Constant folding in all expressions.
	* Removes any ABSTAIN / REINSTATE statement which is always executed
	  (i.e. from the start of the program to the first COME FROM or label
	  which is referenced by a NEXT or STUDY), replacing the DO / DON'T
	  as appropriate.
	* Converts any computed COME FROM for which the label can be guessed
	  at compile time to a normal COME FROM.

	Added placeholders for other optimisations.
	
	Added new test programs to make sure that a program and its optimised
	version do actually produce the same results.

      - Fixed a problem with COME FROM which had a probability assigned,
	but were nevertheless always executed. Now they are treated like
	computed COME FROMs and evaluated at runtime for their probability.

      - Rewritten the parser to just mark with a splat anything with syntax
	errors, instead of barfing. This is required by the language specs.
	To help the programmer, the splat is followed by an error code, which
	is documented somewhere. As I was there, I've enhanced the readability
	of the parser itself by splitting it into subroutines and removing
	three of the four large regular expressions, and reducing the fourth
	one from fiftyeight (58) lines to a manageable fiftyone (51).

	After all, this isn't the April 1st release any more...

 0.04 - Noticed that the input routine did not accept OH for ZERO and NINER
	for NINE - fixed. Also some other minor bugs hunted and squashed.

      - Allowed nonconstant probabilities (DO %.1 .1 <- #1). Thanks to
	Adam J. Thornton for this valuable suggestion (the responsibility
	for actually doing this instead of taking it as a joke is all mine).
	Changed the test program t/33-double-oh-seven.t to test for this
	(it's now been renamed t/33-007.t for no reason).

      - Changed function _roman in Language::INTERCAL::PerlRuntime to
	correspons more closely to the behaviour of INTERCAL-72.

      - Added rules for Quantum INTERCAL in the parser (see reference manual)
	and added emulation of quantum computers on multithreaded systems in
	the "Perl" and "PerlText" back ends (see reference manual for this too).

      - Completely rewritten runtime library to allow for easier
	interoperability of quantum and non-quantum programs.

 0.05 - Completely rewritten the parser, removing all the huge regular
	expressions. This is *definitely* not the April 1st release anymore.
	Also, changed (and extended) the format of the parse tree.
	Moved the parser to a separate module,
	Language::INTERCAL::Parser::CLCintercal;
	two other parsers can be optionally used:
	Language::INTERCAL::Parser::Cintercal, which attempts to be
	compatible with C-INTERCAL, and
	Language::INTERCAL::Parser::ThreadedINTERCAL, which attempts
	to be compatible with 'thick'.

	The new parser now works on ASCII source code. The input character
	set, however, can be any installed character set (the compiler ships
	with modules for extended Baudot and modified EBCDIC), and the compiler
	will guess the character set to use for each source file.

	The new parser uses the same production for "label" in COME FROM,
	ABSTAIN FROM, REINSTATE, STUDY, and NEXT (deprecated), so now
	all these statements can have computed labels.

	Another difference with the old parser is that the class name
	in STUDY does not need to be constant, it could be a register
	expression which is resolved at runtime. Also, the subject numbers
	in STUDY, ENROL, and LEARN can now be expressions instead of
	constants.

	Extended all test program to make absolutely sure that the new
	parser is compatible with its documentation (there's a novel idea!)

	Rewritten the quantum emulator and extended the test suite so
	every non-quantum test now also runs under the quantum emulator
	and their results are compared.

	Added two new statements, collectively known as "The C-unlike
	postprocessor directives". See the reference manual. Added yet
	more test programs, to make sure that the postprocessor does not
	change the behaviour of anything unless it is explicitely used,
	and of course to test the new statements, CONVERT and SWAP. There
	was discussion for a third postprocessor directive, CREATE, which
	has not yet been implemented.

	Allowed ABSTAIN and REINSTATE to use a statement template instead
	of a gerund. See the reference manual.

	Rewritten the optimiser, which is now divided in two parts:
	optimisations which can be done on separate programs (done
	as soon as possible after parsing), and optimisations which
	require to see the whole program (done after linking). Moved
	the optimiser to a separate module. This change is a preparation
	for the new, improved, optimiser I keep talking about. The new
	optimiser is in Language::INTERCAL::Optimiser.

	Updated the two standard back ends to understand the new parse
	tree format and the new statements. Moved them to
	Language::INTERCAL::Backend::<name>

	Fixed a problem with ascii2baudot (in Charset::Baudot), which would
	in some rare cases generate incorrect shift values. Also added
	backslat to the EBCDIC character set (RFC1345 does not list backslat
	or backslash anywhere, so I just selected a random code)

	Altered the way 'oo, ick' and the runtime handle input/output
	when non-default character sets are used.

	Allowed 'oo, ick' to pass parameters to back ends -- use the
	form "-l backend=parameter,parameter"

	Added a operand overloading in a slightly different form than
	the one proposed for C-INTERCAL. The operators are the same,
	however, when overloading a range of registers, the register
	being overloaded will be accessible as $@0 (in other words, @0
	will be enslaved to the overloaded register). In case of nested
	overloading, one can also have 2@0, 3@0, etc.

	Allowed (unlike the proposal, but like the C-INTERCAL implementation)
	to assign to overloaded registers. Unlike the C-INTERCAL overload,
	we allow to assign to any expression, if it is possible to invert
	it. For example, if .1 is overloaded with .2~.3, then assigning
	a value to .1 will actually assign two values, one to .2 and one
	to .3 (.1 will remain unchanged). The two values are such that
	evaluating .2~.3 returns the original value. If the equation is not
	solvable, you get a runtime error.

	Added two new constructs which can be replace the wane used by
	C-INTERCAL's overloading. The worm returns the number of a register,
	for example -.1 would be the same as #1, and -$@0 would be the number
	of the register being overloaded. This must not be confused with the
	bookworm (V backspace -), which might get printed the same as the
	worm on VDUs. The intersection-worm builds an indirect register given
	two registers: it takes the type of the first, and the number of
	the second. For example +:6-.5 is the same as :5

	Added another threading construct, "DO STATEMENT1 WHILE STATEMENT2",
	which will keep repeating STATEMENT2 while STATEMENT1 is running.
	Also, "DO EXPRESSION WHILE STATEMENT" will run STATEMENT as soon
	as EXPRESSION becomes meaningful. It is possible to swap the
	"condition" and "body" of the WHILE using the new SWAP operator.

	Added a new variable, "*", which returns the code of the last error.
	It is an error to use it if there hasn't been an error. Of course,
	since all errors cause program termination, this is only useful to
	check whether a different thread died.

	Added support for non-English numerals. This should have been there
	five releases ago... In addition to the ones supported by INTERCAL-72
	and C-INTERCAL, I've added support for Scottish Gaelic, and might
	provide support for other popular languages in a future version.

	Fixed a bug in the runtime which caused binary I/O to work only
	when used from within the compiler, not when producing standalone
	programs.

	Fixed a problem with one of the example programs (eg/factor) which
	would not terminate in some cases (given that it runs like a fork
	bomb, I had never found that out with the old Quantum Emulator).
	Added another example program, a handy RPN calculator in INTERCAL.

