This is the long-form history of the project.  For the short form used
to generate release announcements, see NEWS.

== Release 0.31 (by Eric S. Raymond) 12 Jun 2019 ==

1. Added flex-2.6.3 compatibility fix by Nicholas Vinson <nvinson234@gmail.com>

2. Added guess/i documentation by Brendan Gregg <bgregg@netflix.com>

3. Project is now hosted at GitLab.

== Release 0.30 (by Alex Smith, Eric S. Raymond) 2 Apr 2015 ==

=== Changes by Eric S. Raymond ===

1.  Typo and formatting fixes to THEORY.txt.

=== Changes by Mark J. Reed, Alex Smith ===

2.  Build system fixes required by recent versions of autoconf, which is
    in randomness and ugliness and propensity to mutate a perfect match
    for INTERCAL.

=== Changes by Alex Smith ===

3.  Some potential undefined behaviour (which happens to do the right
    thing on every compiler tested) related to the -g option has been
    fixed.  (Thanks to Michael Tautschnig for reporting the bug.)

4.  Document how the build system works.  (That is, how everything fits
    together, as opposed to the individual files.)

5.  Fixes for two nasty dependency issues to do with testing. One issue
    was that the tests could potentially be run against an old version
    of the compiler (they now ensure the compiler is up-to-date); the
    other was that tests on a non-installed compiler could potentially
    use library files from an installed version, which might not
    necessarily be the same version of the compiler and might not
    contain the same bugfixes.

6.  C-INTERCAL now understands C11 in the external calls system, the
    same way that it understands C89 and C99. This gives us a gap of
    (2011-1972 = 39) years between languages standards simultaneously
    supported by the same compiler. Anyone know if this is a record?

7.  Most of the tests in the pit are run by a common framework.
    However, one of the tests is different; yapp's test involves
    another call to ick to make sure that the output is correct
    INTERCAL that produces the correct output. Guess what happened.
    This change fixes it. (Hint if you're still guessing: what needs
    to be done to make an INTERCAL program with no double-oh-sevens
    run in a reproducible way, as might be required by an automated
    testsuite?)

8.  Fixed a typo in the definition of the "smudgeleft" and "smudgeright"
    helper functions. This might theoretically have lead to code being
    misoptimized, although I don't know of any specific situation in which
    that would occur.

== Release 0.29 (by Alex Smith, Eric S. Raymond) 29 Nov 2010 ==

=== Changes by Eric S. Raymond ===

1.  There is now a compiler regression-test suite, invoked through the test
    production in the pit makefile.

2.  There are two new compiler error messages, E990 and E994.

3.  A new program for the pit: Brendan Gregg's guess game.

4.  The floating-point library is now automatically included if
    a program NEXTs to labels in the range 5000-5999.  Internally,
    line-range to system library mappings are no longer hardcoded but
    rather declared as an array of associations that can be easily
    modified.

5.  The source now uses explicit bool, rather than using int everywhere.

6.  README, HISTORY, and BUGS are now mastered in asciidoc for easier
    web-page generation.

7.  The history of the hitherto-mysterious "Atari implementation" is now
    documented.

=== Bugs reported and changes patched by Arvid Norlander ===

8.  Fixed a typo in the perpet.c version of the help information.

9.  Fixed the CREATE statement to work on 64-bit architectures.

10. The availability of variable argument list mechanisms is now determined
    automatically by the configure script, rather than relying on the old
    method of checking which usually gets the wrong answer with modern
    compilers, leading to build failures on many modern systems (previously
    this was patched just for DJGPP, the patch now applies to all operating
    systems and platforms). This bug is known to have affected the build on
    DOS, FreeBSD and Mac OS X, and possibly affects other platforms. (also
    reported independently by Elliott Hird)

11. Fixed some nonsense in the -@ help screen that was generated by an errant
    search-and-replace.

12. Made several changes to bring the new Befunge-98 interface code (see
    below) in line with changes in the Befunge-98 interpreter in use.

13. Added consts and statics in the code, hopefully to make bugs easier to
    notice.

14. Refactored main(). It needed it, badly.

=== Bugs reported by Elliott Hird ===

15. Fixed the configure script to work with the default Debian shell dash.
    (also reported independently by Debian)

16. Actually fixed unlambda.i; the fix was meant to be in 0.28, and is
    described in its changelog, but for some reason never made it to
    the distributed tarball.

17. The -F option again works. (AIS: I accidentally broke it in the preceding
    version, making it basically a no-op by mistake.)

18. The build now succeeds (with warnings) when lex or yacc are missing,
    rather than failing with mysterious error messages that seem to have
    nothing to do with the problems. (The success is made possible by using
    the prebuilt versions; see change 11 of version 0.26, this is finishing
    what that started.)

=== Bugs reported, changes requested, and patches by Joris Huizer ===

19. The [xoritself] optimiser idiom has been generalised to handle some
    situations where the redundant XOR operands are on different grouping
    levels; this helps to optimise some heavily inlined greater-than tests.

20. Fixed unary operators applied to constants (AIS: it seems that my patch to
    solve this issue earlier was itself buggy).

21. The -g option now causes optimisation of the output compiled C to be
    turned off, and adds comments to the output file the same way -c does.

22. Added more optimiser idioms: [cxorand16], [cxorand32], [cfoldintoorinand],
    [or16and], [xor16and], [lshift32half], [rshiftoutofneg], [andoutofneg];
    also generalised the idiom-matching code to compare 16-bit and 32-bit
    constants as equal if they have the same value, and fixed some typos in
    the current 16-bit complement idioms.

23. ABSTAINING or REINSTATING are now a lot more efficient, taking an amount
    of time proportional to the number of commands effected, rather than the
    number of commands in the program. (AIS: I implemented this with the
    algorithm in the patch Joris provided, but with different code, to make it
    easier to maintain.)

=== Changes by Stefan O'Rear ===

24. Added INTERCAL syntax highlighting information for vim. Why should Emacs
    have all the fun?

=== Changes reported by Phantom Hoover ===

25. Fixed a nasty documentation typo.

=== Changes reported by the Debian autobuilders and Joey Hess ===

26. The build of the optimiser idioms is now split over many files, to reduce
    the memory usage of gcc when it tries to compile the giant output C file.
    This was a problem on ia64. (The ulimit method of preventing thrashing has
    been removed, as this method works better; likewise, the optimiser
    optimisation now works again.)

=== Changes by Alex Smith ===

27. The build system has been completely redone, again; it now uses automake
    as well as a much newer version of autoconf. This means that there is now
    one build system that works the same way on all systems, and that all
    sorts of clever tricks like out-of-tree builds, a self-rebuilding build
    system, and building the distribution directly from the Makefile, are
    possible. As a side effect, the directory structure looks somewhat
    different to how it looked in previous versions; src, doc, etc and pit are
    still there, but now there's prebuilt instead of temp, an extra directory
    buildaux, and bin, lib and include have disappeared.

28. The distribution now comes in compressed pax format. (Before anyone
    complains that they have no idea what that is, or that I'm using something
    strange and nonstandard, I'd like to point out that tar is no longer part
    of POSIX, but that pax is. (See man 5 tar on a recent Linux system for
    details of the whole mess.)  Luckily, pax is forward-compatible with tar
    so tar readers should be able to read it just fine, if you can't get your
    hands on a pax reader.)

29. convickt can now produce its output as INTERCAL initialisation of a tail
    array. (This doesn't auto-offset between the different characters; it is
    therefore mostly useful for producing Baudot arrays for CLC-INTERCAL-style
    IO.)

30. The function clock_gettime is now supported by the yuk profiler as an
    alternative method of getting a high-resolution clock for profiling (it
    is available on at least Linux).

31. The profiler now autodetects the same profiling mechanism at compile
    time and at run time. (It was getting confused as to what mechanism it was
    using, causing some really weird bugs.)

32. Added support for computed CREATE (the computation is done at create-time,
    rather than when the unknown statement is encountered); partly because
    this was rather easy, but mostly because it can be used to simulate a
    computed NEXT, thus making the example expansion library compunex (which I
    forgot to mention in the 0.28 release notes) redundant. Because it was
    deprecated when I added it, compunex is now doubly deprecated, and anyone
    tempted to use it should use computed CREATE instead. (I have always
    maintained that if computed NEXT were ever added to C-INTERCAL, it would
    be deprecated on arrival; the computed CREATE method implements all
    features of NEXT, anyway, rather than the small subset COMPUNEX could
    manage.)

33. Plugged a couple of small memory leaks; however, there are still several
    much bigger memory leaks that could do with being fixed.

34. Added support for CREATING operators, with similar syntax to the CREATION
    of commands.  This requires the -ea options to be set to work properly.

35. More file extensions are now supported by the external calls system. The
    .c99 extension indicates a C99 (rather than C89) file; all .c99 files are
    preprocessed as C99, and if any C99 files are used the final compilation
    which compiles and links everything will be done as C99 rather than C89
    (this causes no problems for C-INTERCAL's output which is both legal C89
    and legal C99). Also, libraries can be linked in; to link in the maths
    library for instance (i.e. pass -lm to gcc), write libm.a as a filename at
    the end of the command line. (The file's real name is libm.a; if a
    filename is in lib*.a format, then ick will look in the normal library
    locations instead of the current directory.) Other .a files can be linked
    in from the current directory.

36. Fixed the handling of division by zero in the syslibc expansion library.
    (The Revamped Manual states 'In all cases, division by 0 returns 0'.)

37. Made several changes to the documentation, including fixes for some rather
    nasty typos (two of the worst were specifying variables as IGNORED by
    default, and stating that select acts like OR in TriIntercal!).

38. Fixed a bug in the external calls system that made it impossible to write
    a COME FROM in more than one file at a time whilst still having the
    resulting program work reliably.

39. Added support for external calls to Befunge-98 programs; however, this
    distribution does not ship with a Funge-98 interpreter, so in order to use
    this feature you will first have to compile a Funge-98 interpreter into a
    library for use with C-INTERCAL (see README.txt or the Revamped Manual for
    information on this). Also added a test program for this to the pit.

40. Fixed some bugs in the go-away command in interfunge.i.

41. Fixed many bugs in the optimiser, and added a fuzz-tester ("make fuzz") for
    the optimiser which has a chance at finding any new optimiser bugs that may
    be introduced, or any that the maintainers don't know about.

== Release 0.28 (by Alex Smith) 1 Apr 2008 ==

=== Patches, suggestions and bugs found by Joris Huizer ===

1.  Fixed a typo in the [noopxor] optimiser idiom.

2.  Added a [redundantdoublenot] optimiser idiom (a generalisation of Joris'
    suggestion of and code for [triplenot]).

3.  Fixed a typo that caused the flow optimiser to optimise some errors into
    non-erroring code.

4.  Fixed the [lshift16] optimiser idiom; previously it was giving incorrect
    values in some cases where the bits being selected from the original
    number weren't contiguous.

5.  There is now no longer a segfault when the unusual option combination -f
    (without specifying -O) is used.

6.  It is again possible to recompile more than one source file at a time.

7.  The flow optimiser now recognises that comments can be reinstated in
    programs where they can be reinstated.

=== Changes by Alex Smith ===

8.  Fixed some typos in the documentation.

9.  Applying an infix unary operator to a constant (as in &#26) now returns
    the correct value; previously it returned the unary operator applied to a
    sequence number that was 0 for the first unique constant that was the
    argument of a unary operator, 1 for the second unique constant, and so
    on. (This was a bug in the parser.)

10. Added doc/THEORY.txt back in. (It seems that it went missing some time
    between 1.26 and 0.27.) Updated it to describe the current compiler.

11. Turned off optimisation of the optimiser, and also placed a 128MB limit on
    the data segment and virtual memory it was allowed to use. This is to
    prevent Linux thrashing and/or invoking the dreaded oom-killer when
    recompiling idiotism.c. (This happened only rarely, but it happened to me
    twice, each time making my computer unusable for about half an hour.
    Therefore, a fix to prevent the situation happening again was added,
    assuming your computer has at least 128MB free memory and disk space.) As
    a bonus, the build process is now considerably faster, because the
    optimisation of the optimiser was the slowest step of the process.

12. Internally, all symbols that are visible globally are now name-mangled (by
    using the prefix ick_). This allows other files to be linked with files
    compiled from INTERCAL without namespace collisions. This does not include
    symbols that are only useful in multithreading (as INTERCAL's
    multithreading model is incompatible with other programs), only for the
    debugger (because linking yuk into a program causes all sorts of chaos if
    non-INTERCAL programs are involved), or only used by the compiler (which
    hopefully should never be linked to another program that isn't
    specifically designed to be linked to it).

13. Thoroughly delinted the code, using Splint; the code is now annotated to
    show Splint what is being done where (and all the non-obvious annotations
    are explained so that humans can figure out what is going on as well);
    over 800 warnings have been fixed, including some which identified bugs in
    the original program (many of which were to do with edge cases involving
    unusually long strings, and some of which were buffer overflows). All
    comments from /*@ to @*/ are mine, and are annotations for Splint.

14. Implemented external calls, which allow multiple INTERCAL programs to be
    linked to each other, and/or to C programs, via the -e option and NEXT /
    COME FROM / NEXT FROM / FORGET / RESUME statements. See the manual for
    more details. (Note that external calls require you to use gcc, GNU cpp,
    and GNU ld, because they rely on features of those programs to work.)

15. Two other new compiler options have been added: -E (don't link system
    library), and -w (enable +printflow debugging even for non-multithread
    programs). +printflow has been enhanced to show what's going on in
    externally-called programs to some extent, too.

16. Added a version of the INTERCAL system library written in C, as
    pit/lib/syslibc.c. A new compiler feature allows the inclusion of such
    expansion libraries via the command line; to include this library, you
    would write the command line as ick -eE yourprogram.i syslibc (possibly
    adding other options than -eE). The main advantage of the C-based system
    library is speed; also, note that an implemented-in-a-faster-language-
    than-INTERCAL system library existed in the Princeton compiler (which is
    possibly how the INTERCAL version managed to stay buggy for decades
    without anyone noticing), so this is another case of catching up with
    historically available features. (The feature is also somewhat reminicent
    of CLC-INTERCAL's 'preloads', but is implemented differently, and is
    useful for different things, as it doesn't affect the compiler.)
    Expansion libraries are included via -e, like non-INTERCAL programs are,
    but are distinguished by not having an extension.

17. The handling of syntax errors has been improved; many lines that
    previously caused E017 at compile time are now correctly interpreted as
    run-time errors. The only way to cause E017 nowadays is to write a
    constant out of the onespot range, and the manual description of the error
    has been changed accordingly. (Note that I caused several regressions
    while implementing this; I hope they're all fixed now, but there may be
    some left. Please report any remaining parsing problems caused by this;
    they mostly manifest as either the line after a comment being corrupted or
    ignored, or as the line before a comment being taken to be part of the
    comment.)

18. A new 'just-in-case' compilation method is used for syntax errors. If a
    syntax error is encountered at compile-time, and contains just capital
    letters with no other meaning (i.e. they don't form keywords and none of
    them is the letter V), variables, and expressions, and there are no two
    consecutive expressions or variables involved (i.e. they are separated by
    keywords), the compiler will compile it anyway, just in case it happens to
    gain a meaning later (see the next changelog entry). This is sort of the
    converse of the way CLC-INTERCAL goes about compiling things that don't
    have a meaning yet (it uses a 'just-too-late' compiler which waits for the
    offending statement to error out, then recompiles it to see if it's gained
    a meaning in the meantime), and this difference in handling typifies the
    difference between the compilers quite well.

19. Implemented the CREATE statement, because I could (see point 18). This
    allows new syntax to be created at runtime. CLC-INTERCAL also has a CREATE
    statement, but its syntax is totally different (it specifies the bytecode
    for the command, whereas C-INTERCAL's CREATE statement allows you to
    specify what the new command does in INTERCAL itself.)  A function call
    ick_create is also available; it's usable from externally-called programs
    and from expansion libraries, and means that INTERCAL commands can now be
    defined to do things which were previously well out of INTERCAL's
    reach. This makes expansion libraries act even more like CLC-INTERCAL
    preloads.

20. Fixed a strange bug in yuk when the basename of the INTERCAL program was
    the same as that of a shell builtin or command on the user's path.

21. Programs accept a new option +instapipe that causes output to be output
    immediately, even if not followed by a newline, by flushing the output
    after every character. This is most useful with binary output into pipes,
    and occasionally useful for getting the output to very slow programs
    faster.

22. Fixed an error in an optimiser idiom that could optimise erroring code
    involving mingles into non-erroring code (which is of course incorrect);
    also edited unlambda.i in the pit, which was taking advantage of this
    error (and erroring out if optimisation was turned off).

23. Fixed a bug with the ON THE WAY TO line number displayed when COME FROMs
    are involved that I accidentally introduced in 0.25.

=== Changes from elsewhere ===

24. Added yet another nontrivial INTERCAL program to the pit; interfunge.i
    (written by Jeffrey Lee) is a Befunge-93 interpreter written in INTERCAL.
    (It appears to conform to the standard (I actually ran it against a
    testsuite, and it passed); its only pecularities, apart from the language
    in which it's written, appear to be the need for a blank line at the end
    of the program, but no blank lines earlier (because INTERCAL can't sense
    EOF, although there are plans to change that), the restriction to 80x25 is
    enforced (this seems to be an implied requirement in the standard, but
    most Befunge-93 interpreters don't enforce it), and numeric output is in
    Roman numerals (what did you expect?).)

== Release 0.27 (by Alex Smith) 22 Dec 2007 ==

1.  Joris Huizer pointed out that the manual nowhere says that a GIVE UP line
    can't be abstained from by line number. This was probably a mistake in the
    INTERCAL-72 manual, but the behaviour specified by the original manual is
    now implemented; after all, it wouldn't do to violate the original de facto
    standard. (Note that if a GIVE UP line is abstained by line number, there
    is then no way to reinstate it; also, if the -X switch for CLC-INTERCAL
    compatibility is used, ABSTAINING FROM a GIVE UP line by line number is
    also silently ignored.)

2.  Rewrote the optimizer in a language (OIL) invented specifically for the
    purpose; the set of optimizer idioms is now in idiotism.oil, and translated
    into C and linked with the rest of the compiler at metacompile time (that
    is, when the compiler itself is being compiled). It contains many of the
    same idioms, but some have been generalised or reduced into smaller parts
    and some new ones were added. Documentation for OIL has been added as part
    of the documentation for the distribution as a whole.

3.  Joris Huizer submitted a patch to fix a memory allocation bug which
    occasionally caused memory corruption when a program had a number of
    commands that was 1 less than a multiple of 256.

4.  Completely redid the autoconfiguration. The install should now progress
    with less user interaction than before. As a bonus, if you have a range of
    GNU utilities including make, sed, tr, and bash (and possibly others), it's
    now possible to compile using 'sh configdj.sh' followed by 'make' under
    DJGPP. (To be specific, some settings that previously sometimes had to be
    set by the user, such as whether lex provided yylineno and yyrestart, are
    now either detected by config.sh or no longer relevant. Other settings that
    were not previously detected, such as what extension executables have, are
    now detected so that the config script works on DJGPP as well, now;
    compiling the config script on a non-DJGPP system seems to result in a
    script that fails on DJGPP, and likewise compiling the script on DJGPP
    seems to result on a script that fails on other systems, so both scripts
    are provided. The autoconfigurer now also adapts coopt.sh so that -F works
    on DJGPP too, sort of (or else detects that it won't work and disables it).

5.  Improved the action of 'make install', so that it actually installs
    everything in the right place. It works under DJGPP, now, too, as long as
    you have the programs installed that allow configdj.sh and make to work.

6.  Fixed a bug involving COME FROM in multithreaded programs; now, if a line
    COMEs FROM itself (either because this is written explicitly or because it
    is a computed COME FROM computing to its own line number), the loop this
    creates doesn't block all the other threads in the program.

7.  Added support for statement WHILE statement, with similar semantics to CLC-
    INTERCAL. (The second statement is repeated for as long as the first
    statement is executing; NEXTing to the statement nexts to the first
    statement and doesn't set off the loop, and COMING or NEXTING FROM the
    first statement leaves the loop running until the NEXT FROM returns.) With
    the current implementation, strange things happen if the same WHILE is
    simultaneously run by multiple threads, although I decided to work out
    exactly what the rules were anyway and document them, so those strange
    things are now official.

8.  Fixed some weird bugs in the multithreader that could cause segfaults in
    several situations involving backtracking; it's kind of surprising that
    they didn't turn up sooner.

9.  Prevented a segfault in some situations where a syntax error was the
    target of a noncomputed COME FROM or NEXT FROM.

10. CALCULATING now includes array dimensioning. (There previously was no
    gerund for this situation; the original manual doesn't say what to do but
    implies that this is a special case of calculate.)

11. Made operand overloading interact more sensibly with multithreading.
    Previously, overloading information was shared between all threads, but the
    stashes for operand overloading were separate in each thread. Now, the
    overloading is not shared between threads, except when they are woven by a
    WHILE statement.

12. There's no longer a need to set or modify copyloc in the makefile by hand;
    COPYING.txt is now found the same way as syslib and the skeleton. It's also
    now copied out of the distribution to the same place as the other data
    files when installing, preventing the need to keep the original
    installation directory around.

13. The compiler now actually looks for a temporary directory to place a file
    in when creating a temporary file; this was meant to be fixed in 1.26, but
    the fix didn't actually work.

14. Added a new program to the pit: an Unlambda interpreter written by Oerjan
    Johansen in 2001, and also a commented version as documentation.

15. Section 23 of the release notes for version 0.26 is wrong; I was obviously
    confused when I wrote them because they were speaking nonsense.  For the
    record: no, there is nothing special about NEXT in connection with
    backtracking.  It should have said "NEXT", not "choicepoint".  Instead of
    rewriting history, this changelog entry is added as a fix.

16. Added an entirely new set of documentation, the Revamped Manual, which is
    available in a wide range of formats and documents recent language changes,
    as well as many other things INTERCAL. The Revised Manual has been
    preserved, but it seems unlikely to be updated in the near future (it is
    still well worth a read anyway).

17. For compatibility, the COMMENT gerund can now be spelt COMMENTS or
    COMMENTING.

18. Corrected the Emacs INTERCAL mode to work with more recent versions of
    Emacs than it previously worked with, hopefully without sacrificing too
    much backward compatibility.

19. Added a conversion program 'convickt'; it can convert between the Latin-1,
    Baudot and EBCDIC character sets used by CLC-INTERCAL (Latin-1 is also
    accepted by C-INTERCAL, so this gives a practical way to run CLC-INTERCAL
    programs in unusual character sets on C-INTERCAL), and can also attempt to
    convert into the 'Atari character set' (which uses $ instead of the cent
    sign, ? instead of yen, and so on for the other characters that differ
    between C-INTERCAL and CLC-INTERCAL).

20. Reorganised the Makefile and environment variable system for finding
    locations to make more logical sense; various definitions and environment
    variables now do what their name suggests rather than something completely
    different, a situation which confused the programmers previously.  The new
    version should be better at finding files that it needs, and also cuts
    down on the amount of useless copying that the Makefile did (such copying
    is now only done if the destination file doesn't already exist or is out
    of date).

21. Fixed some problems in the PIC-INTERCAL code: one problem with finding the
    correct location for the skeleton, and some code duplication between the
    two header files. Also clarified one of the comments.

22. Added support for CLC-INTERCAL-style Baudot I/O (generalised array I/O is
    currently unimplemented, though). This has a two minor differences to the
    CLC-INTERCAL version: unrecognised characters, instead of causing an
    error, become 0 when WRITING IN (except that tabs are translated to single
    spaces) and ASCII code 26 when READING OUT. (Baudot characters not in
    ASCII will be translated to Latin-1; there are more of these than might be
    expected, because the CLC-INTERCAL extended Baudot is being used).

23. The man pages and some fixes for the documentation Makefile from the
    Debian package were copied into the main distribution. The man page was
    written originally by Mark W. Eichin and later modified by Joey Hess (and
    was further modified by me prior to placing it in the distribution); the
    Makefile fixes are due to Joey Hess. Strangely, many of the changes I made
    to the Makefile for this version have much the same effect as fixes that
    the Debian package maintainers had come up with earlier; a new Makefile
    variable ick_specific_subdir has been added to hopefully make the Debian
    maintainer's job easier (it allows elimination of versioned
    subdirectories, replacing them with versionless subdirectories).

24. Added a new test program to the pit, tests/ignorret.i, that demonstrates
    how the interaction between IGNORE and RETRIEVE is different between
    C-INTERCAL, CLC-INTERCAL, and J-INTERCAL, and documentation showing the
    results on each version.

  Release 1.26 (by Alex Smith) [a bugfix of 0.26]  3 Sep 2007

1.  Fixed an optimizer bug (thanks to Joris Huizer for pointing it out),
    relating to active-bits deduction in some expressions involving select.

2.  Fixed a bug in the flow optimizer that caused it to occasionally confuse
    ABSTAIN with REINSTATE when gerunds were used.

3.  Simplified the compilation of INTERCAL files to .exe under DJGPP, to avoid
    some temporary files (hopefully solving some problems users may be having
    with finding which directory the temporary files are in under DJGPP);
    when under DJGPP a temporary file other than .c or .exe is needed, the
    compiler now looks for a directory reserved for temporary files to place it
    in rather than just using the current directory.

4.  The original INTERCAL manual specifies that GIVE UP cannot be REINSTATED
    or ABSTAINED FROM; this is now implemented, by taking only the original
    DO/DO NOT status into account when executing a GIVE UP statement.

5.  Dealt with problems with what happens with the 'original' stdin (this
    information was previously lost, making it hard for the debugger to accept
    input because it had no obvious place to accept it from), and removed the
    previous hacky workarounds for this problem (which were my fault).

6.  Made several improvements to the documentation, especially with respect to
    installing and running under DJGPP.

7.  Modified the version number scheme, so that minor revisions and bugfixes
    now increment the major version number rather than the minor version number
    (it was getting a little bored stuck at 0). The next major release will be
    version 0.27.

== Release 0.26 (by Alex Smith)  1 Apr 2007 ==

1.  Fixed a few bugs in the previous release (some bugfixed by Joris Huizer).

2.  Ported to DJGPP. The compiler now works on both POSIX and DJGPP systems.

3.  Reorganized the directory structure.

4.  Added support for cross-compiling to the PIC microcontroller.

5.  Added a simple test program for PIC cross-compilation.

6.  Improved further searching for skeletons and executables.

7.  Delinted some of the code, and turned up the default gcc warning level.

8.  Reformatted some of the documentation.

9.  Renamed and split files; all files used in the build now have 8.3
    filenames, to prevent any problems using DJGPP on 8.3 systems. The
    optimizer was split from the code degeneration into dekludge.c (optimizer)
    and feh2.c (degeneration), because feh.c was getting too large.

10. The text documentation (README, COPYING, NEWS, and BUGS) was renamed to
    end .txt (again for DJGPP compatibility); formatting changes were made to
    README in addition to the addition of extra readme information.

11. Included precompiled-to-C versions of the parser and the lexer so that
    DJGPP (or I suppose, POSIX if you hacked the makefile) implementations
    without bison or flex could still compile the rest of C-INTERCAL and give
    a running program.

12. Fixed a bug involving optimization of Tri-INTERCAL programs.

13. Added to the lexer, so that it supports CLC-INTERCAL syntax for operators
    that were already present in C-INTERCAL, as long as they don't conflict
    with C-INTERCAL syntax. (Using the -X switch will support CLC-INTERCAL
    syntax for operators that were already present in C-INTERCAL even if they
    conflict with C-INTERCAL syntax.) For the symbols present in the
    CLC-INTERCAL character set but not in ASCII, ISO-8859-1 is supported as an
    encoding as well as UTF-8 (to increase the chance that CLC-INTERCAL
    programs will run without modification); it was meant to be supported to
    some extent before, but seemed not to be working.

14. Added the COMMENT gerund, with the same semantics as in CLC-INTERCAL.

15. Added COME FROM gerund. This suffers from the same restrictions as
    computed COME FROM, in that it can't be used in PIC programs and causes
    the program to end up substantially less efficient.

16. Added support for prefix as well as infix unary operators. The rule is
    that any number of prefix unary operators, but only one infix unary
    operator, is allowed on each group, variable, and/or mesh. (Previously,
    only infix operators were supported, and then only one per mesh.)

17. Added positional precedences to the parser. INTERCAL still doesn't have
    operator precedences (that would be completely contrary to the spirit of
    INTERCAL) but it now has rules for deciding on the meaning of previously
    ambiguous expressions. Chains of select and mingle operations right-
    associate, and when a unary operator could legitimately be in either a
    prefix or infix position, the infix position is assumed (although remember
    that only one infix operator is allowed for each group, variable, and/or
    mesh).

18. Added the not character as a synonym for NOT.

19. Added operand overloading, for onespot and twospot variables. This uses
    the slat operator in almost, but not quite, the same way as
    CLC-INTERCAL. Note that the width of unary operations will mostly depend
    on the type a variable appears to have in an expression, rather than on
    its actual bitwidth (if a onespot is overloaded to a twospot or vice
    versa). Note that meshes won't change as the result of operand overloading
    unless the -v option is used (an error will be generated instead).

20. Added an option for generalised assignments. With the -v option,
    expressions (rather than just variables) can appear on the left of an
    assignment. Any meshes on the left of an assignment (even if in apparently
    inoccuous positions) may change value as a result. (Note that such
    assignments aren't always possible.) If the left-hand-side of an
    expression is anything other than simply a variable or a constant, the
    compiler will try to change the values of meshes and non-ignored variables
    in the expression to make it fit. (In bases other than 2, it will nearly
    always fail.) Unlike CLC-INTERCAL, assigning to a mesh only changes that
    mesh, not line labels or other uses of the number.

21. Restricted the compiler to just one input file at a time (it used to break
    if this wasn't done anyway).

22. Fixed a nonportability involving stdin and stdout in cesspool.c.

23. Added support for the NEXT FROM command, with the same semantics as COME
    FROM (including computed NEXT FROM and NEXT FROM gerund), except that it
    saves the line that was NEXTed FROM on the choicepoint stack.

24. Fixed a bug where the yuk debugger accessed unallocated memory.

== Release 0.25 (by Alex Smith)  21 Jun 2006 ==

1. Added support for computed ABSTAIN and TRY AGAIN.

2. Added support for computed COME FROM.

3. Added support for multithread programs. This includes ONCE and AGAIN,
   which also work in singlethread programs.

4. Expanded intercal.el to support Font Lock and some utilities for
   generating INTERCAL-style constants. It also works with the
   compilation routines of Emacs to compile INTERCAL programs without
   the need for make. Degenerated C code now has a mode line to help
   with Emacs compatibility.

5. Added a rudimentary debugger and profiler for singlethread programs. The
   debugger's features include useful things like 'write out INTERCAL expression
   in simpler terms' (which is only possible if -O is on). The profiler works
   much like gcov, counting the length of time spent in and number of executions
   of each command in the code.

6. Changed searching for includes, libraries, syslib, skeleton. This
   is so that non-root users, or people who want to evaluate ick, can
   do so more simply. The compiler will search for the above files in
   the directory they should have been installed in, the current
   directory, and the directory in which ick's executable resides (in
   that order). Skeleton problems, in particular, seem to have been a
   major problem for unfamiliar users trying out ick.

7. Added several new test programs to the Pit.

8. Greatly expanded the original optimizer (which optimizes
   expressions). It can now recognize most of the idioms in syslib,
   and many idioms in other Pit programs. Also added a new optimizer,
   to try to optimize program flow, which is important because
   otherwise INTERCAL wouldn't have any rudimentary optimizers.  There
   is also the -F optimizer, which I hope will become infamous. It
   creates object code which is close to maximally fast in some
   specialized situations, at the expense of compile time (compilation
   can take a very long time when -F is active) and object file
   size. I suggest checking its effect on primes.i.

9. Fixed the grammar (again) in a spark/ears situation involving array
   subscripts, after proving that the previous fixes weren't adequate.

10. Added support for backtracking (MAYBE, GO AHEAD, GO BACK). Note
    that it is possible for multithreading, backtracking, computed
    ABSTAIN, and computed COME FROM to all be used simultaneously in
    the same program, to help maximize obfuscation.

11. Added an option (-l) for generating warnings. To prevent this
    actually being useful, it is designed to generate far too many
    warnings, which all have to be trawled through to find the
    important ones, and has no way to turn the unimportant ones off.

12. Added the +printflow and +mystery options for executing INTERCAL programs.
    Note that it is not entirely obvious what either of them do (+printflow is a
    debugging aid, but the output is somewhat obfuscated, and I am not going to
    explain what +mystery does in this document).

== Release 0.24  (by Eric S. Raymond) 31 Dec 2003 ==

1. RPMs can now be built by non-root users.

== Release 0.23  (by Eric S. Raymond) 9 Mar 2003 ==

1. More fixes by Don Knuth.  He found a bug in the type-propagation logic.

== Release 0.22  (by Eric S. Raymond) 4 Mar 2003 ==

1. Incorporated a minor fix patch from Donald Knuth.  Yes, *the*
Donald Knuth.  Seems he found a weakness in the code for handling
comments, and fixed it to do multiline comments properly.  He also made
some improvements to intercal.el, and contributed a test program.

2. Updated build machinery.  This package now uses GNU autoconf.

== Release 0.21 (by Eric S. Raymond) 30 July 2002 ==

1. Jonathan Nieder sent a grammar fix for BLR's old bug #5 (a bad spark-ears
   interaction.)

2. Latin-1 support and makefile fixes from Magnus Bodin.

== Release 0.20 (by Eric S. Raymond) 16 September 1999 ==

  (The following changes are due to John Cowan <cowan@ccil.org>)

1. In addition to Latin-1, UTF-8 is now acceptable in source code as well.
   All the numerous currency symbols of Unicode (ISO 10646) can be used as
   big-money alternatives in their UTF-8 format.  Indeed, a random mixture of
   Latin-1 and UTF-8 also works fine; this seems very much in the spirit of
   Intercal.

2. Intercal has now been localized for the Ancient Roman as well as the
   Posix/C locale.  You may input numbers in Latin and write Intercal programs
   using Latin keywords.  See lexer.l for a list of equivalences.

3. The Makefile in the pit directory now works like a real Makefile, and
   won't compile anything that's already been compiled.

== Release 0.19 (by Eric S. Raymond) 16 August 1998 ==

1. Fixed a code-generation error in assignments from tail and hybrid
   variables. (Error pointed out by Malcom Ryan.)

== Release 0.18 (by Eric S. Raymond) 29 April 1998 ==

(The following changes are due to John Cowan <cowan@ccil.org>)

1. The source code is now POSIXly correct.  By making the POSIX
   variable in the Makefile undefined, you can restore the use of
   <varargs.h>, but otherwise <stdarg.h> is now used.

2. Latin-1 (ISO 8859-1) is now the standard input charset of C-INTERCAL.
   This means that the change operator (0xA2) has returned as an alternative to
   big money ($).  Furthermore, the quid (0xA3) and zlotnik (0xA4) are also
   acceptable.  For those using Latin-9 (ISO 8859-15), the euro (0xA4) will also
   work.  ("Euro", like "ampersand", cannot be sillified further.)
   New names have been added to intercal.mm.

3. A fortiori, input of Volap\"uk digits may now be in Latin-1 or TeX format.

4. Yacc is now deprecated in favor of bison; some old yaccs don't do proper
   error recovery, and lines like "DO ~ ERROR" failed at compile time.

5. Some minor portability bugs on systems where ptr_diff is not the same
   as int were removed by casting expressions of the form (ptr - ptr) to int.

== Release 0.17 (by Eric S. Raymond) 27 Feb 1998 ==

Incorporates a minor bug fix by Jeff Uphoff <juphoff@tarsier.cv.nrao.edu>.

== Release 0.16 (by Brian Raiter and Eric S. Raymond) 26 May 1997 ==

This is the 25th-anniversary release of INTERCAL.  This language, conceived
in irony a quarter century ago today, has outlasted many more serious and
high-minded essays in computer language design.  This fact should give us
pause to reflect, or possibly frighten the crap out of us.  Or both.

1. Corrected manual bugs.

2. Fixed over-enthusiastic install production in the Makefile.

3. DO PLEASE is no longer accepted (Brian Raiter pointed out that the
   manual does not sanction it).

4. Fixed various bugs in the optimizer.

5. Incorporated fixes made by William Walter Patterson for bugs that
   appeared when multiple files are given on the command line.

(The following changes are due to Brian Raiter)

6. The system library is now available for TriINTERCAL (all bases, 3 to 7).
   The compiler has been updated to use the right library automagically.

7. The error 774 feature has been brought into conformance with the
   Princeton compiler. The odds are now a flat 10% (but still 0% with -b).

8. The compiler has been modified to allocate memory dynamically, and
   the hard-coded limits on program size and number of variables has
   been removed. Programs are now only limited by the amount of
   available memory.

9. Array output now fflushes after outputting newlines.

10. Two minor bug fixes: one in wimpmode input, which was clamping
    input to the signed integer range, and one in politesse checking.
    The latter was causing programs to be recognized as impolite only
    if their ratio was less that one-sixth, not one-fifth. (Fixing this
    also necessitated adding a few PLEASEs to pit/rot13.i.)

11. Several new programs have been tossed into the pit.

== Release 0.15 (by Eric S. Raymond) 20 Jun 1996 ==

1. Switched the INTERCAL manual master to mgm in order to be able to handle
   section crossreferences properly.  The manual has now been carefully
   proofread against the paper version by ESR and seems to match.  It's
   also been independently proofread for typos by Brian Raiter.

2. The optimizer now does complete analysis and evaluation of constant
   expressions at compile time.

3. Added optimization templates for ~, |, &, ^ expressions.  Also added
   |, &, ^ idioms to the system library, and documented them.

(The following changes are due to Brian Raiter)

4. Every one of the INTERCAL-72 messages is now emitted when appropriate.
   including the previously un-emitted E000, E197, and E200 (and see below).

5. A close reading (while proofing) of the sections of the manual on
   error messages seems to indicate that splatted lines were only
   splatted in the default listing printed after a successful
   compile. (This seems to be a standard feature of IBM compilers; I
   remember that RPG did this as well.) My understanding of the manual is
   when the syntactically offensive line is encountered at runtime, it is
   printed as error E000. I have modified the code to do this.

6. I have fixed INTERCAL in order to add another bug. Namely, I have
   implemented the BUG/NOBUG option in the Princeton compiler. By
   default, there is a chance that INTERCAL will randomly insert error
   E774 into your executable. (The odds are 1/128 per statement, not
   counting COME FROMs. Is there any way to find out what the
   Princeton compiler's odds were?) The new option -b turns this
   feature off.

7. The new file pit/lib/numio.i contains routines for wimpmode I/O.
   These routines are documented in the file pit/lib/numio.doc.
   It is my earnest hope that C-INTERCAL programmers everywhere will
   flock to these handy routines, and C-INTERCAL users will thus no
   longer need to fear that they might succumb to the foul and awful
   temptation to use the dastardly +wimpmode option.

== Release 0.14 (by Eric S. Raymond) 9 Jun 1996 ==

1. The documentation has been reorganized and cleaned up (you can now
   format either a C-INTERCAL or INTERCAL-72 manual from the same master).
   The diagrams in the paper original have been transcribed as pic figures.
   See doc/READ.ME for details.

2. Yet more code.  The pit now includes a second random-number generator,
   a ROT13 filter, and even two programs in TriINTERCAL!

3. Louis Howell's corrected system library is now included.

4. The distribution is now formally GPLed.

== Release 0.13 (by Eric S. Raymond) 5 Jun 1996 ==

1. I folded in patches by Brian Raiter <breadbox@muppetlabs.com> that port
   this code to Linux, ANSIfies it, and enables it to use flex.  Note: This
   version has been tested on Linux and SunOS but not yet elsewhere.

2. Another piece of nontrivial INTERCAL code has been found!  (Doubtless
   hell is freezing over even as I write.)  We've added to the pit the
   `beer' program by Matt DiMeo <mdimeo@brooktree.com>, courtesy of the
   infamous Beer List (URL:http://www.ionet.net/~timtroyr/funhouse/beer.html).

== Release 0.12 (by Eric S. Raymond) 22 Mar 1995 ==

1. The code now compiles and runs under Linux, using bison and lex.  It does
   *not* yet work with flex;  C.P. Osborne's patches for 0.11 turned out not
   to be sufficient (at least for flex 2.4.6 under Linux using the -l option).
   See the BUGS list.

2. Note 3 under 0.11 was incorrect.  We're in conformance after all.

3. The politesse check is a little smarter about programs too small to
   conform to the 1/5-to-1/3 criterion.  All the pit programs have been
   checked for conformance.  Also, the politesse error message now tells
   you the offending program's line count.

== Release 0.11 (by Eric S. Raymond) 24 Sep 1994 ==

1. Incorporated changes by Jan-Pieter Cornet <cornet@OTech.fgg.EUR.nl> for
   magical inclusion of the system library.  These address an outstanding bug

   2. (SS) The `system library' should be precompiled and `linked' to user
      written code, at least optionally.  Doing this with the current compiler
      presents a few problems.

   which has accordingly been removed from the BUGS file.  They also fix a
   previously unknown bug; due to a minor oversight in the lexer, it was not
   possible to ABSTAIN FROM WRITING IN or READING OUT.  Jan also contributed
   a test program that demonstrates gerund abstention.

2. Despite the obvious appeal of the idea, and much discussion on
   alt.lang.intercal, I decided *not* to add Klingon; maintaining two parallel
   grammars just so the compiler could support SVO and OSV languages would be
   too painful.  There was also a minor mess near case-sensitivity in the
   digits.  The workaround kluges I was offered instead failed to satisfy.

3. We fess up to a violation of the INTERCAL-72 standard.  That implementation,
   instead of accepting an entire multiple-digit number per line of input,
   expected one digit per *card image* (input line).  It is unclear how
   INTERCAL-72 programs ever managed to input more than one number.

4. Added patches by C.P.Osborne <boris@ibmpcug.co.uk> to make the lexer work
   using flex, for Linux and BSD/386 support.  I didn't use his error-reporting
   patch, though; instead, I changed the parser to catch errors at logical-line
   level.  I also kept the N in `RESUBNIT'; this is a carefully preserved
   feature of INTERCAL-72.

5. Volapuk digits are now recognized on input.  TO DO: Recognize Volapuk
   keywords, including gerunds.

== Release 0.10 (by Eric S. Raymond) 9 Sep 1994 ==

1. It is now possible to undo a line-number abstention with a gerund
   reinstatement, or undo a gerund abstention with a line-number
   reinstatement.  In previous versions, gerund abstention/reinstatements and
   line-number abstention/reinstatements were independent of each other.

2. After release 0.5, I wrote in the TO DO list as follows:

   2. (ESR) Input format internationalization -- allow WRITE IN input digits in
   major languages such as Nahuatl, Tagalog, Sanskrit, and Basque.

   The twisted loons in the alt.folklore.computers crowd loved this idea,
   and I actually got sent digit lists for Nahuatl, Tagalog, Sanskrit, and
   Basque -- also, Kwakiutl, Georgian, Ojibwe, and Albanian.  I've left
   out Albanian (didn't want to keep track of the dipthong diacritical)
   and Ojibwe (no zero digit).  So: Nahuatl, Tagalog, Sanskrit, Basque,
   Georgian, and Kwakiutl are now supported in addition to English.

3. The THEORY document has been significantly revised.

== Release 0.9 (by Eric S. Raymond) 5 Mar 1993 ==

1. An embarrassing port bug in the INTERCAL skeleton has been fixed

2. Jamie Zawinski's suggestion for an improved E333 error message has
   been accepted.

3. Added and improved documentation for pit programs.

4. The install production in the Makefile now puts lose.h in place
   as well as cesspool.h.

5. You can now set the C compiler to be used as a back end by INTERCAL
   by setting the environment variable CC.  The default is cc.

== Release 0.8 (many hacks on 0.7 by Eric Raymond) 21 Jan 1992 ==

1. A previously undocumented `feature' of the Princeton compiler,
   revealed by Don Woods, is now emulated.  If fewer than 1/5 or more
   than 1/3 of a program's statements contain the qualifier `PLEASE', the
   program is rejected with an entertaining error message.  Programs in pit
   have been hacked to pass the politesse test.

2. The `sample' program now works correctly, thanks to Louis Howell.  Also,
   he has contributed new programs to calculate pi and to search for prime
   numbers.

3. An intercal mode for GNU Emacs is included.  It helps programmers deal with
   the new politesse check by randomly expanding the abbrev "do" to DO PLEASE
   or PLEASE DO about 1/4 of the time.

4. Improvements in code generation for NEXT/RESUME.

5. Fixes to the optimizer; it handles the results of optimized MINGLEs
   correctly now.  Also, added a rewrite rule that checks for the
   equality-test idiom using XOR.

6. The original error messages from the Princeton compiler have been restored.

The documentation has been updated to reflect these changes.

== Release 0.7 (by Louis Howell) 21 Dec 1991 ==

In addition to bug fixes, new features in this version include arrays,
character I/O, modified (hopefully improved!) semantics for the COME
FROM statement, extensions to bases other than 2, new INTERCAL programs,
and new documentation.

== Release 0.6 (by Steve Swales) 5 Jan 1991 ==

1. Restored Princeton documentation (courtesy of Michael Ernst).

2. Added -@ usage option to ick.

3. Added [+/-]help, [+/-]traditional, and [+/-]wimpmode options for
generated programs; [+/-]traditional is a no-op at this point.

4. Various bug fixes, esp. in lexical analysis.

== Release 0.5 (ESR's second pre-release) 5 Jun 1990 ==

1. As a convenience to all you junior birdmen out there, `NINER' is accepted as
   a synonym for `NINE' in INTERCAL input.

2. The COME FROM statement is now compiled.

== Release 0.3 (ESR's original pre-release) ==

The resurrection of INTERCAL from its grave took place on 12 May 1990
when ESR released 0.3 on an unsuspecting USENET.
