Pre-0.28 'c' snapshot.

(This is a retrospective comment.)

diff --git a/Makefile b/Makefile
index 0ddf7a25b0bb45ce91803623f3628da2d4539b85..50da8ca0e5fff0813648222fd625513df6afa9a2 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -56,7 +56,7 @@ SOURCES = $(CSOURCES) $(ISOURCES) $(YSOURCES) $(HEADERS) $(BUILD) $(MISC) $(DOCS
 
 all: bin/ick bin/convickt lib/libick.a lib/libickmt.a lib/libyuk.a lib/libickec.a ial
 
-ial: include/ick_ec.h include/fiddle.h include/abcess.h include/ick_lose.h include/yuk.h include/syslib.i include/syslib.3i include/syslib.4i include/syslib.5i include/syslib.6i include/syslib.7i lib/ick-wrap.c lib/pickwrap.c lib/coopt.sh lib/COPYING.txt include/atari.bin include/baudot.bin include/ebcdic.bin include/latin1.bin
+ial: include/ick_ec.h include/fiddle.h include/abcess.h include/ick_lose.h include/yuk.h include/syslib.i include/syslib.3i include/syslib.4i include/syslib.5i include/syslib.6i include/syslib.7i lib/ick-wrap.c lib/pickwrap.c lib/coopt.sh lib/COPYING.txt lib/syslibc.c include/atari.bin include/baudot.bin include/ebcdic.bin include/latin1.bin
 
 include/ick_ec.h: src/ick_ec.h
        -cp src/ick_ec.h include/ick_ec.h
@@ -94,6 +94,9 @@ lib/coopt.sh:temp/coopt.sh
 lib/COPYING.txt:COPYING.txt
        -cp COPYING.txt lib/COPYING.txt
 
+lib/syslibc.c:pit/lib/syslibc.c
+       -cp pit/lib/syslibc.c lib/syslibc.c
+
 include/atari.bin:src/atari.bin
        -cp src/atari.bin include/atari.bin
 include/baudot.bin:src/baudot.bin
@@ -230,6 +233,7 @@ install-common: all
        cp include/*.bin $(DESTDIR)$(datadir)
        cp src/ick-wrap.c src/pickwrap.c $(DESTDIR)$(datadir)
        cp include/syslib.i include/syslib.?i $(DESTDIR)$(datadir)
+       cp lib/*.c $(DESTDIR)$(datadir)
        cp temp/coopt.sh $(DESTDIR)$(datadir)
        cp COPYING.txt $(DESTDIR)$(datadir)
        -mkdir -p $(DESTDIR)$(mandir)/man1

diff --git a/Makefile.in b/Makefile.in
index 4826388f00ff2b17200d7c60e5ba46b418e9492b..07300294740d5983702976f4c8d47382be0f69eb 100644 (file)
--- a/Makefile.in
+++ b/Makefile.in
@@ -55,7 +55,7 @@ SOURCES = $(CSOURCES) $(ISOURCES) $(YSOURCES) $(HEADERS) $(BUILD) $(MISC) $(DOCS
 
 all: bin/ick@EXEEXT@ bin/convickt@EXEEXT@ lib/libick.a lib/libickmt.a lib/libyuk.a lib/libickec.a ial
 
-ial: include/ick_ec.h include/fiddle.h include/abcess.h include/ick_lose.h include/yuk.h include/syslib.i include/syslib.3i include/syslib.4i include/syslib.5i include/syslib.6i include/syslib.7i lib/ick-wrap.c lib/pickwrap.c lib/coopt.sh lib/COPYING.txt include/atari.bin include/baudot.bin include/ebcdic.bin include/latin1.bin
+ial: include/ick_ec.h include/fiddle.h include/abcess.h include/ick_lose.h include/yuk.h include/syslib.i include/syslib.3i include/syslib.4i include/syslib.5i include/syslib.6i include/syslib.7i lib/ick-wrap.c lib/pickwrap.c lib/coopt.sh lib/COPYING.txt lib/syslibc.c include/atari.bin include/baudot.bin include/ebcdic.bin include/latin1.bin
 
 include/ick_ec.h: src/ick_ec.h
        -cp src/ick_ec.h include/ick_ec.h
@@ -93,6 +93,9 @@ lib/coopt.sh:temp/coopt.sh
 lib/COPYING.txt:COPYING.txt
        -cp COPYING.txt lib/COPYING.txt
 
+lib/syslibc.c:pit/lib/syslibc.c
+       -cp pit/lib/syslibc.c lib/syslibc.c
+
 include/atari.bin:src/atari.bin
        -cp src/atari.bin include/atari.bin
 include/baudot.bin:src/baudot.bin
@@ -229,6 +232,7 @@ install-common: all
        cp include/*.bin $(DESTDIR)$(datadir)
        cp src/ick-wrap.c src/pickwrap.c $(DESTDIR)$(datadir)
        cp include/syslib.i include/syslib.?i $(DESTDIR)$(datadir)
+       cp lib/*.c $(DESTDIR)$(datadir)
        cp temp/coopt.sh $(DESTDIR)$(datadir)
        cp COPYING.txt $(DESTDIR)$(datadir)
        -mkdir -p $(DESTDIR)$(mandir)/man1

diff --git a/NEWS.txt b/NEWS.txt
index 17ca360606f9df577e87fe199b6d0c88c83906eb..6b7cac06b557fd33e88be6136ea5b1df412ab99a 100644 (file)
--- a/NEWS.txt
+++ b/NEWS.txt
@@ -6,35 +6,38 @@ Patches, suggestions and bugs found by Joris Huizer
 
 1.  Fixed a typo in the [noopxor] optimiser idiom.
 
-2.  Fixed a typo that caused the flow optimiser to optimise some errors into
+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.
 
-3.  Fixed the [lshift16] optimiser idiom; previously it was giving incorrect
+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.
 
-4.  There is now no longer a segfault when the unusual option combination -f
+5.  There is now no longer a segfault when the unusual option combination -f
     (without specifying -O) is used.
 
-5.  It is again possible to recompile more than one source file at a time.
+6.  It is again possible to recompile more than one source file at a time.
 
-6.  The flow optimiser now recognises that comments can be reinstated in
+7.  The flow optimiser now recognises that comments can be reinstated in
     programs where they can be reinstated.
 
 Changes by Alex Smith
 
-7.  Fixed some typos in the documentation.
+8.  Fixed some typos in the documentation.
 
-8.  Applying an infix unary operator to a constant (as in &#26) now returns
+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.)
 
-9.  Added doc/THEORY.txt back in. (It seems that it went missing some time
+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.
 
-10. Turned off optimsation of the optimiser, and also placed a 128MB limit on
+11. Turned off optimsation 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
@@ -44,7 +47,7 @@ Changes by Alex Smith
     a bonus, the build process is now considerably faster, because the
     optimisation of the optimiser was the slowest step of the process.
 
-11. Internally, all symbols that are visible globally are now name-mangled (by
+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
@@ -54,7 +57,7 @@ Changes by Alex Smith
     hopefully should never be linked to another program that isn't
     specifically designed to be linked to it).
 
-12. Thoroughly delinted the code, using Splint; the code is now annotated to
+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
@@ -62,14 +65,84 @@ Changes by Alex Smith
     unusually long strings, and some of which were buffer overflows). All
     comments from /*@ to @*/ are mine, and are annotations for Splint.
 
-13. Implemented external calls, which allow multiple INTERCAL programs to be
+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.
+    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).
 
 Changes from elsewhere
 
-14. Added yet another nontrivial INTERCAL program to the pit; interfunge.i
+23. 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

diff --git a/doc/ick.1 b/doc/ick.1
index 3a0c7a6cd228f970629e8f261cf9fdb01d99e572..3b5f91e8282eb5e56186c3cf41fb9797887eeb92 100644 (file)
--- a/doc/ick.1
+++ b/doc/ick.1
@@ -7,7 +7,10 @@
 ick \- INTERCAL compiler
 .SH SYNOPSIS
 .B ick
-.I "[options] file"
+.I "[options] file..."
+.PP
+.B ick
+.I "-e [options] intercal-file [non-intercal-file...] [library...]"
 .SH "DESCRIPTION"
 This manual page documents briefly the
 .BR ick
@@ -38,6 +41,12 @@ Note that the base in which a program is written is deduced from its
 extension; INTERCAL programs in base 2 must have the extension .i,
 INTERCAL programs in bases from 3 to 7 must have an extension from .3i
 to .7i respectively.
+.PP
+No options take arguments; multiple options can be given separately or
+combined in the usual way (even -e).
+The order in which options is given is irrelevant unless they
+conflict, in which case the options that are given last on the command
+line take precedence.
 .SH OPTIONS
 .TP
 .B \-c
@@ -65,7 +74,7 @@ Optimize control flow in generated code (prevents -yp).
 .B \-F
 Optimize everything in generated code for
 speed, regardless of how slow the compiler becomes or how
-large the object file becomes. Implies -fO, prevents -cdghpyH.
+large the object file becomes. Implies -fO, prevents -cdeghpyH.
 .TP
 .B \-h
 Print optimizer debugging information (implies -cO).
@@ -74,16 +83,39 @@ Print optimizer debugging information (implies -cO).
 Print verbose optimizer debugging information (implies -cO).
 .TP
 .B \-hH
-Print optimizer debugging information in a different form (implies -cO).
+Print optimizer debugging information in a different form (implies
+-cO).
+.TP
+.B \-w
+Enable the +printflow option in output programs even if they are not
+multithreaded.
 .TP
 .B \-y
-Run the yuk debugger on the code (prevents -fm).
+Run the yuk debugger on the code (prevents -fme).
 .TP
 .B \-p
-Run the yuk profiler on the code (prevents -fm).
+Run the yuk profiler on the code (prevents -fme).
 .TP
 .B \-m
-Allow multithreading and backtracking (prevents -yp).
+Allow multithreading and backtracking (prevents -ype, implies -w).
+.TP
+.B \-e
+Link one INTERCAL file to non-INTERCAL files or to expansion libraries.
+Doing this changes the syntax of the command line; the first file
+given must be the INTERCAL source file, then this can be followed by
+any number of files in other languages to link via the external calls
+system (currently only C programs are allowed), and then any number of
+expansion libraries.
+The non-INTERCAL files will be processed to link them to the INTERCAL
+files, and then compiled with gcc and linked to the main INTERCAL
+program.
+.TP
+.B \-E
+Do not link the system library, even if the code suggests that it is
+needed (prevents -P).
+.TP
+.B \-a
+Allow the use of the CREATE statement (prevents -P).
 .TP
 .B \-v
 Allow anything on the left of an assignment, and turn off the
@@ -91,7 +123,7 @@ protection that constants otherwise have against being assigned to
 (prevents -fFOP).
 .TP
 .B \-P
-Compile PIC-INTERCAL rather than INTERCAL (prevents -mFvx, implies -cfO).
+Compile PIC-INTERCAL rather than INTERCAL (prevents -amFvxeE, implies -cfO).
 .TP
 .B \-o
 Output to stdout rather than .c (implies -c).
@@ -127,6 +159,6 @@ CLC-INTERCAL) are currently hosted.
 .
 .SH AUTHOR
 .B ick
-was written by Eric S. Raymond.
+was originally written by Eric S. Raymond.
 This manual page was originally written by Mark W. Eichin
 <eichin@kitten.gen.ma.us>, for the Debian GNU/Linux system.

diff --git a/doc/ick.txi b/doc/ick.txi
index 0d7719a606473b431b694ba4fd343879421b1a62..0ec1082cbdaa72748c47a1aa07e2249f7f08e0b1 100644 (file)
--- a/doc/ick.txi
+++ b/doc/ick.txi
@@ -164,6 +164,7 @@ Basic @ical{} features
 * Multithreading and Backtracking:: Running @ical{} programs in parallel
 * Operand Overloading::             Where one expression stands for another
 * PIC-INTERCAL::                    @ical{} on embedded systems
+* CREATE::                          Creating new syntax at runtime
 * External Calls::                  Linking @ical{} with other languages
 * Differences to Other Compilers::  @cic{} vs. @clcic{}
 
@@ -853,7 +854,22 @@ This option makes it possible to link non-@ical{} programs with
 @ical{} programs; instead of giving @ical{} programs only on the
 command line, give one @ical{} program, followed by any number of
 programs in other languages that have been written to be able to link
-to @ical{} programs. For more information, @xref{External Calls}.
+to @ical{} programs.  It also allows expansion libraries to be
+specified on the command line, after the @ical{} program (expansion
+libraries are given with no extension). For more information,
+@xref{External Calls}.
+
+@ianchorc -E
+@opindex -E
+@cindex system library, disabling
+This option causes the system library to never be linked; this option
+is only useful if your program references a line number in the range
+1000 to 1999, contains no line numbers in that range, and yet still
+doesn't want the system library to be linked in; therefore, it is
+mostly useful with @option{-e} when adding in a custom replacement
+system library written in a non-@ical{} language, especially the
+expansion library @option{syslibc} (a system library replacement
+written in C).
 
 @ianchor -t
 @opindex -t
@@ -863,6 +879,16 @@ This option tells the compiler to treat the source code as @icst{}; as a
 result, any language constructs that are used but weren't available in
 1972 will trigger error E111 (@pxref{E111}).
 
+@ianchor -a
+@opindex -a
+@cindex CREATE, enabling
+This option allows the CREATE statement to be used.  Note that enabling
+it carries a run-time penalty, as it means that operand overloading
+code has to be generated for every variable in the program. (This
+option is not necessarily needed for the external call version of
+CREATE to work, but the external call version has fewer features
+without it.)
+
 @ianchor -v
 @opindex -v
 @cindex constants, assigning to
@@ -870,12 +896,14 @@ result, any language constructs that are used but weren't available in
 It is possible to write @ical{} code sufficiently tortuous that it ends
 up assigning to a constant.  Generally speaking, this isn't what you
 wanted to do, so the compiler will kindly cause an error (E277;
-@pxref{E277}) that stops the insanity at that point, but at the cost of
-a significant amount of performance you can give this option to tell the
+@pxref{E277}) that stops the insanity at that point, but at the cost of a
+significant amount of performance you can give this option to tell the
 compiler to simply change the constant and keep on going anyway.  (Note
 that unlike @clcic{}, this only changes uses of the constant preceded by
 @code{#} in your program, not things like line numbers; you want
-@uref{http://esolangs.org/wiki/Forte,Forte} for that.)
+@uref{http://esolangs.org/wiki/Forte,Forte} for that.)  This option also
+allows you to write arbitary expressions on the left of an assignment
+statement if you wish.
 
 @ianchorc -C
 @opindex -C
@@ -1019,6 +1047,18 @@ fact, identify all the timings that particular commands in the program
 take; so @code{WRITE IN} instructions will often show up as taking a
 long time due to their need to wait for input.
 
+@ianchor -w
+@opindex -w
+@cindex +printflow, enabling
+@cindex printflow, enabling
+
+This option causes the produced program to support the
+@option{printflow} option fully; when this option is not given,
+@option{printflow} will in most cases have partial or no support
+(except in multithreaded programs, where this option is redundant),
+because not all the code needed for it will be included in the program
+to save space.
+
 @ianchor -u
 @opindex -u
 @cindex skeleton file, directory problems
@@ -1229,6 +1269,18 @@ should rarely have to use this mode.
 
 This option does not actually appear to do anything.
 
+@ianchorpm instapipe
+@opindex +instapipe
+@opindex -instapipe
+@cindex output, flushing
+@cindex flushing
+
+This option causes standard output to be flushed whenever any characters
+are output when the @samp{+} version is used, rather than on each newline
+(the default @samp{-} version).  It is most useful for more responsive
+pipes when outputting binary data, and also useful for debugging very
+slow programs.
+
 @ianchorpm printflow
 @opindex +printflow
 @opindex -printflow
@@ -1240,14 +1292,18 @@ This option does not actually appear to do anything.
 
 The usual debugging methods don't work with multithreaded or
 backtracking programs.  This option exists to give at least a slim
-chance of working out what is going on with them.  It causes the program
-to print the line number of the command it thinks it may be executing
-next (i.e.@: the line number that would be printed if that line had an
-error) immediately after executing each command, and also an internal
-identifier for the thread that that command was in.  It also prints a
-trace of what parts of the multithreader are being activated; so for
-instance, it will tell you when a thread is being forked into multiple
-threads or when a choicepoint has been deleted.
+chance of working out what is going on with them.  It causes the
+program to print the line number of the command it thinks it may be
+executing next (i.e.@: the line number that would be printed if that
+line had an error) immediately after executing each command, and also
+an internal identifier for the thread that that command was in.  It
+also prints a trace of what parts of the multithreader are being
+activated; so for instance, it will tell you when a thread is being
+forked into multiple threads or when a choicepoint has been deleted.
+Note that the @option{-w} option (@pxref{-w}) must be given to gain
+full support for flow printing in non-multithreaded non-backtracking
+programs, because otherwise the required code to print this
+information will not be generated.
 
 @ianchorpm mystery
 @opindex +mystery
@@ -1344,14 +1400,14 @@ is one of the mechanisms available for writing comments.)  The text of
 the error message is simply the statement that couldn't be decoded.
 
 @ieanchor E017
-@cindex syntax error, serious
+@cindex constant, twospot
+@cindex overflow, in constant
 @quotation
 DO YOU EXPECT ME TO FIGURE THIS OUT?
 @end quotation
 
-It sometimes happens that a syntax error manages to get the parser so
-confused that it can't figure out what to do next; that causes this
-error, which happens at compile time.
+This error occurs when there is an attempt to use a constant with a
+value outside the onespot range; it's a compile-time error.
 
 @ieanchor E079
 @cindex politesse
@@ -3091,6 +3147,11 @@ you are planning to use this, note that a bug in older versions of
 @cic{} means that assignments to arrays are not affected by this
 gerund before version 0.27.
 
+@clcic{} from 1.-94.-4 onwards, and @cic{} from 0.26 onwards, allow
+arbitrary expressions on the left hand side of an assignment (@cic{}
+only if the @code{-v} option is used); for more information on how
+such `reverse assignments' work, see @ref{Operand Overloading}.
+
 @node NEXT FORGET and RESUME
 @section NEXT, FORGET and RESUME
 @findex NEXT
@@ -3810,6 +3871,13 @@ divided by #12
 @tab 2, 3, 4, 5, 6, 7
 @end multitable
 
+If you happen to be using base 2, and are either using the external
+call system (@pxref{External Calls}) or are willing to use it, it is
+possible to use a version of the system library written in C for
+speed, rather than the default version (which is written in @ical{}).
+To do this, use the command line options @option{-eE} (before the
+@ical{} file), and @option{syslibc} (at the end of the command line).
+
 @ifset notsplit
 @partheading{PART III: @ical{} DIALECTS AND EXTENSIONS}
 @end ifset
@@ -4427,6 +4495,94 @@ but it's trivial to just send the same output again (which has no
 effect, because the voltage on sending pins is maintained at the same
 level until it is changed), or to ignore the input received.
 
+@node CREATE
+@chapter CREATE
+@findex CREATE
+@cindex creating syntax
+@cindex syntax, creating
+
+@portability{no, version 0.28+, see text, no}
+
+The @code{CREATE} command allows the creation of new syntax at
+runtime.  @clcic{} has had such a command since 1.-94.-8, but its
+syntax is completely different and incompatible with the @cic{}
+version, and so is not documented here (see the @clcic{} documentation
+for more details).  The @cic{} version is only defined if the
+@code{-a} option is used on the command line (and a runtime error E000
+otherwise), because it forces the operand overloading code to be
+introduced and so slows down every variable access in the program.
+
+The syntax of the @code{CREATE} command is to write @code{CREATE},
+then a line label, then anything.  OK, well not quite anything; you're
+restricted to syntax that is supported by the `just-in-case' compiler
+that runs on comments at compile time just in case they gain a meaning
+later (see below).  The anything provides an example statement to
+@code{CREATE}; statements which look the same (but may differ in
+details) are created. Typical syntax for a @code{CREATE} statement
+would therefore look something like this:
+
+@example
+       DO CREATE (5) SWITCH .1 WITH .2
+@end example
+
+Here, a new @code{SWITCH WITH} statement (there is no such statement
+in @ical{} normally) is being created.  This command makes it possible
+to do this:
+
+@example
+        DO SWITCH .3 WITH .4
+@end example
+
+Normally that line would be an error (E000) due to being unrecognised,
+but having been @code{CREATE}d, it's now a real statement.  (The
+gerund to affect created statements is @code{COMMENT}, just like
+before they were created; the gerund to affect @code{CREATE} itself is
+@code{CREATION} (@code{CREATING} is also allowed, but not as
+elegant).)  When the created statement is encountered, it @code{NEXT}s
+to line (5), the line number specified in the @code{CREATE} statement.
+In order for the code there to be able to affect the variables
+mentioned in the statement, the variables @code{:1601} (for the first
+variable or expression mentioned), @code{:1602} (for the second
+variable or expression mentioned), and so on, are @code{STASH}ed and
+then overloaded to the respective expressions or variables mentioned
+in the created command; so @code{:1601} has been overloaded to mean
+@code{.3} and @code{:1602} has been overloaded to mean @code{.4} at
+this point.  Then, the code at (5) runs; if it returns via a
+@code{RESUME #1}, @code{:1601} and @code{:1602} will be
+@code{RETRIEVE}d automatically and the program will continue from
+after the created statement.  (If you do not resume to that point, say
+if you're creating a flow control statement, you'll have to deal with
+the stashes for the 1600-range variables yourself.)
+
+So what syntax is available in created statements@?  All the capital
+letters except @samp{V} (which is an operator in @ical{}) are
+available and can be used freely and as many times as desired; they
+match themselves literally.  Whitespace is allowed, but is ignored
+(both in the @code{CREATE} template statement, and in the code being
+created; so @code{DO SW ITCH :8 WITH :50} will also have been
+created).  Then, there are three groups of matchable data: scalar
+variables (onespot or twospot variables, as used in the examples
+above) match other scalar variables, array elements (like @code{,4 SUB
+'.5~.6'}) match other array elements, and other expressions match
+other other expressions.  Two matchable data may not appear
+consecutively in a created command, but must be separated by at least
+one capital letter (to prevent array-subscript-related ambiguities;
+remember that the just-in-case compiler has to compile these
+statements at compile time without knowing what they are).  The actual
+expressions used in the @code{CREATE} statement don't matter; they're
+just examples for the runtime to match against.
+
+Some other points: a newer @code{CREATE} statement supercedes an older
+@code{CREATE} statement if they give equivalent templates, multiple
+@code{CREATE} statements may aim at the same line (this is the
+recommended technique for creating a statement that can handle
+expressions even if they're array elements or variables; you do this
+by specifying multiple templates in multiple @code{CREATE}
+statements), and strange things happen if a twospot variable in the
+1600-range is used as an argument to a created statement itself
+(because of the stash/retrieve, such a variable can usually be read,
+but may not always be able to be written without the data being lost).
+
 @node External Calls
 @chapter External Calls
 @cindex external calls
@@ -4434,10 +4590,12 @@ level until it is changed), or to ignore the input received.
 @cindex foreign functions
 @cindex calls, external
 
-@cic{} (from version 0.28 onwards) has a feature allowing @ical{} and
-non-@ical{} code to be mixed.  This is achieved by causing the
-non-@ical{} programs to participate in the @ical{} line-numbering
-model.
+@portability{no, version 0.28+, no, no}
+
+@cic{} has a feature allowing @ical{} and non-@ical{} code to be
+mixed.  This is achieved by causing the non-@ical{} programs to
+participate in the @ical{} line-numbering model.  The same feature
+allows expansion libraries to be linked into the code.
 
 To create a combined program containing @ical{} and non-@ical{} code,
 use @command{ick} as the compiler as normal, but specify both the
@@ -4456,10 +4614,14 @@ or the non-@ical{} program to @code{COME FROM} or @code{NEXT FROM} the
 non-@ical{} program first.
 
 Note that external calls are incompatible with PIC-INTERCAL and with
-multithreading.
+multithreading; note also that you must use @command{gcc} as your
+compiler, and @acronym{GNU} cpp and ld, for them to work in the
+current version of @cic{}.
 
 @menu
 * External Calls to C::      How to put @ical{} calls in C.
+* Using External Calls::     What happens when you use -e.
+* Expansion Libraries::      Expanding the compiler's capabilities.
 @end menu
 
 @node External Calls to C
@@ -4490,6 +4652,29 @@ starting with @code{ick_} or @code{ICK_} should be used anywhere in
 the linked C program for any reason, except where specified in this
 manual.
 
+@menu
+* External C Call Infrastructure:: Enabling a C program for external calls
+* ick_startup::                    Doing things at startup
+* ick_linelabel::                  Labelling lines...
+* ick_labeledblock::               ...and labelling blocks
+* ick_comefrom and ick_nextfrom::  Stealing control from elsewhere
+* ick_next::                       The INTERCAL answer to subroutine calls
+* ick_resume::                     Going back to before a NEXT
+* ick_forget::                     Discarding NEXT stack entries
+* ick_get/setone/twospot::         Accessing INTERCAL variables from C
+* ick_create::                     CREATE statements via external calls
+* External Calls and auto::        Considerations for auto variables
+@end menu
+
+@node External C Call Infrastructure
+@subsection External C Call Infrastructure
+@cindex C, external call infrastructure
+@cindex external calls, C infrastructure
+
+For a C program to be connected to an @ical{} program, it needs to be
+marked with the correct header file, and needs to have functions marked
+for communication with the @ical{} program.
+
 @table @code
 
 @item #include <ick_ec.h>
@@ -4498,7 +4683,13 @@ The header file @file{ick_ec.h} must be included using the
 preprocessor in any file which uses any of the @ical{} external call
 functions, variables, or macros.  (Note that this file may not
 necessarily exist, or exist in the usual place; @command{ick} will
-deal with making sure the correct header file is included.)
+deal with making sure the correct header file is included.)  This will
+include @file{stdint.h} (a standard C header file, which must exist on
+your system), so that you can access @ical{} variables (the @ical{}
+types onespot, twospot, tail, hybrid correspond to the C types
+uint16_t, uint32_t, uint16_t*, uint32_t* respectively); also, it will
+provide the prototypes for all the functions below on this page and
+definitions for all the macros below on this page.
 
 @item ICK_EC_FUNC_START
 @itemx ICK_EC_FUNC_END
@@ -4549,7 +4740,32 @@ by some means at that point, but may fail.  If a function is unsure
 whether it gained control from C or from INTERCAL code, it may use
 @code{ick_return_or_resume} (described below).
 
-@item ick_linelabel
+Because you are not allowed to declare two C functions with the same
+name (even in different modules), all functions declared with
+@code{ICK_EC_FUNC_START} must have unique names across the entire
+compilation.
+
+@end table
+
+@node ick_startup
+@subsection ick_startup
+@findex ick_startup
+@cindex startup code, C
+
+It is sometimes necessary for a C program to do its own initialisation
+before the INTERCAL program starts running.  To do so, it can use the
+@code{ick_startup} macro inside a function declared with
+@code{ICK_EC_FUNC_START}; the syntax is @code{ick_startup(block)},
+where the argument is an expression, statement, or compound statement
+to run.  The argument itself must not contain any ick_-prefixed macros
+or functions, may have side effects, and must fit the C preprocessor's
+idea of what a macro argument should look like (it's more used to
+parsing expressions than blocks; the general rule is to avoid commas
+except when they're directly or indirectly inside parentheses or
+strings).
+
+@node ick_linelabel
+@subsection ick_linelabel
 @findex ick_linelabel
 @cindex line labels, C
 
@@ -4585,7 +4801,8 @@ imaginary label preceding it.  Due to this possibility, an
 @code{ick_linelabel} is only allowed within a function defined with
 @code{ICK_EC_FUNC_START}.
 
-@item ick_labeledblock
+@node ick_labeledblock
+@subsection ick_labeledblock
 @findex ick_labeledblock
 @cindex labeled blocks
 @cindex blocks, labeled
@@ -4611,8 +4828,8 @@ computed line labels are allowed, but the expression that computes
 them must not have side effects, and it is only allowed within a
 function defined with @code{ICK_EC_FUNC_START}).
 
-@item ick_comefrom
-@itemx ick_nextfrom
+@node ick_comefrom and ick_nextfrom
+@subsection ick_comefrom and ick_nextfrom
 @findex ick_comefrom
 @findex ick_nextfrom
 @cindex COME FROM, in C
@@ -4641,92 +4858,437 @@ will do nothing if the expression evaluates to a value larger than
 65535).  In keeping with the best C traditions, these caveats are not
 checked, but instead result in undefined behaviour if breached.
 
-@item ick_next
+@findex ick_comefromif
+@findex ick_nextfromif
+There are also versions @code{ick_comefromif} and @code{ick_nextfromif},
+which take a second parameter, which is a condition that specifies
+whether control is actually stolen from the target.  The condition may
+have side effects, and is only run when the line numbers match; it should
+return 0 or NULL to leave control flow alone, or nonzero to steal
+control, and should be either an integral type or a pointer type.
+Although side effects are allowed, the condition must not look at or
+alter @code{auto} or @code{register} variables in the enclosing function,
+not even if they are also marked @code{volatile}.  (Global and
+@code{static} variables are fine, though.)
+
+@node ick_next
+@subsection ick_next
 @findex ick_next
 @cindex NEXT, in C
 
 @code{ick_next} is a macro that acts like the @ical{} statement
-@code{NEXT}.  Contrary to the other @ical{}-like macros, it can be
-used in any function regardless of whether it was defined with
-@code{ICK_EC_FUNC_START}; however, it must still be used as a
-statement by itself, and a call to it looks like
-@code{ick_next(expression);}.  The expression is the label to
-@code{NEXT} to, and works under the same rules as the expressions for
-@code{ick_comefrom}; it need not be constant (unlike in @cic{}!), but
-must not have side effects, must not be negative, must fit into the
-range of an unsigned long, and is ignored if it is over 65535.  If
-there happen to be multiple labels with the correct value at the time,
-the compiler will @code{NEXT} to one of them.
+@code{NEXT}.  Contrary to the other @ical{}-like macros, it can be used
+in any function regardless of whether it was defined with
+@code{ICK_EC_FUNC_START}; however, it must still be used as a statement
+by itself, and a call to it looks like @code{ick_next(expression);}.  The
+expression is the label to @code{NEXT} to, and works under the same rules
+as the expressions for @code{ick_comefrom}; it need not be constant
+(unlike in @cic{}!), but must not have side effects, must not be
+negative, must fit into the range of an unsigned long, and is ignored if
+it is over 65535.  If there happen to be multiple labels with the correct
+value at the time, the compiler will @code{NEXT} to one of them.  Bear in
+mind that there is a limit of 80 entries to the @code{NEXT} stack, and
+that this limit is enforced.
 
 If the resulting @code{NEXT} stack entry is @code{RESUME}d to, the
-program will continue after the @code{ick_next} as if via
-@code{setjmp}, with all the usual restrictions that that entails; if
-the resulting @code{NEXT} stack entry is forgotten, then the
-@code{ick_next} call will never return.
-
-@item ick_resume
+program will continue after the @code{ick_next} as if via @code{setjmp},
+with all the usual restrictions that that entails; if the resulting
+@code{NEXT} stack entry is forgotten, then the @code{ick_next} call will
+never return.  (Notice the 'as if via setjmp' condition allows you to
+preserve the vales of @code{auto} and @code{alloca}-allocated storage as
+long as its value has not changed since the @code{ick_next} was called,
+which is a significantly more lenient condition than that normally
+imposed on such variables (@pxref{External Calls and auto}).
+
+@node ick_resume
+@subsection ick_resume
 @findex ick_resume
 @cindex RESUME, in C
 
-@code{ick_resume} is a macro, but there are few restrictions on its
-use; it is permitted to use it inside an expression (but it returns
-void, making this not particularly useful), and acts like a function
-which takes an unsigned short argument, returns void, and has a
-prototype (but you cannot take its address; if you need to be able to
-do that, write a wrapper function for it).  It can be used within any
-function regardless of how it was declared, and never returns;
-instead, it pops the specified number of @code{NEXT} stack entries and
-resumes execution at the last one popped, just as the @ical{}
-statement does.  This causes the same errors as the @ical{} statement
-if the amount of entries popped is zero or larger than the @code{NEXT}
-stack.
-
-@item ick_return_or_resume
-@findex ick_return_or_resume
-
-This macro must be called as @code{ick_return_or_resume();}; it can
-only be used inside a function defined with @code{ICK_EC_FUNC_START},
-and is equivalent to @code{return;} if the function was called from C,
-or @code{ick_resume(1);} if the function was called from @ical{}.
-It's therefore a safe way to return from such a C function if you
-don't know how control reached it in the first place.
+@code{ick_resume} is a macro, but there are few restrictions on its use;
+it is permitted to use it inside an expression (but it returns void,
+making this not particularly useful), and acts like a function which
+takes an unsigned short argument, returns void, and has a prototype (but
+you cannot take its address; if you need to be able to do that, write a
+wrapper function for it).  It can be used within any function regardless
+of how it was declared, and never returns; instead, it pops the specified
+number of @code{NEXT} stack entries and resumes execution at the last one
+popped, just as the @ical{} statement does.  This causes the same errors
+as the @ical{} statement if the amount of entries popped is zero or
+larger than the @code{NEXT} stack.
 
-@item ick_forget
+@findex ick_return_or_resume
+There is also a macro @code{ick_return_or_resume();}; it can only be used
+inside a function defined with @code{ICK_EC_FUNC_START}, and is
+equivalent to @code{return;} if the function was called from C, or
+@code{ick_resume(1);} if the function was called from @ical{}.  It's
+therefore a safe way to return from such a C function if you don't know
+how control reached it in the first place.
+
+@node ick_forget
+@subsection ick_forget
 @findex ick_forget
 @cindex FORGET, in C
 
-This is actually a function (prototype @code{void ick_forget(unsigned
-short)}), that serves the purpose of removing items from the
-@code{NEXT} stack.  More so than other @ical{} flow control
-statements, though, this one has several technical issues.  As it is a
-function, it can be called from anywhere (and it's even possible to
-take its address), and it always removes the stated number of items
-from the @code{NEXT} stack (or as many as possible if that number is
-more than the number of items on the @code{NEXT} stack), but it is
-incapable of deallocating the corresponding entries on C's call
-stack.  To avoid causing a memory leak, therefore, it is neccessary to
-make sure that the C call stack entries are deallocated, which will
-happen in the following situations:
+The @code{ick_forget} macro removes @code{NEXT} stack entries, and the
+corresponding C stack entries. It must be called as a statement by
+itself, and its invocation looks like this: @code{ick_forget(expr);},
+where the expression is the number of @code{NEXT} stack entries to forget
+(all of them will be forgotten if the number is higher than the number of
+entries).  The expression will be casted to an @code{unsigned short}.
+
+@code{ick_forget} can only be used inside a function declared with
+@code{ICK_EC_FUNC_START}.  As it is removing stack entries both in
+@ical{} and in C, it will clobber the value of all @code{auto} variables
+created since the highest remaining @code{NEXT} stack entry came into
+being (or since the start of the program, if the @code{NEXT} stack is
+emptied by the command) and also deallocate all @code{alloca} storage
+allocated since then.  It also causes the return address of the current
+function to become undefined, so that function must not return; control
+may leave it via @code{RESUME}, or via @code{COME FROM}, or via
+@code{NEXT} or @code{NEXT FROM} followed by the relevant @code{NEXT}
+stack entry being forgotten (the function is still 'running' but
+suspended while the @code{NEXT} stack entry still exists).  (Note that
+these restrictions are stronger than those on @code{RESUME}; this is
+because @code{RESUME} preserves most of the stack, but @code{FORGET}
+destroys parts of the stack and therefore cannot avoid destroying the
+data stored there.  It could be much worse; a previous (never released)
+version of the code didn't remove those parts of the stack in many
+circumstances, leading to a stack leak that caused programs to segfault
+after a while.)
+
+@node ick_get/setone/twospot
+@subsection ick_get/setone/twospot
+@findex ick_getonespot
+@findex ick_setonespot
+@findex ick_gettwospot
+@findex ick_settwospot
+@cindex variables, from C
+
+This class of four functions make it possible to get and set @ical{}
+scalar variables from C code.  Their prototypes are as follows:
 
-@itemize
-@item
-when a @code{NEXT} stack entry below the forgotten @code{NEXT} stack
-entries is @code{RESUME}d to (note that @code{RESUMING} to a low
-@code{NEXT} stack entry is not a problem), all those forgotten entries
-will have their memory deallocated, and
-@item
-whenever a line label is encountered, all but one of the @code{NEXT}
-stack entries that were forgotten before the most recent @code{NEXT}
-or @code{NEXT FROM} will have their memory deallocated.  (This second
-situation is not particularly useful, as it cannot prevent the C stack
-entries leaking out of control, but it can help to some extent.)
-@end itemize
+@example
+uint16_t ick_getonespot(unsigned short varnumber);
+void ick_setonespot(unsigned short varnumber, uint16_t newvalue);
+uint32_t ick_gettwospot(unsigned short varnumber);
+void ick_settwospot(unsigned short varnumber, uint32_t newvalue);
+@end example
 
-Even worse, even @code{FORGET}s in an @ical{} program have the same
-problem if it is linked to a C program (due to their need to be able
-to handle @code{NEXT} stack entries in a general manner), so the moral
-of the story is: @code{FORGET} is evil. Use @code{COME FROM} instead.
-@end table
+The program will error out with a fatal error (@pxref{E200}) if the
+variable you request is mentioned nowhere in the @ical{} program; if
+you attempt to set an @code{IGNORE}d variable, the attempt will
+silently fail (just as if you assigned to it in an @ical{} program).
+The get functions are safe to use in a computed line label, so you can
+use them to produce computed line labels that depend on @ical{}
+variables.  (@code{uint16_t} and @code{uint32_t} are standard C data
+types; if your system doesn't provide them, get better system header
+files.)
+
+If you care about speed, note that .1 is the fastest variable of all
+to access, and otherwise variables first mentioned near the top of the
+@ical{} program will be faster to access than variables mentioned
+lower down.
+
+@node ick_create
+@subsection ick_create
+@cindex CREATE, in C
+@cindex C, CREATE
+
+The @code{ick_create} function (prototype: @code{void
+ick_create(char*, unsigned long)}) allows the external calls system to
+be used to create new @ical{} syntax; to do this, you give a
+`signature' representing the syntax you want to define and a line
+number to the function (which are its two arguments, respectively).
+The signature defines the syntax that you are defining; whenever that
+syntax is encountered within the @ical{} program, it will @code{NEXT}
+to the line number you specify, which can do various clever things and
+then @code{RESUME} back to the @ical{} program (or if you're defining
+a flow-control operation, you might want to @code{FORGET} or even
+leave the @code{NEXT} stack entry there and do other things).  This
+allows the external calls system to define whole new @ical{} commands,
+with the same power as any other programming language.
+
+There are various restrictions on what syntax you can @code{CREATE}
+with this method, which are best explained by an explanation of the
+relevant @cic{} compiler internals.  When an @ical{} program is
+compiled by @cic{}, any unrecognised statements it comes across are
+compiled by a `just-in-case' compiler that attempts to compile them
+anyway with no knowledge of their syntax, just in case the syntax
+becomes defined later.  (E000 (@pxref{E000}) will be thrown when such
+statements are encountered at runtime, unless the syntax has been
+@code{CREATE}d since to give a statement a meaning.)  For the
+just-in-case compiler to run, the resulting statement must be
+completely unrecognised; this means that it may contain no keywords
+(not even a sequence of letters that forms a keyword, such as
+@code{FROM} or @code{DO}), it must consist only of variable names,
+expressions, and capital letters other than @samp{V} (because @samp{V}
+is a unary operator, so otherwise there would be ambiguity), and in
+which any two variable names or expressions are separated by at least
+one capital letter.  The compiler will produce a `signature' for the
+unknown command that can be defined.
+
+A signature consists of a sequence of characters (and is represented
+as a null-terminated string; the runtime makes a shallow copy of the
+string and keeps it until the end of the program, so arrangements must
+be made to ensure that the storage in which the string is allocated
+stays around that long, but this opens up interesting possibilities in
+which the signature that was actually @code{CREATE}d can be modified
+retroactively); whitespace is not allowed in a signature.  Capital
+letters can be used (apart from @samp{V}), and match the same capital
+letters literally in the @ical{} syntax being created; also available
+are the special characters @samp{.,;~}, which match respectively a
+scalar variable (a onespot or twospot variable such as @code{:1}), an
+array variable (such as @code{;2}), an array element (such as @code{,3
+SUB #4 #5}), and an expression that isn't a variable name and isn't an
+array element (such as @code{.4$.5}).  If you want to be able to match
+other things (say, to be able to match all expressions), you will need
+to submit multiple signatures using multiple calls to
+@code{ick_create}; maybe you could write a library to do that
+automatically.
+
+The routine that is @code{NEXT}ed to will presumably want to be able
+to see what in the @ical{} program was matched by the signature, so a
+range of function-like macros is provided to access that.  They must
+be run from within the invocation of the function which was
+@code{NEXT}ed into by the created syntax (@pxref{External Calls and
+auto} for when a function invocation ends, which could be sooner than
+you think when the @cic{} external calls system is used), and are
+undefined behaviour when that invocation did not gain control from a
+@code{CREATE}d statement.  Here are their effective prototypes:
+
+@example
+int ick_c_width(int);
+int ick_c_isarray(int);
+unsigned short ick_c_varnumber(int);
+uint32_t ick_c_value(int);
+/* These require -a to work */
+uint32_t ick_c_getvalue(int);
+void ick_c_setvalue(int, uint32_t);
+@end example
+
+The first argument to all these macros is the position of the match in
+the signature (0 for the first non-capital-letter match in the
+signature, 1 for the second, and so on until no more items are left in
+the signature to match); specifying a position that isn't in the
+signature is undefined behaviour.
+
+@code{ick_c_width} returns the data type, as a width in bits, of the
+expression (or the width in bits of an element of the passed in
+array), and @code{ick_c_isarray} returns 1 if the argument was an
+array variable or 0 if it was an expression (array elements and scalar
+variables are expressions).  @code{ick_c_varnumber} returns the
+variable's number (for instance 123 for @code{.123}), or 0 if the
+corresponding argument was not a variable; in the cases where the
+argument was a variable, these three functions together provide enough
+information to figure out which variable (which is useful if you're
+writing an extension which takes a variable name as an argument).
+
+@code{ick_c_value} returns the value of the corresponding expression
+at the time the @code{CREATE}d command was called;
+@code{ick_c_getvalue} is almost equivalent, but only works if the
+@option{-a} option (@pxref{-a}) was used during compilation, and
+returns the value of the corresponding expression now.  (The uint32_t
+return type is large enough to hold either a onespot or twospot value,
+and will be zero-extended if the corresponding expression had onespot
+type.)  @code{ick_c_setvalue} also depends on @option{-a}, and will
+assign to the corresponding expression (be careful not to provide a
+value that is too large for it!@:).  In the case that the corresponding
+expression is not a variable, this will attempt to perform a reverse
+assignment to the expression, and can produce ordinary @ical{} errors
+if it fails.  It is not possible to redimension an array this way, as
+this is assignment, not a calculate operation.
+
+@node External Calls and auto
+@subsection External Calls and auto
+@cindex auto
+@cindex alloca
+@cindex external calls, and auto
+@cindex C, auto/alloca
+
+Because the external calls system merges the @ical{} @code{NEXT} stack
+with the C return value and data storage stack (note for pedants: the C
+standards nowhere mandate the existence of such a stack, or even mention
+one, but the restrictions stated in them imply that implementations have
+to act as if such a stack existed, because of the way the scoping rules
+and recursion work), the external calls system therefore has severe
+effects on data that happens to be stored there.  (In @ical{} terms,
+imagine what would happen if data could be stored on the @code{NEXT}
+stack; if C used the more sensible system of having a @code{STASH} for
+each variable, these problems would never occur in the first place,
+instead causing an entirely differnet set of problems.)  Similar
+considerations apply to the common nonstandard C extension @code{alloca},
+which dynamically alters the size of the stack; also, in what goes below,
+@code{register} variables should be considered to be @code{auto}, because
+the compiler may choose to allocate them on the stack.  Theoretical
+considerations would lead one to conclude that variable-length arrays
+should obey most of the same restrictions; in practice, though, it's
+unwise to attempt to mix those with @ical{} code at all, except by
+separating them into separate functions which aren't flagged with
+@code{ICK_EC_FUNC_START} and use no @code{ick_}-prefixed identifiers,
+even indirectly.  (They may cause a compile to fail completely because
+they don't mix well with @code{goto}.)
+
+In the description below, @ical{} commands should be taken to include the
+equivalent C macros.
+
+@code{NEXT}/@code{NEXT FROM} paired with @code{RESUME} have the least
+effect, and the most obvious effect, on @code{auto} variables in the
+function that was @code{NEXT}ed from, which is the same effect that the
+standard C function @code{longjmp} has.  That is, @code{alloca} storage
+stays intact, and @code{auto} variables have their values `clobbered'
+(that is, their value is no longer reliable and should not be used) if
+they changed since the corresponding @code{NEXT} and are not marked as
+@code{volatile}.  (This is a very easy restriction to get around, because
+changing the values of such variables is quite difficult without using
+statically-allocated pointers to point to them (a dubious practice in any
+case), and @code{volatile} is trivial to add to the declaration.)
+
+@code{COME FROM} has more restrictions; it deallocates all @code{alloca}
+storage in the function that was @code{COME FROM}, and functions that
+called it or that called functions that called it, etc.@:, using C calls
+(as opposed to @code{NEXT}), and those invocations of the functions will
+cease to exist (thus destroying any @code{auto} variables in them), even
+in the case of @code{COMING FROM} a function into the same function.
+@code{auto} variables in the function that is come into will start
+uninitialised, even if initialisers are given in their declaration, and
+it will be a `new' invocation of that function.  (It is quite possible
+that the uninitialised values in the @code{auto} variables will happen by
+chance to have the values they had in some previous invocation of the
+function, though, because they are likely to be stored in much the same
+region of memory; but it is highly unwise to rely on this.)  Note that
+@code{volatile} will not help here.  Observant or source-code-reading
+readers may note that there is a mention of an @code{ick_goto} in the
+source code to @cic{}; this is undocumented and this manual does not
+officially claim that such a macro exists (after all, if it did, what in
+@ical{} could it possibly correspond to?), but if such a macro does exist
+it obeys the same restrictions as @code{COME FROM}.
+
+@code{FORGET} is the worst of all in terms of preserving data on the
+stack; it deallocates @code{alloca} data and clobbers or deletes
+@code{auto} variables in all function invocations that have come into
+existence since the @code{NEXT} that created topmost remaining
+@code{NEXT} stack entry was called, or since the start of the program if
+the @code{NEXT} stack is emptied, and the current function will continue
+in a new invocation.  @code{volatile} is useless in preventing this,
+because the relevant parts of the stack where the data were stored are
+deleted by the command (that's what @code{FORGET} does, remove stack).
+If any of these data are required, they have to be backed up into static
+storage (variables declared with @code{static} or global variables), or
+into heap storage (as in with @code{malloc}), or other types of storage
+(such as temporary files) which are not on the stack.  (Incidentally,
+suddenly deleting parts of the stack is excellent at confusing C
+debuggers; but even @code{RESUME} and @code{COME FROM} tend to be
+sufficient to confuse such debuggers.  More worrying is probably the fact
+that the C standard provides a portable method for deleting the stack
+like that, and in fact the external calls runtime library is written in
+standard freestanding-legal C89 (with the exception of
+@option{+printflow} debug output which requires a hosted implementation),
+meaning that in theory it would be possible to split it out to create an
+implementation of a C-plus-COME-FROM-and-NEXT language, and doing so
+would not be particularly difficult.)
+
+Note that @ical{} variables are not stored on the C stack, nor are any of
+the metadata surrounding them, and so are not affected unduly by control
+flow operations.
+
+@node Using External Calls
+@section Using External Calls
+@cindex using external calls
+@cindex external calls, using
+
+Whatever language your source files are written in, when @option{-e}
+is used (@pxref{-e}), the compiler will go through much the same
+steps.
+
+First, the @ical{} program specified is compiled into a C program that
+uses the @ical{} external call conventions for its control flow
+operations.  The resulting @samp{.c} file will be left behind in the
+same directory (even if @option{-g} isn't used); if you look at it,
+you'll see the @code{#include <ick_ec.h>} line, and the other
+hallmarks of an external call program (for instance, @ical{}
+@code{NEXT}s will translate into slightly modified @code{ick_next}s;
+the modification is simply to allow the correct line number to be
+displayed in case of error).
+
+After that, the resulting files are preprocessed twice.  First, the C
+preprocessor is run on the files; then, a special @cic{}
+`preprocessor' is run on the files.  (`Preprocessor' is a bit of a
+misnomer here, as it's near the end of the compilation process;
+`postprocessor' would likely be more accurate, or maybe
+`interprocessor'.)  Its job is to fix line labels between the gotos
+that are used to implement jumping into the middle of a C function, to
+assign unique numbers to things that need them, and to keep track of
+which functions need to be checked for line labels and for @code{COME
+FROM}s and @code{NEXT FROM}s.  The resulting file will have the
+extension @samp{.cio}; it is almost human-readable, especially if you
+run it through a C code indenter, and consists of C code (or code in
+whatever language is being linked to the @ical{} code, but so far only
+C is accepted) and instructions to @command{gcc}.  The @samp{.cio}
+file will be left behind for you to look at, if you like.
+
+Once the @samp{.cio} files have been produced, @command{gcc} is used
+to compile all the @samp{.cio} files and link them together into an
+executable; the executable will have the same name as the @ical{}
+source, minus any extension (and on DJGPP, assuming that its version
+of @command{gcc} could handle the resulting command line (not
+necessarily guaranteed), a @samp{.exe} extension is added), and will
+consist of all the C files linked together with the @ical{}.  Any
+functions named @code{main} in the C files will be deleted; likewise,
+if there is a name clash between any two functions, the one in the
+file named earlier on the command line will be used.  There is
+presumably some use for this feature, although I haven't figured out
+what it is yet.
+
+Extending this to other compiled languages is mostly a problem of
+determining how they fit into the @ical{} control structure, which is
+not a trivial task, and of figuring out how to link them to C code,
+which in some cases is trivial (especially if the language is one that
+@command{gcc} can compile!) and in other cases is very difficult.  If
+anyone has any ideas of new languages that could be added to the
+external calls system, feel free to contact the current @cic{}
+maintainer with suggestions or patches.
+
+@node Expansion Libraries
+@section Expansion Libraries
+@cindex expansion libraries
+@cindex libraries
+
+The @cic{} distribution comes with libraries that can be used to
+extend its capabilities; they are implemented using the external call
+mechanism, and are in effect standard files to include using that
+mechanism.  To use an expansion library, give the @option{-e} option
+to @command{ick} (note that this means you cannot use them with the
+debugger or profiler, nor with multithreaded or backtracking
+programs), and specify the expansion library's name at the end of the
+command line (or to be precise, anywhere after the initial @ical{}
+file).  The libraries themselves are written in C and have a @samp{.c}
+extension, and are human-readable; @cic{} will look for them in the
+same place as it looks for the system library (including in the
+current directory, so you can test your own expansion libraries
+without having to install them).
+
+Expansion libraries are available from @cic{} version 0.28; @clcic{}
+has a similar concept (that of `preloads'), but implemented a
+completely different way.
+
+@subheading syslibc
+@findex syslibc
+
+@option{syslibc} is an implementation of the base-2 @ical{} system
+library in C (@pxref{System Library}); using it in programs running in
+other bases is accepted by the compiler, but likely to produce
+unpredictable results.  When using this expansion library, you also
+need to give the @option{-E} option (@pxref{-E+,,-E}) so that the main
+system library is not included, or it will be used in preference to
+the expansion library.  All documented features of the @ical{} base-2
+system library are implemented, but most undocumented features are
+not, so @ical{} programs which relied on them (dubious behaviour in
+any case) will not work with @option{syslibc}.  The main reason to use
+this library is to increase the speed of an @ical{} program; however,
+note that the speed gains in arithmetic will be accompanied by the
+performance penalty of using the external calls infrastructure, unless
+you were already using it.
 
 @node Differences to Other Compilers
 @chapter Differences to Other Compilers
@@ -4735,6 +5297,7 @@ of the story is: @code{FORGET} is evil. Use @code{COME FROM} instead.
 The @cic{} compiler exists in a world of several other compilers.
 
 @subheading Differences to the Princeton compiler
+@cindex Princeton compiler
 The Princeton compiler was the first @ical{} compiler available, and
 compiled @icst{}.  Using @command{convickt} (@pxref{convickt}) to
 translate its programs from the original EBCDIC to Latin-1 or
@@ -4752,6 +5315,7 @@ basically backward-compatible anyway this mostly serves to check newer
 programs for compatibility with older compilers.
 
 @subheading Differences to the Atari compiler
+@cindex Atari compiler
 The Atari compiler was another implementation of @icst{}, which was
 basically identical to the Princeton compiler apart from its use of
 ASCII and Atari syntax.  Everything said under the previous section
@@ -4760,6 +5324,7 @@ applies, except that as it uses the same syntax as @cic{} anyway
 to use @command{convickt}.
 
 @subheading Differences to @jic{}
+@cindex J-INTERCAL
 The @jic{} compiler is an implementation of @ical{} written in Java
 that compiles @ical{} into Java (and so has a similar relationship
 with Java to that of the @cic{} compiler (which is written in C and
@@ -4771,6 +5336,7 @@ also an Atari syntax compiler), except in nonportable cases such as
 @code{IGNORE}/@code{RETRIEVE} interaction.
 
 @subheading Differences to @clcic{}
+@cindex CLC-INTERCAL
 The @clcic{} compiler is the most modern @ical{} compiler apart from
 @cic{} (both compilers are maintained and updated every now and then
 as of the time of writing, so which is more modern is normally a

diff --git a/doc/ick.xml b/doc/ick.xml
deleted file mode 100644 (file)
index 7680d1b..0000000
--- a/doc/ick.xml
+++ /dev/null
@@ -1,7047 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd" [
-  <!ENTITY tex "TeX">
-  <!ENTITY latex "LaTeX">
-]>
-<book lang="en">
-  <title>C-INTERCAL 0.28 Revamped Instruction Manual</title>
-<!-- Command line option index. -->
-<!-- Error index -->
-<!-- Commands and language features are in the predefined fnindex. -->
-<!-- Things generally are in the predefined cpindex. -->
-<!-- Combining indices. -->
-<!-- Adding to the main documentation tree. -->
-<!-- Some macros to ease writing and updating. (The VERSION is set above because -->
-<!-- it's needed to set the title.) -->
-<!-- Part headings for unsplit output -->
-<!-- 'Portability' boxes -->
-<!-- Generating items and anchors together is also helpful. -->
-<!-- Some fixes for HTML. -->
-<!-- %**end of header -->
-  <replaceable>This manual is for <abbrev>C-INTERCAL</abbrev>version 0.28.  It does not replacethe old groff manual, nor is it designed to be read in conjunction withit; instead, it serves a different purpose, of providing informationuseful to users of <abbrev>C-INTERCAL</abbrev>(unlike the other manual, it is not derivedfrom the original <abbrev>INTERCAL-72</abbrev>manual).Copyright &copy; 2007 Alex Smith.
-    <screen>Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
-Texts.  A copy of the license is included in the section entitled
-&ldquo;GNU Free Documentation License.&rdquo;
-
-</screen>              </replaceable>
-  <chapter label="" xreflabel="C-INTERCAL 0.28" id="Top">
-    <para>C-INTERCAL 0.28
-This manual is for <abbrev>C-INTERCAL</abbrev> version 0.28.  It does not replace
-the old groff manual, nor is it designed to be read in conjunction with
-it; instead, it serves a different purpose, of providing information
-useful to users of <abbrev>C-INTERCAL</abbrev> (unlike the other manual, it is not derived
-from the original <abbrev>INTERCAL-72</abbrev> manual).</para>
-    <para>Copyright &copy; 2007 Alex Smith.</para>
-    <screen>Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
-Texts.  A copy of the license is included in the section entitled
-&ldquo;GNU Free Documentation License.&rdquo;
-
-</screen>              
-  </chapter>
-
-  <chapter label="" xreflabel="About this manual" id="About-this-manual">
-    <para>About this manual</para>
-    <informalfigure>About this manual</informalfigure>
-    <para>This is the Revamped Instruction Manual for <abbrev>C-INTERCAL</abbrev> (this version is
-distributed with <abbrev>C-INTERCAL</abbrev> version 0.28).  It is divided into
-four parts.</para>
-    <para>The first part is about the <abbrev>C-INTERCAL</abbrev> compiler <command>ick</command>, and how to
-use it. It covers installing the compiler, using the compiler, what
-error and warning messages are produced by the compiler, and some
-information on how to use the debugger.</para>
-    <para>The second part is about the core <acronym>INTERCAL</acronym> language, invented in 1972,
-and some other commands since then which don't feel like they're
-extensions.  (This is a pretty arbitrary distinction, but people who
-write the documentation are entitled to arbitrary distinctions.  The
-manual's licensed under a license that lets you change it
-(see ), so if you disagree you can move the commands from
-section to section yourself.)  Mostly only commands that are
-implemented in <abbrev>C-INTERCAL</abbrev> are covered here (if you're interested in the
-other commands implemented in other compilers, read <abbrev>CLC-INTERCAL</abbrev>'s
-documentation).  However, a comprehensive guide to portability of
-these commands between <abbrev>C-INTERCAL</abbrev> and other <acronym>INTERCAL</acronym> compilers is given.</para>
-    <para>The third part covers the <acronym>INTERCAL</acronym> extensions and dialects that are
-implemented by <abbrev>C-INTERCAL</abbrev>, such as TriINTERCAL and Threaded <acronym>INTERCAL</acronym>.
-Again, extensions and dialects not implemented have been mostly left
-out.</para>
-    <para>The final part contains appendices (which were known as `tonsils' in
-the original <acronym>INTERCAL</acronym> manual), such as character sets used by <acronym>INTERCAL</acronym>,
-programs other than <command>ick</command> in the <abbrev>C-INTERCAL</abbrev> distribution,
-information on how to read and update the list of optimizer idioms
-used by the compiler, and the copyright.</para>
-  </chapter>
-
-  <chapter label="" xreflabel="PART I: THE C-INTERCAL COMPILER">
-    <para>PART I: THE <abbrev>C-INTERCAL</abbrev> COMPILER</para>
-  </chapter>
-
-  <chapter label="1" id="Installation">
-    <para>Installation</para>
-    <informalfigure>installation</informalfigure>
-    <informalfigure><command>ick</command>, installing</informalfigure>
-    <para>The <abbrev>C-INTERCAL</abbrev> distribution is distributed in source code form; this means
-that before using it, you first have to compile it.  Don't worry: if you
-have the right software, it's not at all difficult.  Most Linux-based
-and UNIX-based computers are likely to have the software needed already;
-the software needed to compile source-distributed packages is also
-readily available for free for other operating systems.  The following
-instructions will help you install the distribution in a method
-appropriate for your system.</para>
-    <para>(If you happen to be using Debian or Ubuntu, you can also obtain and
-install binaries with the command &lsquo;<literal>sudo apt-get install
-intercal</literal>&rsquo;, making the rest of this chapter redundant.  If you do this,
-use Debian's bug tracker to report bugs, rather than reporting them
-directly to the maintainers.)</para>
-
-    <sect1 label="1.1" id="Obtaining">
-      <para>Obtaining</para>
-      <informalfigure>obtaining C-INTERCAL</informalfigure>
-      <informalfigure>C-INTERCAL, obtaining a copy</informalfigure>
-      <para><abbrev>C-INTERCAL</abbrev> distributions have been stored in many different places over
-time; it can sometimes be hard to make sure that you are finding the
-most recent version.  In order to make sure that you have the most
-recent version, the easiest way is to look at the
-alt.lang.intercal newsgroup; all releases
-of the <abbrev>C-INTERCAL</abbrev> compiler ought to be announced there.  (If you are
-interested in what other <acronym>INTERCAL</acronym> compilers are available, it may also be
-worth looking there.)  If you don't have access to a newsreader, your
-newsreader doesn't cover that newsgroup, or the distance between
-releases has been too large for your news server to keep the message,
-it's likely that you can find the announcement in an archive on the
-World Wide Web; at the time of writing (2007), the archives of the
-newsgroup are stored by Google Groups,
-and a search for &lsquo;<literal>alt.lang.intercal</literal>&rsquo; there should tell you where to
-find a copy.</para>
-      <para>If you're looking for the latest version, note that the number after the
-dot represents the major version number; you want to maximise this in
-favour of the number before the dot, which is the bugfix level within a
-major version.  (Major versions are released as version 0.whatever; if a
-new version comes out that fixes bugs but adds no new features, nowadays
-its number will be of the form 1.whatever, with the same major number.
-This has not always been the case, though.)</para>
-    </sect1>
-
-    <sect1 label="1.2" id="Unpacking">
-      <para>Unpacking</para>
-      <informalfigure>C-INTERCAL, unzipping</informalfigure>
-      <informalfigure>C-INTERCAL, unpacking</informalfigure>
-      <informalfigure>unzipping C-INTERCAL</informalfigure>
-      <informalfigure>unpacking C-INTERCAL</informalfigure>
-      <informalfigure>ick-0-28.tgz</informalfigure>
-      <para>The distribution is likely to be a single file with extension
-&lsquo;<literal>.tgz</literal>&rsquo;; this refers to a gzipped tar file.  Most computer systems
-can extract files in this format (nowadays even many computers running
-Windows have the appropriate software).</para>
-      <para>It doesn't matter where you extract the distribution file to: it's best
-if you don't put it anywhere special.  If you aren't an administrator,
-you should extract the file to somewhere in your home directory (Linux
-or UNIX-like systems) or to your My Documents directory (recent versions
-of Windows; if you're using an older version, then you <emphasis>are</emphasis> an
-administrator, or at least have the same privileges, and can extract it
-anywhere).  Some commands that you might use to extract it:</para>
-      <term><indexterm>Generic UNIX/Linux
-          <variablelist>
-            <programlisting>
-gunzip ick-0-28.tgz
-tar xvf ick-0-28.tar
-</programlisting>                                             On most UNIX-based and Linux-based systems, <command>tar</command> will beavailable to unpack the installation files once they've beenuncompressed with <command>gunzip</command>.  <command>gunzip</command> is also likely tobe available; if it isn't, you will need to download a copy from theInternet.</variablelist>
-        </indexterm><indexterm>Using GNU tar
-          <variablelist>
-            <programlisting>
-tar xzvf ick-0-28.tgz
-</programlisting>If you are using the GNU version of <command>tar</command> (which is very likelyon Linux), you can combine the two steps into one as shown here.</variablelist>
-        </indexterm><indexterm>Using DJGPP
-          <variablelist>
-            <programlisting>
-djtar -x ick-0-28.tgz
-</programlisting>On a DOS or Windows system, you will have to install DJGPP anyway to beable to compile the distribution (see ), and onceyou've done that you will be able to use DJGPP's decompressing andunpacking utility to extract the files needed to install thedistribution.  (You will need to type this at the command line; onWindows 95 and later, try choosing Run..&period; from the start menu thentyping <command>cmd</command> (or <command>command</command> if that fails) in the dialogbox that opens to get a command prompt, which you can exit by typing<command>exit</command>.  After typing any command at a command line, press<keycap>RET</keycap> to tell the shell to execute that command.)</variablelist>
-        </indexterm><indexterm>On Windows
-          <variablelist>If you're running a Windows system, you could always try double-clickingon the ick-0-28.tgz file.  It's quite possible thatyou'll have a program installed that's capable of decompressing andunpacking it.  Unfortunately, I can't guess what program that might be,so I can't give you any instructions for using it.</variablelist>
-        </indexterm>
-      </term>
-      <para>Whatever method you use, you should end up with a directory created
-called <filename>ick-0.28</filename>; this is your main installation
-directory where all the processing done by the installation will be
-carried out.  You will need to have that directory as the current
-directory during install (at the command prompt in all the operating
-systems I know, you can set the current directory by typing <command>cd
-ick-0.28</command>).</para>
-    </sect1>
-
-    <sect1 label="1.3" id="Simple-Installation">
-      <para>Simple Installation</para>
-      <informalfigure>installation, simple</informalfigure>
-      <informalfigure>simple installation</informalfigure>
-      <informalfigure>config.sh</informalfigure>
-      <informalfigure>configdj.sh</informalfigure>
-      <informalfigure>make</informalfigure>
-      <informalfigure>make install</informalfigure>
-      <informalfigure>compiling, <command>ick</command> itself</informalfigure>
-      <informalfigure>installation, via autoconf and make</informalfigure>
-      <informalfigure>configuring</informalfigure>
-      <para>There are scripts included in the distribution to automate the process
-of installing, in various ways.  The simplest method of installing is to
-use the following routine:</para>
-      <varlistentry numeration="arabic">
-        <variablelist>Configure <abbrev>C-INTERCAL</abbrev>, by typing <command>sh config.sh</command> (or <command>shconfigdj.sh</command> if you're using DJGPP)</variablelist>
-        <variablelist>Compile the source code, with the command <command>make</command></variablelist>
-        <variablelist>Install the executables, help files, include files, and libraries,using <command>make install</command>.  (This is the only step that needsroot/administrator permissions; so on a system that uses sudo toelevate permissions, for instance, write it as <command>sudo makeinstall</command>.)</variablelist>
-      </varlistentry>
-      <para>On all systems, it's worth just trying this to see if it works.  This
-requires a lot of software on your computer to work, but all of it is
-standard on Linux and UNIX systems.  The first command is a
-shell-script which will analyse your system and set settings
-accordingly; it will explain what it's doing and what settings it
-detected, and create several files in the installation directory to
-record its results.  (This is a configure script produced by the GNU
-autoconf (config.sh is produced by the Linux version, configdj.sh by
-the DJGPP version); its autoconf source code is available in the file
-<filename>config.in</filename>.)  The second command actually compiles the source
-code to produce binaries; this takes the longest of any of the steps.
-You will see all the commands that it's running as it runs them.  (The
-most time-consuming one is the compilation of <filename>idiotism.c</filename>, by
-the way; be prepared for this to take longer than the other
-compilations.)  The third command will copy the files it's compiled to
-appropriate shared locations on your system so that anyone on the
-system can just use <command>ick</command>.</para>
-      <para>There may be various factors that prevent this simple installation
-method working.  On a system not based on UNIX or Linux, you may find
-that you don't have some of the software required to run this (for
-instance, you may be missing the shell <command>sh</command>, and don't have the
-shell <command>bash</command> which can emulate it, and so can't run <command>sh
-config.sh</command> that depends on one of those shells being available) and so
-this method won't work for you.  In such cases, one solution may be to
-install all the software required; the GNU project has a version of all
-the commands required, for instance, and there may be ports available
-for your operating system.  However, the only software absolutely
-required is a C compiler (<abbrev>C-INTERCAL</abbrev> was designed to work with <command>gcc</command>
-and has only been tested in combination with that compiler, but in
-theory it should be possible to adapt it to work with other compilers)
-and the associated software needed to compile C files to object files
-and executables, combine object files into libraries, etc.</para>
-      <para>Another possiblity that might stop this process working is if your
-version of the relevant software is incompatible with the GNU versions
-that were used for testing.  For instance, I have come across
-proprietary versions of <command>lex</command> that need directives in the source
-file to say in advance how much memory the lexer-generator needs to
-allocate.  In such cases, pay attention to the error messages you're
-getting; normally they will suggest trivial modifications to the source
-files that will cause the compilation to work again.</para>
-      <informalfigure>installation, Debian</informalfigure>
-      <informalfigure>installation, Ubuntu</informalfigure>
-      <informalfigure>Debian</informalfigure>
-      <informalfigure>Ubuntu</informalfigure>
-      <para>Some Linux and UNIX systems (notably Debian and Ubuntu) don't have the
-required files for compilation installed by default.  To install them,
-just download and install the required packages: for Ubuntu at the
-time of writing, they are &lsquo;<literal>binutils</literal>&rsquo;, &lsquo;<literal>bison</literal>&rsquo;, &lsquo;<literal>cpp</literal>&rsquo;,
-&lsquo;<literal>flex</literal>&rsquo;, &lsquo;<literal>gcc</literal>&rsquo;, &lsquo;<literal>libc6-dev</literal>&rsquo;, &lsquo;<literal>make</literal>&rsquo; to compile
-<abbrev>C-INTERCAL</abbrev>, and if you want to modify it, you may also need
-&lsquo;<literal>autoconf</literal>&rsquo;.  For debugging help, you may also want &lsquo;<literal>gdb</literal>&rsquo;,
-and to recompile the documentation, you may need &lsquo;<literal>groff</literal>&rsquo;,
-&lsquo;<literal>tetex-bin</literal>&rsquo;, &lsquo;<literal>texinfo</literal>&rsquo;, and &lsquo;<literal>tidy</literal>&rsquo;.  Of course, if
-<acronym>INTERCAL</acronym> ever (the author of this sentence was going to write something
-like &ldquo;becomes popular, someone will probably package up a compiler
-for Debian or Ubuntu anyway&rdquo;, but at that point on a whim did an
-Ubunutu package search for 'intercal' and actually came up with two
-results, which look suspiciously like <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev>, later
-confirming this.  The author was vaguely aware that there was a
-<abbrev>CLC-INTERCAL</abbrev> package floating around, but was unaware of the <abbrev>C-INTERCAL</abbrev>
-package, and as a result was too surprised to finish the sentence.)</para>
-      <para>If you're trying to do something unusual, you probably want to set some
-of the settings yourself rather than letting the compilation process
-guess everything.  In this case, use <command>sh config.sh --help</command> to
-view the options that you can set on <command>config.sh</command>; there's a wide
-range of settings that you can set available there, and one of them may
-be what you want.  For the special case of a non-administrator user who
-wants to test the <abbrev>C-INTERCAL</abbrev> compiler without having admin rights, or
-equivalently any user who wants to test the compiler without installing
-it, see .</para>
-    </sect1>
-
-    <sect1 label="1.4" id="DOS-Windows-Install">
-      <para>DOS/Windows Install</para>
-      <informalfigure>installation, on DOS or Windows</informalfigure>
-      <informalfigure>DOS</informalfigure>
-      <informalfigure>Windows</informalfigure>
-      <informalfigure>DJGPP</informalfigure>
-      <informalfigure>makeick.sh</informalfigure>
-      <informalfigure>makeick.bat</informalfigure>
-      <para>On DOS and Windows, it's possible to install <abbrev>C-INTERCAL</abbrev> by using the C
-compiler and utilities provided by DJGPP.  (Possibly other environments
-also work, but DJGPP is the only C compilation system on which recent
-versions of <abbrev>C-INTERCAL</abbrev> have been tested.)  If you don't have a copy of DJGPP,
-or you're not sure whether you have the most recent version, visit
-http://www.delorie.com/djgpp.  I think it's possible to compile
-<abbrev>C-INTERCAL</abbrev> to binaries from only the files in the distribution and the C
-compilation parts of DJGPP, but this relies on some prebuilt files
-enclosed in the distribution, and I haven't actually tested this, so I
-might be wrong.  At the other extreme, if you download and install not
-only the DJGPP C compiler but also all the DJGPP ports of the GNU
-utilities required to run <command>config.sh</command> and <command>make</command>, you
-can use the simple installation method; see .
-(This is actually somewhat recommended; doing this will not only allow
-you to change source code, recompile, and be guaranteed to have your
-changes to the source code affect the executables, and allow you to
-install <abbrev>C-INTERCAL</abbrev> without having to fiddle around with the &lsquo;<literal>PATH</literal>&rsquo;
-environment variable, but also you may then be able to install other
-programs distributed in source form without further hassle.)</para>
-      <para>Assuming that you decide not to download all the utilites required to
-carry out a simple install, follow the following instructions to compile
-and install the <abbrev>C-INTERCAL</abbrev> compiler:</para>
-      <varlistentry numeration="arabic">
-        <variablelist>If you haven't already installed DJGPP, do that now, following theinstructions given there.</variablelist>
-        <variablelist>Open a command prompt if you aren't at one already, unpack thedistribution if you haven't already, and change directory to the maininstallation directory (see ).</variablelist>
-        <variablelist>Run one of two commands included in the distribution especially forinstalling <abbrev>C-INTERCAL</abbrev> under DJGPP.  Which one you run depends on the shellyou're using: if you're running under one of the DOS/Windows shells(<command>cmd.exe</command> or <command>command.com</command>), type<command>makeick.bat</command>, and if you're running under a port of a UNIX orLinux shell (such as <command>bash</command>), type <command>makeick.sh</command>.</variablelist>
-        <variablelist>The distribution should now have been compiled, but it still needs to beinstalled.  To do this, you will need to edit your &lsquo;<literal>PATH</literal>&rsquo;environment variable.  Under DOS and earlier versions of Windows, youcan do this by editing <filename>C:\autoexec.bat</filename>; look for the last commandthat sets the &lsquo;<literal>PATH</literal>&rsquo; environment variable (i&period;e&period; that startswith &lsquo;<literal>set PATH=</literal>&rsquo;), and add another semicolon and the <filename>bin</filename>subdirectory of your main installation directory to it (for instance, ifyour installation directory is<filename>C:\stuff\intercal\ick-0.28</filename>, you want to add&lsquo;<literal>;C:\stuff\intercal\ick-0.28\bin</literal>&rsquo; to the end of thatline).  Under later versions of Windows, this won't work (I'm not sureexactly where the cutoff is, but I know the other method doesn't work onWindows XP); instead, go via the Start menu to Settings, Control Panel,System, Advanced, Environment Variables, and edit either your own or thesystem-wide PATH setting (depending on whether you want to install foryourself or for everyone) to end with the <filename>bin</filename> subdirectory of themain installation directory, the same way as for older versions ofWindows.</variablelist>
-      </varlistentry>                                                             
-      <para>To test that the &lsquo;<literal>PATH</literal>&rsquo; setting is set correctly, try changing to
-an unrelated directory (for instance, by typing <command>cd \</command> at a
-command prompt), and typing <command>ick -@</command>; if you get a usage
-message for <command>ick</command>, then you've set the &lsquo;<literal>PATH</literal>&rsquo; setting
-correctly.  Note that if things go wrong during compilation, other than
-errors about inability to find <command>flex</command> or <command>bison</command> (the
-compilation process can succeed despite either of these errors), it's
-likely that you've messed up your DJGPP installation (maybe by setting
-the &lsquo;<literal>PATH</literal>&rsquo; or &lsquo;<literal>DJDIR</literal>&rsquo; environment variables incorrectly for
-it).</para>
-    </sect1>
-
-    <sect1 label="1.5" id="Not-Installing">
-      <para>Not Installing</para>
-      <informalfigure><command>ick</command>, using without installation</informalfigure>
-      <informalfigure><command>ick</command>, not installating</informalfigure>
-      <informalfigure>trying out <command>ick</command></informalfigure>
-      <informalfigure>not installing</informalfigure>
-      <informalfigure>non-root installation</informalfigure>
-      <informalfigure>installation, non-root</informalfigure>
-      <informalfigure>live CD/USB stick</informalfigure>
-      <informalfigure>making a live CD/USB stick</informalfigure>
-      <para>You don't have to install <abbrev>C-INTERCAL</abbrev> to be able to use it; you can instead
-stop any of the other install techniques just after compiling the source
-code, before the installation step.  (This may be useful if you just
-want to try out <abbrev>C-INTERCAL</abbrev>, or if you aren't a root/admin user and therefore
-don't have the permissions to install things.)  When <abbrev>C-INTERCAL</abbrev> hasn't been
-installed, <command>ick</command> won't be able to find the files it looks for in
-the places that they ought to have been installed, so it will look in a
-variety of places they might be instead (the installation directory, if
-it can figure out where it is; the same directory as the binary; the
-current directory).  In order for this to work, just don't move any of
-the files that were compiled anywhere else.</para>
-      <para>Of course, if you haven't installed the compiler, just typing
-<command>ick</command> is unlikely to work, because your computer won't know what
-you mean.  Instead, you should give a pathname (absolute or relative) to
-where <command>ick</command> is, so that your computer can find it.  With any
-luck, your computer will communicate the pathname you used to
-<command>ick</command> itself, and if that happens <command>ick</command> will use it to
-figure out where the main installation directory is, and find the files
-it needs that way.  If you suspect that errors you are getting are due
-to inability to find files (such as E127 (see ) or E999
-(see )), try giving the <option>-u</option> (see ) option to
-<command>ick</command> to see where it's looking.</para>
-      <para>You can make a `live' CD or USB-stick version of <abbrev>C-INTERCAL</abbrev> using similar
-methods; configure (if possible) and compile it, but instead of
-installing it, copy the entire <filename>ick-0.28</filename> directory to the
-CD or USB stick.  <acronym>INTERCAL</acronym> can then be run from there by explicitly giving
-a pathname to <filename>bin/ick</filename> or <filename>bin/ick.exe</filename>.</para>
-    </sect1>
-
-    <sect1 label="1.6" id="Uninstalling">
-      <para>Uninstalling</para>
-      <informalfigure>uninstalling</informalfigure>
-      <informalfigure><command>ick</command>, uninstalling</informalfigure>
-      <para>It may happen that you decide to uninstall <abbrev>C-INTERCAL</abbrev> after installing it;
-this may be useful if you want to test the installation system, or
-change the location you install programs, or for some reason you don't
-want it on your computer.  It's worth uninstalling just before you
-install a new version of <abbrev>C-INTERCAL</abbrev> because this will save some disk space;
-you cannot install two versions of <abbrev>C-INTERCAL</abbrev> at once (but see  for information on how you can use <abbrev>C-INTERCAL</abbrev> without installing
-it).</para>
-      <para>If you installed <abbrev>C-INTERCAL</abbrev> using <command>make install</command>, you can uninstall
-it by using <command>make uninstall</command> from the installation directory,
-assuming that it still exists.  If you can't use that method for some
-reason, you can uninstall it by deleting the files <filename>ick.exe</filename> where
-your computer installs binaries, <filename>libick.a</filename>, <filename>libickmt.a</filename>,
-<filename>libyuk.a</filename>, <filename>COPYING.txt</filename>, and <filename>coopt.sh</filename> where your
-computer installs libraries, and the subdirectories
-<filename>ick-0.28</filename> in the places where your computer installs
-data files and include files, and their contents.</para>
-      <para>If you installed <abbrev>C-INTERCAL</abbrev> by changing your &lsquo;<literal>PATH</literal>&rsquo; environment
-variable, you can uninstall by changing it back.</para>
-      <para>You can go further than uninstalling.  Running <command>make distr</command>,
-<command>districk.sh</command>, or <command>districk.bat</command> will delete any files
-created by compilation; <command>make distclean</command> will delete those
-files, and also any files created by configuring.  The distribution
-contains prebuilt versions of the parser, lexical analyser and OIL
-compiler; doing <command>make clean</command> (or <command>cleanick.sh</command> or
-<command>cleanick.bat</command>) will do the same thing as <command>make distr</command>
-and also delete those prebuilt versions.</para>
-    </sect1>
-
-    <sect1 label="1.7" id="Reporting-Bugs">
-      <para>Reporting Bugs</para>
-      <informalfigure>bugs, reporting</informalfigure>
-      <informalfigure>reporting bugs</informalfigure>
-      <informalfigure>patches, submitting</informalfigure>
-      <informalfigure>submitting patches</informalfigure>
-      <para>If you can't get <abbrev>C-INTERCAL</abbrev> to install at all, or something goes wrong when
-you're using it, reporting a bug is probably a good idea.  (This is
-still important even if you figure out how to fix it, and the
-information isn't in the manual, because the fix can be added to the
-source code if possible, or at least to the manual, to benefit future
-users.)  For general help, you may want to post to the
-alt.lang.intercal news group; to report
-a bug or submit a patch, email the person who released the most recent
-<abbrev>C-INTERCAL</abbrev> version (which you can determine by looking at that newsgroup).</para>
-      <para>If you do find a bug (either the compiler not behaving in the way you'd
-expect, or if you find a way to cause E778 (see ) without
-modifying the source code), it helps a lot if you can submit a bug
-report explaining what causes it.  If you're not sure, say that; it
-helps if you give examples of input, command line options, etc&period; that
-cause the bug.  There are several debug options (see )
-that you can use to help pin down a bug if you're interested in trying
-to solve the problem yourself; looking at the output C code can also
-help pin down a bug if the compiler gets that far.</para>
-      <para>Information that should be given in a bug report is what you expect to
-happen, what actually happens, what input and command line options you
-gave to the compiler, what operating system you're using, any ideas you
-might have as to what the problem is, and any appropriate debug traces
-(for instance, <option>-H</option> (see -H) output if you think the bug
-is in the optimizer).  Core dumps aren't portable between systems, so
-don't send those; however, if you're getting an internal error and can
-dump core with <option>-U</option> (see -U), it helps if you can load a
-debugger (such as <command>gdb</command>) on the core dump, use the debugger to
-produce a backtrace, and send that backtrace.</para>
-      <para>If you figure out how to solve the bug yourself, and want to submit the
-patches to help other users (this also carries the advantage that your
-patches will then be maintained along with the rest of the distribution,
-and that you won't have to reapply them every time you upgrade to a
-newer version of <abbrev>C-INTERCAL</abbrev>), you must first agree to license your code
-under the same license as the code that surrounds it (normally, that's
-the GNU General Public License, but if you submit a patch to a file with
-a different license, like this manual (yes, documentation patches are
-useful too), you must agree to that license).  You will be credited for
-the patch in the source code unless you specifically ask not to be or
-you don't give your name (in both these cases, you must license the code
-to the public domain so that it can be incorporated without the
-attribution requirement).  Preferably, patches should be submitted in
-the format created by the command <command>diff -u</command>; this command is
-likely to be available on UNIX and Linux systems and versions are also
-available for DOS and Windows (including a DJGPP port of the GNU
-version).  If you can't manage that, just submit your new code with
-enough lines of old code around it to show where it's meant to go, and a
-description of approximately where in the file it was.  Patches should
-be submitted by email to the person who most recently released a version
-of <abbrev>C-INTERCAL</abbrev>.</para>
-      <para>If you have a suggestion for a new feature, it makes sense to first
-discuss it on the alt.lang.intercal news
-group; other <acronym>INTERCAL</acronym> compiler maintainers may also want to implement
-that feature.  If you have developed code to implement that feature in
-<abbrev>C-INTERCAL</abbrev>, you can submit it the same way that you would submit a patch for
-a bug.</para>
-    </sect1>
-
-    <sect1 label="1.8" id="Distributing">
-      <para>Distributing</para>
-      <informalfigure>C-INTERCAL, distributing</informalfigure>
-      <informalfigure>distributing C-INTERCAL</informalfigure>
-      <informalfigure>releasing C-INTERCAL</informalfigure>
-      <para>Due to the licensing conditions of <abbrev>C-INTERCAL</abbrev>, you are allowed to release
-your own version or distribution if you want to.  In such cases, it's
-recommended that you follow the following guidelines:</para>
-      <varlistentry numeration="arabic">
-        <variablelist>Make sure the new version is based on the most recent existing version.Looking at the alt.lang.intercalnewsgroup will normally let you know what version is most recent.</variablelist>
-        <variablelist>Increment the version number; if you add any new features, incrementthe major version number (after the decimal point) and drop the minorversion number (before the decimal point) to 0, and otherwiseincrement the minor version number.  You have to update the versionnumber in the following files: <filename>config.in</filename>, <filename>config.sh</filename>,<filename>configdj.sh</filename>, and <filename>doc/ick.txi</filename>.  You also have to renamethe installation directory to reflect the new version number.</variablelist>
-        <variablelist>Add an entry to the <filename>NEWS.txt</filename> file explaining what's new in theversion that you're releasing, following the same format as the otherentries.</variablelist>
-        <variablelist>Update the <filename>README.txt</filename> with a description of any new files you mayhave added.</variablelist>
-        <variablelist>Remove any autosave or backup files that may be littering theinstallation directory or its subdirectories.</variablelist>
-        <variablelist>Run <command>make distclean</command>, or <command>districk.sh</command> or<command>districk.bat</command> if you didn't manage to configure; this willremove all files created by the compilation process that shouldn't bein the distribution.</variablelist>
-        <variablelist>Update the <filename>MANIFEST.txt</filename> file that lists all files in thedistribution; on a Linux or UNIX system, you can do this by typing<command>ls -R1 &gt; MANIFEST.txt</command> in the main installation directory.</variablelist>
-        <variablelist>If creating the distribution under DJGPP, run <command>etc/ctrlmfix.bat</command>or <command>etc/ctrlmfix.sh</command>, even if you managed to configure; thiswill sort out portability problems with newlines.</variablelist>
-        <variablelist>Create a gzipped tar file containing the installation directory.  Itsfilename should be &lsquo;<literal>ick-</literal>&rsquo;, followed by the version number with thedot replaced by a dash, followed by &lsquo;<literal>.tgz</literal>&rsquo;; this form of filenameis friendly to DOS.</variablelist>
-        <variablelist>Place the new version somewhere on the Internet, and announce thelocation and the fact that a new version has been released onalt.lang.intercal.</variablelist>
-      </varlistentry>              
-    </sect1>
-  </chapter>
-
-  <chapter label="2" id="Invoking-ick">
-    <para>Invoking ick</para>
-    <informalfigure>command line options</informalfigure>
-    <informalfigure>options, to <command>ick</command></informalfigure>
-    <informalfigure><command>ick</command>, command line options</informalfigure>
-    <informalfigure><command>ick</command>, invoking</informalfigure>
-    <informalfigure><command>ick</command>, options</informalfigure>
-    <informalfigure>compiling, <acronym>INTERCAL</acronym> source code</informalfigure>
-    <para>All operations on <acronym>INTERCAL</acronym> source code available in <abbrev>C-INTERCAL</abbrev> are currently
-carried out by the compiler <command>ick</command>.</para>
-    <para>The syntax is</para>
-    <programlisting>
-ick -options <replaceable>inputfile</replaceable>
-</programlisting>
-    <para role="continues">(Options can be given preceded by separate hyphens, or all in a row
-after one hyphen, or a mixture; they're all single characters.)  By
-default, this compiles one <acronym>INTERCAL</acronym> program given as the input file
-directly to an executable without doing anything fancy; usually you will
-want to give options, which are described below.</para>
-
-    <sect1 label="2.1" id="Language-affecting-Options">
-      <para>Language-affecting Options</para>
-      <informalfigure>options, language-affecting</informalfigure>
-      <informalfigure>language-affecting options</informalfigure>
-      <informalfigure>options, dialect</informalfigure>
-      <informalfigure>dialect options</informalfigure>
-      <para>The following command-line options to <command>ick</command> affect what dialect
-of the <acronym>INTERCAL</acronym> language is compiled by the compiler; you may need to set
-one or more of these options if your input is not the default <abbrev>C-INTERCAL</abbrev> but
-instead some other language like <abbrev>INTERCAL-72</abbrev> or <abbrev>CLC-INTERCAL</abbrev>, or just because
-you like certainty or like being different with respect to your output.
-Note that there is no command-line option corresponding to
-<abbrev>TriINTERCAL</abbrev> (or the base 4-7 versions); instead, the numeric base
-to use is determined by looking at the filename extension (&lsquo;<literal>.i</literal>&rsquo; for
-base 2, the default, or &lsquo;<literal>.3i</literal>&rsquo; to &lsquo;<literal>.7i</literal>&rsquo; for the base 3-7
-versions.)</para>
-      <term><indexterm><option>-b</option>
-          <variablelist><inlinemediaobject name="-b"></inlinemediaobject>
-            <informalfigure>-b</informalfigure>
-            <informalfigure>random bug</informalfigure>
-            <informalfigure>E774, disabling</informalfigure>If this option is <emphasis>not</emphasis> given, there is a small chance that arandom bug appears in the compiler, which causes the programs it createsto manifest a bug that causes error E774 (see ).  Giving theoption means that this bug will not happen.  (You may wonder why thisbug was preserved; it is in fact a bug that was carefully preservedsince the days of <abbrev>INTERCAL-72</abbrev>, in this case, but the option to turn it offis available as a workaround.  (There are no plans to fix this or any ofthe other carefully preserved bugs any time soon, because that wouldkind of defeat the point of having preserved them.)  Interestingly, the<abbrev>INTERCAL-72</abbrev> compiler documentation mentions a similar command-line optionthat is a workaround for the same bug.)</variablelist>
-        </indexterm><indexterm><option>-m</option>
-          <variablelist><inlinemediaobject name="-m"></inlinemediaobject>
-            <informalfigure>-m</informalfigure>
-            <informalfigure>multithreading, enabling</informalfigure>
-            <informalfigure>backtracking, enabling</informalfigure>This option needs to be given to allow any multithreading orbacktracking commands or identifiers to be used.  (Unlike with otherlanguage features, this is not autodetected because it's legal to have aprogram with multiple COME FROM (see ) commands aiming atthe same line even when it isn't multithreaded, in which case thecommands cause error E555 (see ) when that line is encountered(with the usual caveats about both commands having to be active at thetime).)  Attempts to use non-COME FROM multithreading or backtrackingcommands without this option produce error E405 (see ).</variablelist>
-        </indexterm><indexterm><option>-t</option>
-          <variablelist><inlinemediaobject name="-t"></inlinemediaobject>
-            <informalfigure>-t</informalfigure>
-            <informalfigure>INTERCAL-72 compatibility mode</informalfigure>
-            <informalfigure>compatibility, INTERCAL-72</informalfigure>This option tells the compiler to treat the source code as <abbrev>INTERCAL-72</abbrev>; as aresult, any language constructs that are used but weren't available in1972 will trigger error E111 (see ).</variablelist>
-        </indexterm><indexterm><option>-v</option>
-          <variablelist><inlinemediaobject name="-v"></inlinemediaobject>
-            <informalfigure>-v</informalfigure>
-            <informalfigure>constants, assigning to</informalfigure>
-            <informalfigure>assigning to constants</informalfigure>It is possible to write <acronym>INTERCAL</acronym> code sufficiently tortuous that it endsup assigning to a constant.  Generally speaking, this isn't what youwanted to do, so the compiler will kindly cause an error (E277;see ) that stops the insanity at that point, but at the cost ofa significant amount of performance you can give this option to tell thecompiler to simply change the constant and keep on going anyway.  (Notethat unlike <abbrev>CLC-INTERCAL</abbrev>, this only changes uses of the constant preceded by<literal>#</literal> in your program, not things like line numbers; you wantForte for that.)</variablelist>
-        </indexterm><indexterm><option>-C</option>
-          <variablelist><inlinemediaobject name="-C+"></inlinemediaobject>
-            <informalfigure>-C</informalfigure>
-            <informalfigure>clockface mode</informalfigure>When this option is given, the generated programs will write the number4 as &lsquo;<literal>IIII</literal>&rsquo; rather than &lsquo;<literal>IV</literal>&rsquo;, in case you're writing a clockprogram.</variablelist>
-        </indexterm><indexterm><option>-P</option>
-          <variablelist><inlinemediaobject name="-P+"></inlinemediaobject>
-            <informalfigure>-P</informalfigure>
-            <informalfigure>PIC-INTERCAL, command line option</informalfigure>
-            <informalfigure>E256, avoiding</informalfigure>
-            <informalfigure>E652, avoiding</informalfigure>This tells the compiler to treat the input as <abbrev>PIC-INTERCAL</abbrev>(see ) rather than ordinary <abbrev>C-INTERCAL</abbrev> input, and generatePIC output code accordingly.  There are a lot of options that areincompatible with this, as well as many language features, due to thelimited memory available on a PIC.  If you get error E256(see ), you have this option given when it shouldn't be;likewise, if you get error E652 (see ), you should be using thisoption but aren't.  (A few simple programs are<abbrev>C-INTERCAL</abbrev>/<abbrev>PIC-INTERCAL</abbrev> polyglots, but such programs are incapable ofdoing input or output, meaning that they aren't particularly useful.)</variablelist>
-        </indexterm><indexterm><option>-X</option>
-          <variablelist><inlinemediaobject name="-X+"></inlinemediaobject>
-            <informalfigure>-X</informalfigure>
-            <informalfigure>Princeton syntax, option</informalfigure>
-            <informalfigure>syntax, Princeton</informalfigure>The <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> compilers use different notation for variousthings, sometimes to the extent where the same notation is legal in bothcases but has a different meaning.  As this is the <abbrev>C-INTERCAL</abbrev> compiler, itrather guessably uses its own notation by default; however, the <abbrev>CLC-INTERCAL</abbrev>notation can be used as the default instead using this option.  (In mostsituations where there isn't an ambiguity about what something means,you can use the `wrong' syntax freely.) The option causes ambiguouscharacters like <literal>?</literal> to be interpreted with Princeton rather thanAtari meanings.</variablelist>
-        </indexterm><indexterm><option>-x</option>
-          <variablelist><inlinemediaobject name="-x"></inlinemediaobject>
-            <informalfigure>-x</informalfigure>
-            <informalfigure>CLC-INTERCAL compatibility mode</informalfigure>
-            <informalfigure>compatibility, CLC-INTERCAL</informalfigure>This option causes some constructs with different meanings in <abbrev>C-INTERCAL</abbrev>and <abbrev>CLC-INTERCAL</abbrev> to use the <abbrev>CLC-INTERCAL</abbrev> meaning rather than the <abbrev>C-INTERCAL</abbrev>meaning. At present, it affects the abstention of a GIVE UP(see ) command by line number, which is possible as long asthis switch isn't given; reading through the <abbrev>INTERCAL-72</abbrev> manual, there area lot of things that imply that this probably wasn't intended to bepossible, but as far as I can tell that manual doesn't actually<emphasis>say</emphasis> anywhere that this particular case is disallowed, eventhough it rules out all other similar cases.  It also causes I/O onarray variables to be done in <abbrev>CLC-INTERCAL</abbrev>'s extended Baudot syntax,rather than using the Turing Tape method.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.2" id="Debug-Options">
-      <para>Debug Options</para>
-      <informalfigure>options, debug</informalfigure>
-      <informalfigure>debug options</informalfigure>
-      <para>Sometimes things will go wrong with your program, or with the way
-<command>ick</command> was installed.  There may even be unknown bugs in
-<command>ick</command> itself (if you find one of these, please report it).  The
-following options are used to debug the whole system on various levels.</para>
-      <term><indexterm><option>-d</option>
-          <variablelist><inlinemediaobject name="-d"></inlinemediaobject>
-            <informalfigure>-d</informalfigure>
-            <informalfigure>debugging, parser</informalfigure>
-            <informalfigure>parser, debugging</informalfigure>
-            <informalfigure>debugging, lexical analyser</informalfigure>
-            <informalfigure>lexical analyser, debugging</informalfigure>If you think that something has gone wrong with the parser, or you wantto see how your program is being parsed, you can give this option on thecommand line.  All the debug output produced by the parser and lexicalanalyser will be output on standard error.</variablelist>
-        </indexterm><indexterm><option>-g</option>
-          <variablelist><inlinemediaobject name="-g"></inlinemediaobject>
-            <informalfigure>-g</informalfigure>
-            <informalfigure>debugging, C code</informalfigure>
-            <informalfigure>C code, debugging</informalfigure>
-            <informalfigure>C code, leaving in place</informalfigure>This option allows debugging of the final executable at the C codelevel.  Any C code generated will be left in place, and the <option>-g</option>option will be given to the C compiler that's used to compile the code,so all the information needed for a C debugger to be used on theexecutable will be present there.</variablelist>
-        </indexterm><indexterm><option>-h</option><option>-H</option><option>-hH</option>
-          <variablelist><inlinemediaobject name="-h"></inlinemediaobject><inlinemediaobject name="-H+"></inlinemediaobject><inlinemediaobject name="-hH"></inlinemediaobject>
-            <informalfigure>-h</informalfigure>
-            <informalfigure>-H</informalfigure>
-            <informalfigure>-hH</informalfigure>
-            <informalfigure>optimizer, debugging</informalfigure>
-            <informalfigure>debugging, optimizer</informalfigure>
-            <informalfigure>OIL, debugging</informalfigure>
-            <informalfigure>debugging, OIL</informalfigure>These options allow debugging of the optimiser, or produce outputhelpful for understanding how your program has been summarised.<option>-h</option> produces a summary of what optimiser rules were used, theinitial expression and what it was optimised to; <option>-H</option> produces amore expanded view that shows each intermediate step of optimisation,and <option>-hH</option> shows the same output as <option>-H</option>, but writtencompletely using C syntax (the other options output in a strange mix of<acronym>INTERCAL</acronym> and C).</variablelist>
-        </indexterm><indexterm><option>-l</option>
-          <variablelist><inlinemediaobject name="-l"></inlinemediaobject>
-            <informalfigure>-l</informalfigure>
-            <informalfigure>warnings, enabling</informalfigure>This option turns on generation of warnings (see ).  To makesure that they aren't actually useful, or are only marginally useful,the warning generator is far too sensitive, and there is no way todecide which warnings are given and which ones aren't; you either getall of them or none.</variablelist>
-        </indexterm><indexterm><option>-p</option>
-          <variablelist><inlinemediaobject name="-p"></inlinemediaobject>
-            <informalfigure>-p</informalfigure>
-            <informalfigure>profiling</informalfigure>
-            <informalfigure>yuk, profiling</informalfigure>This option causes the program to run immediately after being compiled,and profiles the resulting program to identify performance bottlenecks,etc.  The usefulness of this depends on the resolution of the timers onthe computer and operating system; DOS, in particular, is really badwith timer resolution.  The output will be saved in a file called<filename>yuk.out</filename> when the program finishes running.  It's legal to turn onboth the profiler and the interactive debugger at the same time, but ifyou do this the profiler will also identify bottlenecks in the persontyping in commands to step through the program! The profiler will, infact, identify all the timings that particular commands in the programtake; so <literal>WRITE IN</literal> instructions will often show up as taking along time due to their need to wait for input.</variablelist>
-        </indexterm><indexterm><option>-u</option>
-          <variablelist><inlinemediaobject name="-u"></inlinemediaobject>
-            <informalfigure>-u</informalfigure>
-            <informalfigure>skeleton file, directory problems</informalfigure>
-            <informalfigure>system library, directory problems</informalfigure>
-            <informalfigure>syslib, directory problems</informalfigure>
-            <informalfigure>directory problems</informalfigure>
-            <informalfigure>E999, debugging</informalfigure>
-            <informalfigure>E127, debugging</informalfigure>When you are getting problems with finding files &ndash; for instance, thecompiler can't find the skeleton file (see ) or the systemlibrary (see ) &ndash; this option will let you know, on standarderror, where the compiler is looking for files.  This may hopefully helpyou pin down where the file-finding problems are coming from, and alsooffers the option of simply placing copies of the files where thecompiler is looking as a last resort.</variablelist>
-        </indexterm><indexterm><option>-y</option>
-          <variablelist><inlinemediaobject name="-y"></inlinemediaobject>
-            <informalfigure>-y</informalfigure>
-            <informalfigure>yuk, command line option</informalfigure>This is the main debugging option: it loads yuk, an interactive <acronym>INTERCAL</acronym>debugger with ability to step through the program, set breakpoints, viewand modify variables, etc.  See .</variablelist>
-        </indexterm><indexterm><option>-U</option>
-          <variablelist><inlinemediaobject name="-U+"></inlinemediaobject>
-            <informalfigure>-U</informalfigure>
-            <informalfigure>internal errors, debugging</informalfigure>
-            <informalfigure>debugging, internal errors</informalfigure>
-            <informalfigure>internal errors, dumping core</informalfigure>
-            <informalfigure>dumping core on error</informalfigure>
-            <informalfigure>E778, debugging</informalfigure>The internal error E778 (see ) should never happen.  However,there are all sorts of potential problems that may come up, and if partof the code detects something impossible, or more usually when theoperating system detects things have got too insane and segfaults,normally this error will just be generated and that's that.  (I mostoften get this when I've been writing a new section of code and havemade a mistake; hopefully, all or at least most of these errors arefixed before release, though.)  If you want more information as to what'sgoing on, you can give the <option>-U</option> option, which will cause thecompiler to raise an abort signal when an internal error happens.  Thiscan generally be caught by a debugger that's being run on <command>ick</command>itself at the time; on many systems, it will also cause a core dump.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.3" id="Output-Options">
-      <para>Output Options</para>
-      <informalfigure>output options</informalfigure>
-      <informalfigure>options, output</informalfigure>
-      <para>These options allow you to control how far to compile (all the way to an
-executable, or only to C, etc&period;), and where the output will be created.
-Note that the output options may change depending on the other options
-selected; for instance, many of the debug options will prevent the code
-being compiled all the way to an executable.</para>
-      <term><indexterm><option>-c</option>
-          <variablelist><inlinemediaobject name="-c"></inlinemediaobject>
-            <informalfigure>-c</informalfigure>
-            <informalfigure>code generation, stopping at C code</informalfigure>
-            <informalfigure>C, stopping after C is generated</informalfigure>
-            <informalfigure>output, C only</informalfigure>By default, the original <acronym>INTERCAL</acronym> code will be compiled all the way to anexecutable, and the intermediate C and object files produced will bedeleted.  Giving this option causes the compiler to stop when it hasfinished producing the C file, leaving the C file there as the finaloutput of the compiler.  (Its filename is the same as the source file,but with &lsquo;<literal>.c</literal>&rsquo; as its extension/suffix rather than the source file'sextension.)  Without this option, an executable will be produced with theextension changed to whatever's appropriate for the system you are on(or omitted entirely if that's appropriate for the system).This option also places verbose comments in the output C file.</variablelist>
-        </indexterm><indexterm><option>-o</option>
-          <variablelist><inlinemediaobject name="-o"></inlinemediaobject>
-            <informalfigure>-o</informalfigure>
-            <informalfigure>output, to standard output</informalfigure>
-            <informalfigure>standard output</informalfigure>This option causes the compiler to progress no further than producingthe C output file, but instead of writing it to a file writes itdirectly to standard output.  This might occasionally be useful whenusing <command>ick</command> as part of a pipe; it can also be useful to see howfar the compiler gets with compiling code before an error happens, whenyou're trying to track down an error.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.4" id="Optimizer-Options">
-      <para>Optimizer Options</para>
-      <informalfigure>optimizer options</informalfigure>
-      <informalfigure>options, optimizer</informalfigure>
-      <informalfigure>optimization</informalfigure>
-      <para>There are various command line options that can be used to tell
-<command>ick</command> whether and in what ways to optimize code.</para>
-      <term><indexterm><option>-f</option>
-          <variablelist><inlinemediaobject name="-f"></inlinemediaobject>
-            <informalfigure>-f</informalfigure>
-            <informalfigure>flow optimization</informalfigure>
-            <informalfigure>optimization, flow</informalfigure>
-            <informalfigure>optimization, control flow</informalfigure>This option requests the compiler to attempt to analyse the flow of theprogram and optimize accordingly; for instance, it will detect whichcommands can't possibly be <literal>ABSTAINED</literal> from and refrain fromgenerating code to check the abstention status of those commands.</variablelist>
-        </indexterm><indexterm><option>-F</option>
-          <variablelist><inlinemediaobject name="-F+"></inlinemediaobject>
-            <informalfigure>-F</informalfigure>
-            <informalfigure>optimization, extreme</informalfigure>
-            <informalfigure>extreme optimization</informalfigure>This option tells the compiler to optimize the output for speed.  Thisis done to crazy extremes; the compiler may take several hours/daysanalysing the program in some cases and still not come up with animprovement.  It turns on all the other optimizer options.  Note thatnot all systems accept this option, because it sometimes outputs a shellscript disguised as an executable rather than an actual executable.</variablelist>
-        </indexterm><indexterm><option>-O</option>
-          <variablelist><inlinemediaobject name="-O+"></inlinemediaobject>
-            <informalfigure>-O</informalfigure>
-            <informalfigure>optimization, idioms</informalfigure>
-            <informalfigure>idiom optimization</informalfigure>
-            <informalfigure>optimization, OIL</informalfigure>
-            <informalfigure>OIL, optimizing code</informalfigure>This option tells the compiler to apply optimizer idioms to theexpressions in the code given, when appropriate.  The list of idioms isstored in the file <filename>src/idiotism.oil</filename>; note that it is compiledinto the compiler, though, so you will have to rebuild and reinstall thecompiler if you change it.  For more information about changing the listof idioms, see .</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.5" id="Other-Options">
-      <para>Other Options</para>
-      <informalfigure>other options</informalfigure>
-      <informalfigure>options, other</informalfigure>
-      <para>Some options just can't be classified.</para>
-      <term><indexterm><option>-@</option>
-          <variablelist><inlinemediaobject name="-at"></inlinemediaobject>
-            <informalfigure>-@</informalfigure>
-            <informalfigure>options, help</informalfigure>
-            <informalfigure>help with options</informalfigure>
-            <informalfigure>usage instructions, printing</informalfigure>If this option is given, the compiler doesn't run at all, but insteadprints a set of instructions for using it, explaining which options areavailable on the system you're on and which options conflict with whichother options.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.6" id="Options-to-Generated-Programs">
-      <para>Options to Generated Programs</para>
-      <informalfigure>generated programs, options</informalfigure>
-      <informalfigure>options, to generated programs</informalfigure>
-      <para>Once the compiler runs and produces an output executable, that
-executable itself will accept a range of options that control the way it
-runs.  None of these options have to be used; a default value will be
-assumed if they aren't.</para>
-      <term><indexterm><option>+help</option><option>-help</option>
-          <variablelist><inlinemediaobject name="+help"></inlinemediaobject><inlinemediaobject name="-help"></inlinemediaobject>
-            <informalfigure>+help</informalfigure>
-            <informalfigure>-help</informalfigure>Whether &lsquo;<literal>+</literal>&rsquo; or &lsquo;<literal>-</literal>&rsquo; is given at the start of this option, itwill cause the program to print out what options are available and whatstate they are in.  It will then cause the program to exit via aninternal error.</variablelist>
-        </indexterm><indexterm><option>+wimpmode</option><option>-wimpmode</option>
-          <variablelist><inlinemediaobject name="+wimpmode"></inlinemediaobject><inlinemediaobject name="-wimpmode"></inlinemediaobject>
-            <informalfigure>+wimpmode</informalfigure>
-            <informalfigure>-wimpmode</informalfigure>
-            <informalfigure>wimpmode</informalfigure>
-            <informalfigure>Roman numerals, disabling</informalfigure>
-            <informalfigure>Arabic numberals, enabling</informalfigure>
-            <informalfigure>input, in Arabic numerals</informalfigure>
-            <informalfigure>output, in Arabic numerals</informalfigure>If the &lsquo;<literal>+</literal>&rsquo; version of this is given (rather than the default&lsquo;<literal>-</literal>&rsquo;), then the program will print a message explaining that you area wimp (the mode itself is known as wimpmode), and for the rest ofexecution will input in Arabic numerals (&lsquo;<literal>123</literal>&rsquo; rather than&lsquo;<literal>ONE TWO THREE</literal>&rsquo;) and likewise will output in Arabic numerals ratherthan Roman numerals (such as &lsquo;<literal>CXXIII</literal>&rsquo;).  True <acronym>INTERCAL</acronym> programmersshould rarely have to use this mode.</variablelist>
-        </indexterm><indexterm><option>+traditional</option><option>-traditional</option>
-          <variablelist><inlinemediaobject name="+traditional"></inlinemediaobject><inlinemediaobject name="-traditional"></inlinemediaobject>
-            <informalfigure>+traditional</informalfigure>
-            <informalfigure>-traditional</informalfigure>This option does not actually appear to do anything.</variablelist>
-        </indexterm><indexterm><option>+printflow</option><option>-printflow</option>
-          <variablelist><inlinemediaobject name="+printflow"></inlinemediaobject><inlinemediaobject name="-printflow"></inlinemediaobject>
-            <informalfigure>+printflow</informalfigure>
-            <informalfigure>-printflow</informalfigure>
-            <informalfigure>flow, printing</informalfigure>
-            <informalfigure>debugging, flow</informalfigure>
-            <informalfigure>debugging, multithreaded programs</informalfigure>
-            <informalfigure>multithreading, debugging</informalfigure>
-            <informalfigure>backtracking, debugging</informalfigure>The usual debugging methods don't work with multithreaded orbacktracking programs.  This option exists to give at least a slimchance of working out what is going on with them.  It causes the programto print the line number of the command it thinks it may be executingnext (i.e&period; the line number that would be printed if that line had anerror) immediately after executing each command, and also an internalidentifier for the thread that that command was in.  It also prints atrace of what parts of the multithreader are being activated; so forinstance, it will tell you when a thread is being forked into multiplethreads or when a choicepoint has been deleted.</variablelist>
-        </indexterm><indexterm><option>+mystery</option><option>-mystery</option>
-          <variablelist><inlinemediaobject name="+mystery"></inlinemediaobject><inlinemediaobject name="-mystery"></inlinemediaobject>
-            <informalfigure>+mystery</informalfigure>
-            <informalfigure>-mystery</informalfigure>This option is occasionally capable of doing something, but isdeliberately undocumented.  Normally changing it will have no effect,but changing it is not recommended.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="2.7" id="Environment-Variables">
-      <para>Environment Variables</para>
-      <informalfigure>environment variables</informalfigure>
-      <para>Various environment variables can be set to affect the operation of
-<command>ick</command>.</para>
-      <colspec>
-        <thead cols="2">
-          <tbody colwidth="30*"></tbody>
-          <tbody colwidth="70*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo>Variable</bookinfo>
-              <bookinfo>Meaning</bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>ICKINCLUDEDIRICKLIBDIRICKDATADIR</bookinfo>
-              <bookinfo>
-These three environment variables suggest locations in which
-<command>ick</command> should look to find various files that it needs: the
-skeleton file, system library, C header files and libraries that it
-needs, constant-output optimiser, and the GNU General Public License
-(which the debugger needs to be able to display on demand for legal
-reasons).</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo>CC</bookinfo>
-              <bookinfo>
-The name of a C compiler to use (defaults to gcc, which is the only
-compiler with which <abbrev>C-INTERCAL</abbrev> has been tested recently).  This option has
-no effect on DJGPP, where gcc is always used.</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo>ICKTEMPTMPDIRTEMPTMP</bookinfo>
-              <bookinfo>
-On DJGPP, <command>ick</command> creates temporary files to pass options to gcc
-as a method of getting around the limit on the length of a command line
-that can sometimes affect DOS programs.  These four environment
-variables are tried (in this order) to determine a location for the
-temporary file; if none of them are set, the current directory is used.</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-    </sect1>
-  </chapter>
-
-  <chapter label="3" id="Errors-and-Warnings">
-    <para>Errors and Warnings</para>
-    <informalfigure><command>ick</command>, errors and warnings</informalfigure>
-    <informalfigure>errors and warnings</informalfigure>
-    <para>Things may go wrong, either during the compilation or the execution of
-your program.  Note that some things that would be compile-time errors
-in many other languages &ndash; such as syntax errors &ndash; are in fact run-time
-errors in <acronym>INTERCAL</acronym>.</para>
-    <para>Errors and warnings appear as an error code starting with &lsquo;<literal>ICL</literal>&rsquo;,
-followed by a three digit number, followed by &lsquo;<literal>I</literal>&rsquo; for an error or
-&lsquo;<literal>W</literal>&rsquo; for a warning.  However, they will be notated here as
-&lsquo;<literal>E000</literal>&rsquo;, etc&period;, to save space and because consistency was never a
-strong point of <acronym>INTERCAL</acronym>.  This is followed by a text description of the
-error, and a hint as to the location of the error.  This is not the line
-on which the error occurred, but rather the line on which the next
-command to be executed is.  To add to the fun, the calculation of the
-next command to be executed is done at compile-time rather than runtime,
-so it may be completely wrong due to things like abstention on
-<literal>COME FROM</literal>s or computed <literal>COME FROM</literal>s.  The moral of this
-story is that, if you really want to know where the error is, use a
-debugger.  Note also that if the error happens at compile-time, there is
-no guarantee that the line number given makes any sense at all.  Some
-errors don't give next line numbers, mostly those for which it doesn't
-make logical sense, such as E633 (see ).  After this is a
-suggestion to correct (or reconsider) the source code and to resubnit
-it.  (This typo has been carefully preserved for over a decade.)</para>
-
-    <sect1 label="3.1" id="Errors">
-      <para>Errors</para>
-      <informalfigure>errors</informalfigure>
-      <informalfigure><command>ick</command>, errors</informalfigure>
-      <para>This is a list of the error messages that might be produced during the
-compilation or execution of an <acronym>INTERCAL</acronym> program.</para>
-      <term><indexterm>E000
-          <variablelist><inlinemediaobject name="E000"></inlinemediaobject>
-            <informalfigure>E000</informalfigure>
-            <informalfigure>syntax error</informalfigure>This is an unusual error; it's what's printed when a syntax error isencounted at runtime, in a situation in which it would be executed.  (An<literal>ABSTAIN</literal>ed syntax error, for instance, would not be executed; thisis one of the mechanisms available for writing comments.)  The text ofthe error message is simply the statement that couldn't be decoded.</variablelist>
-        </indexterm><indexterm>E017
-          <variablelist><inlinemediaobject name="E017"></inlinemediaobject>
-            <informalfigure>E017</informalfigure>
-            <informalfigure>syntax error, serious</informalfigure>
-            <screen>DO YOU EXPECT ME TO FIGURE THIS OUT?
-</screen>It sometimes happens that a syntax error manages to get the parser soconfused that it can't figure out what to do next; that causes thiserror, which happens at compile time.</variablelist>
-        </indexterm><indexterm>E079
-          <variablelist><inlinemediaobject name="E079"></inlinemediaobject>
-            <informalfigure>E079</informalfigure>
-            <informalfigure>politesse</informalfigure>
-            <informalfigure><literal>PLEASE</literal>, proportion required</informalfigure>
-            <screen>PROGRAMMER IS INSUFFICIENTLY POLITE
-</screen>The balance between various statement identifiers is important.  If lessthan approximately one fifth of the statement identifiers used are thepolite versions containing <literal>PLEASE</literal>, that causes this error atcompile time.</variablelist>
-        </indexterm><indexterm>E099
-          <variablelist><inlinemediaobject name="E099"></inlinemediaobject>
-            <informalfigure>E099</informalfigure>
-            <screen>PROGRAMMER IS OVERLY POLITE
-</screen>Of course, the same problem can happen in the other direction; thiserror is caused at compile time if over about one third of the statementidentifiers are the polite form.</variablelist>
-        </indexterm><indexterm>E111
-          <variablelist><inlinemediaobject name="E111"></inlinemediaobject>
-            <informalfigure>E111</informalfigure>
-            <screen>COMMUNIST PLOT DETECTED, COMPILER IS SUICIDING
-</screen>This error happens when you give the <option>-t</option> option (see ) butyou use a language construct that wasn't available in <abbrev>INTERCAL-72</abbrev>.  If thishappens, then either there's a mistake in the program that prevents itbeing <abbrev>INTERCAL-72</abbrev> or you shouldn't be compiling it as <abbrev>INTERCAL-72</abbrev> in the firstplace.</variablelist>
-        </indexterm><indexterm>E123
-          <variablelist><inlinemediaobject name="E123"></inlinemediaobject>
-            <informalfigure>E123</informalfigure>
-            <informalfigure>black lagoon</informalfigure>
-            <informalfigure><literal>NEXT</literal>, stack overflow</informalfigure>
-            <informalfigure>stack overflow</informalfigure>
-            <screen>PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
-</screen>There is a hard limit of 80 <command>NEXT</command>s at a time; this is todiscourage excessive use of <command>NEXTING</command> for things like recursion.(Recursive programs are entirely legal; you simply have to figure outhow to do it with computed <command>COME FROM</command> instead.  (For therecord, it is possible.  (Using lots of nested brackets when talkingabout recursion is great (yay&excl;).)))  Another problem with writing thesource code that can cause this error is a failure to properly<command>FORGET</command> the entry on the <command>NEXT</command> stack created whentrying to simulate a goto.</variablelist>
-        </indexterm><indexterm>E127
-          <variablelist><inlinemediaobject name="E127"></inlinemediaobject>
-            <informalfigure>E127</informalfigure>
-            <informalfigure>system library, errors</informalfigure>
-            <informalfigure>syslib, errors</informalfigure>
-            <screen>SAYING 'ABRACADABRA' WITHOUT A MAGIC WAND WON'T DO YOU ANY GOOD
-</screen>Your program asked to include the system library (by specifying a linenumber from 1000 to 1999 inclusive without including a line with thatnumber), but due to installation problems the copmiler couldn't find thesystem library to include.  You could try using the <option>-u</option>(see ) option to see where the compiler's looking; that may giveyou an idea of where you need to copy the system library so that thecompilation will work.  This error happens at compile time and doesn'tgive a next command line number.</variablelist>
-        </indexterm><indexterm>E129
-          <variablelist><inlinemediaobject name="E129"></inlinemediaobject>
-            <informalfigure>E129</informalfigure>
-            <informalfigure><literal>NEXT</literal>, nonexistent target</informalfigure>
-            <screen>PROGRAM HAS GOTTEN LOST
-</screen>This error happens at compile time when the compiler can't figure outwhere a <command>NEXT</command> command is actually aiming (normally due to atypo in either the line label given or the line label on the line aimedfor).  The logic behind this error means that the next line to beexecuted is unknown (after all, that's the whole point of the error) andis therefore not given.</variablelist>
-        </indexterm><indexterm>E139
-          <variablelist><inlinemediaobject name="E139"></inlinemediaobject>
-            <informalfigure>E139</informalfigure>
-            <informalfigure><literal>ABSTAIN</literal>, nonexistent target</informalfigure>
-            <informalfigure><literal>REINTSTATE</literal>, nonexistent target</informalfigure>
-            <screen>I WASN'T PLANNING TO GO THERE ANYWAY
-</screen>This error happens at compile time when an <literal>ABSTAIN</literal> or<literal>REINSTATE</literal> references a non-existent target line.  This generallyhappens for much the same reasons as E129 (see ).</variablelist>
-        </indexterm><indexterm>E182
-          <variablelist><inlinemediaobject name="E182"></inlinemediaobject>
-            <informalfigure>E182</informalfigure>
-            <informalfigure>line label, duplicate</informalfigure>
-            <informalfigure>duplicate line label</informalfigure>
-            <screen>YOU MUST LIKE THIS LABEL A LOT!
-</screen>At present, it's impossible to have more than one line with the sameline number.  That would make <literal>NEXT</literal> act too much like <literal>COMEFROM</literal> in reverse to be interesting.  This error happens at compile time.</variablelist>
-        </indexterm><indexterm>E197
-          <variablelist><inlinemediaobject name="E197"></inlinemediaobject>
-            <informalfigure>E197</informalfigure>
-            <informalfigure>line label, illegal value</informalfigure>
-            <informalfigure>illegal line label value</informalfigure>
-            <informalfigure>invalid line label value</informalfigure>
-            <screen>SO!  65535 LABELS AREN'T ENOUGH FOR YOU?
-</screen>Legal values for line labels are 1 to 65535 (with values from 1000 to1999 reserved if you want to use the system library).  This error comesup if you use nonpositive or twospot values for a line label.</variablelist>
-        </indexterm><indexterm>E200
-          <variablelist><inlinemediaobject name="E200"></inlinemediaobject>
-            <informalfigure>E200</informalfigure>
-            <informalfigure>variable, illegal number</informalfigure>
-            <informalfigure>illegal variable number</informalfigure>
-            <informalfigure>invalid variable number</informalfigure>
-            <screen>NOTHING VENTURED, NOTHING GAINED
-</screen>You used a variable that isn't actually in your program.  Failing that(which would be quite impressive and is probably impossible, at least inthe present version of <abbrev>C-INTERCAL</abbrev>), you specified an illegal number for avariable (legal numbers are positive and onespot).  This error happensat compile time, at least for illegal variable numbers.</variablelist>
-        </indexterm><indexterm>E222
-          <variablelist><inlinemediaobject name="E222"></inlinemediaobject>
-            <informalfigure>E222</informalfigure>
-            <informalfigure>out of memory, during <literal>STASH</literal></informalfigure>
-            <screen>BUMMER, DUDE!
-</screen>In <acronym>INTERCAL</acronym>, you're allowed to <literal>STASH</literal> as much as you like; thismakes the language Turing-complete and allows for unlimited recursionwhen combined with computed <literal>COME FROM</literal> in the right way.Unfortunately, real computers aren't so idealised; if you manage towrite a program so memory-intensive that the computer runs out of memoryto store stashes, it causes this error at runtime.  To fix this error,you either have to simplify the program or upgrade your computer'smemory, and even then that will only help to some extent.</variablelist>
-        </indexterm><indexterm>E240
-          <variablelist><inlinemediaobject name="E240"></inlinemediaobject>
-            <informalfigure>E240</informalfigure>
-            <informalfigure>array, invalid dimension</informalfigure>
-            <informalfigure>invalid array dimension</informalfigure>
-            <informalfigure>illegal array dimension</informalfigure>
-            <screen>ERROR HANDLER PRINTED SNIDE REMARK
-</screen>Arrays have to be large enough to hold at least one element; you triedto dimension an array which isn't large enough to hold any data.  Thiserror happens at run time.</variablelist>
-        </indexterm><indexterm>E241
-          <variablelist><inlinemediaobject name="E241"></inlinemediaobject>
-            <informalfigure>E241</informalfigure>
-            <informalfigure>array, wrong dimension</informalfigure>
-            <informalfigure>wrong array dimension</informalfigure>
-            <informalfigure>array, out of bounds</informalfigure>
-            <informalfigure>out of bounds</informalfigure>
-            <screen>VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE
-</screen>This error happens at run time when the subscripts given to an arrayare inconsistent with the way the array was dimensioned, eitherbecause there were the wrong number of subscripts or because asubscript was too large to fit in the array.  It can also happen whena multidimensional array is given to a command, such as <literal>WRITEIN</literal>, that expects it to be monodimensional.</variablelist>
-        </indexterm><indexterm>E252
-          <variablelist><inlinemediaobject name="E252"></inlinemediaobject>
-            <informalfigure>E252</informalfigure>
-            <informalfigure>I/O, out of memory</informalfigure>
-            <informalfigure>out of memory, I/O</informalfigure>
-            <screen>I'VE FORGOTTEN WHAT I WAS ABOUT TO SAY
-</screen>This run-time error message is caused by the compiler running out ofmemory whilst trying to do I/O; at present, it can only happen during<abbrev>CLC-INTERCAL</abbrev>-style I/O.</variablelist>
-        </indexterm><indexterm>E256
-          <variablelist><inlinemediaobject name="E256"></inlinemediaobject>
-            <informalfigure>E256</informalfigure>
-            <informalfigure>PIC-INTERCAL, unsupported command</informalfigure>
-            <screen>THAT'S TOO HARD FOR MY TINY BRAIN
-</screen>Some commands simply aren't available in <abbrev>PIC-INTERCAL</abbrev>.  I mean,<acronym>PIC</acronym>s generally have less than a kilobyte of memory; you're notgoing to be able to use some of the more confusing language featureswith that sort of resource limitation.  The solution is to replace theaffected command, or to not give the <option>-P</option> option(see -P) if you didn't mean to compile as <abbrev>PIC-INTERCAL</abbrev>in the first place.</variablelist>
-        </indexterm><indexterm>E275
-          <variablelist><inlinemediaobject name="E275"></inlinemediaobject>
-            <informalfigure>E275</informalfigure>
-            <informalfigure>overflow, over onespot</informalfigure>
-            <informalfigure>overflow, over 16 bits</informalfigure>
-            <informalfigure>onespot overflow</informalfigure>
-            <informalfigure>16 bit overflow</informalfigure>
-            <screen>DON'T BYTE OFF MORE THAN YOU CAN CHEW
-</screen>This error happens when there is an attempt to store a twospot value ina onespot variable.  The actual size of the value is what matters whencounting its spots; so you can store the output of a mingle in a onespotvariable if it happens to be less than or equal to 65535, for instance.(This is not necessarily the case in versions of <acronym>INTERCAL</acronym> other than<abbrev>C-INTERCAL</abbrev>, though, so you have to be careful with portability when doingthis.)</variablelist>
-        </indexterm><indexterm>E277
-          <variablelist><inlinemediaobject name="E277"></inlinemediaobject>
-            <informalfigure>E277</informalfigure>
-            <informalfigure>reverse assignment, impossible</informalfigure>
-            <informalfigure>reverse assignment, error</informalfigure>
-            <informalfigure>operand overloading, impossible</informalfigure>
-            <informalfigure>impossible reverse assignment</informalfigure>
-            <screen>YOU CAN ONLY DISTORT THE LAWS OF MATHEMATICS SO FAR
-</screen>Reverse assignments are not always mathematically possible.  Also,sometimes they require changing the value of a constant; this is onlylegal if you specifically specified that it was legal by using the<option>-v</option> option.  In the case of an impossible reverse assignment(including a situation in which operand overloading causes a reverseassignment to happen), this error happens at runtime.</variablelist>
-        </indexterm><indexterm>E281
-          <variablelist><inlinemediaobject name="E281"></inlinemediaobject>
-            <informalfigure>E281</informalfigure>
-            <informalfigure>spark, nesting limit</informalfigure>
-            <informalfigure>ears, nesting limit</informalfigure>
-            <informalfigure>rabbit-ears, nesting limit</informalfigure>
-            <informalfigure>nesting limit</informalfigure>
-            <informalfigure>SENESTMAX</informalfigure>
-            <screen>THAT MUCH QUOTATION AMOUNTS TO PLAGIARISM
-</screen>There is a limit of 256 on the number of nested spark/ears groupsallowed.  If you somehow manage to exceed that limit, that will causethis error.  Try breaking the expression up into smaller expressions.(The limit is trivial to increase by changing <literal>SENESTMAX</literal> in<filename>ick.h</filename>; if you ever actually come across a program that hits thelimit but wasn't designed to, just email the maintainer to request ahigher limit.)</variablelist>
-        </indexterm><indexterm>E333
-          <variablelist><inlinemediaobject name="E333"></inlinemediaobject>
-            <informalfigure>E333</informalfigure>
-            <informalfigure>variables, limit</informalfigure>
-            <screen>YOU CAN'T HAVE EVERYTHING, WHERE WOULD YOU PUT IT?
-</screen>Your program references so many variables that the compiler couldn'tcope.  This error is unlikely to ever happen; if it does, try reducingthe number of variables you use by combining some into arrays.  This isa compile-time error.</variablelist>
-        </indexterm><indexterm>E404
-          <variablelist><inlinemediaobject name="E404"></inlinemediaobject>
-            <informalfigure>E404</informalfigure>
-            <informalfigure><literal>GO BACK</literal>, no choicepoint</informalfigure>
-            <informalfigure><literal>GO AHEAD</literal>, no choicepoint</informalfigure>
-            <screen>I'M ALL OUT OF CHOICES!
-</screen>Your program asked that a choicepoint be backtracked to or removed, butthere aren't any choicepoints at the moment.  This runtime error usuallyindicates a logic mistake in your program.  In backtracking programstranslated from other backtracking languages, this indicates that theprogram has failed.</variablelist>
-        </indexterm><indexterm>E405
-          <variablelist><inlinemediaobject name="E405"></inlinemediaobject>
-            <informalfigure>E405</informalfigure>
-            <informalfigure>multithreading, not enabled</informalfigure>
-            <informalfigure>backtracking, not enabled</informalfigure>
-            <informalfigure><literal>WHILE</literal>, not enabled</informalfigure>
-            <informalfigure><literal>MAYBE</literal>, not enabled</informalfigure>
-            <informalfigure><literal>GO AHEAD</literal>, not enabled</informalfigure>
-            <informalfigure><literal>GO BACK</literal>, not enabled</informalfigure>
-            <screen>PROGRAM REJECTED FOR MENTAL HEALTH REASONS
-</screen>Your program used a construct that only makes sense when multithreadingor backtracking (<literal>WHILE</literal>, <literal>MAYBE</literal>, <literal>GO BACK</literal>, or <literal>GOAHEAD</literal>), but you didn't specify the <option>-m</option> option (see ).  Ifyou meant to write a multithreaded or backtracking program, just givethat option; if you didn't, be careful what words you use in comments!This error happens at compile-time.</variablelist>
-        </indexterm><indexterm>E436
-          <variablelist><inlinemediaobject name="E436"></inlinemediaobject>
-            <informalfigure>E436</informalfigure>
-            <informalfigure><literal>RETRIEVE</literal>, without stashing</informalfigure>
-            <informalfigure>stash failure</informalfigure>
-            <screen>THROW STICK BEFORE RETRIEVING!
-</screen>In order to <literal>RETRIEVE</literal> a variable, it has to be <literal>STASH</literal>edfirst; if it isn't, then this error happens at runtime.</variablelist>
-        </indexterm><indexterm>E444
-          <variablelist><inlinemediaobject name="E444"></inlinemediaobject>
-            <informalfigure>E444</informalfigure>
-            <informalfigure><literal>COME FROM</literal>, no target</informalfigure>
-            <informalfigure><literal>NEXT FROM</literal>, no target</informalfigure>
-            <screen>IT CAME FROM BEYOND SPACE
-</screen>A <literal>COME FROM</literal> aiming at a line label &mdash; as opposed to a computed<literal>COME FROM</literal>, which is allowed to be pointing at a nonexistent line&mdash; must point to a valid line label.  The same applies to <literal>NEXTFROM</literal>.  This error happens at compile time if a nonexistent line label isfound in one of these contexts.</variablelist>
-        </indexterm><indexterm>E533
-          <variablelist><inlinemediaobject name="E533"></inlinemediaobject>
-            <informalfigure>E533</informalfigure>
-            <informalfigure>overflow, over twospot</informalfigure>
-            <informalfigure>overflow, over 32 bits</informalfigure>
-            <informalfigure>twospot overflow</informalfigure>
-            <informalfigure>32 bit overflow</informalfigure>
-            <screen>YOU WANT MAYBE WE SHOULD IMPLEMENT 64-BIT VARIABLES?
-</screen>This error is like E275 (see ), but applies when an attempt ismade at runtime to store a threespot value (or even a fourspot ormorespot value) in a twospot variable, or a threespot or greater valueis produced as an intermediate during a calculation (for instance by amingle operation).  No values above twospot are allowed at any pointduring an <acronym>INTERCAL</acronym> program; if you want to process higher numbers, youhave to figure out a different way of storing them.</variablelist>
-        </indexterm><indexterm>E555
-          <variablelist><inlinemediaobject name="E555"></inlinemediaobject>
-            <informalfigure>E555</informalfigure>
-            <informalfigure><literal>COME FROM</literal>, ambiguity</informalfigure>
-            <screen>FLOW DIAGRAM IS EXCESSIVELY CONNECTED
-</screen>Aiming two <literal>COME FROM</literal>s at the same line only makes sense in amultithreaded program.  In a non-multithread program, doing that willcause this error at compile time (if neither <literal>COME FROM</literal> iscomputed) or at run time (if the command that has just finished runningis simultaneously the target of two or more <literal>COME FROM</literal>s).  Thiseither indicates an error in your program or that you've forgotten touse the <option>-m</option> option (see ) if you are actually trying tosplit the program into two threads.</variablelist>
-        </indexterm><indexterm>E562
-          <variablelist><inlinemediaobject name="E562"></inlinemediaobject>
-            <informalfigure>E562</informalfigure>
-            <informalfigure>input, EOF</informalfigure>
-            <informalfigure>EOF</informalfigure>
-            <informalfigure>end of file</informalfigure>
-            <screen>I DO NOT COMPUTE
-</screen>The program asked for input, but for some reason it wasn't available.(This is a runtime error, obviously.)   The error may happen because theinput is being piped in from a command or file which has reachedend-of-file, or because the user typed <userinput><keycap>CTRL</keycap>-<keycap>D</keycap></userinput>(UNIX/Linux) or <userinput><keycap>CTRL</keycap>-<keycap>Z</keycap></userinput> (DOS/Windows) while the programwas trying to <literal>WRITE IN</literal> some data.</variablelist>
-        </indexterm><indexterm>E579
-          <variablelist><inlinemediaobject name="E579"></inlinemediaobject>
-            <informalfigure>E579</informalfigure>
-            <informalfigure>input, invalid</informalfigure>
-            <screen>WHAT BASE AND/OR LANGUAGE INCLUDES <replaceable>string</replaceable>?
-</screen>When reading spelt-out-digit input, the input didn't seem to be a validdigit in English, Sanskrit, Basque, Tagalog, Classical Nahuatl,Georgian, Kwakiutl, Volap&uuml;k, or Latin.  This seems to have languagescovered pretty well; what on earth were you using, or did you just makea spelling mistake?</variablelist>
-        </indexterm><indexterm>E621
-          <variablelist><inlinemediaobject name="E621"></inlinemediaobject>
-            <informalfigure>E621</informalfigure>
-            <informalfigure><literal>RESUME</literal>, by 0</informalfigure>
-            <screen>ERROR TYPE 621 ENCOUNTERED
-</screen>The compiler encountered error E621 (see ).  This happens atruntime when the program requests that no entries are removed from the<literal>NEXT</literal> stack (which is possible), but that the last entry removedshould be jumped to (which given the circumstances isn't, because noentries were removed).</variablelist>
-        </indexterm><indexterm>E632
-          <variablelist><inlinemediaobject name="E632"></inlinemediaobject>
-            <informalfigure>E632</informalfigure>
-            <screen>THE NEXT STACK RUPTURES.  ALL DIE.  OH, THE EMBARRASSMENT!
-</screen>When an attempt is made to <literal>RESUME</literal> past the end of the <literal>NEXT</literal>stack, the program ends; however, this cause the program to end in amanner other than via <literal>GIVE UP</literal> or <literal>DON'T TRY AGAIN</literal>, so anerror message must be printed, and this is that error message.</variablelist>
-        </indexterm><indexterm>E633
-          <variablelist><inlinemediaobject name="E633"></inlinemediaobject>
-            <informalfigure>E633</informalfigure>
-            <screen>PROGRAM FELL OFF THE EDGE
-</screen>You can't just let execution run off the end of the program.  At least,that is, if it doesn't end with <literal>TRY AGAIN</literal>.  An attempt to do thatcauses this error at runtime.  Note that if your program references thesystem library, then it counts as being appended to your program and sothe program will run into the first line of the system library ratherthan cause this error.  As it happens, the first line of the systemlibrary is a syntax error, so doing this will cause E000 (see )with the error text &lsquo;<literal>PLEASE KNOCK BEFORE ENTERING</literal>&rsquo;.  There isn't anext statement to be executed with E633, so the next statement won't begiven in the error message.</variablelist>
-        </indexterm><indexterm>E652
-          <variablelist><inlinemediaobject name="E652"></inlinemediaobject>
-            <informalfigure>E652</informalfigure>
-            <informalfigure><literal>PIN</literal>, in a non-PIC program</informalfigure>
-            <screen>HOW DARE YOU INSULT ME!
-</screen>The <literal>PIN</literal> command doesn't make much sense for anything bigger thana <acronym>PIC</acronym>; using it in a non-<acronym>PIC</acronym> program causes thiserror at compile-time.  Try using the normal input and output mechanismsinstead.  This error may also be a clue that you are trying to compile a<abbrev>PIC-INTERCAL</abbrev> program without giving the <option>-P</option> option(see -P).</variablelist>
-        </indexterm><indexterm>E666
-          <variablelist><inlinemediaobject name="E666"></inlinemediaobject>
-            <informalfigure>E666</informalfigure>
-            <informalfigure>out of memory, during compile</informalfigure>
-            <screen>COMPILER HAS INDIGESTION
-</screen>There isn't a limit on the length of an input program other than yourcomputer's memory; if your computer does run out of memory duringcompilation, it causes this error.</variablelist>
-        </indexterm><indexterm>E774
-          <variablelist><inlinemediaobject name="E774"></inlinemediaobject>
-            <informalfigure>E774</informalfigure>
-            <informalfigure>random bug, error message</informalfigure>
-            <screen>RANDOM COMPILER BUG
-</screen>No compiler is perfect; sometimes errors just happen at random.  In thiscase, the random error is E774.  If you don't like the idea that yourprogram may be shot down by a random compiler bug, or you are doingsomething important, you can use the <option>-b</option> option (see ) toprevent this bug happening.  (You may wonder why this bug is in there atall if it's so easily prevented.  The answer is that such a bug waspresent in the original <abbrev>INTERCAL-72</abbrev> compiler, which also had an option toturn the bug off.  It's also a reward for people who actually read themanual.)</variablelist>
-        </indexterm><indexterm>E777
-          <variablelist><inlinemediaobject name="E777"></inlinemediaobject>
-            <informalfigure>E777</informalfigure>
-            <informalfigure>directory problems, source file</informalfigure>
-            <informalfigure>no source file</informalfigure>
-            <screen>A SOURCE IS A SOURCE, OF COURSE, OF COURSE
-</screen>You specified a file to compile on the command line, but the compilercouldn't find or couldn't open it.  This is almost certainly because youmade a typo specifying the file.</variablelist>
-        </indexterm><indexterm>E778
-          <variablelist><inlinemediaobject name="E778"></inlinemediaobject>
-            <informalfigure>E778</informalfigure>
-            <informalfigure>internal errors</informalfigure>
-            <screen>UNEXPLANED COMPILER BUG
-</screen>This should never come up, either at compile time or at run time.  Itcould come up at either when an internal check by the compiler or theruntime libraries realises that something has gone badly wrong; mistakeshappen, and in such cases the mistake will have been detected.  (If thishappens at compile time you can use the <option>-U</option> option(see -U) to cause the compiler to send an abort signal &ndash; whichnormally causes a core dump &ndash; when the error happens, to help debugwhat's causing it.)  More often, this error comes up when the operatingsystem has noticed something impossible, like an attempt to freeallocated memory twice or to write to a null pointer, and tells thecompiler an error has occured, in which case the same response ofputting up this error happens.  The point is that in all cases thiserror indicates a bug in the compiler (even if it happens at run time);in such cases, it would be very helpful if you figure out what caused itand send a bug report (see ).</variablelist>
-        </indexterm><indexterm>E810
-          <variablelist><inlinemediaobject name="E810"></inlinemediaobject>
-            <informalfigure>E810</informalfigure>
-            <informalfigure>yuk, input overflow</informalfigure>
-            <screen>ARE ONE-CHARACTER COMMANDS TOO SHORT FOR YOU?
-</screen>This is a debug-time error caused when you give too much input to thedebugger when all it wanted was to know what you wanted to do next.</variablelist>
-        </indexterm><indexterm>E811
-          <variablelist><inlinemediaobject name="E811"></inlinemediaobject>
-            <informalfigure>E811</informalfigure>
-            <informalfigure>yuk, breakpoint overflow</informalfigure>
-            <informalfigure>yuk, too many breakpoints</informalfigure>
-            <informalfigure>breakpoints, too many</informalfigure>
-            <screen>PROGRAM IS TOO BADLY BROKEN TO RUN
-</screen>There's a limit to how many breakpoints you can have in a program;you've broken the limit and therefore broken the debugger.  This is adebug-time error.</variablelist>
-        </indexterm><indexterm>E888
-          <variablelist><inlinemediaobject name="E888"></inlinemediaobject>
-            <informalfigure>E888</informalfigure>
-            <screen>I HAVE NO FILE AND I MUST SCREAM
-</screen>The output file couldn't be written, maybe because the disk is full orbecause there's already a read-only file with the same name.  This is acompile-time error.</variablelist>
-        </indexterm><indexterm>E991
-          <variablelist><inlinemediaobject name="E991"></inlinemediaobject>
-            <informalfigure>E991</informalfigure>
-            <informalfigure>out of memory, multithreading</informalfigure>
-            <informalfigure>out of memory, backtracking</informalfigure>
-            <informalfigure>multithreading, out of memory</informalfigure>
-            <informalfigure>backtracking, out of memory</informalfigure>
-            <screen>YOU HAVE TOO MUCH ROPE TO HANG YOURSELF
-</screen>There is no limit on the number of threads or choicepoints that you canhave in a multithreaded or backtracking program (in a program that isn'tmultithreaded or backtracking, these are obviously limited to 1 and 0respectively).  However, your computer may not be able to cope; if itruns out of memory in the multithreader, it will cause this error atruntime.</variablelist>
-        </indexterm><indexterm>E993
-          <variablelist><inlinemediaobject name="E993"></inlinemediaobject>
-            <informalfigure>E993</informalfigure>
-            <informalfigure><literal>TRY AGAIN</literal>, not last</informalfigure>
-            <screen>I GAVE UP LONG AGO
-</screen><literal>TRY AGAIN</literal> has to be the last command in a program, if it's thereat all; you can't even follow it by comments, not even if you know inadvance that they won't be <literal>REINSTATE</literal>d.  This error happens atcompile time if a command is found after a <literal>TRY AGAIN</literal>.</variablelist>
-        </indexterm><indexterm>E995
-          <variablelist><inlinemediaobject name="E995"></inlinemediaobject>
-            <informalfigure>E995</informalfigure>
-            <screen>DO YOU REALLY EXPECT ME TO HAVE IMPLEMENTED THAT?
-</screen>Some parts of the code haven't been written yet.  There ought to be noway to cause those to actually run; however, if you do somehow find away to cause them to run, they will cause this error at compile time.</variablelist>
-        </indexterm><indexterm>E997
-          <variablelist><inlinemediaobject name="E997"></inlinemediaobject>
-            <informalfigure>E997</informalfigure>
-            <informalfigure>whirlpool, in base 2</informalfigure>
-            <informalfigure>sharkfin, in base 2</informalfigure>
-            <informalfigure>TriINTERCAL, operators in base 2</informalfigure>
-            <screen>ILLEGAL POSSESSION OF A CONTROLLED UNARY OPERATOR
-</screen>Some operators (such as whirlpool (<literal>@</literal>) and sharkfin (<literal>^</literal>))only make sense in <abbrev>TriINTERCAL</abbrev> programs, and some have a minimumbase in which they make sense.  This error happens at compile-time ifyou try to use an operator that conflicts with the base you're in (suchas using <abbrev>TriINTERCAL</abbrev> operators in an <acronym>INTERCAL</acronym> program in thedefault base 2).</variablelist>
-        </indexterm><indexterm>E999
-          <variablelist><inlinemediaobject name="E999"></inlinemediaobject>
-            <informalfigure>E999</informalfigure>
-            <informalfigure>skeleton file, errors</informalfigure>
-            <screen>NO SKELETON IN MY CLOSET, WOE IS ME!
-</screen>The skeleton file <filename>ick-wrap.c</filename> or <filename>pickwrap.c</filename> is needed to beable to compile <acronym>INTERCAL</acronym> to C.  If the compiler can't find it, it willgive this error message.  This indicates a problem with the way thecompiler has been installed; try using the <option>-u</option> option(see ) to find out where it's looking (you may be able to place acopy of the skeleton file in one of those places).</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="3.2" id="Warnings">
-      <para>Warnings</para>
-      <informalfigure>warnings</informalfigure>
-      <informalfigure><command>ick</command>, warnings</informalfigure>
-      <para>This is a list of the warnings stored in the warning database.
-Warnings only come up when the <option>-l</option> option (see ) is
-given; even then, some of the warnings are not currently implemented
-and therefore will never come up.</para>
-      <term><indexterm>W016
-          <variablelist><inlinemediaobject name="W016"></inlinemediaobject>
-            <informalfigure>W016</informalfigure>
-            <screen>DON'T TYPE THAT SO HASTILY
-</screen>The positional precedence rules for unary operators are somewhatcomplicated, and it's easy to make a mistake.  This warning is meant todetect such mistakes, but is not currently implemented.</variablelist>
-        </indexterm><indexterm>W018
-          <variablelist><inlinemediaobject name="W018"></inlinemediaobject>
-            <informalfigure>W018</informalfigure>
-            <screen>THAT WAS MEANT TO BE A JOKE
-</screen>If an <acronym>INTERCAL</acronym> expression has been translated from another language suchas C, the optimiser is generally capable of translating it back intosomething similar to the original, at least in base 2.  When afteroptimisation there are still <acronym>INTERCAL</acronym> operators left in an expression,then this warning is produced.  (Therefore, it's likely to come up quitea lot if optimisation isn't used!)  The system library produces some ofthese warnings (you can tell if a warning has come up in the systemlibrary because you'll get a line number after the end of your program).</variablelist>
-        </indexterm><indexterm>W112
-          <variablelist><inlinemediaobject name="W112"></inlinemediaobject>
-            <informalfigure>W112</informalfigure>
-            <informalfigure>warnings, non-INTERCAL-72</informalfigure>
-            <informalfigure>non-INTERCAL-72 warning</informalfigure>
-            <screen>THAT RELIES ON THE NEW WORLD ORDER
-</screen>This warning comes up whenever the compiler recognises that you've addedsome code that didn't exist in <abbrev>INTERCAL-72</abbrev>.  This allows you to checkwhether your code is valid <abbrev>INTERCAL-72</abbrev> (although <option>-t</option> (see ) ismore useful for that); it also warns you that code might not be portable(because <abbrev>INTERCAL-72</abbrev> is implemented by most <acronym>INTERCAL</acronym> compilers, but morerecent language features may not be).</variablelist>
-        </indexterm><indexterm>W128
-          <variablelist><inlinemediaobject name="W128"></inlinemediaobject>
-            <informalfigure>W128</informalfigure>
-            <screen>SYSLIB IS OPTIMIZED FOR OBUSCATION
-</screen>There is an idiom used in the system library that does a right-shift byselecting alternate bits from a twospot number and then mingling themthe other way round.  A rightshift can much more easily be done with asingle rightshift, so this is a silly way to do it, and this warningwarns that this idiom was used.  However, the present optimizer isincapable of recognising whether this problem exists or not, so thewarning is not currently implemented.</variablelist>
-        </indexterm><indexterm>W276
-          <variablelist><inlinemediaobject name="W276"></inlinemediaobject>
-            <informalfigure>W276</informalfigure>
-            <informalfigure>onespot, overflow warning</informalfigure>
-            <informalfigure>overflow, warning</informalfigure>
-            <screen>YOU CAN'T EXPECT ME TO CHECK BACK THAT FAR
-</screen>It's an error to assign a twospot value (a value over 65535) to aonespot variable, or to use it as an argument to a mingle.  If theoptimizer can't guarantee at compile time that there won't be anoverflow, it issues this warning.  (Note that this doesn't necessarilymean there's a problem &mdash; for instance, the system library generatessome of these warnings &mdash; only that the optimiser couldn't work out forsure that there wasn't a problem.)</variablelist>
-        </indexterm><indexterm>W239
-          <variablelist><inlinemediaobject name="W239"></inlinemediaobject>
-            <informalfigure>W239</informalfigure>
-            <screen>WARNING HANDLER PRINTED SNIDE REMARK
-</screen>Your code looks like it's trying to assign 0 to an array, giving it nodimension; this is an error.  This warning is produced at compile timeif it looks like a line in your code will cause this error, but it isn'tnecessarily an error because that line of code might never be executed.</variablelist>
-        </indexterm><indexterm>W278
-          <variablelist><inlinemediaobject name="W278"></inlinemediaobject>
-            <informalfigure>W278</informalfigure>
-            <screen>FROM A CONTRADICTION, ANYTHING FOLLOWS
-</screen>It's sometimes impossible to reverse an assignment (a reverseassignment can happen if the <option>-v</option> option (see ) is usedand an expression is placed on the left of an assignment, or inoperand overloading); if the compiler detects that a reversal failureis inevitable, it will cause this warning.  Note that this doesn'talways cause an error, because the relevant code might never beexecuted.</variablelist>
-        </indexterm><indexterm>W534
-          <variablelist><inlinemediaobject name="W534"></inlinemediaobject>
-            <informalfigure>W534</informalfigure>
-            <informalfigure>unary operators, portability</informalfigure>
-            <informalfigure>portability, unary operators</informalfigure>
-            <screen>KEEP LOOKING AT THE TOP BIT
-</screen><abbrev>C-INTERCAL</abbrev> uses a slightly different typing mechanism to some other <acronym>INTERCAL</acronym>compilers; types are calculated at compile time rather than run time.This only makes a difference in some cases involving unary operators.It's impossible to detect at compile time for certain whether such acase has come up or not, but if the compiler or optimizer thinks thatsuch a case might have come up, it will issue this warning.</variablelist>
-        </indexterm><indexterm>W622
-          <variablelist><inlinemediaobject name="W622"></inlinemediaobject>
-            <informalfigure>W622</informalfigure>
-            <screen>WARNING TYPE 622 ENCOUNTERED
-</screen>Your code looks like it's trying to resume by 0; this is an error.  Thiswarning is produced at compile time if it looks like a line in your codewill cause this error, but it isn't necessarily an error because thatline of code might never be executed.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-  </chapter>
-
-  <chapter label="4" id="The-yuk-debugger">
-    <para>The yuk debugger</para>
-    <informalfigure>yuk</informalfigure>
-    <informalfigure>debugging, yuk</informalfigure>
-    <informalfigure>debugging, runtime</informalfigure>
-    <informalfigure>runtime debugger</informalfigure>
-    <para><inlinemediaobject name="yuk"></inlinemediaobject></para>
-    <para>The <abbrev>C-INTERCAL</abbrev> distribution contains a runtime debugger called `yuk'.
-Unlike most other debuggers, it is stored as object code rather than as
-an executable, and it is compiled into the code rather than operating on
-it.  To debug code, add <option>-y</option> (see ) to the command line of
-<command>ick</command> when invoking it; that tells it to compile the debugger
-into the code and then execute the resulting combination.  (The
-resulting hybrid debugger/input executable is deleted afterwards; this
-is to prevent it being run by mistake, and to prevent spreading the
-debugger's licence onto the code it was compiled with.)</para>
-    <para>yuk can also be used as a profiler using the <option>-p</option> option
-(see ); this produces a file <filename>yuk.out</filename> containing information
-on how much time was spent running each command in your program, and
-does not prompt for debugger commands.</para>
-    <para>Note that some command line arguments are incompatible with the
-debugger, such as <option>-m</option> and <option>-f</option>.  In particular, this
-means that multithreaded programs and programs that use backtracking
-cannot be debugged using this method; the <option>+printflow</option> option
-(see ) to a compiled program may or may not be useful for
-debugging multithreaded programs.</para>
-    <para>When the debugger starts, it will print a copyright message and a
-message on how to access online help; then you can enter commands to
-run/debug the program.  The debugger will show a command prompt,
-&lsquo;<literal>yuk007 </literal>&rsquo;, to let you know you can input a command.</para>
-    <informalfigure>yuk, commands</informalfigure>
-    <para>Here are the commands available.  Commands are single characters
-followed by newlines, or followed by a line number (in decimal) and a
-newline or a variable name (a <literal>.</literal>, <literal>,</literal>, <literal>:</literal> or <literal>;</literal>
-followed by a number in decimal; note that some commands only allow
-onespot and twospot variables as arguments).</para>
-    <colspec>
-      <thead cols="2">
-        <tbody colwidth="15*"></tbody>
-        <tbody colwidth="85*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo>Command</bookinfo>
-            <bookinfo>Description</bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>a<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-All non-abstained commands on line <replaceable>LINE</replaceable> become abstained from
-once.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>b<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-A breakpoint is set on line <replaceable>LINE</replaceable>.  The breakpoint causes execution
-with &lsquo;<literal>c</literal>&rsquo; to stop when it is reached.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>c</bookinfo>
-            <bookinfo>
-The program is run until it ends (which also ends the debugger) or a
-breakpoint is reached.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>d<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Any breakpoint that may be on line <replaceable>LINE</replaceable> is removed.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>e<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-An explanation of the main expression in each command on line <replaceable>LINE</replaceable>
-is printed to the screen.  The explanation is in the same format as the
-format produced by <option>-h</option> (see ) and shows what the optimiser
-optimised the expression to (or the original expression if the optimiser
-wasn't used).</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>f<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Removes the effect of the &lsquo;<literal>m</literal>&rsquo; command on line <replaceable>LINE</replaceable>.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>g<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Causes the current command to be the first command on <replaceable>LINE</replaceable> (if not
-on that line already) or the next command on <replaceable>LINE</replaceable>, as if that line
-was <literal>NEXT</literal>ed to and then that <literal>NEXT</literal> stack item was forgotten.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>h</bookinfo>
-            <bookinfo>
-Lists 10 lines either side of the current line; if there aren't 10 lines
-to one or the other side of the current line, instead more lines will be
-shown on the other side to compensate, if available.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>i<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Causes variable <replaceable>VAR</replaceable> to become <literal>IGNORE</literal>d, making it read-only.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>j<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Causes variable <replaceable>VAR</replaceable> to become <literal>REMEMBER</literal>ed, making it no
-longer read-only.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>k</bookinfo>
-            <bookinfo>
-Continues executing commands until the <command>NEXT</command> stack is the same
-size or smaller than it was before.  In other words, if the current
-command is not a <command>NEXT</command> and doesn't have a <command>NEXT FROM</command>
-aiming at it, one command is executed; but if a <command>NEXT</command> does
-happen, execution will continue until that <command>NEXT</command> returns or is
-forgotten.  A breakpoint or the end of the program also end this.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>l<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Lists 10 lines of source code either side of line <replaceable>LINE</replaceable>, the same
-way as with &lsquo;<literal>h</literal>&rsquo;, but using a line stated in the command rather than
-the current line.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>m<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Produces a message onscreen every time a command on line <replaceable>LINE</replaceable> is
-executed, but without interrupting the program.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>n</bookinfo>
-            <bookinfo>
-Show the <command>NEXT</command> stack on the screen.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>o</bookinfo>
-            <bookinfo>
-Continue executing commands until the <command>NEXT</command> stack is smaller
-than it was before.  If you are using <command>NEXT</command>s like procedures,
-then this effectively means that the procedure will run until it
-returns.  A breakpoint or the end of the program also end this.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>p</bookinfo>
-            <bookinfo>
-Displays the value of all onespot and twospot variables.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>q</bookinfo>
-            <bookinfo>
-Aborts the current program and exits the debugger.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>r<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Reinstates once all abstained commands on line <replaceable>LINE</replaceable>.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>s</bookinfo>
-            <bookinfo>
-Executes one command.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>t</bookinfo>
-            <bookinfo>
-Continues execution until the end of the program or a breakpoint: each
-command that executes is displayed while this command is running.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>u<replaceable>LINE</replaceable></bookinfo>
-            <bookinfo>
-Continues execution of the program until just before a command on line
-<replaceable>LINE</replaceable> is run (or a breakpoint or the end of the program).</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>v<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Adds a `view' on variable <replaceable>VAR</replaceable> (which must be onespot or twospot),
-causing its value to be displayed on the screen whenever a command is
-printed on screen (for instance, because the command has just been
-stepped past, or due to the &lsquo;<literal>m</literal>&rsquo; or &lsquo;<literal>t</literal>&rsquo; commands).</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>w</bookinfo>
-            <bookinfo>
-Displays the current line and current command onscreen.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>x<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Removes any view and any action that may be associated with it on
-variable <replaceable>VAR</replaceable> (which must be onespot or twospot).</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>y<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Adds a view on variable <replaceable>VAR</replaceable>; also causes a break, as if a
-breakpoint was reached, whenever the value of that variable changes.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>z<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-Adds a view on variable <replaceable>VAR</replaceable>; also causes a break, as if a
-breakpoint was reached, whenever that variable's value becomes 0.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo><replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-A onespot or twospot variable written by itself prints out the value of
-that variable.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>&lt;<replaceable>VAR</replaceable></bookinfo>
-            <bookinfo>
-<command>WRITEs IN</command> a new value for variable <replaceable>VAR</replaceable>.  Note that input
-must be in the normal &lsquo;<literal>ONE TWO THREE</literal>&rsquo; format; input in any other
-format will cause error E579 (see ) and as that is a fatal
-error, the debugger and program it's debugging will end.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>*</bookinfo>
-            <bookinfo>
-Displays the license conditions under which <command>ick</command> is
-distributed.</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>?</bookinfo>
-            <bookinfo>
-Displays a summary of what each command does.  (&lsquo;<literal>@</literal>&rsquo; does the same
-thing.)</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para>While the code is executing (for instance, during a &lsquo;<literal>c</literal>&rsquo;, &lsquo;<literal>k</literal>&rsquo;,
-&lsquo;<literal>o</literal>&rsquo;, &lsquo;<literal>t</literal>&rsquo; or &lsquo;<literal>u</literal>&rsquo; command), it's possible to interrupt it
-with <userinput><keycap>CTRL</keycap>-<keycap>C</keycap></userinput> (on UNIX/Linux) or
-<userinput><keycap>CTRL</keycap>-<keycap>BREAK</keycap></userinput> (on Windows/DOS); this will cause the
-current command to finish running and the debugger prompt to come back
-up.</para>
-  </chapter>
-
-  <chapter label="" xreflabel="PART II: THE INTERCAL LANGUAGE">
-    <para>PART II: THE <acronym>INTERCAL</acronym> LANGUAGE</para>
-  </chapter>
-
-  <chapter label="5" id="Syntax">
-    <para>Syntax</para>
-    <informalfigure>syntax, INTERCAL</informalfigure>
-    <informalfigure>INTERCAL, syntax</informalfigure>
-    <para><acronym>INTERCAL</acronym> programs consist of a list of statements.  Execution of a
-program starts with its first statement; generally speaking each
-statement runs after the previous statement, although many situations
-can change this.</para>
-    <para>Whitespace is generally insignificant in <acronym>INTERCAL</acronym> programs; it cannot be
-added in the middle of a keyword (unless the keyword contains whitespace
-itself) or inside a decimal number, but it can be added more or less
-anywhere else, and it can be removed from anywhere in the program as
-well.</para>
-    <para>An <acronym>INTERCAL</acronym> statement consists of an optional line label, a statement
-identifier, an optional execution chance, the statement itself
-(see ), and optionally <literal>ONCE</literal> or <literal>AGAIN</literal>.</para>
-
-    <sect1 label="5.1" id="Princeton-and-Atari-Syntax">
-      <para>Princeton and Atari Syntax</para>
-      <informalfigure>syntax, dialects</informalfigure>
-      <informalfigure>dialects of syntax</informalfigure>
-      <informalfigure>character sets</informalfigure>
-      <para>The history of <acronym>INTERCAL</acronym> is plagued with multiple syntaxes and character
-sets.  The result has settled down with two versions of the syntax;
-the original Princeton syntax, and the Atari syntax (which is more
-suited to the operating systems of today).</para>
-      <informalfigure>syntax, Princeton</informalfigure>
-      <informalfigure>Princeton syntax</informalfigure>
-      <bridgehead renderas="sect2">Princeton syntax</bridgehead>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>some versions</bookinfo>
-              <bookinfo>version 0.18+</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The original <abbrev>INTERCAL-72</abbrev> compiler was the Princeton compiler, which
-introduced what has become known as the Princeton syntax for <acronym>INTERCAL</acronym>;
-this is the syntax used in the original manual, for instance, and can
-be considered to be the `original' or `official' <acronym>INTERCAL</acronym> syntax.  It
-is notable for containing various characters not found in some
-character sets; for instance, it writes the operator for mingle as a
-cent sign (known as `change').  The other operator that often causes
-problems is the bookworm operator &lsquo;<literal>V</literal>&rsquo;, backspace, &lsquo;<literal>-</literal>&rsquo;, which
-is used for exclusive-or; the backspace can cause problems on some
-systems (which was probably the original intention).  This syntax is
-also the default syntax in the <abbrev>CLC-INTERCAL</abbrev> compiler, which is the <wordasword>de
-facto</wordasword> standard for expanding the Princeton syntax to modern <acronym>INTERCAL</acronym>
-features that are not found in <abbrev>INTERCAL-72</abbrev>; however, it does not appear to
-have been used as the default syntax in any other compilers.
-Nowadays, there are other ways to write the required characters than
-using backspace; for instance, the cent sign appears in Latin-1 and
-UTF-8, and there are various characters that approximate bookworms
-(for instance, <abbrev>CLC-INTERCAL</abbrev> uses the Latin-1 yen symbol for this, which
-just to make things confusing, refers to a mingle in modern Atari
-syntax).</para>
-      <informalfigure>syntax, Atari</informalfigure>
-      <informalfigure>Atari syntax</informalfigure>
-      <bridgehead renderas="sect2">Atari syntax</bridgehead>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>some versions</bookinfo>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>version 0.05+</bookinfo>
-              <bookinfo>yes</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The other main syntax is the Atari syntax, so called because it was
-originally used by the &ldquo;Atari implementation&rdquo; of <abbrev>INTERCAL-72</abbrev>.  It is not
-clear why the implementation was given this name, because the authors
-of the implementation are not known; it is not clear whether it has
-any connection with Atari other than running on an Atari computer, for
-instance.  The syntax was designed to work better on ASCII-based
-systems, by avoiding the change character (although it can still be
-written as &lsquo;<literal>c</literal>&rsquo;, backspace, &lsquo;<literal>/</literal>&rsquo;, which the Atari compiler
-documentation claims that the Princeton compiler supported) in favour
-of a `big money' character (&lsquo;<literal>$</literal>&rsquo;), and using the `what' (&lsquo;<literal>?</literal>&rsquo;)
-as an alternative character for exclusive-or.  This is the syntax that
-<abbrev>C-INTERCAL</abbrev> and <abbrev>J-INTERCAL</abbrev> have always used, and is the one most commonly used
-for communicating <acronym>INTERCAL</acronym> programs on Usenet and other similar fora
-(where ASCII is one of the most reliable-to-send character sets).  It
-is also the syntax used for examples in this manual, for much the same
-reason.  The Atari syntax for constructs more modern than <abbrev>INTERCAL-72</abbrev> is
-normally taken to be that used by the <abbrev>C-INTERCAL</abbrev> compiler, because it is
-the only Atari-syntax-based compiler that contains non-<abbrev>INTERCAL-72</abbrev>
-constructs that actually need their own notation.</para>
-    </sect1>
-
-    <sect1 label="5.2" id="Line-Labels">
-      <para>Line Labels</para>
-      <informalfigure>line label</informalfigure>
-      <informalfigure>line number</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The first part of an <acronym>INTERCAL</acronym> statement is a line label that specifies
-what its line number is.  This is optional; it's allowed to have a
-statement without a line number, although that prevents other commands
-referring to it by number.  Line numbers must be constants, and unique
-within the program.  However, they do not have to be in order; unlike
-some other languages with line numbers, a line with a higher number can
-come earlier in the program than a line with a lower number, and the
-numbers don't affect the order in which commands are executed.</para>
-      <para>A line label is a integer expressed in decimal within a wax/wane pair
-(<literal>(</literal> and <literal>)</literal>).  For instance, this is a valid line label:</para>
-      <programlisting>
-(1000)
-</programlisting>
-      <para>Note that line numbers from 1000 to 1999 are used by the system library,
-so using them within your own programs may produce unexpected errors if
-the system library is included.  Apart from this, line numbers from 1 to
-65535 are allowed.</para>
-      <para>It has become reasonably customary for people writing <acronym>INTERCAL</acronym> libraries
-to pick a range of 1000 line numbers (for instance, 3000 to 3999) and
-stick to that range for all line numbers used in the program (apart from
-when calling the system library), so if you want to write an <acronym>INTERCAL</acronym>
-library, it may be a good idea to look at the existing libraries (in the
-<filename>pit/lib</filename> directory in the <abbrev>C-INTERCAL</abbrev> distribution) and choose a range
-of numbers that nobody else has used.  If you aren't writing a library,
-it may be a good idea to avoid such number ranges (that is, use only
-line numbers below 1000 or very high numbers that are unlikely to be
-used by libraries in the future), so that you can easily add libraries
-to your program without renumbering in the future.</para>
-    </sect1>
-
-    <sect1 label="5.3" id="Statement-Identifiers">
-      <para>Statement Identifiers</para>
-      <informalfigure>statement identifier</informalfigure>
-      <informalfigure>DO</informalfigure>
-      <informalfigure>PLEASE</informalfigure>
-      <informalfigure>NOT</informalfigure>
-      <informalfigure>N'T</informalfigure>
-      <informalfigure>abstain, at program start</informalfigure>
-      <informalfigure>reinstate, at program start</informalfigure>
-      <informalfigure>initial abstention</informalfigure>
-      <informalfigure>abstained state</informalfigure>
-      <informalfigure>reinstated state</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>After the line label (if a statement has one) comes the statement
-identifier, which marks where the statement starts.  Either the label or
-the statement identifier, whichever one comes first, marks where the
-preceding statement finishes.</para>
-      <para><inlinemediaobject name="DO"></inlinemediaobject><inlinemediaobject name="PLEASE"></inlinemediaobject></para>
-      <para>The main statement identifier is <literal>DO</literal>.  It also has two synonyms,
-<literal>PLEASE</literal> and <literal>PLEASE DO</literal>; these synonyms are the 'polite'
-forms of statement identifiers.  Although the three identifiers have the
-same meaning, using either polite or non-polite identifiers too much can
-cause an error; the correct proportion is approximately 3 non-polite
-identifiers for every polite identifier used.  None of these identifiers
-actually does anything else apart from marking where the statement
-starts; they leave the statements in the default `reinstated' state.</para>
-      <para><inlinemediaobject name="NOT"></inlinemediaobject><inlinemediaobject name="N'T"></inlinemediaobject></para>
-      <para>Adding <literal>NOT</literal> or <literal>N'T</literal> to the end of any of these identifiers,
-to create a statement identifier such as <literal>DO NOT</literal> or <literal>PLEASE
-DON'T</literal>, also creates a valid statement identifier.  These differ in
-meanings from the previous set of identifiers, though; they cause the
-statement they precede to not be executed by default; that is, the
-command will be skipped during execution (this is known as the
-`abstained' state).  This applies even if the command in question is in
-fact a syntax error, thus causing this to be a useful method of writing
-comments.  One common idiom is to write code like this:</para>
-      <programlisting>
-PLEASE NOTE: This is a comment.
-</programlisting>
-      <para>The statement identifier (<literal>PLEASE NOT</literal>) is the only part of this
-statement that is valid <acronym>INTERCAL</acronym>; however, because the statement
-identifier is in the negated form that contains <literal>NOT</literal>, the syntax
-error won't be executed, and therefore this is a valid statement.  (In
-<acronym>INTERCAL</acronym>, syntax errors happen at runtime, so a program containing a
-statement like <literal>DOUBT THIS WILL WORK</literal> will still compile, and will
-not end due to the syntax error unless that statement is actually
-executed.  See .)</para>
-      <para>The <literal>ABSTAIN</literal> and <literal>REINSTATE</literal> statements can override the
-<literal>NOT</literal> or otherwise on a statement identifier; see .</para>
-      <para>In backtracking programs, <literal>MAYBE</literal> is also a valid statement
-identifier; see .  It comes before the other keywords in the
-statement identifier, and an implicit <literal>DO</literal> is added if there wasn't
-one already in the statement identifier (so <literal>MAYBE</literal>, <literal>MAYBE
-DO</literal>, <literal>MAYBE DON'T</literal>, <literal>MAYBE PLEASE</literal>, and so on are all valid
-statement identifiers).</para>
-    </sect1>
-
-    <sect1 label="5.4" id="Execution-Chance">
-      <para>Execution Chance</para>
-      <informalfigure>execution chance</informalfigure>
-      <informalfigure>double-oh-seven</informalfigure>
-      <informalfigure>%</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>version 0.02+</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>It's possible to specify that a command should be run only a certain
-proportion of the time, at random.  This is a rarely used feature of
-<acronym>INTERCAL</acronym>, although it is the only way to introduce randomness into a
-program.  (The <abbrev>C-INTERCAL</abbrev> compiler approximates this with pseudorandomness.)
-An execution chance specification comes immediately after the statement
-identifier, but before the rest of the statement, and consists of a
-double-oh-seven (<literal>%</literal>) followed by an integer from 1 to 99
-inclusive, written in decimal; this gives the percentage chance of the
-statement running.  The execution chance only acts to prevent a
-statement running when it otherwise would have run; it cannot cause a
-statement that would otherwise not have run to run.  For instance, the
-statement <literal>DO %40 WRITE OUT #1</literal> has a 40% chance of writing out
-&lsquo;<literal>I</literal>&rsquo;, but the statement <literal>DON'T %40 WRITE OUT #1</literal> has no chance
-of writing out <literal>I</literal> or anything else, because the <literal>N'T</literal>
-prevents it running and the double-oh-seven cannot override that.</para>
-    </sect1>
-
-    <sect1 label="5.5" id="ONCE-and-AGAIN">
-      <para>ONCE and AGAIN</para>
-      <informalfigure>ABSTAIN, self-abstaining</informalfigure>
-      <informalfigure>REINSTATE, self-reinstating</informalfigure>
-      <informalfigure>self-abstaining</informalfigure>
-      <informalfigure>self-reinstating</informalfigure>
-      <informalfigure>ONCE</informalfigure>
-      <informalfigure>AGAIN</informalfigure>
-      <para><inlinemediaobject name="ONCE"></inlinemediaobject><inlinemediaobject name="AGAIN"></inlinemediaobject></para>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>version 0.25+</bookinfo>
-              <bookinfo>no</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The last part of a statement is an optional <literal>ONCE</literal> or <literal>AGAIN</literal>.
-<literal>ONCE</literal> specifies that the statement is self-abstaining or
-self-reinstating (this will be explained below); <literal>AGAIN</literal> specifies
-that the statement should behave like it has already self-reinstated or
-self-abstained.  Whether the behaviour is self-abstention or
-self-reinstatement depends on whether the statement was initially
-abstained or not; a <literal>ONCE</literal> on an initially reinstated statement or
-<literal>AGAIN</literal> on an initially abstained statement indicates a
-self-abstention, and a <literal>ONCE</literal> on an initially abstained statement
-or <literal>AGAIN</literal> on an initially reinstated statement indicates a
-self-reinstatement.</para>
-      <para>The first time a self-abstaining statement is encountered, it is
-executed as normal, but the statement is then abstained from and
-therefore will not run in future.  Likewise, the first time
-self-reinstating statement is encountered, it is not executed (as is
-normal for an abstained statement), but then becomes reinstated and will
-run in future.  In each of these cases, the <literal>ONCE</literal> effectively
-changes to an <literal>AGAIN</literal>; the <literal>ONCE</literal> only happens once, as might
-be expected.</para>
-      <para><literal>REINSTATING</literal> a currently abstained self-abstaining statement or
-<literal>ABSTAINING</literal> (that is, with the <literal>ABSTAIN</literal> or <literal>REINSTATE</literal>
-commands) a currently reinstated self-reinstating statement causes the
-<literal>AGAIN</literal> on the statement to change back into a <literal>ONCE</literal>, so the
-statement will again self-abstain or self-reinstate.  Likewise,
-<literal>REINSTATING</literal> a currently abstained self-reinstating statement or
-<literal>ABSTAINING</literal> a currently reinstated self-abstaining statement
-causes its <literal>ONCE</literal> to turn into an <literal>AGAIN</literal>.</para>
-      <para>Historical note: <literal>ONCE</literal> was devised by Malcom Ryan as a method of
-allowing synchronisation between threads in a multithreaded program
-(<literal>ONCE</literal> is atomic with the statement it modifies, that is, there is
-no chance that threads will change between the statement and the
-<literal>ONCE</literal>).  <literal>AGAIN</literal> was added to Malcom Ryan's Threaded Intercal
-standard on the suggestion of Kyle Dean, as a method of adding extra
-flexibility (and to allow the <literal>ONCE</literal>s to happen multiple times,
-which is needed to implement some multithreaded algorithms).</para>
-    </sect1>
-  </chapter>
-
-  <chapter label="6" id="Expressions">
-    <para>Expressions</para>
-    <informalfigure>expressions</informalfigure>
-    <para>Many <acronym>INTERCAL</acronym> statements take expressions as arguments.  Expressions are
-made up out of operands and operators between them.  Note that there is
-no operator precedence in <acronym>INTERCAL</acronym>; different compilers resolve
-ambiguities different ways, and some versions of some compilers
-(including the original <abbrev>INTERCAL-72</abbrev> compiler) will cause error messages on
-compiling or executing an ambiguous expression, so it's safest to fully
-group each expression.</para>
-
-    <sect1 label="6.1" id="Constants-and-Variables">
-      <para>Constants and Variables</para>
-      <informalfigure>constant</informalfigure>
-      <informalfigure>variable</informalfigure>
-      <informalfigure>mesh</informalfigure>
-      <informalfigure>onespot</informalfigure>
-      <informalfigure>twospot</informalfigure>
-      <informalfigure>tail</informalfigure>
-      <informalfigure>hybrid</informalfigure>
-      <informalfigure>#</informalfigure>
-      <informalfigure>.</informalfigure>
-      <informalfigure>:</informalfigure>
-      <informalfigure>,</informalfigure>
-      <informalfigure>;</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The basic operands in <acronym>INTERCAL</acronym> are constants and variables.  These
-together make up what in other languages are known as `lvalues', that
-is, operands to which values can be assigned.  (Constants can also be
-lvalues in <acronym>INTERCAL</acronym>, but by default <abbrev>C-INTERCAL</abbrev> turns this off because it
-carries an efficiency penalty and can be confusing; this can be turned
-on with the <option>-v</option> option (see ).)</para>
-      <para>Constants can have any integer value from 0 to 65535 inclusive; higher
-values (up to 4294967295) can be generated in programs, but cannot be
-specified literally as constants.  (The usual way to work around this
-limitation is to interleave two constants together; see .) A
-constant is written as a mesh (<literal>#</literal>) followed by a number in
-decimal.  At the start of the program, all constants have the same value
-as the number that identifies them; for instance, <literal>#100</literal> has 100 as
-its value, and it's strongly advised not to change the value of a
-constant during the execution of a program.</para>
-      <para>There are four types of variable: 16-bit and 32-bit unsigned integers,
-and arrays of 16-bit and 32-bit unsigned integers.  These are
-represented with a spot, twospot, tail, and hybrid (<literal>.</literal>, <literal>:</literal>,
-<literal>,</literal>, and <literal>;</literal>) respectively.  For this reason, integers within
-the range 0 to 65535 inclusive are known as `onespot numbers', and
-integers within the range 0 to 4294967295 inclusive are known as
-`twospot numbers'; variables with those ranges are known as onespot and
-twospot variables.  (Note that arrays did not work in <abbrev>C-INTERCAL</abbrev> before
-version 0.7.)</para>
-      <para>Variables are represented with a character representing their data type,
-followed by an integer from 1 to 65535 inclusive, written in decimal.
-Non-array variables don't need to be declared before they are used; they
-automatically exist in any program that uses them.  For instance,
-<literal>.1</literal> and <literal>.001</literal> are the same variable, onespot number 1.
-Array variables need to be dimensioned before they are used, by
-assigning dimensions to them; see .</para>
-    </sect1>
-
-    <sect1 label="6.2" id="Grouping-Rules">
-      <para>Grouping Rules</para>
-      <informalfigure>grouping rules</informalfigure>
-      <informalfigure>positional precedence</informalfigure>
-      <informalfigure>spark</informalfigure>
-      <informalfigure>rabbit-ears</informalfigure>
-      <informalfigure>ears</informalfigure>
-      <informalfigure>'</informalfigure>
-      <informalfigure>"</informalfigure>
-      <para>Because there are no operator precedences in <acronym>INTERCAL</acronym>, there are various
-solutions to specifying what precedences actually are.</para>
-      <term><indexterm>The portable solution
-          <variablelist>All known versions of <acronym>INTERCAL</acronym> accept the <abbrev>INTERCAL-72</abbrev> grouping rules.  Thesestate that it's possible to specify that an operator takes precedence bygrouping it inside sparks (<literal>'</literal>) or rabbit-ears (<literal>"</literal>), the sameway as wax/wane pairs (parentheses) are used in other programminglanguages.  <abbrev>INTERCAL-72</abbrev> and earlier <abbrev>C-INTERCAL</abbrev> versions demanded thatexpressions were grouped fully like this, and this practice is stillrecommended because it leads to portable programs and is easier tounderstand.  Whether sparks or rabbit-ears (often called just `ears' forshort) are used normally doesn't matter, and programmers can use one orthe other for clarity or for aesthetic appeal.  (One common technique isto use just sparks at the outermost level of grouping, just ears at thenext level, just sparks at the next level, and so on; but expressionslike <literal>''#1~#2'~"#3~#4"'~#5</literal> are completely unambiguous, at least tothe compiler.)There are, however, some complicated situations involving arrayssubscripting where it is necessary to use sparks and ears at alternatelevels, if you want to write a portable program.  This limitation is in<abbrev>C-INTERCAL</abbrev> to simplify the parsing process; <abbrev>INTERCAL-72</abbrev> has the same limitation,probably for the same reason.  Compare these two statements:
-            <programlisting>
-DO .1 &lt;- ,3SUB",2SUB.1".2
-DO .1 &lt;- ,3SUB",2SUB.1".2~.3"".4
-</programlisting>The problem is that in the first statement, the ears close a group, andin the second statement, the ears open a group, and it's impossible totell the difference without unlimited lookahead in the expression.Therefore, in similar situations (to be precise, in situations where agroup is opened inside an array subscript), it's necessary to use theother grouping character to the one that opened the current group if youwant a portable program.One final comment about sparks and rabbit-ears; if the next character inthe program is a spot, as often happens because onespot variables arecommon choices for operands, a spark and the following spot can becombined into a wow (<literal>!</literal>).  Unfortunately, none of the charactersets that <abbrev>C-INTERCAL</abbrev> accepts as input (UTF-8, Latin-1, and ASCII-7) containthe rabbit character, although the Hollerith input format that <abbrev>CLC-INTERCAL</abbrev>can use does.</variablelist>
-        </indexterm><indexterm>Positional precedences: <abbrev>CLC-INTERCAL</abbrev> rules
-          <variablelist>The precedence rules used by <abbrev>CLC-INTERCAL</abbrev> for grouping when full groupingisn't used are simple to explain: the largest part of the input thatlooks like an expression is taken to be that expression.  The mainpractical upshot of this is that binary operators right-associate; thatis, <literal>.1~.2~.3</literal> is equivalent to <literal>.1~'.2~.3'</literal>.  <abbrev>C-INTERCAL</abbrev> versions0.26 and later also right-associate binary operators so as to producethe same results as <abbrev>CLC-INTERCAL</abbrev> rules in this situation, but as nobody hasyet tried to work out what the other implications of <abbrev>CLC-INTERCAL</abbrev> rules arethey are not emulated in <abbrev>C-INTERCAL</abbrev>, except possibly by chance.</variablelist>
-        </indexterm><indexterm>Prefix and infix unary operators
-          <variablelist><inlinemediaobject name="Prefix and infix unary operators"></inlinemediaobject>
-            <informalfigure>unary operator, prefix</informalfigure>
-            <informalfigure>unary operator, infix</informalfigure>In <abbrev>INTERCAL-72</abbrev> and versions of <abbrev>C-INTERCAL</abbrev> before 0.26, unary operators werealways in the `infix' position.  (If you're confused about how you canhave an infix unary operator: they go one character inside a group thatthey apply to, or one character after the start of a constant orvariable representation; so for instance, to portably apply the unaryoperator <literal>&amp;</literal> to the variable <literal>:1</literal>, write <literal>:&amp;1</literal>, and toportably apply it to the expression <literal>'.1~.2'</literal>, write<literal>'&amp;.1~.2'</literal>.)  <abbrev>CLC-INTERCAL</abbrev>, and versions of <abbrev>C-INTERCAL</abbrev> from 0.26 onwards,allow the `prefix' position of a unary operator, which is just beforewhatever it applies to (as in <literal>&amp;:1</literal>).  This leads to ambiguities asto whether an operator is prefix or infix.  The portable solution is, ofcourse, to use only infix operators and fully group everything, but whenwriting for recent versions of <abbrev>C-INTERCAL</abbrev>, it's possible to rely on itsgrouping rule, which is: unary operators are interpreted as infix wherepossible, but at most one infix operator is allowed to apply to eachvariable, constant, or group, and infix operators can't apply toanything else.  So for instance, the <abbrev>C-INTERCAL</abbrev> <literal>'&amp;&amp;&amp;.1~.2'</literal> isequivalent to the portable <literal>'&amp;"&amp;.&amp;1"~.2'</literal> (or the more readableversion of this, <literal>"&amp;'"&amp;.&amp;1"~.2'"</literal>, which is also portable).  Ifthese rules are counter-intuitive to you, remember that this is <acronym>INTERCAL</acronym>we're talking about; note also that this rule is unique to <abbrev>C-INTERCAL</abbrev>, atleast at the time of writing, and in particular <abbrev>CLC-INTERCAL</abbrev> is likely tointerpret this expression differently.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-
-    <sect1 label="6.3" id="Operators">
-      <para>Operators</para>
-      <informalfigure>operator</informalfigure>
-      <para>Operators are used to operate on operands, to produce more complicated
-expressions that actually calculate something rather than just fetch
-information from memory.  There are two types of operators, unary and
-binary operators, which operate on one and two arguments respectively.
-Binary operators are always written between their two operands; to
-portably write a unary operator, it should be in the `infix' position,
-one character after the start of its operand; see  for the full details of how to write unary operators
-portably, and how else you can use them if you aren't aiming for
-portability.  This section only describes <abbrev>INTERCAL-72</abbrev> operators; many
-<acronym>INTERCAL</acronym> extensions add their own operators.</para>
-
-      <sect2 label="6.3.1" id="Mingle">
-        <para>Mingle</para>
-        <informalfigure>mingle</informalfigure>
-        <informalfigure>interleave</informalfigure>
-        <informalfigure>$</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>yes</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para>Mingle, or interleave, is one of the two binary operators in <abbrev>INTERCAL-72</abbrev>.
-However, different <acronym>INTERCAL</acronym> compilers represent it in different ways, so
-it is impossible to write a mingle in a program completely portably,
-because it differs between Princeton and Atari syntax, and worse, the
-sequence of character codes needed to represent it in each syntax has
-varied from compiler to compiler.</para>
-        <para>The original <abbrev>INTERCAL-72</abbrev> compiler (the Princeton compiler) used the
-'change' (cent) character for a mingle, represented as <literal>c</literal>,
-backspace, <literal>/</literal>.  (By the way, this is still the most portable way
-to write a mingle; both <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> accept it, at least if a
-lowercase <literal>c</literal> is used, the Atari compiler accepted it, and its
-documentation claimed that the Princeton compiler also accepted it;
-<abbrev>CLC-INTERCAL</abbrev> also accepts a capital <literal>C</literal> before the backspace and
-<literal>/</literal>, and allows <literal>|</literal> rather than <literal>/</literal>.)  The Atari
-compiler, another <abbrev>INTERCAL-72</abbrev> compiler, used a 'big money' character
-(<literal>$</literal>) as the mingle character; this character is also the only
-one accepted for mingle by the <abbrev>J-INTERCAL</abbrev> compiler.  <abbrev>C-INTERCAL</abbrev> originally
-also used the <literal>$</literal> character for mingle, and this character is the
-one most commonly seen in existing <abbrev>C-INTERCAL</abbrev> programs, and most often
-used when giving examples of <acronym>INTERCAL</acronym> on Usenet, because it exists in
-the ASCII-7 character set, and because it doesn't contain control
-characters.  From version 0.18 of <abbrev>C-INTERCAL</abbrev> onwards, various other units
-of currency (change, quid, and zlotnik if Latin-1 is used as the
-input, and euro if Latin-9 is used as the input) are accepted; from
-version 0.20 onwards, in addition to the Latin-1 characters, all the
-currency symbols in Unicode are accepted if UTF-8 is used as the input
-format.  <abbrev>CLC-INTERCAL</abbrev> has always used the change character (either the
-Latin-1 version or the version that contains a backspace) for mingle.
-In this manual, mingle will be represented as <literal>$</literal>, but it's
-important to bear in mind that this character is not the most portable
-choice.</para>
-        <para>The mingle operator should be applied to two operands or expressions.
-To be portable, the operands must both be onespot expressions, that is
-expressions which have a 16-bit result; <abbrev>C-INTERCAL</abbrev> relaxes this rule
-slightly and only requires that the result be in the onespot range.
-(This is because the data type of a select operator's value is meant to
-be determined at runtime; <abbrev>C-INTERCAL</abbrev> determines all data types at compile
-time, so has to guess a 32-bit result for a select with a 32-bit type as
-its right operand even when the result might actually turn out to be of
-a 16-bit type, and so this behaviour prevents an error when a select
-operation returns a value with a 16-bit data type and is used as an
-argument to amingle.)  The result is a 32-bit value (that is, it is of a
-32-bit data type, even if its value fits into the onespot range), which
-consists of bits alternated from the two arguments; to be precise, its
-most significant bit is the most significant bit of its first argument,
-its second most significant bit is the most significant bit of its
-second argument, its third most significant bit is the second most
-significant bit of its first argument, and so on until its least
-significant bit, which is the least significant bit of its second
-argument.</para>
-        <para>One of the most common uses of interleaving is to create a constant with
-a value greater than 65535; for instance, 65536 is <literal>#256$#0</literal>.  It
-is also commonly used in expressions that need to produce 32-bit
-results; except in some simple cases, this is usually coded by
-calculating separately the odd-numbered and even-numbered bits of the
-result, and mingling them together at the end.  It is also used in
-expressions that need to left-shift values or perform similar
-value-increasing operations, as none of the other operators can easily
-do this; and mingle results are commonly used as the argument to unary
-binary logic operators, because this causes them to behave more like the
-binary logic operators found in some other languages.</para>
-      </sect2>
-
-      <sect2 label="6.3.2" id="Select">
-        <para>Select</para>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>yes</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para>The select operator is one of the two binary operators in <abbrev>INTERCAL-72</abbrev>;
-unlike mingle, every known implementation of <acronym>INTERCAL</acronym> ever has used the
-sqiggle character (<literal>~</literal>) as the representation of the select
-operator, meaning that writing it portably is easy.</para>
-        <para>The select operator takes two arguments, which can be of either
-datatype (that is, 16- or 32-bit).  It returns a value made by
-selecting certain bits of its first operand indicated by the second
-operand, and right-justifying them.  What it does is that it ignores
-all the bits of the first operand where the second operand has a 0 as
-the corresponding bit, that is, deletes them from a copy of the
-operand's value; the bits that are left are squashed together towards
-the least-significant end of the number, and the result is filled with
-0s to make it up to 16 or 32 bits.  (In <abbrev>INTERCAL-72</abbrev> the minimum multiple
-of 16 bits possible that the result fits into is chosen, although if
-:1 has the value 131061 (in hex, 1FFFF) the expression <literal>#21~:1</literal>
-produces a 32-bit result because 17 bits were selected, even though
-many of the leading bits were zeros; in <abbrev>C-INTERCAL</abbrev> the data type of the
-result is the same as of the right operand of the select, so that it
-can be determined at run time, and so using a unary binary logic
-operator on the result of select when the right operand has a 32-bit
-type is nonportable and not recommended.)  As an example,
-<literal>#21~:1</literal> produces 21 as its result if :1 has the value 131061, 10
-as its result if :1 has the value 30 (1E in hex; the least significant
-bit of 21 is removed because it corresponds to a 0 in :1), and 7 as
-its result if :1 has the value 21 (because three bits in 21 are set,
-and those three bits from 21 are therefore selected by 21).</para>
-        <para>Select is used for right-shifts, to select every second bit from a
-number (either to produce what will eventually become an argument to
-mingle, or to interpret the result of a unary binary logic operator, or
-occasionally both), to test if a number is zero or not (by selecting it
-from itself and selecting 1 from the result), in some cases as a limited
-version of bitwise-and (that only works if the right operand is 1 less
-than a power of 2), and for many other purposes.</para>
-      </sect2>
-
-      <sect2 label="6.3.3" id="Unary-Binary-Logic">
-        <para>Unary Binary Logic</para>
-        <informalfigure>unary binary logic</informalfigure>
-        <informalfigure>and</informalfigure>
-        <informalfigure>or</informalfigure>
-        <informalfigure>xor</informalfigure>
-        <informalfigure>exor</informalfigure>
-        <informalfigure>exclusive or</informalfigure>
-        <informalfigure>?</informalfigure>
-        <informalfigure>&amp;</informalfigure>
-        <informalfigure>V</informalfigure>
-        <informalfigure>what</informalfigure>
-        <informalfigure>ampersand</informalfigure>
-        <informalfigure>book</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>yes</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para>There are three unary operators in <abbrev>INTERCAL-72</abbrev>, each of which carries out
-a binary logic operation on adjacent bits of the number. The operators
-are and, or, and exclusive or; and and or are represented by an
-ampersand (<literal>&amp;</literal>) and book (<literal>V</literal>) respectively, and exclusive
-or has the same notational problems as mingle, as it differs between
-Princeton and Atari syntax.  It was represented by a bookworm, written
-<literal>V</literal>, backspace, <literal>-</literal>, in the Princeton <abbrev>INTERCAL-72</abbrev>
-implementation, and this is still the most portable way to write it
-(<abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> accept it).  The Atari implementation of <abbrev>INTERCAL-72</abbrev>
-wrote it with a what (<literal>?</literal>), and this is the representation
-originally used by <abbrev>C-INTERCAL</abbrev> (and still accepted), the only
-representation accepted by <abbrev>J-INTERCAL</abbrev>, the one most commonly used on
-Usenet, and the one used in this manual (although again, it's worth
-pointing out that this isn't portable).  <abbrev>CLC-INTERCAL</abbrev> approximates a
-bookworm with the yen character, which being a currency character is
-one of the possible representations for mingle in <abbrev>C-INTERCAL</abbrev>; <abbrev>C-INTERCAL</abbrev> uses
-the rather confusing method of interpreting a yen character as
-exclusive-or if input in Latin-1 but as mingle if input in UTF-8.
-(This usually does the right thing, because <abbrev>CLC-INTERCAL</abbrev> doesn't support
-UTF-8.)  In the same way, <abbrev>CLC-INTERCAL</abbrev> has a <abbrev>C-INTERCAL</abbrev> compatibility option
-to allow the use of <literal>?</literal> for exclusive-or.</para>
-        <para>The operators take each pair of consecutive bits in their arguments
-(that is, the least significant with the second least significant, the
-second least significant with the third least significant, the third
-least significant with the fourth least significant, and so on, with the
-pair consisting of the most significant and least significant being used
-to calculate the most significant bit of the result), and perform an
-appropriate logic operation on them; and sets a bit of the result if and
-only if both bits in the pair were set, or sets each bit corresponding to
-each pair where either bit was set, and exclusive or sets if and only if
-the bits in the pair had different values (that is, one was set, but not
-both).  So for instance, <literal>#&amp;26</literal> is 16 (26 is 1A in hexadecimal or
-11010 in binary); <literal>#V26</literal> is 31 (11111 in binary), and <literal>#?26</literal>
-is 23 (10111 in binary).</para>
-        <para>The most commonly seen use for these operators is to carry out bitwise
-ands, ors, and exclusive ors between two different 16-bit expressions,
-by mingling them together, applying a unary binary logic operator, and
-selecting every second bit of the result; such code often results due to
-people thinking in terms of some other language when writing <acronym>INTERCAL</acronym>,
-but is still often useful.  (Historically, the first idiom added to the
-optimizer, apart from constant folding, was the mingle/unary/select
-sequence.)  There are more imaginative uses; one impressive example is
-the exclusive or in the test for greater-than from the original <abbrev>INTERCAL-72</abbrev>
-system library:</para>
-        <programlisting>
-DO :5 &lt;- "'?":1~'#65535$#0'"$":2~'#65535$#0'"'
-     ~'#0$#65535'"$"'?":1~'#0$#65535'"$":2~'#0$
-     #65535'"'~'#0$#65535'"
-DO .5 &lt;- '?"'&amp;"':2~:5'~'"'?"'?":5~:5"~"#65535~
-     #65535"'~'#65535$#0'"$#32768'~'#0$#65535'"
-     $"'?":5~:5"~"#65535$#65535"'~'#0$#65535'"'
-     "$"':5~:5'~#1"'~#1"$#2'~#3
-</programlisting>
-        <para>The first statement works out the value of :1 bitwise exclusive or :2;
-the second statement then works out whether the most significant set bit
-in :5 (that is, the most significant bit that differs between :1 and :2)
-corresponds to a set bit in :2 or not.  In case that's a bit too
-confusing to read, here's the corresponding optimizer idiom (in OIL):</para>
-        <programlisting>
-((_1~:2)~((?32(:2~:2))^#2147483648))-&gt;(_1&gt;(:2^_1))
-</programlisting>
-        <para>(Here, the ^ refers to a bitwise exclusive or, an operation found in OIL
-but not in <acronym>INTERCAL</acronym>, which is why the <acronym>INTERCAL</acronym> version is so much longer.)
-The <acronym>INTERCAL</acronym> version also has some extra code to check for equality and
-to produce 1 or 2 as the output rather than 0 or 1.</para>
-      </sect2>
-
-      <sect2 label="6.3.4" id="Array-Subscript">
-        <para>Array Subscript</para>
-        <informalfigure>arrays, subscripting</informalfigure>
-        <informalfigure>subscripts</informalfigure>
-        <informalfigure>SUB</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>yes</bookinfo>
-                <bookinfo>version 0.7+</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>all versions</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para>In order to access the elements of an array, either to read or write
-the array, it is necessary to use the array subscript operator
-<literal>SUB</literal>.  Note that an array element is not a variable, so it is
-not accepted as an acceptable argument to statements like
-<literal>IGNORE</literal>; however, it can be assigned to.</para>
-        <para>The syntax for an array element is the array, followed by the keyword
-<literal>SUB</literal>, followed by an expression for the element number in the
-array.  In the case of a multidimensional array, more than one
-expression is given after the keyword <literal>SUB</literal> to give the location
-of the element in each of the array's dimensions.  The first element
-in an array or array dimension is numbered 1.</para>
-        <para>For instance, this is a legal (but not particularly useful) <acronym>INTERCAL</acronym>
-program with no syntax errors that shows some of the syntaxes possible
-with array subscripting:</para>
-        <programlisting>
-PLEASE ,1 &lt;- #2
-DO .1 &lt;- #2
-DO ,1 SUB .1 &lt;- #1
-DO ,1 SUB #1 &lt;- ,1 SUB #2
-PLEASE ;1 &lt;- #2 BY #2
-DO ;1 SUB #1 #2 &lt;- ,1 SUB ,1 SUB .1
-DO READ OUT ;1SUB#1.1
-DO GIVE UP
-</programlisting>
-        <para>Grouping can get complicated when nested array subscripting is used,
-particularly with multiple subscripts.  It is the programmer's job to
-write an unambiguous statement, and also obey the extra grouping rules
-that apply to array subscripts; see .</para>
-      </sect2>
-    </sect1>
-  </chapter>
-
-  <chapter label="7" id="Statements">
-    <para>Statements</para>
-    <informalfigure>statements</informalfigure>
-    <informalfigure>statements, INTERCAL</informalfigure>
-    <para>There is a wide range of statements available to <acronym>INTERCAL</acronym> programs;
-some identifiably belong to a particular variant or dialect (such as
-Backtracking <acronym>INTERCAL</acronym>), but others can be considered to be part of the
-'core language'.  The statements listed here are those that the <abbrev>C-INTERCAL</abbrev>
-compiler will accept with no compiler switches to turn on particular
-dialect options.  Note that many statements have slightly different
-effects in different implementations of <acronym>INTERCAL</acronym>; known
-incompatibilities are listed here, but it's important to check your
-program on multiple compilers when attempting to write a portable
-program.</para>
-
-    <sect1 label="7.1" id="Syntax-Error">
-      <para>Syntax Error</para>
-      <informalfigure>syntax error</informalfigure>
-      <informalfigure>comment</informalfigure>
-      <informalfigure>COMMENT</informalfigure>
-      <informalfigure>COMMENTS</informalfigure>
-      <informalfigure>COMMENTING</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>version 0.15+</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>One of the more commonly-used commands in <acronym>INTERCAL</acronym> is the syntax error.
-A properly-written syntax error looks nothing like any known <acronym>INTERCAL</acronym>
-command; a syntax error that looks vaguely like a command but isn't
-may confuse <abbrev>C-INTERCAL</abbrev>, and possibly other compilers, into bailing out at
-compile time in some situations (this is known as a `serious syntax
-error'), and so is not portable.  For other syntax errors, though, the
-semantics are easily explained: there is a run-time error whenever the
-syntax error is actually executed, and the line containing the syntax
-error is used as the error message.</para>
-      <para>One purpose of this is to allow your programs to produce their own
-custom errors at run time; however, it's very important to make sure
-that they start and end in the right place, by manipulating where
-statement identifiers appear.  Here's a correct example from the
-system library:</para>
-      <programlisting>
-DOUBLE OR SINGLE PRECISION ARITHMETIC OVERFLOW
-</programlisting>
-      <para>This is a valid <acronym>INTERCAL</acronym> command, that produces an error when run (note
-the <literal>DO</literal> at the start).  An even more common use is to produce an
-initially abstained syntax error by using an appropriate statement
-identifier, for instance</para>
-      <programlisting>
-PLEASE NOTE THAT THIS IS A COMMENT
-</programlisting>
-      <para>This would produce an error if reinstated somehow, but assuming that
-this isn't done, this is a line of code that does nothing, which is
-therefore equivalent to a comment in other programming languages.
-(The initial abstention is achieved with the statement identifier
-<literal>PLEASE NOT</literal>; the extra <literal>E</literal> causes the command to be a
-syntax error, and this particular construction is idiomatic.)</para>
-      <para>Referring to the set of all syntax errors in a program (or the set of
-all commands of any other given type) is achieved with a special
-keyword known as a `gerund'; gerund support for syntax errors is
-resonably recent, and only exists in <abbrev>CLC-INTERCAL</abbrev> (version 1.-94.-3 and
-later, with <literal>COMMENT</literal>, <literal>COMMENTS</literal>, or <literal>COMMENTING</literal>),
-and <abbrev>C-INTERCAL</abbrev> (<literal>COMMENT</literal> in version 0.26 and later, and also
-<literal>COMMENTS</literal> and <literal>COMMENTING</literal> in version 0.27 and later).
-Therefore, it is not portable to refer to the set of all syntax errors
-by gerund; using a line label is a more portable way to refer to an
-individual syntax-error command.</para>
-    </sect1>
-
-    <sect1 label="7.2" id="Calculate">
-      <para>Calculate</para>
-      <informalfigure>CALCULATING</informalfigure>
-      <informalfigure>calculate</informalfigure>
-      <informalfigure>assignment</informalfigure>
-      <informalfigure>arrays, dimensioning</informalfigure>
-      <informalfigure>dimensioning arrays</informalfigure>
-      <informalfigure>variables, assignment</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>At present, the only <acronym>INTERCAL</acronym> command that contains no keywords (apart
-from the statement identifier and possibly <literal>ONCE</literal> or
-<literal>AGAIN</literal>) is what is known as the `calculate' command.  It is used
-to assign values to variables, array elements, and arrays; assigning a
-value to an array changes the number of elements that that array can
-hold, and causes the values of all elements previously in that array
-to be lost.  The syntax of a calculate command is as follows:</para>
-      <programlisting>
-DO .1 &lt;- ':2~:3'~#55
-</programlisting>
-      <para>That is, the command is written as a variable or array element, then
-the <literal>&lt;-</literal> operator (known as an `angle-worm' and pronounced
-`gets'), then an expression to assign to it.  In the special case when
-an array is being dimensioned by assigning a value to it, the
-expression can contain the keyword <literal>BY</literal> to cause the array to
-become multidimensional; so for a 3 by 4 by 5 array, it would be
-possible to write</para>
-      <programlisting>
-DO ,1 &lt;- #3 BY #4 BY #5
-</programlisting>
-      <para>The calculate command always evaluates the expression, even if for
-some reason the assignment can't be done (for instance, if the
-variable being assigned to is read-only); this is important if the
-expression has side-effects (for instance, giving an overflow error).
-If the variable does happen to be read-only, there is not an error;
-the expression being assigned to it is just evaluated, with the
-resulting value being discarded.</para>
-      <para>The gerund to refer to calculations is <literal>CALCULATING</literal>; however, if
-you are planning to use this, note that a bug in older versions of
-<abbrev>C-INTERCAL</abbrev> means that assignments to arrays are not affected by this
-gerund before version 0.27.</para>
-    </sect1>
-
-    <sect1 label="7.3" id="NEXT-FORGET-and-RESUME">
-      <para>NEXT, FORGET and RESUME</para>
-      <informalfigure>NEXT</informalfigure>
-      <informalfigure>FORGET</informalfigure>
-      <informalfigure>RESUME</informalfigure>
-      <informalfigure>NEXTING</informalfigure>
-      <informalfigure>FORGETTING</informalfigure>
-      <informalfigure>RESUMING</informalfigure>
-      <informalfigure>NEXT stack</informalfigure>
-      <informalfigure>flow control, INTERCAL-72</informalfigure>
-      <informalfigure>stack, NEXT</informalfigure>
-      <informalfigure>stack, instruction pointer</informalfigure>
-      <para><inlinemediaobject name="NEXT"></inlinemediaobject>
-<inlinemediaobject name="FORGET"></inlinemediaobject></para>
-      <para><inlinemediaobject name="RESUME"></inlinemediaobject></para>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>see text</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The only flow-control commands in <abbrev>INTERCAL-72</abbrev> were <literal>NEXT</literal>,
-<literal>RESUME</literal>, and <literal>FORGET</literal>; together these manipulate a stack of
-locations in the program known as the `NEXT stack'.  Although all
-<acronym>INTERCAL</acronym> compilers have implemented these, from <abbrev>CLC-INTERCAL</abbrev> version 0.05
-onwards <abbrev>CLC-INTERCAL</abbrev> has considered them obsolete, and therefore a special
-command-line switch needs to be used to enable them.  (They are still
-the most portable flow-control commands currently available, though,
-precisely because <abbrev>INTERCAL-72</abbrev> implements nothing else.)  Note that there
-is a strict limit of 80 locations on the NEXT stack, enforced by all
-known <acronym>INTERCAL</acronym> compilers; this helps to enforce good programming style,
-by discouraging NEXT-stack leaks (which are otherwise quite easy to
-write).</para>
-      <para>Here are examples to show the syntax of these three statements:</para>
-      <programlisting>
-DO (1000) NEXT
-DO FORGET '.1~.1'~#1
-DO RESUME .5
-</programlisting>
-      <para>The <literal>NEXT</literal> command takes a line label as its argument (unlike
-most other <acronym>INTERCAL</acronym> commands, it comes after its argument rather than
-before); both <literal>FORGET</literal> and <literal>RESUME</literal> take expressions.
-(<abbrev>C-INTERCAL</abbrev> from version 0.05 onwards also allows an expression in
-<literal>NEXT</literal>, rather than a label, to give a computed <literal>NEXT</literal>, but
-this behaviour was not implemented in other compilers, and is
-deprecated in <abbrev>CLC-INTERCAL</abbrev> along with noncomputed <literal>NEXT</literal>; if computed
-<literal>NEXT</literal> is ever implemented in <abbrev>C-INTERCAL</abbrev>, it will likely likewise be
-deprecated upon introduction).  Running a <literal>NEXT</literal> causes the
-program control to transfer to the command whose line label is
-referenced, and also saves the location in the program immediately
-after the <literal>NEXT</literal> command on the top of the NEXT stack.</para>
-      <para>In order to remove items from the <literal>NEXT</literal> stack, to prevent it
-filling up (which is what happens with a naive attempt to use the
-<literal>NEXT</literal> command as an equivalent to what some other languages call
-GOTO), it is possible to use the <literal>FORGET</literal> or <literal>RESUME</literal>
-commands.  They each remove a number of items from the NEXT stack
-equal to their argument; <literal>RESUME</literal> also transfers control flow to
-the last location removed from the <literal>NEXT</literal> stack this way.  Trying
-to remove no items, or more items than there are in the stack, does
-not cause an error when <literal>FORGET</literal> is used (no items or all the
-items are removed respectively); however, both of these cases are
-errors in a <literal>RESUME</literal> statement.</para>
-      <para>Traditionally, boolean values in <acronym>INTERCAL</acronym> programs have been stored
-using #1 and #2 as the two logic levels.  This is because the easiest
-way to implement an if-like construct in <abbrev>INTERCAL-72</abbrev> is by <literal>NEXTING</literal>,
-then <literal>NEXTING</literal> again, then <literal>RESUMING</literal> either by 1 or 2
-according to an expression, and then if the expression evaluated to 1
-<literal>FORGETTING</literal> the remaining NEXT stack entry.  By the way, the
-previous sentence also explained what the appropriate gerunds are for
-<literal>NEXT</literal>, <literal>RESUME</literal>, and <literal>FORGET</literal>.</para>
-    </sect1>
-
-    <sect1 label="7.4" id="STASH-and-RETRIEVE">
-      <para>STASH and RETRIEVE<inlinemediaobject name="STASH"></inlinemediaobject>
-<inlinemediaobject name="RETRIEVE"></inlinemediaobject></para>
-      <informalfigure>STASH</informalfigure>
-      <informalfigure>RETRIEVE</informalfigure>
-      <informalfigure>STASHING</informalfigure>
-      <informalfigure>RETRIEVING</informalfigure>
-      <informalfigure>stack, variable</informalfigure>
-      <informalfigure>stashes</informalfigure>
-      <informalfigure>variables, stashes</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The NEXT stack is not the only stack available in an <acronym>INTERCAL</acronym> program;
-each variable used in the program also has its own stack, which holds
-values of the same type as the variable.  The <literal>STASH</literal> command
-pushes a variable's value onto that variable's stack; <literal>RETRIEVE</literal>
-can be used in the same way to pop the top element of a variable's
-stack to replace that variable's value.  The syntax is the same as
-most other <acronym>INTERCAL</acronym> commands, with the word <literal>STASH</literal> or
-<literal>RETRIEVE</literal> followed by the variable or variables to stash or
-retrieve:</para>
-      <programlisting>
-DO STASH .1 + ;2
-DO RETRIEVE ,3
-</programlisting>
-      <para>Note that it is possible to stash or retrieve multiple variables at
-once, by listing their names separated by intersections (<literal>+</literal>);
-it's even possible to stash or retrieve a variable twice in the same
-statement.</para>
-      <para>It is not entirely clear how <literal>RETRIEVE</literal> interacts with
-<literal>IGNORE</literal> in historical <abbrev>INTERCAL-72</abbrev> compilers; the three modern
-<acronym>INTERCAL</acronym> compilers all use different rules for the interaction:</para>
-      <informalfigure><literal>IGNORE</literal>/<literal>RETRIEVE</literal> interaction</informalfigure>
-      <informalfigure><literal>RETRIEVE</literal>/<literal>IGNORE</literal> interaction</informalfigure>
-      <listitem mark="bullet">
-        <variablelist><abbrev>C-INTERCAL</abbrev> treats a retrieval just like an assignment.  That is, aread-only variable will not be changed by a retrieval, and will remainread-only, but the side-effect of popping that variable's stash willstill happen.</variablelist>
-        <variablelist><abbrev>J-INTERCAL</abbrev> ignores the read-only status of a variable when retrieving itfrom a stash; the value of the variable changes despite beingread-only.  The variable remains read-only; the <literal>RETRIEVE</literal> simplyallows a change to its value despite the read-only status.</variablelist>
-        <variablelist><abbrev>CLC-INTERCAL</abbrev> is the most complicated; it stores read-only status orotherwise in the stash, along with the variable's value.  This meansthat if a variable was stashed when read-only, retrieving it willretrieve its value and set it to read-only regardless of its previousread-only status; likewise, if a variable was stashed when read-write,retrieving it will retrieve its value and set it to read-write even ifit was previously read-only.</variablelist>
-      
-      </listitem>
-      <para>The appropriate gerunds for <literal>STASH</literal> and <literal>RETRIEVE</literal> are
-<literal>STASHING</literal> and <literal>RETRIEVING</literal> respectively.</para>
-    </sect1>
-
-    <sect1 label="7.5" id="IGNORE-and-REMEMBER">
-      <para>IGNORE and REMEMBER<inlinemediaobject name="IGNORE"></inlinemediaobject>
-<inlinemediaobject name="REMEMBER"></inlinemediaobject></para>
-      <informalfigure>IGNORE</informalfigure>
-      <informalfigure>IGNORING</informalfigure>
-      <informalfigure>REMEMBER</informalfigure>
-      <informalfigure>REMEMBERING</informalfigure>
-      <informalfigure>variables, read-only</informalfigure>
-      <informalfigure>variables, read-write</informalfigure>
-      <informalfigure>read-only variables</informalfigure>
-      <informalfigure>read-write variables</informalfigure>
-      <informalfigure>variables, ignoring</informalfigure>
-      <informalfigure>variables, remembering</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>Variables in <acronym>INTERCAL</acronym> can be either read-write or read-only.  At the
-start of a program, all variables are read-only, but this status can
-be changed dynamically during execution of a program using the
-<literal>IGNORE</literal> and <literal>REMEMBER</literal> statements (whose gerunds are
-<literal>IGNORING</literal> and <literal>REMEMBERING</literal> respectively).  The syntax is
-the same as for <literal>STASH</literal> and <literal>RETRIEVE</literal>: the command's name
-followed by an intersection-separated list of variables.  For
-instance:</para>
-      <programlisting>
-DO IGNORE .4
-DO REMEMBER ,4 + ;5
-</programlisting>
-      <para>Using the <literal>IGNORE</literal> statement sets a variable to be read-only (or
-does nothing if it's read-only already); <literal>REMEMBER</literal> sets it to be
-read-write.  Any attempt to assign to a read-only variable silently
-fails.  One place that this is used is in the system library; instead
-of not assigning to a variable in certain control flow paths, it
-instead sets it to be read-only so that subsequent assignments don't
-change its value (and sets it to be read-write at the end, which
-succeeds even if it was never set read-only in the first place); the
-advantage of this is that it doesn't need to remember what flow path
-it's on except in the variable's ignorance status.</para>
-      <para>The interaction between <literal>IGNORE</literal> and <literal>RETRIEVE</literal> was never
-defined very clearly, and is in fact different in <abbrev>C-INTERCAL</abbrev>, <abbrev>CLC-INTERCAL</abbrev> and
-<abbrev>J-INTERCAL</abbrev>; for more details, see .</para>
-    </sect1>
-
-    <sect1 label="7.6" id="ABSTAIN-and-REINSTATE">
-      <para>ABSTAIN and REINSTATE<inlinemediaobject name="ABSTAIN"></inlinemediaobject>
-<inlinemediaobject name="REINSTATE"></inlinemediaobject></para>
-      <informalfigure>ABSTAIN</informalfigure>
-      <informalfigure>ABSTAINING</informalfigure>
-      <informalfigure>REINSTATE</informalfigure>
-      <informalfigure>REINSTATING</informalfigure>
-      <informalfigure>abstain, during execution</informalfigure>
-      <informalfigure>reinstate, during execution</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The statement identifier of a statement determines whether it's
-in an abstained or reinstated state at the start of a program; these
-states determine whether the statement runs at all when it's
-encountered.  It is, however, possible to change this state
-dynamically during a program's execution, and the statements to do
-this are rather appropriately named <literal>ABSTAIN</literal> and
-<literal>REINSTATE</literal>.  There are two forms of each, one which takes a
-single line label (which must be constant in most compilers, but can
-instead be an expression in recent <abbrev>CLC-INTERCAL</abbrev> versions), and one which
-takes an intersection-delimited list of gerunds.  They look like this:</para>
-      <programlisting>
-DO ABSTAIN FROM ABSTAINING + REINSTATING
-DO ABSTAIN FROM (10)
-DO REINSTATE CALCULATING
-DO REINSTATE (22)
-</programlisting>
-      <para>(This also illustrates the gerunds used for these commands; note that
-<literal>ABSTAINING</literal> from <literal>REINSTATING</literal> is generally a bad idea!)
-The line referenced, or every command represented by any gerund
-referenced, are reinstated or abstained as appropriate (effectively
-changing the DO to DON'T (or PLEASE to PLEASE DON'T, etc&period;), or vice
-versa).  Using these forms of <literal>ABSTAIN</literal> and/or <literal>REINSTATE</literal>
-won't abstain from a command that's already abstained, or reinstate a
-command that's already reinstated.</para>
-      <para>There is a strange set of restrictions on <literal>ABSTAIN</literal> and
-<literal>REINSTATE</literal> that has existed since <abbrev>INTERCAL-72</abbrev>; historically such
-restrictions have not always been implemented, or have not been
-implemented properly.  They together define an unusual interaction of
-<literal>ABSTAIN</literal> and <literal>GIVE UP</literal> (note, for instance, that there
-isn't a gerund for <literal>GIVE UP</literal>).  The wording used in the <abbrev>INTERCAL-72</abbrev>
-manual is:</para>
-      <screen>[...] the statement DO ABSTAIN FROM GIVING UP is not accepted, even
-though DON'T GIVE UP is. [...] DO REINSTATE GIVING UP is invalid, and
-attempting to REINSTATE a GIVE UP statement by line label will have no
-effect.  Note that this insures that DON'T GIVE UP will always be a
-"do-nothing" statement.
-</screen>
-      <para>This restriction was not implemented at all in the only <abbrev>CLC-INTERCAL</abbrev>
-version before 0.02 (i.e&period; version 0.01), or in <abbrev>C-INTERCAL</abbrev> versions
-before 1.26.  The restriction was implemented in <abbrev>C-INTERCAL</abbrev> version 1.26
-and <abbrev>CLC-INTERCAL</abbrev> versions 0.02 and later as &ldquo;<literal>GIVE UP</literal> cannot be
-<literal>REINSTATED</literal> or <literal>ABSTAINED FROM</literal>&rdquo;; however, this is not
-strictly the same as the definition used by <abbrev>INTERCAL-72</abbrev> (<abbrev>C-INTERCAL</abbrev> still uses
-this definition in <abbrev>CLC-INTERCAL</abbrev> compatibility mode).  The <abbrev>J-INTERCAL</abbrev>
-implementation of this restriction is to make <literal>REINSTATING</literal> or
-<literal>ABSTAINING</literal> from a line label that refers to a <literal>GIVE UP</literal>
-statement a compile-time error, but this does not fit the <abbrev>INTERCAL-72</abbrev>
-definition either.  The definition adopted with version 0.27 and
-later of <abbrev>C-INTERCAL</abbrev>, which is hopefully correct, is to allow abstaining
-from a <literal>GIVE UP</literal> statement by line number but to rule out the
-other three cases (reinstating by line number silently fails,
-reinstating or abstaining by gerund is impossible because there is no
-gerund).</para>
-      <para>As well as <abbrev>CLC-INTERCAL</abbrev>'s extension to abstain/reinstate by computed line
-number, there is also (since version 0.25) a <abbrev>C-INTERCAL</abbrev>-specific extension
-to <literal>ABSTAIN</literal>, also known as `computed abstain', but with a
-different syntax and different semantics.  It's written like an
-ordinary <literal>ABSTAIN</literal>, but with an expression between the words
-<literal>ABSTAIN</literal> and <literal>FROM</literal>, for instance:</para>
-      <programlisting>
-DO ABSTAIN #1 FROM (1000)
-DO ABSTAIN .2 FROM WRITING IN
-</programlisting>
-      <para>Unlike non-computed <literal>ABSTAIN</literal>, this form (available from <abbrev>C-INTERCAL</abbrev>
-version 0.25 onwards) allows a command to be abstained from even if
-it's already been abstained from; so if the first example command is
-run and line (1000) is already abstained, it becomes
-`double-abstained'.  The number of times the statement is abstained
-from is equal to the number of times it was already abstained from,
-plus the expression (whereas with non-computed abstain, it ends up
-abstained once if it wasn't abstained at all, and otherwise stays at
-the same abstention status).  Reinstating a statement always
-de-abstains it exactly once; so double-abstaining from a statement,
-for instance, means it needs to be reinstated twice before it will
-actually execute.</para>
-      <para>There are many uses for <literal>ABSTAIN</literal> (both the computed and
-non-computed versions) and <literal>REINSTATE</literal>, especially when
-interacting with <literal>ONCE</literal> and <literal>AGAIN</literal> (see ); the computed version, in particular, is a major part of a
-particular concise way to write conditionals and certain kinds of
-loops.  They also play an important role in multithreaded programs.</para>
-    </sect1>
-
-    <sect1 label="7.7" id="READ-OUT-and-WRITE-IN">
-      <para>READ OUT and WRITE IN<inlinemediaobject name="READ OUT"></inlinemediaobject>
-<inlinemediaobject name="WRITE IN"></inlinemediaobject></para>
-      <informalfigure>READ OUT</informalfigure>
-      <informalfigure>READING OUT</informalfigure>
-      <informalfigure>WRITE IN</informalfigure>
-      <informalfigure>WRITING IN</informalfigure>
-      <informalfigure>I/O</informalfigure>
-      <informalfigure>input</informalfigure>
-      <informalfigure>output</informalfigure>
-      <para>The <literal>READ OUT</literal> and <literal>WRITE IN</literal> commands are the output and
-input commands in <acronym>INTERCAL</acronym>; they allow communication between the
-program and its user.  There was a numeric I/O mechanism implemented
-in <abbrev>INTERCAL-72</abbrev>, and it (or trivial variants) have been likewise
-implemented in all more modern variants.  However, it had some obvious
-deficiences (such as not being able to read its own output) which
-meant that other methods of I/O were implemented in <abbrev>C-INTERCAL</abbrev> and
-<abbrev>CLC-INTERCAL</abbrev>.</para>
-      <para>The syntax of <literal>READ OUT</literal> and <literal>WRITE IN</literal> is the same in all
-cases: the name of the command followed by an intersection-separated
-list of items; the form of each item, the compiler you are using, and
-its command line arguments together determine what sort of I/O is
-used, which can in be different for different elements in the list.</para>
-
-      <sect2 label="7.7.1" id="INTERCAL-72-I-O">
-        <para>INTERCAL-72 I/O</para>
-        <informalfigure>I/O, INTERCAL-72</informalfigure>
-        <informalfigure>input, INTERCAL-72</informalfigure>
-        <informalfigure>output, INTERCAL-72</informalfigure>
-        <informalfigure>INTERCAL-72, I/O</informalfigure>
-        <informalfigure>Roman numerals</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>yes</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>see text</bookinfo>
-                <bookinfo>all versions</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para><abbrev>INTERCAL-72</abbrev> had its own versions of I/O commands; these commands are
-available in all modern <acronym>INTERCAL</acronym> compilers as well (but <abbrev>CLC-INTERCAL</abbrev>
-implements output slightly differently).  To distinguish <abbrev>INTERCAL-72</abbrev> input
-and output from the other more modern types of I/O, the <literal>READ
-OUT</literal> and <literal>WRITE IN</literal> commands must take one of the following
-values: a onespot or twospot variable, a single element of a tail or
-hybrid array, or (in the case of <literal>READ OUT</literal>) a constant, meaning
-that these are some examples of the possible forms:</para>
-        <programlisting>
-READ OUT .1
-READ OUT ;2 SUB .3:4
-READ OUT #3
-WRITE IN :4
-WRITE IN ,5 SUB #6
-</programlisting>
-        <para>The statements do what you would expect; <literal>READ OUT</literal> outputs its
-argument to the user, and <literal>WRITE IN</literal> inputs a number from the
-user and assigns it to the variable or array element referenced.  (If
-the variable, or the array that contains the array element, happens to
-be read-only, the input or output still happens but in the case of
-<literal>WRITE IN</literal> silently skips the assignment, instead throwing away
-the input.)  The formats used for input and output are, however,
-different from each other and from the formats used by most mainstream
-languages.</para>
-        <para>Input is achieved by writing a number in decimal, one digit at a time,
-with each digit written out as a word; so to input the number 12345, a
-user would have to type <literal>ONE TWO THREE FOUR FIVE</literal> as input (if
-they were using English, the most portable choice of language).  In
-<abbrev>INTERCAL-72</abbrev> only English is accepted as a language, but other compilers
-accept other languages in addition.  <abbrev>C-INTERCAL</abbrev> from version
-0.10 onwards accepts English, Sanskrit, Basque, Tagalog, Classical
-Nahuatl, Georgian, and Kwakiutl; also Volap&uuml;k from version 0.11
-onwards, and Latin from version 0.20 onwards.  <abbrev>J-INTERCAL</abbrev> accepts the same
-languages, except with Esperanto instead of Latin; from version 0.05
-of <abbrev>CLC-INTERCAL</abbrev> onwards, the same list of languages as <abbrev>C-INTERCAL</abbrev> is supported
-(apart from Latin, which was added in version 1.-94.-8).</para>
-        <para>The format that output can be read in is a modified form of Roman
-numerals, known as `butchered' Roman numerals.  <abbrev>INTERCAL-72</abbrev>, <abbrev>C-INTERCAL</abbrev> and
-<abbrev>J-INTERCAL</abbrev> do this the same way; <abbrev>CLC-INTERCAL</abbrev> is somewhat different. The
-characters &lsquo;<literal>I</literal>&rsquo;, &lsquo;<literal>V</literal>&rsquo;, &lsquo;<literal>X</literal>&rsquo;, &lsquo;<literal>L</literal>&rsquo;, &lsquo;<literal>C</literal>&rsquo;, &lsquo;<literal>D</literal>&rsquo;,
-and &lsquo;<literal>M</literal>&rsquo; mean 1, 5, 10, 50, 100, 500 and 1000 respectively,
-placing a lower-valued letter after a higher-valued letter adds them,
-and placing a lower-valued letter before a higher-valued letter
-subtracts it from the value; so &lsquo;<literal>XI</literal>&rsquo; is 11 and &lsquo;<literal>IX</literal>&rsquo; is 9,
-for instance.  In <abbrev>INTERCAL-72</abbrev>, <abbrev>C-INTERCAL</abbrev>, and <abbrev>J-INTERCAL</abbrev>, a bar over a numeral
-multiplies its value by 1000, and writing a letter in lowercase
-multiplies its value by 1000000; however, <abbrev>CLC-INTERCAL</abbrev> uses lowercase to
-represent multiplication by 1000 and for multiplication by 1000000
-writes a backslash before the relevant numeral.</para>
-      </sect2>
-
-      <sect2 label="7.7.2" id="C-INTERCAL-I-O">
-        <para>C-INTERCAL I/O</para>
-        <informalfigure>I/O, C-INTERCAL</informalfigure>
-        <informalfigure>input, C-INTERCAL</informalfigure>
-        <informalfigure>output, C-INTERCAL</informalfigure>
-        <informalfigure>C-INTERCAL, I/O</informalfigure>
-        <informalfigure>Turing Tape</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>no</bookinfo>
-                <bookinfo>version 0.07+</bookinfo>
-                <bookinfo>version 0.05+</bookinfo>
-                <bookinfo>no</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para><abbrev>C-INTERCAL</abbrev>'s method of character-based (rather than numeric) input and
-output is known as the Turing Tape method; it is a binary
-(character-set-agnostic) input/output mechanism.  To specify that
-<abbrev>C-INTERCAL</abbrev>-style I/O is being used, an array must be used as the argument
-to <literal>READ OUT</literal> or <literal>WRITE IN</literal>; as the syntax is the same as
-for <abbrev>CLC-INTERCAL</abbrev>'s I/O, command-line arguments and the capabilities of the
-version of the compiler being used serve to distinguish the two
-mechanisms.</para>
-        <para>The character-based input writes as many characters into a tail or
-hybrid array as will fit, one character in each element.  The number
-that's written into the array is not the character code, though, but
-the difference between the character code and the previous character
-code, modulo 256.  (To be precise, the code is the new character minus
-the previous character, or 256 minus (the previous character minus the
-new character) if the previous character had a higher character code;
-the 'previous character' is the previous character from the input, not
-the previous character written into the array.)  End-of-file causes
-256 to be written into the array.  The concept is that of a circular
-tape containing all the characters, where the program measures how
-many spaces it needs to move along the tape to reach the next
-character.  The 'previous character' starts at 0, but is preserved
-throughout the entire program, even from one <literal>WRITE IN</literal> to the
-next.</para>
-        <para>Character-based output uses a similar model, but conceptually the
-output device moves on the inside of the tape, rather than on the
-outside.  Therefore, the character is that is actually output is the
-bit-reversal of the difference between the last character output
-before it was bit-reversed and the number found in the array
-(subtracting in that order, and adding 256 if the result is
-negative).  (Rather than trying to parse the previous sentence, you
-may find it easier to look either at the source code to the compiler
-if you have it (the relevant part is binout in <filename>src/cesspool.c</filename>)
-or at some example <abbrev>C-INTERCAL</abbrev> programs that do text-based I/O.)</para>
-      </sect2>
-
-      <sect2 label="7.7.3" id="CLC-INTERCAL-I-O">
-        <para>CLC-INTERCAL I/O</para>
-        <informalfigure>Baudot</informalfigure>
-        <informalfigure>I/O, Baudot</informalfigure>
-        <informalfigure>I/O, CLC-INTERCAL</informalfigure>
-        <informalfigure>CLC-INTERCAL I/O</informalfigure>
-        <informalfigure>input, CLC-INTERCAL</informalfigure>
-        <informalfigure>output, CLC-INTERCAL</informalfigure>
-        <colspec>
-          <thead cols="4">
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <tbody colwidth="23*"></tbody>
-            <entry>
-              <abstract>
-                <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-                <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-                <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-              
-              </abstract>
-            </entry>
-            <row>
-              <abstract>
-                <bookinfo>no</bookinfo>
-                <bookinfo>version 0.27+</bookinfo>
-                <bookinfo>all versions</bookinfo>
-                <bookinfo>no</bookinfo>
-              
-              </abstract>
-            </row>
-          </thead>
-        </colspec>
-        <para>There are also two <abbrev>CLC-INTERCAL</abbrev>-specific I/O mechanisms.  These are
-Baudot-based text I/O (which is also implemented from <abbrev>C-INTERCAL</abbrev> version
-0.27 onwards), and <abbrev>CLC-INTERCAL</abbrev> generalised binary I/O (not implemented in
-<abbrev>C-INTERCAL</abbrev>).</para>
-        <para>Baudot text-based I/O is specified by using a tail array as an
-argument to <literal>WRITE IN</literal> or <literal>READ OUT</literal>.  (A tail array can
-also be used to specift <abbrev>C-INTERCAL</abbrev>-style Turing Tape I/O.  In order to
-determine which is used: both <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> use their own sort
-of I/O unless a command-line argument instructs them to use the
-other.)  In the case of <literal>WRITE IN</literal>, one line of input is
-requested from the user (<abbrev>C-INTERCAL</abbrev> requires this to be input in Latin-1,
-and will then automatically convert it; <abbrev>CLC-INTERCAL</abbrev> gives the option of
-various character sets for this input as command-line options); the
-final newline is removed from this line, then it is converted to
-extended Baudot and stored in the tail array specified (causing an
-error if the array is too small).  Because Baudot is only a 5-bit
-character set, each element is padded to 16 bits; <abbrev>CLC-INTERCAL</abbrev> pads with
-zeros, <abbrev>C-INTERCAL</abbrev> pads with random bits.  Trying to input at end-of-file
-will act as if the input were a blank line.  <literal>READ OUT</literal> is the
-reverse; it interprets the array as extended Baudot and converts it to
-an appropriate character set (Latin-1 for <abbrev>C-INTERCAL</abbrev>, or whatever was
-specified on the command line for <abbrev>CLC-INTERCAL</abbrev>), which is output to the
-user, followed by a newline.  Note that the Baudot is often longer
-than the corresponding character in other character sets due to the
-need to insert shift codes; for information on the extended Baudot
-character set, .</para>
-        <para>Generalised binary I/O is specified using a hybrid array as an
-argument to <literal>WRITE IN</literal> or <literal>READ OUT</literal>.  Input works by
-reading in a number of bytes equal to the length of the array (without
-trying to interpret them or translating them to a different character
-set), prepending a byte with 172 to the start, padding each byte to 16
-bits with random data, then replacing each pair of consecutive bytes
-(that is, the first and second, the second and third, the third and
-fourth, and so on) with (the first element selected from the second
-element) mingled with (the complement of the first element selected from
-the complement of the second element).  Output is the exact opposite
-of this process.  End-of-file reads a 0, which is padded with 0s
-rather than random data; if a non-end-of-file 0 comes in from the
-data, its padding will contain at least one 1.  Any
-all-bits-0-even-the-padding being read out will be skipped.</para>
-      </sect2>
-    </sect1>
-
-    <sect1 label="7.8" id="GIVE-UP">
-      <para>GIVE UP</para>
-      <informalfigure>GIVE UP</informalfigure>
-      <informalfigure>quitting</informalfigure>
-      <informalfigure>exiting</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>yes</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-              <bookinfo>all versions</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The <literal>GIVE UP</literal> command causes the program to end (or, in a
-multithreaded program, causes the current thread to end).  It is
-written simply as <literal>GIVE UP</literal>.  There is not much else to say about
-it, except to mention that it is the only way to end the program
-without an error unless the last line of the program is <literal>TRY
-AGAIN</literal>, and that it has an unusual interaction with <literal>ABSTAIN</literal>;
-for details of this, see .  (Going past the last command
-in the program is an error.)</para>
-      <para>There is no gerund for <literal>GIVE UP</literal>; in particular, <literal>GIVING UP</literal>
-is a syntax error.</para>
-    </sect1>
-
-    <sect1 label="7.9" id="TRY-AGAIN">
-      <para>TRY AGAIN</para>
-      <informalfigure>TRY AGAIN</informalfigure>
-      <informalfigure>loops, entire program</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>version 0.25+</bookinfo>
-              <bookinfo>no</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The <literal>TRY AGAIN</literal> command is a very simple command with many
-limitations; its effect is to place the entire program in a loop.  If
-it exists, it must be the very last command in the program (it cannot
-even be followed by syntax errors), and it causes execution of the
-program to go back to the first command.  If the <literal>TRY AGAIN</literal>
-command is abstained or for some other reason doesn't execute when
-reached, it exits the program without the error that would usually be
-caused by going past the last line of code.</para>
-      <para>The gerund for <literal>TRY AGAIN</literal> is <literal>TRYING AGAIN</literal>.</para>
-    </sect1>
-
-    <sect1 label="7.10" id="COME-FROM-and-NEXT-FROM">
-      <para>COME FROM and NEXT FROM<inlinemediaobject name="COME FROM"></inlinemediaobject>
-<inlinemediaobject name="NEXT FROM"></inlinemediaobject></para>
-      <informalfigure>COME FROM</informalfigure>
-      <informalfigure>NEXT FROM</informalfigure>
-      <informalfigure>reverse goto</informalfigure>
-      <informalfigure>goto, time-reversed</informalfigure>
-      <informalfigure>time-reversed goto</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>see text</bookinfo>
-              <bookinfo>see text</bookinfo>
-              <bookinfo>see text</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The <literal>COME FROM</literal> statement (incidentally also invented in 1972,
-but not in connection with <acronym>INTERCAL</acronym>) is the main control-flow command
-in <abbrev>CLC-INTERCAL</abbrev> (which deprecates <literal>NEXT</literal>), and one of two main
-control flow structures in other modern <acronym>INTERCAL</acronym> compilers.  It takes
-either a label or an expression as its argument; these forms are
-noncomputed <literal>COME FROM</literal> and computed <literal>COME FROM</literal>.</para>
-      <para>Noncomputed <literal>COME FROM</literal> was implemented in version 0.5 of <abbrev>C-INTERCAL</abbrev>,
-but did not conform to modern-day semantics until version 0.7; it is
-available in every version of <abbrev>CLC-INTERCAL</abbrev> and <abbrev>J-INTERCAL</abbrev>.  Computed
-<literal>COME FROM</literal> support is available in every version of <abbrev>CLC-INTERCAL</abbrev> and
-in <abbrev>C-INTERCAL</abbrev> from version 0.25 onwards, but not in <abbrev>J-INTERCAL</abbrev>; the variant
-<literal>NEXT FROM</literal> of <literal>COME FROM</literal> is available from <abbrev>CLC-INTERCAL</abbrev>
-version 1.-94.-8 and <abbrev>C-INTERCAL</abbrev> version 0.26 (both computed and
-noncomputed).  <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> also have a from-gerund form of
-<literal>COME FROM</literal> and <literal>NEXT FROM</literal>, which was also implemented from
-<abbrev>CLC-INTERCAL</abbrev> version 1.-94.-8 and <abbrev>C-INTERCAL</abbrev> version 0.26.</para>
-      <para>The basic rule of <literal>COME FROM</literal> is that if a <literal>COME FROM</literal>
-statement references another statement, whenever that statement is
-reached, control flow will be transferred to the <literal>COME FROM</literal>
-after that statement finishes executing.  (<literal>NEXT FROM</literal> is
-identical except that in addition to the <literal>COME FROM</literal> behaviour,
-the location immediately after the statement that was nexted from is
-saved on the NEXT stack, in much the same way as if the statement
-being nexted from was iteslf a <literal>NEXT</literal>.)</para>
-      <para>Here are examples of noncomputed, computed, and from-gerund <literal>COME
-FROM</literal>:</para>
-      <programlisting>
-DO COME FROM (10)
-DO COME FROM #2$'.1~#1'
-DO COME FROM COMING FROM
-</programlisting>
-      <para>(The last example is an infinite loop.  If it said <literal>DO NEXT FROM
-NEXTING FROM</literal>, it would not be an infinite loop because the NEXT stack
-would overflow and cause an error.  This also establishes the gerunds
-used for <literal>COME FROM</literal> and <literal>NEXT FROM</literal>.)</para>
-      <para>There are some things to be careful with involving <literal>COME FROM</literal>
-and <literal>NEXT FROM</literal>.  First, if the statement come from or nexted
-from happens to be a <literal>NEXT</literal>, the <literal>NEXT</literal> doesn't count as
-'finishing executing' until the NEXT stack entry created by the
-<literal>NEXT</literal> is <literal>RESUME</literal>d to.  In particular, this means that if
-<literal>FORGET</literal> is used to remove the entry, or a <literal>RESUME</literal> with a
-large argument resumes a lower entry, the <literal>COME FROM</literal> doesn't
-steal execution at all.</para>
-      <para>Second, you may be wondering what happens if two <literal>COME FROM</literal>s or
-<literal>NEXT FROM</literal>s aim at the same line.  In a non-multithreaded
-program (whether a program is multithreaded or not is determined by a
-compiler option for those compilers that support it), this is an
-error; but it is only an error if the statement that they both point
-to finishes running, and both <literal>COME FROM</literal>s or <literal>NEXT FROM</literal>s
-try to execute as a result (they might not if, for instance, one is
-abstained or has a double-oh-seven causing it not to run some of the
-time).  If both <literal>COME FROM</literal>s or <literal>NEXT FROM</literal>s are
-noncomputed, however, a compiler can (but does not have to) give a
-compile time error if two <literal>COME FROM</literal>s or <literal>NEXT FROM</literal>s share
-a label, and so that situation should be avoided in portable code.
-(If it is wanted, one solution that works for <abbrev>C-INTERCAL</abbrev> and <abbrev>CLC-INTERCAL</abbrev> is
-to use computed <literal>COME FROM</literal>s or <literal>NEXT FROM</literal>s with a constant
-expression.)</para>
-    </sect1>
-  </chapter>
-
-  <chapter label="8" id="System-Library">
-    <para>System Library</para>
-    <informalfigure>system libary</informalfigure>
-    <informalfigure>syslib</informalfigure>
-    <colspec>
-      <thead cols="4">
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-            <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>yes</bookinfo>
-            <bookinfo>all versions</bookinfo>
-            <bookinfo>no</bookinfo>
-            <bookinfo>all versions</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para><acronym>INTERCAL</acronym> has a system library, called &lsquo;<literal>syslib</literal>&rsquo;.  It is included
-automatically at the end of your program by the compiler whenever your
-program refers to a line from (1000) to (1999) without defining any
-line in that range in the program.  (Although it is not added
-automatically by the compiler in <abbrev>CLC-INTERCAL</abbrev>, it is trivial to
-concatenate a copy onto the end of the program.)</para>
-    <para>The intention of the system library is to provide a range of useful
-capabilities, like multiplication, that can otherwise be hard to write
-in <acronym>INTERCAL</acronym>.  System library routines are used by <literal>NEXTING</literal> to
-their line number (see ), where they will make changes to
-certain variables depending on certain other variables (depending on
-which routine is called), and <literal>RESUME</literal> back to the original
-program.  As the system library is itself written in <acronym>INTERCAL</acronym>, there
-are some restrictions that need to be obeyed for calls to it to be
-guaranteed to work; none of the variables it uses (<literal>.1</literal> to
-<literal>.6</literal> and <literal>:1</literal> to <literal>:5</literal>) should be read-only or
-overloaded (although the value of any variables that aren't mentioned
-in the routine's description will be preserved by the routine), and
-none of the lines in it should have their abstention status changed by
-lines outside it (this can happen with blatant infractions like
-<literal>DO ABSTAIN FROM (1500)</literal> or more subtle problems like
-gerund-abstention) or have <literal>COME FROM</literal>s or <literal>NEXT FROM</literal>s
-aiming at them.</para>
-    <para>The system library is currently available in all bases from 2 to 7
-(see ), but not every command is available in every
-base, and <abbrev>C-INTERCAL</abbrev> is the only one of the three compilers listed above
-that use the system library to ship with a version in bases other than
-2.  (This table was originally based on the <abbrev>INTERCAL-72</abbrev> manual, but has
-had extra information added for bases other than 2.) Here, &ldquo;overflow
-checked&rdquo; means that #1 is assigned to .4 if there is not an overflow,
-and #2 is assigned to .4 if there is; &ldquo;overflow captured&rdquo; means that
-if there is overflow, the digit that overflowed is stored in the
-variable referenced.  In all cases, division by 0 returns 0.</para>
-    <colspec>
-      <thead cols="3">
-        <tbody colwidth="10*"></tbody>
-        <tbody colwidth="70*"></tbody>
-        <tbody colwidth="15*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo>Line</bookinfo>
-            <bookinfo>Description</bookinfo>
-            <bookinfo>Bases</bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>(1000)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 plus .2, error exit on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1009)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 plus .2, overflow checked</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1010)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 minus .2, no action on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1020)</bookinfo>
-            <bookinfo>
-.1 &lt;- .1 plus #1, no action on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1030)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 times .2, error exit on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1039)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 times .2, overflow checked</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1040)</bookinfo>
-            <bookinfo>
-.3 &lt;- .1 divided by .2</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1050)</bookinfo>
-            <bookinfo>
-.2 &lt;- :1 divided by .1, error exit on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1200)</bookinfo>
-            <bookinfo>
-.2 &lt;- .1 times #2, overflow captured in .3</bookinfo>
-            <bookinfo>4, 6</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1210)</bookinfo>
-            <bookinfo>
-.2 &lt;- .1 divided by #2, one digit after the quartic or sextic point
-stored in .3</bookinfo>
-            <bookinfo>4, 6</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1500)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 plus :2, error exit on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1509)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 plus :2, overflow checked</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1510)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 minus :2, no action on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1520)</bookinfo>
-            <bookinfo>
-:1 &lt;- .1 concatenated with .2</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1530)</bookinfo>
-            <bookinfo>
-:1 &lt;- .1 times .2</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1540)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 times :2, error exit on overflow</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1549)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 times :2, overflow checked</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1550)</bookinfo>
-            <bookinfo>
-:3 &lt;- :1 divided by :2</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1700)</bookinfo>
-            <bookinfo>
-:2 &lt;- :1 times #2, overflow captured in .1</bookinfo>
-            <bookinfo>4, 6</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1710)</bookinfo>
-            <bookinfo>
-:2 &lt;- :1 divided by #2, one digit after the quartic or sextic point
-stored in .1</bookinfo>
-            <bookinfo>4, 6</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1720)</bookinfo>
-            <bookinfo>
-:2 &lt;- :1 times the least significant digit of .1, overflow captured in
-.2</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1900)</bookinfo>
-            <bookinfo>
-.1 &lt;- uniform random number from #0 to #65535</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>(1910)</bookinfo>
-            <bookinfo>
-.2 &lt;- normal random number from #0 to .1, with standard deviation .1
-divided by #12</bookinfo>
-            <bookinfo>2, 3, 4, 5, 6, 7</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-  </chapter>
-
-  <chapter label="" xreflabel="PART III: INTERCAL DIALECTS AND EXTENSIONS">
-    <para>PART III: <acronym>INTERCAL</acronym> DIALECTS AND EXTENSIONS</para>
-  </chapter>
-
-  <chapter label="9" id="TriINTERCAL">
-    <para>TriINTERCAL</para>
-    <informalfigure>TriINTERCAL</informalfigure>
-    <informalfigure>ternary</informalfigure>
-    <informalfigure>whirlpool</informalfigure>
-    <informalfigure>sharkfin</informalfigure>
-    <informalfigure>BUT</informalfigure>
-    <informalfigure>add-without-carry</informalfigure>
-    <informalfigure>subtract-without-borrow</informalfigure>
-    <informalfigure>controlled unary operator</informalfigure>
-    <informalfigure>^</informalfigure>
-    <informalfigure>@</informalfigure>
-    <colspec>
-      <thead cols="4">
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-            <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>no</bookinfo>
-            <bookinfo>version 0.7+</bookinfo>
-            <bookinfo>version 1.-94.-8+</bookinfo>
-            <bookinfo>no</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para>One extension to <acronym>INTERCAL</acronym> that is implemented by both <abbrev>C-INTERCAL</abbrev> and
-<abbrev>CLC-INTERCAL</abbrev> is known as TriINTERCAL, and extends <acronym>INTERCAL</acronym> to bases other
-than binary.  Unlike ordinary <acronym>INTERCAL</acronym> programs, which have the
-extension &lsquo;<literal>.i</literal>&rsquo;, TriINTERCAL programs in bases from 3 to 7 (the
-only allowed bases) have extensions from &lsquo;<literal>.3i</literal>&rsquo; to &lsquo;<literal>.7i</literal>&rsquo;
-respectively.</para>
-    <para>The change of numeric base only affects expressions, and in particular
-the behaviour of operators, and the range of variables.  (The onespot
-and twospot ranges become the highest number of trits or other digits
-in the base required that fit inside the binary ranges, so for
-instance, the maximum value of a onespot variable in ternary is 59048,
-or 3 to the power 10 minus 1.) Interleave/mingle is the simplest to
-explain; it alternates digits just as it alternated bits in binary.
-The other operators all change, as follows:</para>
-    <listitem mark="bullet">
-      <variablelist>Exclusive-or becomes two operators, known either assubtract-without-borrow and add-without-carry due to theirmathematical interpretations, or what and sharkfin after their Atarisyntax representations (<literal>?</literal> and <literal>^</literal>).  (In Princeton syntax,these are the bookworm or yen sign, and a spike (<literal>|</literal>).)  The twooperators do the same thing in binary, but differ in higher bases.(Nevertheless, it is an error to use a sharkfin in binary, because itis a so-called `controlled unary operator', as are the rest of thenew operators defined in this section, which has a lower limit onwhich base it is allowed in.)  Instead of doing the exclusive-oroperation, the bits being combined are either subtracted or added; ifthe result is out of range for the base being used, the base is addedor subtracted from the result until it is in range.  (For thesubtraction, the bit that was less significant is subtracted from thebit that was more significant in any given pair of bits, except forthe subtraction between the most and least significant bits, where themost significant bit is subtracted from the least.)</variablelist>
-      <variablelist>The AND and OR operators are generalised into an entire sequence ofoperators; the number of operators available is the same as the basethat is being used.  In base 3, the third operator is known as BUT; inother bases, there are no commonly accepted names for the extraoperators, so names that reflect the notation are used here.The way to think of it is this: in base 2, an AND gives the result 0if either argument is a 0, and otherwise a 1, and likewise, an ORgives the result 1 if either argument is a 1, and otherwise a 0; theycould be said to favour 0 over 1 and 1 over 0 respectively.  In base3, AND favours 0 over 2 over 1, OR favours 2 over 1 over 0, and BUTfavours 1 over 0 over 2.  (The symbol for BUT is <literal>@</literal> (a`whirlpool', which is another name for the BUT operation) in Atarisyntax, and <literal>?</literal> in Princeton syntax.)  The pattern continues: inbase 4, AND favours 0 over 3 over 2 over 1, BUT favours 1 over 0 over3 over 2, 2BUT (written <literal>2@</literal> or <literal>2?</literal>) favours 2 over 1 over0 over 3, and OR favours 3 over 2 over 1 over 0.  (This can beextended to higher bases following the same pattern, introducingoperators <literal>3@</literal> or <literal>3?</literal>, etc., to favour 3, etc., whenneither AND (which always favours 0) nor OR (which favours the highestdigit in the base) are available.)  All the whirlpool operators arecontrolled unary operators, which are only legal when both the basecontains the favoured digit, and they aren't redundant to AND nor OR.</variablelist>
-      <variablelist>Select has its semantics modified to deal with more than one nonzerodigit in the base.  It starts off by doing an OR (in whatever base isbeing used) between the two numbers being selected; then the bits ofthe result are sorted by the bits of the right-hand argument to theselect, with bits corresponding to 0s in the right-hand argumentending up more significant than bits corresponding to high digits inthe right-hand argument.  In base 2, this has the same effect as atraditional-style select.</variablelist>
-    
-    </listitem>
-    <para>Note that the base doesn't affect anything other than variable ranges
-and expressions; in particular, it doesn't affect the bit-reversal
-used by Turing Tape I/O.  (The tape still has characters written on it
-in binary, even though the program uses a different base.)</para>
-  </chapter>
-
-  <chapter label="10" id="Multithreading-and-Backtracking">
-    <para>Multithreading and Backtracking</para>
-    <informalfigure>multithreading</informalfigure>
-    <informalfigure>threading</informalfigure>
-    <informalfigure>Threaded INTERCAL</informalfigure>
-    <informalfigure>Backtracking INTERCAL</informalfigure>
-    <para>The multithreading and backtracking extensions to <acronym>INTERCAL</acronym> were
-originally invented by Malcom Ryan, who implemented <literal>COME
-FROM</literal>-based multithreading as a modified version of <abbrev>C-INTERCAL</abbrev>, but did
-not implement backtracking, known as Threaded <acronym>INTERCAL</acronym>.  (The same
-functionality is implemented in <abbrev>C-INTERCAL</abbrev> today, but with different code.
-Most likely, this means that the original code was better.)  He also
-invented the original version of Backtracking <acronym>INTERCAL</acronym>, but did not
-implement it; the only known implementation is the <abbrev>C-INTERCAL</abbrev> one.  A
-different version of multithreading, using <literal>WHILE</literal>, was
-implemented as part of <abbrev>CLC-INTERCAL</abbrev> (like all extensions first available
-in <abbrev>CLC-INTERCAL</abbrev>, it is most likely due to Claudio Calvelli) and then added
-to <abbrev>C-INTERCAL</abbrev>, although its implications were not noticed for some time
-afterwards.</para>
-    <para>So nowadays, three freely-mixable threading-like extensions to <acronym>INTERCAL</acronym>
-exist, all of which are implemented in <abbrev>C-INTERCAL</abbrev>.  (A fourth, Quantum
-<acronym>INTERCAL</acronym>, is implemented in <abbrev>CLC-INTERCAL</abbrev> but not <abbrev>C-INTERCAL</abbrev>, and so will not be
-discussed further here.)  If you're wondering about the description of
-backtracking as a threading-like extension, it's implemented with much
-of the same code as multithreading in <abbrev>C-INTERCAL</abbrev>, because the <acronym>INTERCAL</acronym>
-version can be seen as roughly equivalent to multithreading where the
-threads run one after another rather than simultaneously.  (This
-conceptualisation is probably more confusing than useful, though, and
-is also not strictly correct.  The same could probably be said about
-<acronym>INTERCAL</acronym> as a whole, for that matter.)</para>
-
-    <sect1 label="10.1" id="Multithreading-using-COME-FROM">
-      <para>Multithreading using COME FROM</para>
-      <informalfigure><literal>COME FROM</literal>, multithreading</informalfigure>
-      <informalfigure><literal>NEXT FROM</literal>, multithreading</informalfigure>
-      <informalfigure>multithreading, separate threads</informalfigure>
-      <informalfigure>threading, separate</informalfigure>
-      <informalfigure>threading, unwoven</informalfigure>
-      <informalfigure>separate threads</informalfigure>
-      <informalfigure>unwoven threads</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>version 0.25+</bookinfo>
-              <bookinfo>version 0.05+</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The original multithreading implementation worked by giving a new
-meaning to what was previously an error condition.  If in a
-multithreaded program (a program is marked as multithreaded using
-options to a compiler) two or more <literal>COME FROM</literal>s or <literal>NEXT
-FROM</literal>s (or a mixture of the two) attempt to steal control
-simultaneously, the original thread splits into multiple threads, one
-for each of the commands trying to take control, and a different
-command gains control of the program in each case.</para>
-      <para>From then on, all the threads run simultaneously.  The only thing
-shared between threads (apart from the environment in which they run)
-is the abstained/reinstated status of each command; everything else is
-separate.  This means, for instance, that it's possible to change the
-value of a variable in one thread, and it will not affect the
-corresponding variable in other threads created this way.  Likewise,
-there is a separate NEXT stack in each thread; if both a <literal>COME
-FROM</literal> and a <literal>NEXT FROM</literal> aim at the same line, for instance, the
-<literal>NEXT FROM</literal> thread will end up with a NEXT stack entry that isn't
-in the <literal>COME FROM</literal> thread, created by the <literal>NEXT FROM</literal>
-itself.  This is known as unwoven thread creation; none of the threads
-created this way are `woven' with any of the other threads created
-this way.  (Whether threads are woven depends on how they were
-created.)  If the thread being split was itself woven with other
-threads, exactly one of the resulting threads after the split is woven
-with the threads that the original thread was woven to, but the rest
-will not be woven to anything.  (If that seems a somewhat unusual
-rule: well, this is <acronym>INTERCAL</acronym>.)</para>
-      <para>In <abbrev>C-INTERCAL</abbrev>, there are other guarantees that can be made about unwoven
-threads (that is, threads not woven to any other thread).  In
-particular, they can all be guaranteed to run at approximately the
-same speed; to be more precise, the number of commands that have been
-given the chance to execute in any given thread will not differ by
-more than 2 from the number of commands that have been given the
-chance to execute in any other thread that was created at the same
-time.  (However, <literal>COME FROM</literal>s and <literal>NEXT FROM</literal>s can make this
-relationship less precise; it is unspecified (in the technical sense
-that means the compiler can choose any option it likes and change its
-mind on a whim without telling anyone) whether a <literal>COME FROM</literal> or
-<literal>NEXT FROM</literal> aiming at the current command counts towards the
-command total or not, thus causing the relationship to become weaker
-the more of them have the chance to execute.  In versions of <abbrev>C-INTERCAL</abbrev>
-from 0.27 onwards, there is a third guarantee; that if a <literal>COME
-FROM</literal> comes from itself, it will actually give other threads at least
-some chance to run, at some speed, by counting itself as a command
-every now and then; previously this requirement didn't exist, meaning
-that a <literal>COME FROM</literal> could block all threads if it aimed for itself
-due to the speed restrictions and the fact that <literal>COME FROM</literal>s need
-not count towards the total command count.)  Also, all commands,
-including any <literal>ONCE</literal> or <literal>AGAIN</literal> attached to the command, are
-atomic; this means that it's impossible for another thread to conflict
-with what the command is doing.  (In a departure from the usual
-<acronym>INTERCAL</acronym> status quo, these guarantees are somewhat <emphasis>better</emphasis> than
-in most other languages that implement threading, amusingly continuing
-to leave <acronym>INTERCAL</acronym> with the status of being unlike any other mainstream
-language.)</para>
-      <para>The only way to communicate between unwoven threads is by changing the
-abstention status of commands; this always affects all threads in the
-program, whether woven or not.  (The combination of <literal>ABSTAIN</literal> and
-<literal>ONCE</literal> is one way to communicate atomically, due to the atomic
-nature of <literal>ONCE</literal>.)</para>
-      <para>If there are at least two threads, the <literal>GIVE UP</literal> command ends the
-current thread, rather than the current program.</para>
-    </sect1>
-
-    <sect1 label="10.2" id="Multithreading-using-WHILE">
-      <para>Multithreading using WHILE</para>
-      <informalfigure>WHILE</informalfigure>
-      <para><inlinemediaobject name="WHILE"></inlinemediaobject></para>
-      <informalfigure>multithreading, connected threads</informalfigure>
-      <informalfigure>threading, connected</informalfigure>
-      <informalfigure>threading, woven</informalfigure>
-      <informalfigure>connected threads</informalfigure>
-      <informalfigure>woven threads</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>version 0.27+</bookinfo>
-              <bookinfo>version 0.05+</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>The <literal>WHILE</literal> command (which is not strictly speaking a command,
-but more a sort of metacommand that joins commands) is a second method
-of achieving multithreading.  (In <abbrev>CLC-INTERCAL</abbrev>, there are at least two
-other meanings for <literal>WHILE</literal>, but only the one implemented in
-<abbrev>C-INTERCAL</abbrev> is discussed here.)  The syntax is somewhat unusual, and
-consists of two commands separated by the <literal>WHILE</literal> keyword, but
-sharing the statement identifier, execution chance, and any
-<literal>ONCE</literal>/<literal>AGAIN</literal> keyword that may be present.  For instance:</para>
-      <programlisting>
-(1) DO COME FROM ".2~.2"~#1 WHILE :1 &lt;-
-      "'?.1$.2'~'"':1/.1$.2'~#0"$#65535'"$
-      "'"'&amp;.1$.2'~'#0$#65535'"$#0'~#32767$#1"
-</programlisting>
-      <para>(OK, maybe that's an unnecessarily complicated example, and maybe it
-shouldn't have included the <literal>/</literal> operator which is part of another
-<acronym>INTERCAL</acronym> extension (see ).  Still, I thought
-that maybe you'd want to see how addition can be implemented in <acronym>INTERCAL</acronym>.)</para>
-      <para>A <literal>WHILE</literal> command starts two threads (the original thread that
-ran that command and a new one), one of which runs the command to the
-left of the <literal>WHILE</literal> and one of which runs the command to the
-right.  Any line number applies to the left-hand command, not the
-WHILE as a whole, which is a metalanguage construct.  <literal>NEXTING
-FROM</literal>, <literal>ABSTAINING FROM</literal> or similar behaviour with respect to the
-<literal>WHILE</literal> itself is impossible, although it's certainly possible to
-abstain from either of its operands (and abstaining from the left
-operand has much the same effect as abstaining from the <literal>WHILE</literal>
-itself; the right-hand thread deliberately takes a bit of time to get
-started just so that this behaviour happens).  The right-command
-thread starts just before the left command is run (so <literal>NEXTING</literal>,
-etc&period;, directly to the left command will not start that loop in the
-first place); if that command finishes (which may be almost
-immediately for something like a calculate command, or take a long
-time for something like <literal>NEXT</literal>), that thread loops and reruns
-that command as long as the left command has not finished;
-<literal>COMING FROM</literal> that command, or a <literal>NEXT</literal>/<literal>NEXT FROM</literal>
-from/aiming at that command, doesn't count as finishing that command
-until it is <literal>RESUME</literal>d back to (if possible; if it's come from,
-that command can never end and the right-hand loop will continue
-forever, or until it <literal>GIVE</literal>s <literal>UP</literal> or the loop ends due to
-the command ending later in another thread).  A <literal>WHILE</literal> command
-itself exists across all threads of a multithreaded program in a way;
-for each left-hand command that ends (in any thread), the next time a
-right-hand command ends it will cause the thread it's looping in to
-end, regardless of whether that thread corresponds to the thread in
-which the left-hand command ended.  (As well as a right-hand command
-ending, there's also the possibility that it never got started; there
-is a delay before the right-hand command runs during which a left-hand
-command ending can prevent the right-hand thread starting in the first
-place; this counts as the same sort of event as terminating a
-right-hand loop, and can substitute for it anywhere a right-hand
-command ending is mentioned.)  There is one exception, in that if two
-or more left-hand commands end in a space of time in which no
-right-hand commands for that <literal>WHILE</literal> ends, they together only
-cause one right-hand command to end.  (What, did you expect the
-logical and orthogonal behaviour?)</para>
-      <para>The two threads produced by a <literal>WHILE</literal> (the original thread and a
-new copy of it) have more in common than ordinary <acronym>INTERCAL</acronym> threads
-created by <literal>COME FROM</literal>; ordinary threads share only
-<literal>ABSTAIN</literal>/<literal>REINSTATE</literal> information, whereas the
-<literal>WHILE</literal>-produced threads count as `woven' threads which also
-share variables and stashes.  (They still have separate instruction
-pointers, separate instruction pointer stacks, such as the NEXT stack,
-and separate choicepoint lists.  Overloading information is shared,
-though.  Being woven is a relationship between two or more threads,
-rather than an attribute of a thread, although a thread can be
-referred to as being unwoven if it is not woven to any other thread.</para>
-      <para>Ordinary multithreading cannot create woven threads. When threads are
-created by multiple <literal>COME FROM</literal>s from an original thread, which
-was woven with at least one other thread, one of the resulting threads
-counts as the `original' thread and remains woven; the rest are `new'
-threads which initially start out with the same data as the original,
-but are not woven with anything.  Backtracking in a thread
-(see ) causes it to unweave with any threads it may be
-woven with at the time (so the data in the thread that backtracks is
-set back to the data it, and the threads it was woven with at the
-time, had at the time of the <literal>MAYBE</literal>, but the other threads
-continue with the same data as before).  The only way to cause three
-or more threads to become woven is with a new <literal>WHILE</literal> inside one
-of the threads that is already woven, which causes all the new threads
-to be woven together (the weaving relationship is transitive).</para>
-    </sect1>
-
-    <sect1 label="10.3" id="Backtracking">
-      <para>Backtracking</para>
-      <informalfigure>backtracking</informalfigure>
-      <informalfigure>choicepoints</informalfigure>
-      <informalfigure>dormant thread</informalfigure>
-      <informalfigure>threading, in series</informalfigure>
-      <informalfigure>threading, dormant</informalfigure>
-      <colspec>
-        <thead cols="4">
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <tbody colwidth="23*"></tbody>
-          <entry>
-            <abstract>
-              <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-              <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-              <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-            
-            </abstract>
-          </entry>
-          <row>
-            <abstract>
-              <bookinfo>no</bookinfo>
-              <bookinfo>version 0.25+</bookinfo>
-              <bookinfo>no</bookinfo>
-              <bookinfo>no</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>A somewhat unusual threading construct that's available is
-backtracking.  In case you haven't come across it before (the concept
-exists in other languages but is implemented differently and usually
-in a less general way), the basic idea is that instead of executing or
-not executing a command, you can <literal>MAYBE</literal> execute a command.  This
-causes the command to be executed, but also creates a dormant thread
-in which the command wasn't executed; at any time later, the program
-can either decide that it liked the consequences of the command and
-<literal>GO AHEAD</literal> and get rid of the dormant thread, or decide that it
-didn't like the consquences of the command and <literal>GO BACK</literal> to the
-dormant thread, discarding the current one.  The dormant thread is
-more commonly called a `choicepoint', that is, a point at which a
-choice was made but a different choice can still be made, and is
-generally not thought of as a thread at all by most programmers.  (In
-case you're wondering: dormant threads are always unwoven.)</para>
-      <para><inlinemediaobject name="MAYBE"></inlinemediaobject></para>
-      <informalfigure>MAYBE</informalfigure>
-      <informalfigure>choicepoints, creating</informalfigure>
-      <para>To create a choicepoint, the statement identifier <literal>MAYBE</literal> is
-used, rather than the more usual <literal>DO</literal> or <literal>PLEASE</literal>.
-(Combination statement identifiers are still allowed, but must be in
-the order <literal>MAYBE DO PLEASE NOT</literal> with optionally some parts
-omitted, or different versions of <literal>NOT</literal> used, or both.) Here's an
-example:</para>
-      <programlisting>
-MAYBE DON'T GIVE UP
-</programlisting>
-      <para>When a command whose statement identifer contains <literal>MAYBE</literal> is
-reached, it is executed or not executed as normal, but in addition a
-choicepoint is created containing the program as it is at that time.
-Only <literal>ABSTAIN</literal> and <literal>REINSTATE</literal>, which always affect all
-threads in a program (even choicepoints), can alter the values stored
-in the choicepoint; so in this way, a choicepoint is also somewhat
-similar to the concept of a continuation in other languages.  The
-choicepoint is placed on a choicepoint stack, which is maintained
-separately for each thread in much the same way that stashes and the
-<literal>NEXT</literal> stack are.</para>
-      <para><inlinemediaobject name="GO BACK"></inlinemediaobject></para>
-      <informalfigure>GO BACK</informalfigure>
-      <informalfigure>choicepoints, activating</informalfigure>
-      <para>The choicepoint does not actually do anything immediately, but if the
-program doesn't like the look of where it's ended up, or it decides to
-change its mind, or just wants to try all the possibilities, it can
-call the <literal>GO BACK</literal> command (which has no arguments, and is just
-the statement identifier, optional execution chance, <literal>GO BACK</literal>,
-and optional <literal>ONCE</literal> or <literal>AGAIN</literal>).  This causes the current
-thread to unweave from all other threads and then replace itself with
-the thread created by the choicepoint on top of the choicepoint stack.
-The difference is that this time, the abstention or reinstatement
-status of the command that was modified with <literal>MAYBE</literal> is
-temporarily reversed for determining whether it runs or not (this
-reversal only lasts immediately after the <literal>GO BACK</literal>, and does not
-affect uses of the command in other threads or later in the same
-thread), so unless it has been <literal>ABSTAIN</literal>ed or <literal>REINSTATE</literal>d
-in the meantime it will run if and only if it wasn't run the first
-time.  The choicepoint stack's top entry is replaced by a `stale'
-choicepoint that definitely isn't a thread; attempting to <literal>GO
-BACK</literal> to a stale choicepoint instead causes the stale choicepoint to
-be deleted and the program to continue executing.  (This is what gives
-<acronym>INTERCAL</acronym>'s backtracking greater flexibility in some ways than some
-other languages; to get backtracking without the stale choicepoints
-having an effect, simply run <literal>COME FROM</literal> the <literal>GO BACK</literal> as
-the previous statement.)</para>
-      <para>Note that, though, when a thread splits into separate threads (whether
-woven or unwoven), the choicepoint stack doesn't split completely, but
-remains joined at the old top of stack.  The two choicepoint stacks
-can add and remove items independently, but an attempt to <literal>GO
-BACK</literal> to before the current thread split off from any other threads
-that are still running instead causes the current thread to end,
-although it will <literal>GO BACK</literal> as normal if all other threads that
-split off from it or that it split off from since the top choicepoint
-of the stack was created have ended since.  This means that it's
-possible to backtrack past a thread splitting and get the effect of
-the thread unsplitting, as long as both resulting threads backtrack;
-this is another way in which <acronym>INTERCAL</acronym>'s backtracking is more flexible
-than that of some other languages.</para>
-      <para><inlinemediaobject name="GO AHEAD"></inlinemediaobject></para>
-      <informalfigure>GO AHEAD</informalfigure>
-      <informalfigure>choicepoints, discarding</informalfigure>
-      <para>If, on the other hand, a program decides that it likes where it is and
-doesn't need to <literal>GO BACK</literal>, or it wants to <literal>GO BACK</literal> to a
-choicepoint lower down the stack while skipping some of the ones
-nearer the top of the stack, it can run the <literal>GO AHEAD</literal> command,
-which removes the top choicepoint on the stack, whether it's a genuine
-choicepoint or just a stale one.</para>
-      <para>Both <literal>GO AHEAD</literal> and <literal>GO BACK</literal> cause errors if an attempt is
-made to use them when the choicepoint stack is empty.</para>
-    </sect1>
-  </chapter>
-
-  <chapter label="11" id="Operand-Overloading">
-    <para>Operand Overloading</para>
-    <informalfigure>operand overloading</informalfigure>
-    <informalfigure>/</informalfigure>
-    <informalfigure>slat</informalfigure>
-    <informalfigure>reverse assignment</informalfigure>
-    <colspec>
-      <thead cols="4">
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-            <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>no</bookinfo>
-            <bookinfo>version 0.26+</bookinfo>
-            <bookinfo>version 0.05+</bookinfo>
-            <bookinfo>no</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para>(Operand overloading in <abbrev>C-INTERCAL</abbrev> is nowhere near as advanced as it is in
-<abbrev>CLC-INTERCAL</abbrev>.  This chapter only explains the partial implementation used
-by <abbrev>C-INTERCAL</abbrev>; for a full implementation, see <abbrev>CLC-INTERCAL</abbrev> and its
-documentation.)</para>
-    <para>Operand overloading is a method of using a onespot or twospot variable
-as a substitute for an expression.  When a variable is overloaded to
-an expression (which could be another variable, or something more
-complex), any uses of that variable cause the expression to be
-substituted instead.</para>
-    <para>At the beginning of the program, all variables stand for themselves;
-so <literal>.1</literal> really does mean <literal>.1</literal>, for instance.  The meaning of
-a variable can be overloaded using the slat operator (<literal>/</literal>), which
-is the same in both Princeton and Atari syntax: it is a binary
-operator whose left argument must be a onespot or variable and whose
-right argument can be any expression.  The slat operator returns the
-true value of its left argument, but as a side effect, changes the
-meaning of its left argument to be its right argument.  Here is an
-example:</para>
-    <programlisting>
-DO .1 &lt;- .2/'.3~.4'
-</programlisting>
-    <para>The example causes <literal>.2</literal>'s true value to be assigned to <literal>.1</literal>
-(unless of course <literal>.1</literal> is read-only), but also causes <literal>.2</literal>
-from then on to actually mean <literal>'.3~.4'</literal>, except when it's the
-left operand of a slat operator.  So for instance, <literal>DO .1 &lt;- .2</literal>
-would actually assign <literal>'.3~.4'</literal> to <literal>.1</literal>.  Somewhat
-confusingly, this also works in the other direction; <literal>DO .2 &lt;-
-.1</literal> would assign <literal>.1</literal> to <literal>'.3~.4'</literal>, which would have the
-effect of changing the values of <literal>.3</literal> and <literal>.4</literal> so that
-<literal>'.3~.4'</literal> had the correct value, or throw an error if it couldn't
-manage this.  (The general rule in this case is that any variable or
-constant in the expression that overloads the variable is at risk of
-being changed; this is known as a `reverse assignment'.  Code like
-<literal>DO .1 &lt;- .1/#1</literal> is entirely capable of changing the value of
-<literal>#1</literal>, although to protect new <acronym>INTERCAL</acronym> users <abbrev>C-INTERCAL</abbrev> will refuse to
-carry out operations that change the value of constants unless a
-command-line switch (see ) is used to give it permission.  In
-<abbrev>C-INTERCAL</abbrev>, changing the value of a constant only changes meshes with that
-value, but in <abbrev>CLC-INTERCAL</abbrev> it can also change non-mesh uses of that
-constant, so doing so is not portable anyway.)</para>
-    <para>When multiple overloading rules are in effect, they are all applied;
-overloading <literal>.1</literal> to <literal>'.2~.3'</literal> and <literal>.2</literal> to
-<literal>'.3$.4'</literal> will cause <literal>.1</literal> to refer to <literal>''.3$.4'~.3'</literal>.
-However, this expansion stops if this would cause a loop; to be
-precise, overloading is not expanded if the expansion is nested within
-the same expansion at a higher level (so <literal>.1/.2</literal> and <literal>.2/.1</literal>
-together cause <literal>.1</literal> to expand to <literal>.2</literal>, which expands to
-<literal>.1</literal>, which cannot expand any further).  In <abbrev>C-INTERCAL</abbrev>, the
-expression on the right hand side of a slat is not evaluated and not
-expanded by operand overloading.</para>
-    <para><literal>STASHING</literal> a variable causes its overloading information to be
-stashed too; <literal>RETRIEVING</literal> it causes its overload rule to also be
-retrieved from the stash (or any overload rule on the variable to be
-removed if there wasn't one when the variable was stashed).</para>
-    <para>Overloading a onespot variable to a twospot variable or vice versa is
-possible, but the results are unlikely to be predictable, especially
-if a onespot variable is used to handle a twospot value.  Possible
-outcomes include truncating the value down to the right bitwidth,
-throwing an error if a value outside the onespot range is used, and
-even temporarily handling the entire twospot value as long as it
-doesn't end up eventually being assigned a value greater than twospot.</para>
-    <para>Note that reverse assignments can cause unpredictable behaviour if an
-attempt is made to reverse-assign the same variable twice in the same
-expression.  In particular, sequences of commands like <literal>DO .1 &lt;-
-.2/'.3$.3' DO .2 &lt;- #6</literal> are liable to succeed assigning garbage to
-<literal>.3</literal> rather than failing as they ought to do, and likewise any
-situation where a variable is reverse-assigned twice in the same
-expression may assign garbage to it.  This behaviour is seen as
-unsatisfactory, though, and plans exist to improve it for future
-versions.</para>
-  </chapter>
-
-  <chapter label="12" id="PIC-INTERCAL">
-    <para>PIC-INTERCAL</para>
-    <informalfigure>PIC-INTERCAL</informalfigure>
-    <informalfigure>embedded systems</informalfigure>
-    <informalfigure>microcontrollers</informalfigure>
-    <colspec>
-      <thead cols="4">
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <tbody colwidth="23*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo><abbrev>INTERCAL-72</abbrev></bookinfo>
-            <bookinfo><abbrev>C-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>CLC-INTERCAL</abbrev></bookinfo>
-            <bookinfo><abbrev>J-INTERCAL</abbrev></bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>no</bookinfo>
-            <bookinfo>version 0.26+</bookinfo>
-            <bookinfo>no</bookinfo>
-            <bookinfo>no</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para>PIC-INTERCAL is a simplified version of <acronym>INTERCAL</acronym> designed especially
-for embedded systems, designed to minimise code and data usage by
-<acronym>INTERCAL</acronym> programs so that they can fit on devices whose memory is
-measured in bytes rather than megabytes.  (It is named after the first
-microcontroller for which code was successfully generated, and which
-influenced the choices of commands, the PIC16F628 manufactured by
-Microchip, and is most likely to be portable to other microcontrollers
-in the same range.)  <abbrev>C-INTERCAL</abbrev> only compilers as far as C code when
-producing PIC-INTERCAL; it is up to the user to find the appropriate
-cross-compiler to translate this C into the relevant dialect of
-machine code.  (Two header files in the distribution,
-<filename>src/pick1.h</filename> and <filename>src/pick2.h</filename>, don't have any affect on
-the compiler but are referenced by the generated code, and the intent
-is for the user to change them to suit the behaviour of the PIC
-compiler used, because these are not as standardised as C compilers
-for everyday systems.)</para>
-    <para>There are several restrictions on PIC-INTERCAL programs:</para>
-    <listitem mark="bullet">
-      <variablelist>It's impossible to store more than one item in the STASH for any givenvariable.</variablelist>
-      <variablelist>Many errors are not checked at runtime; it is the programmer's job toensure that runtime errors are avoided.  (The few errors that aredetected will send the program into an infinite loop, as there is nosensible way to exit from a PIC program.)</variablelist>
-      <variablelist>Double-oh-sevens are not randomised, but instead depend merely onwhether the probability given is greater than 50% or not.</variablelist>
-      <variablelist>The NEXT stack is limited to 16 entries rather than the usual 80.</variablelist>
-      <variablelist><literal>ABSTAIN</literal> and <literal>REINSTATE</literal> still work, but cannot be computed<literal>ABSTAIN</literal>s, and will not necessarily work when used to affect thesystem library or calls to it.</variablelist>
-      <variablelist><literal>READ OUT</literal> and <literal>WRITE IN</literal> don't work.  (See below for areplacement.)</variablelist>
-      <variablelist><literal>COME FROM</literal> and <literal>NEXT FROM</literal> must aim at a label, not anexpression or gerund.</variablelist>
-      <variablelist>Multithreading and TriINTERCAL cannot be used on PICs.  (Operandoverloading can be used, but only if your PIC cross-compiler supportsfunction pointers; some don't.)</variablelist>
-    
-    </listitem>
-    <para><inlinemediaobject name="PIN"></inlinemediaobject></para>
-    <informalfigure>PIN</informalfigure>
-    <informalfigure>I/O, PIC-INTERCAL</informalfigure>
-    <para>In order to provide I/O capabilities, a new command <literal>PIN</literal> is
-available. It controls up to 16 I/O pins on the PIC or other embedded
-system; an I/O pin is capable of receiving or sending voltages to an
-electrical or electronic circuit.  This explanation assumes that the
-device being controlled is a PIC16F628A, and therefore has its pins in
-two blocks of 8 named &lsquo;<literal>PORTA</literal>&rsquo; and &lsquo;<literal>PORTB</literal>&rsquo;; for other
-microcontrollers, adapting the code in <filename>src/pick1.h</filename> is likely to
-be necessary to tell the compiler how to control the I/O pins, and the
-way in which this done will affect which I/O pins it is that the
-program will end up being able to communicate with.</para>
-    <para>The <literal>PIN</literal> command takes one twospot variable as its argument,
-like this:</para>
-    <programlisting>
-DO PIN :2
-</programlisting>
-    <para>The twospot variable is conceptually divided into 4 blocks of 8 bits.
-The highet two blocks control the directions of the pins in
-<literal>PORTB</literal> (most significant block) and <literal>PORTA</literal> (second most
-significant block); a 1 on any bit means that the corresponding I/O
-pin should be set to send data, and a 0 means that it should be set to
-receive data.  The lower two blocks control the values on the pins
-that are sending (and are ignored for receiving pins); the second
-least significant block controls <literal>PORTB</literal> and the least
-significant block controls <literal>PORTA</literal>, with a 1 causing the program
-to set the output voltage to that of the microcontroller's negative
-voltage supply rail, and a 0 causing the program to set the output
-voltage to that of the microcontroller's positive voltage supply
-rail.  (These voltages may vary on other systems; consult your
-system's datasheet and the changes you made to the header files.)
-After setting the pins, the <literal>PIN</literal> command then reads them as part
-of the same operation, this time setting the values of the lower
-blocks that are receiving, rather than setting the pins from the lower
-blocks that are sending.  However, 1 and 0 bits on all bits of the
-twospot variable have the opposite meaning when doing this, so that 1
-means receiving/positive voltage rail and 0 means sending/negative
-voltage rail.  There is no way to input without output, or vice versa,
-but it's trivial to just send the same output again (which has no
-effect, because the voltage on sending pins is maintained at the same
-level until it is changed), or to ignore the input received.</para>
-  </chapter>
-
-  <chapter label="13" id="External-Calls">
-    <para>External Calls</para>
-    <informalfigure>external calls</informalfigure>
-    <informalfigure>other languages</informalfigure>
-    <informalfigure>foreign functions</informalfigure>
-    <informalfigure>calls, external</informalfigure>
-    <para><abbrev>C-INTERCAL</abbrev> (from version 0.28 onwards) has a feature allowing <acronym>INTERCAL</acronym> and
-non-<acronym>INTERCAL</acronym> code to be mixed.  This is achieved by causing the
-non-<acronym>INTERCAL</acronym> programs to participate in the <acronym>INTERCAL</acronym> line-numbering
-model.</para>
-    <para>To create a combined program containing <acronym>INTERCAL</acronym> and non-<acronym>INTERCAL</acronym> code,
-use <command>ick</command> as the compiler as normal, but specify both the
-<acronym>INTERCAL</acronym> and non-<acronym>INTERCAL</acronym> source files on the command line.
-<command>ick</command> will invoke other compilers as necessary, possibly after
-modifying the source files accordingly.  At present, external calls
-are only supported to and from C.</para>
-    <para>In each case, it will be the <acronym>INTERCAL</acronym> program that is invoked first.
-(This means that it is impossible to link together more than one
-<acronym>INTERCAL</acronym> program, but you probably don't want to, because concatenating
-the programs is likely to have a similar effect.)  You can get the
-<acronym>INTERCAL</acronym> program to <literal>NEXT</literal> to the non-<acronym>INTERCAL</acronym> program immediately,
-or the non-<acronym>INTERCAL</acronym> program to <literal>COME FROM</literal> or <literal>NEXT FROM</literal> the
-<acronym>INTERCAL</acronym> program immediately, to obtain the effect of running the
-non-<acronym>INTERCAL</acronym> program first.</para>
-    <para>Note that external calls are incompatible with PIC-INTERCAL and with
-multithreading.</para>
-
-    <sect1 label="13.1" id="External-Calls-to-C">
-      <para>External Calls to C</para>
-      <informalfigure>C</informalfigure>
-      <informalfigure>other languages, C</informalfigure>
-      <informalfigure>external calls, to C</informalfigure>
-      <para>Linking C and <acronym>INTERCAL</acronym> programs is acheived by placing various
-constructs into the C programs that are equivalent to various <acronym>INTERCAL</acronym>
-constructs.  It is possible to simulate a line with a label and a
-dummy command (which serves as a <literal>COME FROM</literal> suckpoint and
-<literal>NEXT</literal> target), <literal>NEXT</literal>, <literal>RESUME</literal>, and <literal>FORGET</literal>,
-and <literal>COME FROM</literal> and <literal>NEXT FROM</literal>.  Onespot and twospot
-variables are accessible from inside the C program, where they can be
-read and written; however, the <acronym>INTERCAL</acronym> program cannot access any
-variables inside the C program that weren't part of the <acronym>INTERCAL</acronym>
-program originally.</para>
-      <para>To prevent various logical impossibilities, there are restrictions on
-where these can be used and what preparation is needed before they are
-used.  Also, the semantics are not always exactly what you might
-expect for technical reasons.</para>
-      <para>It should be observed that the <acronym>INTERCAL</acronym> link intrudes on the user
-namespace.  To prevent possible namespace clashes, no identifiers
-starting with <literal>ick_</literal> or <literal>ICK_</literal> should be used anywhere in
-the linked C program for any reason, except where specified in this
-manual.</para>
-      <term><indexterm><literal>#include &lt;ick_ec.h&gt;</literal>
-          <variablelist>
-            <informalfigure>ick_ec.h</informalfigure>The header file <filename>ick_ec.h</filename> must be included using thepreprocessor in any file which uses any of the <acronym>INTERCAL</acronym> external callfunctions, variables, or macros.  (Note that this file may notnecessarily exist, or exist in the usual place; <command>ick</command> willdeal with making sure the correct header file is included.)</variablelist>
-        </indexterm><indexterm><literal>ICK_EC_FUNC_START</literal><literal>ICK_EC_FUNC_END</literal>
-          <variablelist>
-            <informalfigure>ICK_EC_FUNC_START</informalfigure>
-            <informalfigure>ICK_EC_FUNC_END</informalfigure>Many of the <acronym>INTERCAL</acronym> interface macros (<literal>ick_linelabel</literal>,<literal>ick_comefrom</literal>, and <literal>ick_nextfrom</literal>) make it possible tojump from an <acronym>INTERCAL</acronym> program to a C program.  Because C doesn't allowjumping into the middle of a function, there has to be some way tocreate a block of code which <emphasis>can</emphasis> be jumped into. This is whatthese two macros achieve.This declaration and definition:
-            <programlisting>
-ICK_EC_FUNC_START(identifier)
-{
-  /* code goes here */
-}
-ICK_EC_FUNC_END
-</programlisting>is equivalent to this:
-            <programlisting>
-void identifier(void)
-{
-  /* code goes here */
-}
-</programlisting>except that it is possible to jump from an <acronym>INTERCAL</acronym> program into thedeclared and defined program.  (If you need to write a prototype forthe function early, <literal>void identifier(void);</literal> is perfectlyacceptable, but an early prototype is not required unless you call thefunction from earlier within the C code.)  Of course, you cansubstitute any identifier that's legal as a function name for<literal>identifier</literal> (as long as it doesn't start with <literal>ick_</literal> or<literal>ICK_</literal>).  The resulting function is a function (for instance, youcan take its address or call it in the usual ways); the onlydifferences are that it can be jumped into from <acronym>INTERCAL</acronym> code and thatit is constrained to take no arguments and return no data.  (It canstill access global and <acronym>INTERCAL</acronym> variables.)  If the function is jumpedinto from <acronym>INTERCAL</acronym> code, but then control flow reaches the end of thefunction, a <literal>RESUME #1</literal> is automatically done to give the programsome way to continue.  (There will be the usual error message if the<literal>NEXT</literal> stack happens to be empty at the time.)</variablelist>
-        </indexterm><indexterm><literal>ick_linelabel</literal>
-          <variablelist>
-            <informalfigure>ick_linelabel</informalfigure>
-            <informalfigure>line labels, C</informalfigure>A line label is something that can be <literal>NEXT</literal>ed to and <literal>COMEFROM</literal>.  Unlike an <acronym>INTERCAL</acronym> line label, it does not label a statement,and therefore attempts to <literal>ABSTAIN</literal> or <literal>REINSTATE</literal> it may beerrors, or may be ignored (it's unspecified which, which means thateither may happen for any or no reason, but exactly one will happen inany given case, although the choice might not be consistent).The macro <literal>ick_linelabel(expression);</literal> may appear anywhere acompound statement would normally be able to appear.  (That is, itlooks like a function call being used as a standalone expression, butin fact the places where it can appear are more limited.)  In contrastto ordinary line labels, an expression can be used rather than just aconstant; however, the behaviour is undefined if the expression hasside-effects.  Upon encountering the line label, any <literal>COME FROM</literal>sor <literal>NEXT FROM</literal>s aiming at the line label (including<literal>ick_comefrom</literal>s and <literal>ick_nextfrom</literal>s) will steal control fromthe program; <literal>RESUM</literal>ing after a <literal>NEXT FROM</literal> will work, butsuffers from the same caveats as setjmp/longjmp do (any auto variablesthat change their value between the <literal>NEXT FROM</literal> and <literal>RESUME</literal>will have their value clobbered (i.e. their value is no longerreliable and should not be accessed)).  Note that the <acronym>INTERCAL</acronym>variables are immune to this problem.It is possible to <literal>NEXT</literal> or <literal>ick_donext</literal> to a<literal>ick_linelabel</literal>, which has the same effect as saving the<literal>NEXT</literal> stack, calling the function containing the<literal>ick_linelabel</literal> and then immediately doing a C <literal>goto</literal> to animaginary label preceding it.  Due to this possibility, an<literal>ick_linelabel</literal> is only allowed within a function defined with<literal>ICK_EC_FUNC_START</literal>.</variablelist>
-        </indexterm>
-      </term>
-    </sect1>
-  </chapter>
-
-  <chapter label="14" id="Differences-to-Other-Compilers">
-    <para>Differences to Other Compilers</para>
-    <informalfigure>INTERCAL compilers</informalfigure>
-    <para>The <abbrev>C-INTERCAL</abbrev> compiler exists in a world of several other compilers.</para>
-    <bridgehead renderas="sect2">Differences to the Princeton compiler</bridgehead>
-    <para>The Princeton compiler was the first <acronym>INTERCAL</acronym> compiler available, and
-compiled <abbrev>INTERCAL-72</abbrev>.  Using <command>convickt</command> (see ) to
-translate its programs from the original EBCDIC to Latin-1 or
-Atari-syntax ASCII is required to run them under the <abbrev>C-INTERCAL</abbrev> compiler,
-but apart from that there should be no problems; everything that that
-compiler can do can be reproduced by <abbrev>C-INTERCAL</abbrev>, even including some of
-its bugs.  The only potential problems may be where constructs were
-nonportable or dubious to begin with (such as the
-<literal>IGNORE</literal>/<literal>RETRIEVE</literal> interaction), or where commands intended
-to be syntax errors were used in the program but have a meaning in
-<abbrev>C-INTERCAL</abbrev>.  For extra portability, it's possible to use the <literal>-t</literal>
-compiler option to <command>ick</command> (see ) to tell it to interpret
-the program as <abbrev>INTERCAL-72</abbrev>, but as <abbrev>C-INTERCAL</abbrev>'s dialect of <acronym>INTERCAL</acronym> is
-basically backward-compatible anyway this mostly serves to check newer
-programs for compatibility with older compilers.</para>
-    <bridgehead renderas="sect2">Differences to the Atari compiler</bridgehead>
-    <para>The Atari compiler was another implementation of <abbrev>INTERCAL-72</abbrev>, which was
-basically identical to the Princeton compiler apart from its use of
-ASCII and Atari syntax.  Everything said under the previous section
-applies, except that as it uses the same syntax as <abbrev>C-INTERCAL</abbrev> anyway
-(<abbrev>C-INTERCAL</abbrev>'s syntax was based on the Atari compiler's), there is no need
-to use <command>convickt</command>.</para>
-    <bridgehead renderas="sect2">Differences to <abbrev>J-INTERCAL</abbrev></bridgehead>
-    <para>The <abbrev>J-INTERCAL</abbrev> compiler is an implementation of <acronym>INTERCAL</acronym> written in Java
-that compiles <acronym>INTERCAL</acronym> into Java (and so has a similar relationship
-with Java to that of the <abbrev>C-INTERCAL</abbrev> compiler (which is written in C and
-compiles into C) with C).  <abbrev>J-INTERCAL</abbrev> has much the same feature set as
-older versions of <abbrev>C-INTERCAL</abbrev>, with a few changes (such as the addition of
-Esperanto and error messages coming up in different situations).
-<abbrev>J-INTERCAL</abbrev> programs should run fine on <abbrev>C-INTERCAL</abbrev> without trouble (as it is
-also an Atari syntax compiler), except in nonportable cases such as
-<literal>IGNORE</literal>/<literal>RETRUEVE</literal> interaction.</para>
-    <bridgehead renderas="sect2">Differences to <abbrev>CLC-INTERCAL</abbrev></bridgehead>
-    <para>The <abbrev>CLC-INTERCAL</abbrev> compiler is the most modern <acronym>INTERCAL</acronym> compiler apart from
-<abbrev>C-INTERCAL</abbrev> (both compilers are maintained and updated every now and then
-as of the time of writing, so which is more modern is normally a
-matter of when you happen to check).  Unlike the other three compilers
-mentioned above, it has a quite significant feature set, including
-many features not implemented or only partially implemented in <abbrev>C-INTERCAL</abbrev>,
-and is responsible for the origin of many of the features added in
-more recent versions of <abbrev>C-INTERCAL</abbrev>.  Generally speaking, a <abbrev>CLC-INTERCAL</abbrev>
-program that uses its advanced features is unlikely to run on <abbrev>C-INTERCAL</abbrev>,
-or vice versa, whatever you do (apart from completely rewriting the
-more advanced parts of the program.)</para>
-    <para>However, there are certain steps that can be taken to transfer less
-advanced programs from one compiler to the other.  First, translate
-the program to Latin-1 Princeton syntax (if translating from <abbrev>CLC-INTERCAL</abbrev>
-to <abbrev>C-INTERCAL</abbrev>) or Atari syntax (if translating from <abbrev>C-INTERCAL</abbrev> to <abbrev>CLC-INTERCAL</abbrev>),
-maybe using <command>convickt</command>, if necessary.  (Note that here the
-program is being translated to the syntax that is not default for the
-target compiler.)  Then use command-line arguments to switch the
-compiler into the correct emulation mode for the other compiler;
-<abbrev>C-INTERCAL</abbrev> uses the options <option>-xX</option>, and on <abbrev>CLC-INTERCAL</abbrev> this is done by
-selecting the appropriate preloads, or by changing the program's file
-extension to &lsquo;<literal>.ci</literal>&rsquo;.  In each case other options may be needed to
-turn on various extensions (maybe <option>-m</option> or <option>-v</option> if
-translating to <abbrev>C-INTERCAL</abbrev>, maybe the preload for gerund-based <literal>COME
-FROM</literal> if translating to <abbrev>CLC-INTERCAL</abbrev>), and if translating to <abbrev>CLC-INTERCAL</abbrev> you
-need to append the system library to your program yourself because
-<abbrev>CLC-INTERCAL</abbrev> doesn't load it automatically.</para>
-    <para>In the case of very simple programs, or if you want to spend the
-effort in translating compiler-specific code from one compiler to
-another, you may be able to work without emulation options.  (This is
-a good target to aim for, in any case.)  In such a case, you would do
-nothing other than possibly edit the program to be more portable and a
-possible character set and syntax change using <command>convickt</command>.  If
-you need compiler-specific code, you may be able to detect the
-compiler in the code itself and adapt accordingly; making use of the
-<literal>IGNORE</literal>/<literal>RETRIEVE</literal> interaction is one way to do this, as it
-differs between <abbrev>C-INTERCAL</abbrev>, <abbrev>J-INTERCAL</abbrev>, and <abbrev>CLC-INTERCAL</abbrev>.  The other things to
-watch out for when doing this are that <abbrev>CLC-INTERCAL</abbrev> needs an explicit
-option to enable the use of <literal>NEXT</literal>, that <abbrev>CLC-INTERCAL</abbrev> doesn't load
-the system library iteslf (you need to manually append it to the end
-of the program) and that you probably shouldn't number a line (666)
-unless you know what you're doing, because that line number has a
-special meaning in <abbrev>CLC-INTERCAL</abbrev>.</para>
-  </chapter>
-
-  <chapter label="" xreflabel="PART IV: APPENDICES AND INDICES">
-    <para>PART IV: APPENDICES AND INDICES</para>
-  </chapter>
-
-  <appendix id="Character-Sets">
-    <para>Character Sets</para>
-    <informalfigure>character sets</informalfigure>
-    <informalfigure>Atari, character set</informalfigure>
-    <informalfigure>Baudot</informalfigure>
-    <informalfigure>EBCDIC</informalfigure>
-    <informalfigure>Latin-1</informalfigure>
-    <para>The following table explains the equivalences between the various
-character sets used for <acronym>INTERCAL</acronym>: 7-bit ASCII Atari syntax, 5-bit
-Baudot Princeton syntax, 8-bit EBCDIC Princeton syntax, and 8-bit
-Latin-1 Princeton syntax.  (The Baudot and EBCDIC are the <abbrev>CLC-INTERCAL</abbrev>
-versions, which are used by <acronym>INTERCAL</acronym> compilers but basically nowhere
-else.)  The characters themselves are not shown in the table below,
-because they would have to be shown in some syntax, which would be
-misleading.  (Atari syntax is used throughout this manual; you could
-convert from that, assuming you have an ASCII table handy.)  You can
-also use the <command>convickt</command> command-line tool to translate <acronym>INTERCAL</acronym>
-programs from one format to another (see ).  Note that
-Baudot has more than one 'shift state'; the shift state (1, 2, 3, or
-4) is written before the hexadecimal code for each character, and *
-represents a character available in every shift state.  To change from
-one shift state to another, use character 1f to change from shift
-states 3 or 4 to 1, or from 1 or 2 to 2, and character 1b to change
-from shift states 1 or 2 to 3, or from 3 or 4 to 4.</para>
-    <colspec>
-      <thead cols="4">
-        <tbody colwidth="32*"></tbody>
-        <tbody colwidth="33*"></tbody>
-        <tbody colwidth="33*"></tbody>
-        <tbody colwidth="34*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo>Atari</bookinfo>
-            <bookinfo>Baudot</bookinfo>
-            <bookinfo>EBCDIC</bookinfo>
-            <bookinfo>Latin-1</bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>09</bookinfo>
-            <bookinfo>N/A</bookinfo>
-            <bookinfo>09</bookinfo>
-            <bookinfo>09</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>0a</bookinfo>
-            <bookinfo>* 02</bookinfo>
-            <bookinfo>0a</bookinfo>
-            <bookinfo>0a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>0d</bookinfo>
-            <bookinfo>* 08</bookinfo>
-            <bookinfo>0d</bookinfo>
-            <bookinfo>0d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>20</bookinfo>
-            <bookinfo>* 04</bookinfo>
-            <bookinfo>40</bookinfo>
-            <bookinfo>20</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>21</bookinfo>
-            <bookinfo>3 0d</bookinfo>
-            <bookinfo>4f</bookinfo>
-            <bookinfo>21</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>22</bookinfo>
-            <bookinfo>3 11</bookinfo>
-            <bookinfo>7f</bookinfo>
-            <bookinfo>22</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>23</bookinfo>
-            <bookinfo>4 06</bookinfo>
-            <bookinfo>7b</bookinfo>
-            <bookinfo>23</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>24</bookinfo>
-            <bookinfo>4 01</bookinfo>
-            <bookinfo>4a</bookinfo>
-            <bookinfo>a2</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>25</bookinfo>
-            <bookinfo>4 1c</bookinfo>
-            <bookinfo>6c</bookinfo>
-            <bookinfo>25</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>26</bookinfo>
-            <bookinfo>3 1a</bookinfo>
-            <bookinfo>50</bookinfo>
-            <bookinfo>26</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>27</bookinfo>
-            <bookinfo>3 0b</bookinfo>
-            <bookinfo>7d</bookinfo>
-            <bookinfo>27</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>28</bookinfo>
-            <bookinfo>3 0f</bookinfo>
-            <bookinfo>4d</bookinfo>
-            <bookinfo>28</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>29</bookinfo>
-            <bookinfo>3 12</bookinfo>
-            <bookinfo>5d</bookinfo>
-            <bookinfo>29</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2a</bookinfo>
-            <bookinfo>4 09</bookinfo>
-            <bookinfo>5c</bookinfo>
-            <bookinfo>2a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2b</bookinfo>
-            <bookinfo>4 03</bookinfo>
-            <bookinfo>4e</bookinfo>
-            <bookinfo>2b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2c</bookinfo>
-            <bookinfo>3 0c</bookinfo>
-            <bookinfo>6b</bookinfo>
-            <bookinfo>2c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2d</bookinfo>
-            <bookinfo>3 03</bookinfo>
-            <bookinfo>60</bookinfo>
-            <bookinfo>2d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2e</bookinfo>
-            <bookinfo>3 1c</bookinfo>
-            <bookinfo>4b</bookinfo>
-            <bookinfo>2e</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>2f</bookinfo>
-            <bookinfo>3 1d</bookinfo>
-            <bookinfo>61</bookinfo>
-            <bookinfo>2f</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>30</bookinfo>
-            <bookinfo>3 16</bookinfo>
-            <bookinfo>f0</bookinfo>
-            <bookinfo>30</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>31</bookinfo>
-            <bookinfo>3 17</bookinfo>
-            <bookinfo>f1</bookinfo>
-            <bookinfo>31</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>32</bookinfo>
-            <bookinfo>3 13</bookinfo>
-            <bookinfo>f2</bookinfo>
-            <bookinfo>32</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>33</bookinfo>
-            <bookinfo>3 01</bookinfo>
-            <bookinfo>f3</bookinfo>
-            <bookinfo>33</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>34</bookinfo>
-            <bookinfo>3 0a</bookinfo>
-            <bookinfo>f4</bookinfo>
-            <bookinfo>34</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>35</bookinfo>
-            <bookinfo>3 10</bookinfo>
-            <bookinfo>f5</bookinfo>
-            <bookinfo>35</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>36</bookinfo>
-            <bookinfo>3 15</bookinfo>
-            <bookinfo>f6</bookinfo>
-            <bookinfo>36</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>37</bookinfo>
-            <bookinfo>3 07</bookinfo>
-            <bookinfo>f7</bookinfo>
-            <bookinfo>37</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>38</bookinfo>
-            <bookinfo>3 06</bookinfo>
-            <bookinfo>f8</bookinfo>
-            <bookinfo>38</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>39</bookinfo>
-            <bookinfo>3 18</bookinfo>
-            <bookinfo>f9</bookinfo>
-            <bookinfo>39</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3a</bookinfo>
-            <bookinfo>3 0e</bookinfo>
-            <bookinfo>7a</bookinfo>
-            <bookinfo>3a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3b</bookinfo>
-            <bookinfo>3 1e</bookinfo>
-            <bookinfo>5e</bookinfo>
-            <bookinfo>3b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3c</bookinfo>
-            <bookinfo>4 0f</bookinfo>
-            <bookinfo>4c</bookinfo>
-            <bookinfo>3c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3d</bookinfo>
-            <bookinfo>4 07</bookinfo>
-            <bookinfo>7e</bookinfo>
-            <bookinfo>3d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3e</bookinfo>
-            <bookinfo>4 12</bookinfo>
-            <bookinfo>6e</bookinfo>
-            <bookinfo>3e</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>3f</bookinfo>
-            <bookinfo>4 0c</bookinfo>
-            <bookinfo>65</bookinfo>
-            <bookinfo>a5</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>40</bookinfo>
-            <bookinfo>3 19</bookinfo>
-            <bookinfo>6f</bookinfo>
-            <bookinfo>3f</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>41</bookinfo>
-            <bookinfo>1 03</bookinfo>
-            <bookinfo>c1</bookinfo>
-            <bookinfo>41</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>42</bookinfo>
-            <bookinfo>1 19</bookinfo>
-            <bookinfo>c2</bookinfo>
-            <bookinfo>42</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>43</bookinfo>
-            <bookinfo>1 0e</bookinfo>
-            <bookinfo>c3</bookinfo>
-            <bookinfo>43</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>44</bookinfo>
-            <bookinfo>1 09</bookinfo>
-            <bookinfo>c4</bookinfo>
-            <bookinfo>44</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>45</bookinfo>
-            <bookinfo>1 01</bookinfo>
-            <bookinfo>c5</bookinfo>
-            <bookinfo>45</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>46</bookinfo>
-            <bookinfo>1 0d</bookinfo>
-            <bookinfo>c6</bookinfo>
-            <bookinfo>46</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>47</bookinfo>
-            <bookinfo>1 1a</bookinfo>
-            <bookinfo>c7</bookinfo>
-            <bookinfo>47</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>48</bookinfo>
-            <bookinfo>1 14</bookinfo>
-            <bookinfo>c8</bookinfo>
-            <bookinfo>48</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>49</bookinfo>
-            <bookinfo>1 06</bookinfo>
-            <bookinfo>c9</bookinfo>
-            <bookinfo>49</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4a</bookinfo>
-            <bookinfo>1 0b</bookinfo>
-            <bookinfo>d1</bookinfo>
-            <bookinfo>4a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4b</bookinfo>
-            <bookinfo>1 0f</bookinfo>
-            <bookinfo>d2</bookinfo>
-            <bookinfo>4b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4c</bookinfo>
-            <bookinfo>1 13</bookinfo>
-            <bookinfo>d3</bookinfo>
-            <bookinfo>4c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4d</bookinfo>
-            <bookinfo>1 1c</bookinfo>
-            <bookinfo>d4</bookinfo>
-            <bookinfo>4d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4e</bookinfo>
-            <bookinfo>1 0c</bookinfo>
-            <bookinfo>d5</bookinfo>
-            <bookinfo>4e</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>4f</bookinfo>
-            <bookinfo>1 18</bookinfo>
-            <bookinfo>d6</bookinfo>
-            <bookinfo>4f</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>50</bookinfo>
-            <bookinfo>1 16</bookinfo>
-            <bookinfo>d7</bookinfo>
-            <bookinfo>50</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>51</bookinfo>
-            <bookinfo>1 17</bookinfo>
-            <bookinfo>d8</bookinfo>
-            <bookinfo>51</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>52</bookinfo>
-            <bookinfo>1 0a</bookinfo>
-            <bookinfo>d9</bookinfo>
-            <bookinfo>52</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>53</bookinfo>
-            <bookinfo>1 05</bookinfo>
-            <bookinfo>e2</bookinfo>
-            <bookinfo>53</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>54</bookinfo>
-            <bookinfo>1 10</bookinfo>
-            <bookinfo>e3</bookinfo>
-            <bookinfo>54</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>55</bookinfo>
-            <bookinfo>1 07</bookinfo>
-            <bookinfo>e4</bookinfo>
-            <bookinfo>55</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>56</bookinfo>
-            <bookinfo>1 1e</bookinfo>
-            <bookinfo>e5</bookinfo>
-            <bookinfo>56</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>57</bookinfo>
-            <bookinfo>1 12</bookinfo>
-            <bookinfo>e6</bookinfo>
-            <bookinfo>57</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>58</bookinfo>
-            <bookinfo>1 1d</bookinfo>
-            <bookinfo>e7</bookinfo>
-            <bookinfo>58</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>59</bookinfo>
-            <bookinfo>1 15</bookinfo>
-            <bookinfo>e8</bookinfo>
-            <bookinfo>59</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5a</bookinfo>
-            <bookinfo>1 11</bookinfo>
-            <bookinfo>e9</bookinfo>
-            <bookinfo>5a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5b</bookinfo>
-            <bookinfo>4 10</bookinfo>
-            <bookinfo>9e</bookinfo>
-            <bookinfo>5b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5c</bookinfo>
-            <bookinfo>4 05</bookinfo>
-            <bookinfo>N/A</bookinfo>
-            <bookinfo>5c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5d</bookinfo>
-            <bookinfo>4 13</bookinfo>
-            <bookinfo>5a</bookinfo>
-            <bookinfo>5d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5e</bookinfo>
-            <bookinfo>4 0d</bookinfo>
-            <bookinfo>6a</bookinfo>
-            <bookinfo>7c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>5f</bookinfo>
-            <bookinfo>4 15</bookinfo>
-            <bookinfo>7c</bookinfo>
-            <bookinfo>40</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>60</bookinfo>
-            <bookinfo>N/A</bookinfo>
-            <bookinfo>N/A</bookinfo>
-            <bookinfo>60</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>61</bookinfo>
-            <bookinfo>2 03</bookinfo>
-            <bookinfo>81</bookinfo>
-            <bookinfo>61</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>62</bookinfo>
-            <bookinfo>2 19</bookinfo>
-            <bookinfo>82</bookinfo>
-            <bookinfo>62</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>63</bookinfo>
-            <bookinfo>2 0e</bookinfo>
-            <bookinfo>83</bookinfo>
-            <bookinfo>63</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>64</bookinfo>
-            <bookinfo>2 09</bookinfo>
-            <bookinfo>84</bookinfo>
-            <bookinfo>64</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>65</bookinfo>
-            <bookinfo>2 01</bookinfo>
-            <bookinfo>85</bookinfo>
-            <bookinfo>65</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>66</bookinfo>
-            <bookinfo>2 0d</bookinfo>
-            <bookinfo>86</bookinfo>
-            <bookinfo>66</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>67</bookinfo>
-            <bookinfo>2 1a</bookinfo>
-            <bookinfo>87</bookinfo>
-            <bookinfo>67</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>68</bookinfo>
-            <bookinfo>2 14</bookinfo>
-            <bookinfo>88</bookinfo>
-            <bookinfo>68</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>69</bookinfo>
-            <bookinfo>2 06</bookinfo>
-            <bookinfo>89</bookinfo>
-            <bookinfo>69</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6a</bookinfo>
-            <bookinfo>2 0b</bookinfo>
-            <bookinfo>91</bookinfo>
-            <bookinfo>6a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6b</bookinfo>
-            <bookinfo>2 0f</bookinfo>
-            <bookinfo>92</bookinfo>
-            <bookinfo>6b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6c</bookinfo>
-            <bookinfo>2 13</bookinfo>
-            <bookinfo>93</bookinfo>
-            <bookinfo>6c</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6d</bookinfo>
-            <bookinfo>2 1c</bookinfo>
-            <bookinfo>94</bookinfo>
-            <bookinfo>6d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6e</bookinfo>
-            <bookinfo>2 0c</bookinfo>
-            <bookinfo>95</bookinfo>
-            <bookinfo>6e</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>6f</bookinfo>
-            <bookinfo>2 18</bookinfo>
-            <bookinfo>96</bookinfo>
-            <bookinfo>6f</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>70</bookinfo>
-            <bookinfo>2 16</bookinfo>
-            <bookinfo>97</bookinfo>
-            <bookinfo>70</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>71</bookinfo>
-            <bookinfo>2 17</bookinfo>
-            <bookinfo>98</bookinfo>
-            <bookinfo>71</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>72</bookinfo>
-            <bookinfo>2 0a</bookinfo>
-            <bookinfo>99</bookinfo>
-            <bookinfo>72</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>73</bookinfo>
-            <bookinfo>2 05</bookinfo>
-            <bookinfo>a2</bookinfo>
-            <bookinfo>73</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>74</bookinfo>
-            <bookinfo>2 10</bookinfo>
-            <bookinfo>a3</bookinfo>
-            <bookinfo>74</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>75</bookinfo>
-            <bookinfo>2 07</bookinfo>
-            <bookinfo>a4</bookinfo>
-            <bookinfo>75</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>76</bookinfo>
-            <bookinfo>2 1e</bookinfo>
-            <bookinfo>a5</bookinfo>
-            <bookinfo>76</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>77</bookinfo>
-            <bookinfo>2 12</bookinfo>
-            <bookinfo>a6</bookinfo>
-            <bookinfo>77</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>78</bookinfo>
-            <bookinfo>2 1d</bookinfo>
-            <bookinfo>a7</bookinfo>
-            <bookinfo>78</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>79</bookinfo>
-            <bookinfo>2 15</bookinfo>
-            <bookinfo>a8</bookinfo>
-            <bookinfo>79</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>7a</bookinfo>
-            <bookinfo>2 11</bookinfo>
-            <bookinfo>a9</bookinfo>
-            <bookinfo>7a</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>7b</bookinfo>
-            <bookinfo>4 0a</bookinfo>
-            <bookinfo>9c</bookinfo>
-            <bookinfo>7b</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>7c</bookinfo>
-            <bookinfo>4 1e</bookinfo>
-            <bookinfo>fe</bookinfo>
-            <bookinfo>N/A</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>7d</bookinfo>
-            <bookinfo>4 11</bookinfo>
-            <bookinfo>dc</bookinfo>
-            <bookinfo>7d</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>7e</bookinfo>
-            <bookinfo>4 0b</bookinfo>
-            <bookinfo>a1</bookinfo>
-            <bookinfo>7e</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-  </appendix>
-
-  <appendix id="convickt">
-    <para>convickt</para>
-    <informalfigure>convickt</informalfigure>
-    <informalfigure>character sets, converting</informalfigure>
-    <informalfigure>converting between character sets</informalfigure>
-    <para>A variety of character sets have historically been used to represent
-<acronym>INTERCAL</acronym> programs.  Atari syntax was designed specifically for use with
-ASCII-7, and all Atari-syntax-based <acronym>INTERCAL</acronym> compilers accept that
-character set as possible input.  (<abbrev>C-INTERCAL</abbrev> also accepts Latin-1 and
-UTF-8.)  However, the story is more complicated with Princeton syntax;
-the original Princeton compiler was designed to work with EBCDIC, but
-because modern computers are often not designed to work with this
-character set other character sets are often used to represent it,
-particularly Latin-1.  The <abbrev>CLC-INTERCAL</abbrev> compiler accepts Latin-1, a custom
-dialect of EBCDIC, Baudot, and a punched-card format as input; <abbrev>C-INTERCAL</abbrev>
-can cope with Latin-1 Princeton syntax, but for the other character
-sets, for other compilers, or just for getting something
-human-readable, it's useful to have a conversion program.
-<command>convickt</command> is an <acronym>INTERCAL</acronym> character set conversion program
-designed with these needs in mind.</para>
-    <para>The syntax for using <command>convickt</command> is</para>
-    <programlisting>
-convickt <replaceable>inputset</replaceable> <replaceable>outputset</replaceable> [<replaceable>padding</replaceable>]
-</programlisting>
-    <para>(that is, the input and output character sets are compulsory, but the
-parameter specifying what sort of padding to use is optional).</para>
-    <para>The following values for <replaceable>inputset</replaceable> and <replaceable>outputset</replaceable> are
-permissible:</para>
-    <term><indexterm>&lsquo;<literal>latin1</literal>&rsquo;
-        <variablelist>Latin-1, or to give it its official name ISO-8859-1, is the characterset most commonly used for transmitting <abbrev>CLC-INTERCAL</abbrev> programs, andtherefore nowadays the most popular character set for Princeton syntaxprograms.  Because it is identical to ASCII-7 in all codepoints thatdon't have the high bit set, most of the characters in it can be readby most modern editors and terminals.  It is also far more likely tobe supported by modern editors than EBCDIC, Baudot, or punched cards,all of which have fallen into relative disuse since 1972.  It is alsothe only input character set that <abbrev>C-INTERCAL</abbrev> supports for Princeton syntaxprograms.  It uses 8 bit characters.</variablelist>
-      </indexterm><indexterm>&lsquo;<literal>ebcdic</literal>&rsquo;
-        <variablelist>EBCDIC is an 8-bit character set that was an alternative to ASCII in1972, and is the character set used by the original Princetoncompiler.  Unfortunately, there is no single standard version; theversion of EBCDIC used by <command>convickt</command> is the one that <abbrev>CLC-INTERCAL</abbrev>uses.  It is the default input character set that <abbrev>CLC-INTERCAL</abbrev> uses(although more recent versions of <abbrev>CLC-INTERCAL</abbrev> instead try to guess theinput character set based on the input program.)</variablelist>
-      </indexterm><indexterm>&lsquo;<literal>baudot</literal>&rsquo;
-        <variablelist>Baudot is a 5-bit character set with shift codes; therefore whenstoring it in a file on an 8-bit computer, padding is needed to fillin the remaining three bits.  The standard Baudot character set doesnot contain all the characters needed by <acronym>INTERCAL</acronym>; therefore, <abbrev>CLC-INTERCAL</abbrev>uses repeated shift codes to add two more sets of characters.<command>convickt</command> uses the <abbrev>CLC-INTERCAL</abbrev> version of Baudot, so as to beable to translate programs designed for that compiler; however,standard Baudot is also accepted in input if it contains no redundantshift codes, and if the input contains no characters not in standardBaudot, the output will be written so that it is both correct standardBaudot and correct <abbrev>CLC-INTERCAL</abbrev> Baudot for those characters.</variablelist>
-      </indexterm><indexterm>&lsquo;<literal>atari</literal>&rsquo;
-        <variablelist>This option causes <command>convickt</command> to attempt a limited conversionto or from Atari syntax; this uses ASCII-7 as the character set, butalso tries to translate between Atari and Princeton syntax at thecharacter level, which is sometimes but not always effective.  Forinstance, <literal>?</literal> is translated from Atari to Princeton as a yensign, and from Princeton to Atari as a whirlpool (<literal>@</literal>); thissort of behaviour is often capable of translating expressionsautomatically, but will fail when characters outside ASCII-7 (Atari)or Latin-1 (Princeton) are used, and will not, for instance, translatea Princeton <literal>V</literal>, backspace, <literal>-</literal> into Atari <literal>?</literal>, butinstead leave it untouched.  ASCII-7 is a 7-bit character set, so onan 8 bit computer, there is one bit of padding that needs to begenerated; note, however, that it is usual nowadays to clear the topbit when transmitting ASCII-7, which the `printable' and `zero'padding styles will do, but the `random' style may not do.</variablelist>
-      </indexterm>
-    </term>
-    <para>When using a character set where not all bits in each byte are
-specified, a third argument can be given to specify what sort of
-padding to use for the top bits of each character. There are three
-options for this:</para>
-    <colspec>
-      <thead cols="2">
-        <tbody colwidth="11*"></tbody>
-        <tbody colwidth="52*"></tbody>
-        <entry>
-          <abstract>
-            <bookinfo>Option</bookinfo>
-            <bookinfo>Meaning</bookinfo>
-          
-          </abstract>
-        </entry>
-        <row>
-          <abstract>
-            <bookinfo>printable</bookinfo>
-            <bookinfo>Keep the output in the range 32-126 where possible</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>zero</bookinfo>
-            <bookinfo>Zero the high bits in the output</bookinfo>
-          
-          </abstract>
-          <abstract>
-            <bookinfo>random</bookinfo>
-            <bookinfo>Pad with random bits (avoiding all-zero bytes)</bookinfo>
-          
-          </abstract>
-        </row>
-      </thead>
-    </colspec>
-    <para>Note that not all conversions are possible.  If a character cannot be
-converted, it will normally be converted to a NUL byte (which is
-invalid in every character set); note that this will prevent
-round-tripping, because NUL is interpreted as end-of-input if given in
-the input.  There is one exception; if the character that could not be
-converted is a tab character, it will be converted to the other
-character set's representation of a space character, if possible,
-because the two characters have the same meaning in <acronym>INTERCAL</acronym> (the only
-difference is if the command is a syntax error that's printed as an
-error message).  (The exception exists to make it possible to
-translate existing <acronym>INTERCAL</acronym> source code into Baudot.)</para>
-  </appendix>
-
-  <appendix id="Optimizer-Idiom-Language">
-    <para>Optimizer Idiom Language</para>
-    <informalfigure>Optimizer Idiom Language</informalfigure>
-    <informalfigure>OIL</informalfigure>
-    <para>One file in the <abbrev>C-INTERCAL</abbrev> distribution (<filename>src/idiotism.oil</filename>) is written
-in Optimizer Idiom Language, a programming language designed especially
-for expressing optimizer idioms for <acronym>INTERCAL</acronym> in an easily editable form
-(well, at least it's easier than the unmaintainable set of idioms
-hard-coded in C that were used in previous versions of the <acronym>INTERCAL</acronym>
-compiler).</para>
-
-    <sect1 id="OIL-Basics">
-      <para>OIL Basics</para>
-      <informalfigure>OIL, basics</informalfigure>
-      <informalfigure><filename>src/idiotism.oil</filename></informalfigure>
-      <informalfigure><filename>idiotism.oil</filename></informalfigure>
-      <informalfigure>OIL, execution</informalfigure>
-      <para>The structure of an <acronym>OIL</acronym> file consists of a sequence of idioms.
-An optimizer idiom looks for a certain pattern in an expression (which
-could be an <acronym>INTERCAL</acronym> expression, or an expression that has already been
-partly optimized and therefore contains some non-<acronym>INTERCAL</acronym> operators), and
-replaces it with a replacement that's `simpler' in some sense (in the
-case of <abbrev>C-INTERCAL</abbrev>, `simpler' is interpreted to mean `compiles into a faster
-or smaller executable when run through a C compiler').  When an
-<acronym>OIL</acronym> program acts on an input <acronym>INTERCAL</acronym> file, it keeps on
-matching idioms to simplify expressions, until none of the idioms act
-any more (and if a situation occurs where idioms can keep matching
-indefinitely, the compiler goes into an infinite loop; so don't allow
-that to happen); at present, the idioms are tried from left to right,
-from the leaves of an expression to its root, and from the start of the
-OIL file to the end; but don't rely on that, because it's subject to
-change (and gets confusing when you think about what happens when the
-program actually does a replacement).  Anyway, the point is that if an
-idiom can match an expression, and another idiom doesn't change it
-first, then the idiom will be matched against that part of the
-expression eventually, and the program won't end until there are no
-idioms that match the optimized expression.</para>
-      <para>At present, the only place that <acronym>OIL</acronym> is used in the <abbrev>C-INTERCAL</abbrev>
-compiler is when the <option>-O</option> option (see -O) is used in
-base 2.  (Syntax is planned to extend <acronym>OIL</acronym> to higher bases, and
-some of this is documented and even implemented, but there's no way to
-use it.)  The idioms are read from the file <filename>src/idiotism.oil</filename>
-during the compilation of the <abbrev>C-INTERCAL</abbrev> from sources; you can change the
-idioms, but you will then have to recompile the distribution (and if you
-are using the <command>config.sh</command> method, also reinstall, but that will
-be pretty fast.)</para>
-    </sect1>
-
-    <sect1 id="OIL-Syntax">
-      <para>OIL Syntax</para>
-      <informalfigure>OIL, syntax</informalfigure>
-      <informalfigure>syntax, of OIL</informalfigure>
-      <para>An <acronym>OIL</acronym> file is encoded as an <acronym>ASCII</acronym> text file using
-no codepoints outside the range 0-127; using 10 for newline (as on a
-UNIX or Linux system) is always acceptable, but using 13 then 10 (as is
-common on Windows or DOS) for newline is acceptable only if your C
-compiler recognizes that as a newline.  I have no idea what happens if
-you use just 13 on an Apple computer on which that is the common newline
-convention.</para>
-      <informalfigure>OIL, comments</informalfigure>
-      <informalfigure>comments, OIL</informalfigure>
-      <para>Comments can be given anywhere in the file by writing lines starting
-with semicolons (known as hybrids to <acronym>INTERCAL</acronym> programmers).  It's also
-possible to write a semicolon after part of a line to comment out the
-rest of the line.  Inside braced C expressions, comments can be given
-anywhere whitespace would be allowed by placing them between <literal>/*</literal>
-and <literal>*/</literal> (in such cases, the comments will be copied verbatim to
-the C temporary files used when building the <abbrev>C-INTERCAL</abbrev> compiler, where your
-C compiler will ignore them).  Whitespace is ignored nearly everywhere;
-the only places it isn't ignored are in the middle of a decimal
-constant, inside square brackets, immediately after one of the
-characters &lsquo;<literal>.:#_}</literal>&rsquo;, and anywhere that C doesn't allow it in quoted
-C code.  (This means that you can even place it inside operators like &amp;&amp;
-if you like, as long as they're part of OIL code and not C code,
-although doing this is not recommended.)  If you use whitespace in a
-situation where it isn't ignored, that's almost certainly an error.</para>
-      <informalfigure>OIL, idiom groups</informalfigure>
-      <para>Idioms are grouped into groups of idioms by placing an identifier in
-square brackets before the group; this follows the rules for C
-identifiers, except that there's a maximum length of 30 characters.
-This identifier is the `name' of the group, which has no effect except
-on optimizer debug output; for that matter, the only effect a group has
-is that all idioms in the group look the same in optimizer debug output,
-because they have the same name.  It's recommended that idioms only have
-the same name if they are the same idiom, possibly written in several
-ways.  For example, a shift by 0 has no effect and may as well be
-removed from the output; the way to express this in OIL is:</para>
-      <programlisting>
-[nullshift]
-(_1 &gt;&gt; #0)-&gt;(_1)
-(_1 &lt;&lt; #0)-&gt;(_1)
-</programlisting>
-      <para>Here, nullshift is the name of the group of idioms, and two idioms are
-given; one which removes a null rightshift, and one which removes a null
-leftshift.</para>
-      <informalfigure>OIL, idioms</informalfigure>
-      <informalfigure>idiom</informalfigure>
-      <para>As the example above shows, the syntax of an idiom itself is</para>
-      <programlisting>
-(pattern)-&gt;(replacement)
-</programlisting>
-      <para>The parentheses here are actually part of the pattern and/or
-replacement, and as such sparks (apostrophes) or rabbit-ears (double
-quotes) can be used instead; they're shown in the syntax because the
-outer layer of parenthesising is always required.  Both the pattern and
-replacement are <acronym>OIL</acronym> expressions, although they both have their
-own special syntax elements as well.</para>
-    </sect1>
-
-    <sect1 id="OIL-Expressions">
-      <para>OIL Expressions</para>
-      <informalfigure>expressions, OIL</informalfigure>
-      <informalfigure>OIL, expressions</informalfigure>
-      <para>An <acronym>OIL</acronym> expression is built around subexpressions connected by
-infix binary operators and/or preceded by prefix unary operators, the
-same way as in C or <acronym>INTERCAL</acronym> (although unary operators must be entirely
-before their argument; the one character later position is not allowed.)
-As in <acronym>INTERCAL</acronym>, there is no operator precedence; expressions must be very
-fully bracketed to show unambiguously what the precedences must be, and
-then more so; for instance, bracketing marks must be placed around the
-argument of a unary operator in most circumstances.  Bracketing of
-expressions can be done with parentheses, sparks (apostrophes) or
-rabbit-ears (double-quotes).</para>
-      <para>The following unary and binary operators are allowed in OIL expressions:</para>
-      <informalfigure>OIL, operators</informalfigure>
-      <informalfigure>operators, OIL</informalfigure>
-      <colspec>
-        <thead cols="2">
-          <tbody colwidth="31*"></tbody>
-          <tbody colwidth="66*"></tbody>
-          <row>
-            <abstract>
-              <bookinfo><literal>$</literal></bookinfo>
-              <bookinfo>INTERCAL mingle</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>~</literal></bookinfo>
-              <bookinfo>INTERCAL select</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&amp;16</literal></bookinfo>
-              <bookinfo>INTERCAL unary AND (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>V16</literal></bookinfo>
-              <bookinfo>INTERCAL unary OR (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>?16</literal></bookinfo>
-              <bookinfo>INTERCAL unary XOR (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>^16</literal></bookinfo>
-              <bookinfo>INTERCAL unary sharkfin (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>@16</literal></bookinfo>
-              <bookinfo>INTERCAL unary whirlpool (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>@216..@516</literal></bookinfo>
-              <bookinfo>INTERCAL unary generalised whirlpool (16-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&amp;32</literal></bookinfo>
-              <bookinfo>INTERCAL unary AND (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>V32</literal></bookinfo>
-              <bookinfo>INTERCAL unary OR (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>?32</literal></bookinfo>
-              <bookinfo>INTERCAL unary XOR (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>^32</literal></bookinfo>
-              <bookinfo>INTERCAL unary sharkfin (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>@32</literal></bookinfo>
-              <bookinfo>INTERCAL unary whirlpool (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>@232..@532</literal></bookinfo>
-              <bookinfo>INTERCAL unary generalised whirlpool (32-bit)</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&amp;</literal></bookinfo>
-              <bookinfo>C binary bitwise AND</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>|</literal></bookinfo>
-              <bookinfo>C binary bitwise OR</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>^</literal></bookinfo>
-              <bookinfo>C binary bitwise XOR</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>+</literal></bookinfo>
-              <bookinfo>C addition</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>-</literal></bookinfo>
-              <bookinfo>C subtraction</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>*</literal></bookinfo>
-              <bookinfo>C multiplication</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>/</literal></bookinfo>
-              <bookinfo>C integer division</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>%</literal></bookinfo>
-              <bookinfo>C modulus</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&gt;</literal></bookinfo>
-              <bookinfo>C greater than</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&lt;</literal></bookinfo>
-              <bookinfo>C less than</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>~</literal></bookinfo>
-              <bookinfo>C unary bitwise complement</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>!=</literal></bookinfo>
-              <bookinfo>C not equals operator</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>==</literal></bookinfo>
-              <bookinfo>C equals operator</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&amp;&amp;</literal></bookinfo>
-              <bookinfo>C logical AND</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>||</literal></bookinfo>
-              <bookinfo>C logical OR</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&gt;&gt;</literal></bookinfo>
-              <bookinfo>C bitwise rightshift</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>&lt;&lt;</literal></bookinfo>
-              <bookinfo>C bitwise leftshift</bookinfo>
-            
-            </abstract>
-            <abstract>
-              <bookinfo><literal>!</literal></bookinfo>
-              <bookinfo>C unary logical NOT</bookinfo>
-            
-            </abstract>
-          </row>
-        </thead>
-      </colspec>
-      <para>(Note that in some cases two operators are expressed the same way, but
-that this doesn't matter because one is unary and the other is binary so
-that there can't be any ambiguity, only confusion.  Also note that
-unlike <acronym>INTERCAL</acronym> unary logic operators, OIL unary logic operators must
-have a bitwidth stated.)</para>
-      <para>It hasn't yet been explained what operands these operators have to
-operate on; the syntax for those depends on whether it's a pattern or
-replacement that the expression is representing.</para>
-    </sect1>
-
-    <sect1 id="OIL-Patterns">
-      <para>OIL Patterns</para>
-      <informalfigure>patterns</informalfigure>
-      <informalfigure>OIL, patterns</informalfigure>
-      <para>Patterns are simply <acronym>OIL</acronym> expressions; the expressions match
-either original <acronym>INTERCAL</acronym> input or expressions produced by earlier idioms.
-Each operator must match the same operator in the (possibly
-partially-optimised) input; the operands themselves are pattern
-templates specifying what operands in the input they can match.</para>
-      <para>One special simple form of match is possible: <literal>#<replaceable>NUMBER</replaceable></literal>,
-where <replaceable>NUMBER</replaceable> is in decimal, matches a constant with that value.
-(Unlike in <acronym>INTERCAL</acronym>, this constant is not limited to being a onespot
-value; it is, however, limited to being at most twospot, as are all
-operands and intermediate values in <acronym>OIL</acronym>.)</para>
-      <para>Otherwise, an operand consists of the following parts, written in order:</para>
-      <informalfigure>operands, OIL, in patterns</informalfigure>
-      <informalfigure>patterns, operands</informalfigure>
-      <varlistentry numeration="arabic">
-        <variablelist>A character to specify the data type of what's being matched.  Usually,this will be <literal>_</literal> to specify that any data type can be matched.  Ina few cases, you may want to use <literal>.</literal> or <literal>:</literal> to specify thatyou only want to match a onespot or twospot value respectively (that is,16- or 32-bit).  You can also use <literal>#</literal>; this specifies a value thatcan be any width, but must be known to be a constant with a known valueat optimize time (either because it was hardcoded as a constantoriginally or because a constant was produced there by the optimizer,for instance via a constant folding optimization).</variablelist>
-        <variablelist>Optionally, an expression in braces (<literal>{</literal> and <literal>}</literal>).  Thisexpression is written in C, not <acronym>OIL</acronym> (as are all expressions inbraces), and puts an extra condition on whether the pattern matches.The exact meaning of this will be explained later.</variablelist>
-        <variablelist>A reference number, which must be one decimal digit long.  A referencenumber of 0 causes the operand to be discarded immediately aftermatching; normally, you will want to specify a positive referencenumber.  Two operands with the same reference number must be exactly thesame for the pattern to match (for instance, both references to the samevariable, or identical subexpressions).  The reference number alsoallows the operand to be referenced by C expressions on other operandsand by replacements.  Reference numbers must be unique within the idiom(unless two or reference numbers are deliberately the same so that theoperands they reference have to be identical to produce a match), andthey are scoped only as far as the containing idiom; they don't carryfrom one idiom to another.</variablelist>
-      </varlistentry>
-      <para>Note that syntax like <literal>#2</literal> is ambiguous given what comes so far;
-the first interpretation is the one that is taken in practice, and if
-the second interpretation is wanted the operand should be expressed as
-<literal>#{1}2</literal>, using a no-op braced expression to tell them apart.
-This particular no-op is recommended because it's detected and optimized
-by the <literal>OIL</literal> compiler.</para>
-      <para>Braced expressions, which must be written purely in C, add extra
-conditions; they must return nonzero to allow a possible match or zero
-to prevent one.  They can reference the following variables and
-functions:</para>
-      <informalfigure>functions, OIL in C</informalfigure>
-      <informalfigure>OIL, functions in C</informalfigure>
-      <informalfigure>C, within OIL</informalfigure>
-      <para><inlinemediaobject name="C functions in OIL"></inlinemediaobject></para>
-      <term><indexterm><literal>c</literal><literal>c<replaceable>NUMBER</replaceable></literal>
-          <variablelist>
-            <informalfigure>c</informalfigure>
-            <informalfigure>c1&ndash;c9</informalfigure>This accesses a calculation made automatically by the compiled<acronym>OIL</acronym> program to identify which bits of the operand can possiblybe set, and which ones cannot be.  <literal>c</literal> by itself refers to theoperand to which the braced expression is attached; if a number isgiven, it refers to another node (the number is interpreted as areference numer).  The actual value of <literal>c</literal> is a 32-bit unsignedinteger, each bit of which is true, or 1, if there is any chance thatthe corresponding bit of the operand might be 1, and false, or 0, ifit's known for certain that the corresponding bit of the operand is 0.For instance:
-            <programlisting>
-_{!(c&amp;4294901760LU)}1
-</programlisting>The constant given here is FFFF0000 when expressed in hexadecimal; thepoint is that the expression matches any operand that is known to have avalue no greater than 65535.  Unless the operand is the argument to aunary AND, this check generally makes more point than explicitlyspecifying <literal>.</literal> rather than <literal>_</literal>, because it will identify both16- and 32-bit values as long as they're small enough to fit into aonespot variable.  This code could, for instance, be used to check thatan argument to a mingle must be small enough before optimising it (thisis important because an optimisation shouldn't optimise an error &ndash; inthis case, an overflowing mingle &ndash; into a non-error).</variablelist>
-        </indexterm><indexterm><literal>x</literal><literal>x<replaceable>NUMBER</replaceable></literal>
-          <variablelist>
-            <informalfigure>x</informalfigure>
-            <informalfigure>x1&ndash;x9</informalfigure><literal>x</literal> is like <literal>c</literal>, and refers to operands in the same way,except that it can only refer to an operand marked with <literal>#</literal>.  Itholds the value of that constant (a 32-bit unsigned integer), which willbe known to the optimizer at optimize time.  One common use of this isto detect whether a constant happens to be a power of 2, although thereare many other possibilities that may be useful.</variablelist>
-        </indexterm><indexterm><literal>r</literal>
-          <variablelist>
-            <informalfigure>r</informalfigure>When inside a loop, <literal>r</literal> is the value of the loop counter.  (It'salmost certainly a mistake if you have a loop but don't reference theloop counter at least once, and usually at least twice, within theloop.)  See .</variablelist>
-        </indexterm><indexterm><literal>and16</literal><literal>and32</literal><literal>or16</literal><literal>or32</literal><literal>xor16</literal><literal>xor32</literal><literal>iselect</literal><literal>mingle</literal>
-          <variablelist>
-            <informalfigure>and16</informalfigure>
-            <informalfigure>and32</informalfigure>
-            <informalfigure>or16</informalfigure>
-            <informalfigure>or32</informalfigure>
-            <informalfigure>xor16</informalfigure>
-            <informalfigure>xor32</informalfigure>
-            <informalfigure>iselect</informalfigure>
-            <informalfigure>mingle</informalfigure>These are all functions with one argument (apart from iselect andmingle, which each take two arguments); they exist so that <acronym>INTERCAL</acronym>operators can be used by C expressions.  They all take unsigned longs asinput and output, even if they are onespot operators.  Note that it'sentirely possible for these to cause a compile-time error if used oninvalid arguments (such as mingling with an operand over 65535), or tosilently truncate an invalid argument down to the right number of bits;both of these should be avoided if possible, so the optimiser shouldcheck first to make sure that it doesn't use any of these functions oninvalid arguments.</variablelist>
-        </indexterm><indexterm><literal>xselx</literal>
-          <variablelist>
-            <informalfigure>xselx</informalfigure>This function returns its argument selected with itself; so<literal>xselx(c)</literal> is shorthand for <literal>iselect(c,c)</literal>.  When the argumentis very complicated, this can save a lot of space in the original<acronym>OIL</acronym> program.</variablelist>
-        </indexterm><indexterm><literal>setbitcount</literal>
-          <variablelist>
-            <informalfigure>setbitcount</informalfigure>This function simply returns the number of bits with value 1 in itsargument.  This is sometimes useful with respect to variousselect-related optimisations, and can be a useful alternative to havingto take logarithms in various situations.</variablelist>
-        </indexterm><indexterm><literal>smudgeright</literal><literal>smudgeleft</literal>
-          <variablelist>
-            <informalfigure>smudgeright</informalfigure>
-            <informalfigure>smudgeleft</informalfigure>The <literal>smudgeright</literal> function returns its argument but with all thebits less significant than the most significant bit with value 1 set to1; likewise, <literal>smudgeleft</literal> returns its argument with all the bitsmore significant than the least significant bit with value 1 set to 1.</variablelist>
-        </indexterm>
-      </term>
-      <para>Note that all <acronym>OIL</acronym> character is done internally using unsigned
-32-bit numbers, and C expressions you write should do the same.  The
-practical upshot of this is that you should write <literal>LU</literal> after any
-constant you write in C code; if you don't do this, you are reasonably
-likely to get compiler warnings, and the resulting program may not work
-reliably, although the <acronym>OIL</acronym> compiler itself will not complain.</para>
-      <para>Here's a more complicated example of an optimizer operand:</para>
-      <programlisting>
-#{!(x&amp;2863311530LU)&amp;&amp;iselect(x,1431655765LU)==
-  xselx(iselect(x,1431655765LU))}3
-</programlisting>
-      <para>It helps to understand this if you know that 2863311530 in hexadecimal
-is AAAAAAAA and 1431655765 is hexadecimal is 55555555.  (It's worth
-putting a comment with some frequently-used decimal constants in an
-<acronym>OIL</acronym> input file to help explain what these numbers mean and
-make the code more maintainable.)  The operand matches any constant
-integer which has no bits in common with AAAAAAAA, and for which if any
-bit in common with 55555555 is set, all less significant bits in common
-with that number are also set.</para>
-    </sect1>
-
-    <sect1 id="OIL-Replacements">
-      <para>OIL Replacements</para>
-      <informalfigure>OIL, replacements</informalfigure>
-      <informalfigure>replacements</informalfigure>
-      <para>Replacements have much the same syntax as patterns.  The expressions are
-parsed in much the same way; however, one peculiarity of replacements is
-that bitwidths must be specified.  <acronym>INTERCAL</acronym> has a typecaster that figures
-out whether each expression is 16 bits or 32 bits wide, but it runs
-before the optimizer, and as the optimizer can produce expressions whose
-bitwidths don't obey <acronym>INTERCAL</acronym>'s rules, this information needs to be
-inserted somehow in a replacement.  In <abbrev>C-INTERCAL</abbrev>, it usually doesn't matter
-what the bitwidth is, and in cases where it doesn't matter the normal
-operators (<literal>$</literal>, <literal>~</literal>, and so on) can be used.  (Note that the
-bit width of the entire replacement is always set to the same bit width
-as the bit width of the expression matched by the pattern; so you don't
-have to worry about the effect on unary logical operators that might be
-operating on the expression being optimized.  This is an exception to
-the normal bitwidth rules for a replacement.)  In cases where it does
-matter (due to <abbrev>C-INTERCAL</abbrev>'s lenient interpretation of bitwidth on mingle
-inputs, the only place it matters is in the input to <acronym>INTERCAL</acronym> unary
-logical operators), both the bidwidth of the operator and the argument
-on which it operates must be explicitly given, and given as the same
-value; to set the bitwidth of an operator's result, simply write the
-bitwidth (16 or 32 for onespot and twospot respectively) immediately
-after the operator; for instance, <literal>!=32</literal> will generate a not-equals
-operation with a 32-bit bitwidth.  If an operator's width is set to 16,
-and during the course of execution of the optimized program, a value
-that doesn't fit into 16 bits is encountered, that's undefined behaviour
-and anything might happen (most likely, though, the program will just
-act as though its width had been set to 32 bits instead); this error
-condition is not detected.  Also note that operators like <literal>&amp;32</literal>
-already have a bitwidth specified, so specifying <literal>&amp;3232</literal> (or worse,
-<literal>&amp;3216</literal>) is not allowed.</para>
-      <informalfigure>operands, OIL, in replacements</informalfigure>
-      <informalfigure>replacements, operands</informalfigure>
-      <para>Replacement operands are simpler than pattern operands, because there
-are only a few forms they can take.</para>
-      <term><indexterm><literal>_<replaceable>NUMBER</replaceable></literal><literal>.<replaceable>NUMBER</replaceable></literal><literal>:<replaceable>NUMBER</replaceable></literal>
-          <variablelist>This tells the optimiser to copy the operand or expression withreference number <replaceable>NUMBER</replaceable> to this point in the replacement used forthe expression matched by the pattern.  The three forms are identical;the last two are provided for aesthetic reasons (it can look better andbe clearer to match <literal>.1</literal> in the pattern with <literal>.1</literal> in thereplacement, for instance).  You cannot use <literal>#<replaceable>NUMBER</replaceable></literal> here tocopy in a constant from the left-hand side, though, nor<literal>#{1}<replaceable>NUMBER</replaceable></literal>, because the first means something else andthe second is undefined behaviour (that is, no behaviour for the secondcase has been specifically implemented in the compiler and therefore itsbehaviour is unpredictable and subject to change in future versions);use <literal>_<replaceable>NUMBER</replaceable></literal> to copy over a constant with an unknown atoptimizer compile time (but known at optimize time) value from the lefthand side, as you can do with any other operand being copied.</variablelist>
-        </indexterm><indexterm><literal>#<replaceable>NUMBER</replaceable></literal>
-          <variablelist>Insert a constant with the literal value <replaceable>NUMBER</replaceable> here.</variablelist>
-        </indexterm><indexterm><literal>#{<replaceable>EXPRESSION</replaceable>}0</literal>
-          <variablelist>Calculate the value of <replaceable>EXPRESSION</replaceable> (a C expression, which canreference the same variables and functions as a C expression in apattern can; see .</variablelist>
-        </indexterm>
-      </term>
-      <para>As an example, here's an idiom that moves C bitwise AND operations
-inside leftshifts.  (This is useful because if the optimizer has
-generated a large sequence of mixed ANDs and bitshifts, moving all the
-ANDs to one end allows them to be clumped together and optimized down to
-one AND.)</para>
-      <programlisting>
-((_1 &lt;&lt; #{1}2) &amp; #{1}3)-&gt;((_1 &amp; #{x3&gt;&gt;x2}0) &lt;&lt; _2)
-</programlisting>
-    </sect1>
-
-    <sect1 id="OIL-Loops">
-      <para>OIL Loops</para>
-      <informalfigure>loops, OIL</informalfigure>
-      <informalfigure>OIL, loops</informalfigure>
-      <para>When writing idioms, sometimes instead of using very complicated
-expressions to try to match multiple situations at once it's easier to
-have a separate idiom for each possible situation; for instance, it's
-easier to write idioms for right-shift by 1, right-shift by 2,
-right-shift by 3, etc&period;, rather than a general idiom to rightshift by any
-amount.  When the idioms follow a pattern, as they will do in basically
-every case of this sort, it's possible to automatically generate them
-using a loop.  For instance, idioms to optimize a one-bit rightshift
-and a two-bit rightshift are:</para>
-      <programlisting>
-(_1~#{xselx(x)&lt;&lt;1==x&amp;&amp;x}2)-&gt;((_1&amp;_2)&gt;&gt;#1)
-(_1~#{xselx(x)&lt;&lt;2==x&amp;&amp;x}2)-&gt;((_1&amp;_2)&gt;&gt;#2)
-</programlisting>
-      <para>Adding a loop to automatically generate the idioms, and placing a name
-for the group of idioms at the start, produces the following code:</para>
-      <programlisting>
-[rshift]
-&lt;#1-#31
-(_1~#{xselx(x)&lt;&lt;r==x&amp;&amp;x}2)-&gt;((_1&amp;_2)&gt;&gt;#{r}0)
-&gt;
-</programlisting>
-      <para>That's 31 different idioms, generated with a loop.  As the above example
-shows, a loop starts with <literal>&lt;#<replaceable>NUMBER</replaceable>-#<replaceable>NUMBER</replaceable></literal> and ends
-with <literal>&gt;</literal>; a different idiom is generated for each possible value of
-the loop counter <literal>r</literal> in the range given by the opening line of the
-loop.  Loops must be placed around idioms, but inside a group of
-idioms.  Note the use of <literal>#{r}0</literal> to generate a constant whose
-value is equal to the value of the loop counter.</para>
-    </sect1>
-
-    <sect1 id="OIL-Tips">
-      <para>OIL Tips</para>
-      <informalfigure>tips, OIL</informalfigure>
-      <informalfigure>OIL, tips</informalfigure>
-      <para>Here are some tips for the best use of <acronym>OIL</acronym>:</para>
-      <listitem mark="bullet">
-        <variablelist>
-          <informalfigure>MAXTOFREE</informalfigure>The <acronym>OIL</acronym> compiler has a few deficiencies, such as errormessages that don't give you much of an idea of what you did wrong (tocompensate for this, it does give a reasonably accurate line andcharacter number where the error happened), limits on things like howdeep expressions can be nested and how many idioms are allowed (if youhit the first, you should really break it up into smaller idioms ifpossible, and if you hit the second, increase <literal>MAXTOFREE</literal> in oil.y;this isn't a limit on the number of idioms but on the number of stringsthat are allocated internally to process the idioms), and lack of errorchecking (invalid <acronym>OIL</acronym> may produce errors in the <acronym>OIL</acronym>compiler, or cause the output C code to contain errors or warnings, ormay even appear to work).</variablelist>
-        <variablelist>When you have symmetrical operators in an idiom (like C binary logicaloperators), you need to write the idiom both ways round (in the samegroup of idioms, preferably), or write another idiom to standardise theformat first; the first method can get very tedious when there are manysymmetrical operators in an idiom, and the second is prone to optimizerloops and subtle errors (both methods have been used in the provided<filename>idiotism.oil</filename> file.)</variablelist>
-        <variablelist>Idioms should preferably be as general as possible, broken down intomany separate idioms rather than all as one big idiom, and match thesmallest part of the expression being optimized that is necessary forthe idiom to be correct in all cirucmstances; all of these help toimprove the performance of the optimizer in terms of what it canoptimize.</variablelist>
-        <variablelist>If a program's optimizing incorrectly, or you just want to see how theoptimizer deals with a particular program, it's possible to debug theoptimizer by giving the <option>-h</option>, <option>-H</option>, or <option>-hH</option>(see ) switch to the <abbrev>C-INTERCAL</abbrev> compiler, which will cause debuginformation to be output on stderr.  <option>-h</option> will show the initialand final expressions for each expression that was given as input to theoptimizer, as well as a list of all optimizations used, in a languagethat's a sort of mix of C, <acronym>INTERCAL</acronym>, and <acronym>OIL</acronym>; <option>-H</option> willdo the same, and also show the intermediate stages in the optimization.<option>-hH</option> is like <option>-H</option>, but produces its output entirely in C,so that the various intermediate stages can be tried with a C compiler,or for people who are fed up of reading <acronym>INTERCAL</acronym>.  <option>-H</option> can be auseful learning resource for people who want to understand how aparticular <acronym>INTERCAL</acronym> expression works.</variablelist>
-        <variablelist>Make sure that the optimizer doesn't change a statement from a run-timeerror into something that silently succeeds!  Checking which bits canand can't be 1 is one good way to avoid this, especially with mingles.(At present, there are some idioms that can turn run-time errors intocompile-time errors, such as with the expression<literal>''#65535$#65535'$#0'</literal>; this could be avoided, but for the timebeing it isn't.)</variablelist>
-        <variablelist>You can help!  If you find an idiom that the optimizer isn't optimizingcorrectly, feel free to add it, or multiple idioms that come to the samething, to <filename>idiotism.oil</filename>.  In such a case, it would help otherusers if you would submit your new optimizer idiom to the project(see ); this will help other users and future releasesof <acronym>INTERCAL</acronym>, and also has a chance of allowing other users to check yournew idioms to see if they cause problems or could be written better.</variablelist>
-      
-      </listitem>
-    </sect1>
-
-    <sect1 id="OIL-Example">
-      <para>OIL Example</para>
-      <informalfigure>OIL, example</informalfigure>
-      <informalfigure>examples, OIL</informalfigure>
-      <para>To finish off this appendix, here's an example of the power of
-<acronym>OIL</acronym>; this is the optimization of an idiom from the <abbrev>INTERCAL-72</abbrev>
-system library, as shown with <option>-H</option>; this should give a good idea
-of how <acronym>OIL</acronym> programs work.  (All the relevant idioms are in
-<filename>idiotism.oil</filename> as of the time of writing.)  Note how the expression
-is reduced one small step at a time; the smallness of the steps makes
-the optimizer more general, because if the original expression had been
-slightly different, the optimizer wouldn't have come to the same result
-but could have optimized it quite a bit of the way, up to the point
-where the optimizations were no longer valid; in an older version of
-<acronym>INTERCAL</acronym>, this idiom was simply hardcoded as a special case and so slight
-variations of it weren't optimized at all.  If you look at the idioms
-themselves, it'll also be apparent how <literal>c</literal> (the record of which
-bits of an expression can be 1 and which bits can't be) is important
-information in being able to apply an optimization more aggressively.</para>
-      <screen>.3 &lt;- ((((((((.3 $ 0x0) ~ (0x7fff $ 0x1)) $ 0x0) ~ (0x7fff $ 0x1)) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[minglefold]
-.3 &lt;- ((((((((.3 $ 0x0) ~ 0x2aaaaaab) $ 0x0) ~ (0x7fff $ 0x1)) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[lshift16]
-.3 &lt;- ((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) | 0x0) $ 0x0) ~ (0x7fff $ 0x1)) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[noopor]
-.3 &lt;- (((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) $ 0x0) ~ (0x7fff $ 0x1)) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[minglefold]
-.3 &lt;- (((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) $ 0x0) ~ 0x2aaaaaab) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[lshift16]
-.3 &lt;- (((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) | 0x0) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[noopor]
-.3 &lt;- ((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) $ 0x0) ~ (0x3fff $ 0x3)) $ 0x0) ~ (0xfff $ 0xf))
-[minglefold]
-.3 &lt;- ((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) $ 0x0) ~ 0xaaaaaaf) $ 0x0) ~ (0xfff $ 0xf))
-[lshift16]
-.3 &lt;- ((((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) | 0x0) $ 0x0) ~ (0xfff $ 0xf))
-[noopor]
-.3 &lt;- (((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) $ 0x0) ~ (0xfff $ 0xf))
-[minglefold]
-.3 &lt;- (((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) $ 0x0) ~ 0xaaaaff)
-[lshift16]
-.3 &lt;- (((((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7) | 0x0)
-[noopor]
-.3 &lt;- ((((((((((((.3 &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[nullshift]
-.3 &lt;- (((((((((((.3 &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x0) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[combinelrshift]
-.3 &lt;- ((((((((((.3 &amp; 0x7fff) &lt;&lt; 0x1) &amp; 0x7fff) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[andintolshift]
-.3 &lt;- ((((((((((.3 &amp; 0x7fff) &amp; 0x3fff) &lt;&lt; 0x1) &lt;&lt; 0x1) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[combinellshift]
-.3 &lt;- (((((((((.3 &amp; 0x7fff) &amp; 0x3fff) &lt;&lt; 0x2) &gt;&gt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[combinelrshift]
-.3 &lt;- ((((((((.3 &amp; 0x7fff) &amp; 0x3fff) &lt;&lt; 0x1) &amp; 0x1fff) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[andintolshift]
-.3 &lt;- ((((((((.3 &amp; 0x7fff) &amp; 0x3fff) &amp; 0xfff) &lt;&lt; 0x1) &lt;&lt; 0x3) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[combinellshift]
-.3 &lt;- (((((((.3 &amp; 0x7fff) &amp; 0x3fff) &amp; 0xfff) &lt;&lt; 0x4) &gt;&gt; 0x3) &amp; 0x1ff) &lt;&lt; 0x7)
-[combinelrshift]
-.3 &lt;- ((((((.3 &amp; 0x7fff) &amp; 0x3fff) &amp; 0xfff) &lt;&lt; 0x1) &amp; 0x1ff) &lt;&lt; 0x7)
-[andintolshift]
-.3 &lt;- ((((((.3 &amp; 0x7fff) &amp; 0x3fff) &amp; 0xfff) &amp; 0xff) &lt;&lt; 0x1) &lt;&lt; 0x7)
-[combinellshift]
-.3 &lt;- (((((.3 &amp; 0x7fff) &amp; 0x3fff) &amp; 0xfff) &amp; 0xff) &lt;&lt; 0x8)
-[combineand]
-.3 &lt;- ((((.3 &amp; 0x3fff) &amp; 0xfff) &amp; 0xff) &lt;&lt; 0x8)
-[combineand]
-.3 &lt;- (((.3 &amp; 0xfff) &amp; 0xff) &lt;&lt; 0x8)
-[combineand]
-.3 &lt;- ((.3 &amp; 0xff) &lt;&lt; 0x8)
-</screen>
-    </sect1>
-  </appendix>
-
-  <appendix id="Copying">
-    <para>Copying</para>
-    <informalfigure>copyright</informalfigure>
-    <informalfigure>copying conditions</informalfigure>
-    <para>The majority of the files in the <abbrev>C-INTERCAL</abbrev> distribution are licensed
-under the GNU General Public License (version 2 or later), but with
-some exceptions.  The files <filename>ick-wrap.c</filename> and <filename>pickwrap.c</filename>
-are licensed under a license that allows them to be used for any
-purpose and redistributed at will, and are explicitly not GPL'd.  This
-means that C source code generated by the compiler has the same
-copyright conditions as the original <acronym>INTERCAL</acronym> source.  (Note that the
-libraries <filename>libick.a</filename> and <filename>libickmt.a</filename> are GPL, though, so
-you cannot redistribute an executable produced by <command>ick</command> or by
-linking a C file to either of those libraries unless the original
-<acronym>INTERCAL</acronym> source was GPL.)  Also, this manual, and the files that are
-the source code for creating it, are licensed under the GNU Free
-Documentation License rather than the GPL, and the licenses themselves
-(<filename>fdl-1-2.txi</filename> and <filename>COPYING.txt</filename>) are licensed under a
-license that allows verbatim redistribution but not creation of
-derivative works.  All other files, though (including the
-<command>man</command> pages, which are not part of <emphasis>this</emphasis> manual), are
-licensed under the GPL.  For the full text of the GPL, see the file
-<filename>COPYING.txt</filename> in the distribution.</para>
-
-    <sect1 id="GNU-Free-Documentation-License">
-      <para>GNU Free Documentation License</para>
-      <informalfigure>GFDL</informalfigure>
-      <informalfigure>FDL</informalfigure>
-      <informalfigure>GNU Free Documentation License</informalfigure>
-      <informalfigure>Free Documentation License</informalfigure>
-<!-- The GNU Free Documentation License. -->
-      <blockquote>
-        <para>Version 1.2, November 2002</para>
-      </blockquote>
-<!-- This file is intended to be included within another document, -->
-<!-- hence no sectioning command or @node. -->
-      <screen>
-Copyright &copy; 2000,2001,2002 Free Software Foundation, Inc.
-51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
-
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-</screen>
-      <varlistentry numeration="arabic" role="0">
-        <variablelist>PREAMBLEThe purpose of this License is to make a manual, textbook, or otherfunctional and useful document <firstterm>free</firstterm> in the sense of freedom: toassure everyone the effective freedom to copy and redistribute it,with or without modifying it, either commercially or noncommercially.Secondarily, this License preserves for the author and publisher a wayto get credit for their work, while not being considered responsiblefor modifications made by others.This License is a kind of &ldquo;copyleft&rdquo;, which means that derivativeworks of the document must themselves be free in the same sense.  Itcomplements the GNU General Public License, which is a copyleftlicense designed for free software.We have designed this License in order to use it for manuals for freesoftware, because free software needs free documentation: a freeprogram should come with manuals providing the same freedoms that thesoftware does.  But this License is not limited to software manuals;it can be used for any textual work, regardless of subject matter orwhether it is published as a printed book.  We recommend this Licenseprincipally for works whose purpose is instruction or reference.</variablelist>
-        <variablelist>APPLICABILITY AND DEFINITIONSThis License applies to any manual or other work, in any medium, thatcontains a notice placed by the copyright holder saying it can bedistributed under the terms of this License.  Such a notice grants aworld-wide, royalty-free license, unlimited in duration, to use thatwork under the conditions stated herein.  The &ldquo;Document&rdquo;, below,refers to any such manual or work.  Any member of the public is alicensee, and is addressed as &ldquo;you&rdquo;.  You accept the license if youcopy, modify or distribute the work in a way requiring permissionunder copyright law.A &ldquo;Modified Version&rdquo; of the Document means any work containing theDocument or a portion of it, either copied verbatim, or withmodifications and/or translated into another language.A &ldquo;Secondary Section&rdquo; is a named appendix or a front-matter sectionof the Document that deals exclusively with the relationship of thepublishers or authors of the Document to the Document's overallsubject (or to related matters) and contains nothing that could falldirectly within that overall subject.  (Thus, if the Document is inpart a textbook of mathematics, a Secondary Section may not explainany mathematics.)  The relationship could be a matter of historicalconnection with the subject or with related matters, or of legal,commercial, philosophical, ethical or political position regardingthem.The &ldquo;Invariant Sections&rdquo; are certain Secondary Sections whose titlesare designated, as being those of Invariant Sections, in the noticethat says that the Document is released under this License.  If asection does not fit the above definition of Secondary then it is notallowed to be designated as Invariant.  The Document may contain zeroInvariant Sections.  If the Document does not identify any InvariantSections then there are none.The &ldquo;Cover Texts&rdquo; are certain short passages of text that are listed,as Front-Cover Texts or Back-Cover Texts, in the notice that says thatthe Document is released under this License.  A Front-Cover Text maybe at most 5 words, and a Back-Cover Text may be at most 25 words.A &ldquo;Transparent&rdquo; copy of the Document means a machine-readable copy,represented in a format whose specification is available to thegeneral public, that is suitable for revising the documentstraightforwardly with generic text editors or (for images composed ofpixels) generic paint programs or (for drawings) some widely availabledrawing editor, and that is suitable for input to text formatters orfor automatic translation to a variety of formats suitable for inputto text formatters.  A copy made in an otherwise Transparent fileformat whose markup, or absence of markup, has been arranged to thwartor discourage subsequent modification by readers is not Transparent.An image format is not Transparent if used for any substantial amountof text.  A copy that is not &ldquo;Transparent&rdquo; is called &ldquo;Opaque&rdquo;.Examples of suitable formats for Transparent copies include plainascii without markup, Texinfo input format, La&tex; inputformat, <acronym>SGML</acronym> or <acronym>XML</acronym> using a publicly available<acronym>DTD</acronym>, and standard-conforming simple <acronym>HTML</acronym>,PostScript or <acronym>PDF</acronym> designed for human modification.  Examplesof transparent image formats include <acronym>PNG</acronym>, <acronym>XCF</acronym> and<acronym>JPG</acronym>.  Opaque formats include proprietary formats that can beread and edited only by proprietary word processors, <acronym>SGML</acronym> or<acronym>XML</acronym> for which the <acronym>DTD</acronym> and/or processing tools arenot generally available, and the machine-generated <acronym>HTML</acronym>,PostScript or <acronym>PDF</acronym> produced by some word processors foroutput purposes only.The &ldquo;Title Page&rdquo; means, for a printed book, the title page itself,plus such following pages as are needed to hold, legibly, the materialthis License requires to appear in the title page.  For works informats which do not have any title page as such, &ldquo;Title Page&rdquo; meansthe text near the most prominent appearance of the work's title,preceding the beginning of the body of the text.A section &ldquo;Entitled XYZ&rdquo; means a named subunit of the Document whosetitle either is precisely XYZ or contains XYZ in parentheses followingtext that translates XYZ in another language.  (Here XYZ stands for aspecific section name mentioned below, such as &ldquo;Acknowledgements&rdquo;,&ldquo;Dedications&rdquo;, &ldquo;Endorsements&rdquo;, or &ldquo;History&rdquo;.)  To &ldquo;Preserve the Title&rdquo;of such a section when you modify the Document means that it remains asection &ldquo;Entitled XYZ&rdquo; according to this definition.The Document may include Warranty Disclaimers next to the notice whichstates that this License applies to the Document.  These WarrantyDisclaimers are considered to be included by reference in thisLicense, but only as regards disclaiming warranties: any otherimplication that these Warranty Disclaimers may have is void and hasno effect on the meaning of this License.</variablelist>
-        <variablelist>VERBATIM COPYINGYou may copy and distribute the Document in any medium, eithercommercially or noncommercially, provided that this License, thecopyright notices, and the license notice saying this License appliesto the Document are reproduced in all copies, and that you add no otherconditions whatsoever to those of this License.  You may not usetechnical measures to obstruct or control the reading or furthercopying of the copies you make or distribute.  However, you may acceptcompensation in exchange for copies.  If you distribute a large enoughnumber of copies you must also follow the conditions in section 3.You may also lend copies, under the same conditions stated above, andyou may publicly display copies.</variablelist>
-        <variablelist>COPYING IN QUANTITYIf you publish printed copies (or copies in media that commonly haveprinted covers) of the Document, numbering more than 100, and theDocument's license notice requires Cover Texts, you must enclose thecopies in covers that carry, clearly and legibly, all these CoverTexts: Front-Cover Texts on the front cover, and Back-Cover Texts onthe back cover.  Both covers must also clearly and legibly identifyyou as the publisher of these copies.  The front cover must presentthe full title with all words of the title equally prominent andvisible.  You may add other material on the covers in addition.Copying with changes limited to the covers, as long as they preservethe title of the Document and satisfy these conditions, can be treatedas verbatim copying in other respects.If the required texts for either cover are too voluminous to fitlegibly, you should put the first ones listed (as many as fitreasonably) on the actual cover, and continue the rest onto adjacentpages.If you publish or distribute Opaque copies of the Document numberingmore than 100, you must either include a machine-readable Transparentcopy along with each Opaque copy, or state in or with each Opaque copya computer-network location from which the general network-usingpublic has access to download using public-standard network protocolsa complete Transparent copy of the Document, free of added material.If you use the latter option, you must take reasonably prudent steps,when you begin distribution of Opaque copies in quantity, to ensurethat this Transparent copy will remain thus accessible at the statedlocation until at least one year after the last time you distribute anOpaque copy (directly or through your agents or retailers) of thatedition to the public.It is requested, but not required, that you contact the authors of theDocument well before redistributing any large number of copies, to givethem a chance to provide you with an updated version of the Document.</variablelist>
-        <variablelist>MODIFICATIONSYou may copy and distribute a Modified Version of the Document underthe conditions of sections 2 and 3 above, provided that you releasethe Modified Version under precisely this License, with the ModifiedVersion filling the role of the Document, thus licensing distributionand modification of the Modified Version to whoever possesses a copyof it.  In addition, you must do these things in the Modified Version:
-          <varlistentry numeration="upperalpha">
-            <variablelist>Use in the Title Page (and on the covers, if any) a title distinctfrom that of the Document, and from those of previous versions(which should, if there were any, be listed in the History sectionof the Document).  You may use the same title as a previous versionif the original publisher of that version gives permission.</variablelist>
-            <variablelist>List on the Title Page, as authors, one or more persons or entitiesresponsible for authorship of the modifications in the ModifiedVersion, together with at least five of the principal authors of theDocument (all of its principal authors, if it has fewer than five),unless they release you from this requirement.</variablelist>
-            <variablelist>State on the Title page the name of the publisher of theModified Version, as the publisher.</variablelist>
-            <variablelist>Preserve all the copyright notices of the Document.</variablelist>
-            <variablelist>Add an appropriate copyright notice for your modificationsadjacent to the other copyright notices.</variablelist>
-            <variablelist>Include, immediately after the copyright notices, a license noticegiving the public permission to use the Modified Version under theterms of this License, in the form shown in the Addendum below.</variablelist>
-            <variablelist>Preserve in that license notice the full lists of Invariant Sectionsand required Cover Texts given in the Document's license notice.</variablelist>
-            <variablelist>Include an unaltered copy of this License.</variablelist>
-            <variablelist>Preserve the section Entitled &ldquo;History&rdquo;, Preserve its Title, and addto it an item stating at least the title, year, new authors, andpublisher of the Modified Version as given on the Title Page.  Ifthere is no section Entitled &ldquo;History&rdquo; in the Document, create onestating the title, year, authors, and publisher of the Document asgiven on its Title Page, then add an item describing the ModifiedVersion as stated in the previous sentence.</variablelist>
-            <variablelist>Preserve the network location, if any, given in the Document forpublic access to a Transparent copy of the Document, and likewisethe network locations given in the Document for previous versionsit was based on.  These may be placed in the &ldquo;History&rdquo; section.You may omit a network location for a work that was published atleast four years before the Document itself, or if the originalpublisher of the version it refers to gives permission.</variablelist>
-            <variablelist>For any section Entitled &ldquo;Acknowledgements&rdquo; or &ldquo;Dedications&rdquo;, Preservethe Title of the section, and preserve in the section all thesubstance and tone of each of the contributor acknowledgements and/ordedications given therein.</variablelist>
-            <variablelist>Preserve all the Invariant Sections of the Document,unaltered in their text and in their titles.  Section numbersor the equivalent are not considered part of the section titles.</variablelist>
-            <variablelist>Delete any section Entitled &ldquo;Endorsements&rdquo;.  Such a sectionmay not be included in the Modified Version.</variablelist>
-            <variablelist>Do not retitle any existing section to be Entitled &ldquo;Endorsements&rdquo; orto conflict in title with any Invariant Section.</variablelist>
-            <variablelist>Preserve any Warranty Disclaimers.</variablelist>
-          </varlistentry>If the Modified Version includes new front-matter sections orappendices that qualify as Secondary Sections and contain no materialcopied from the Document, you may at your option designate some or allof these sections as invariant.  To do this, add their titles to thelist of Invariant Sections in the Modified Version's license notice.These titles must be distinct from any other section titles.You may add a section Entitled &ldquo;Endorsements&rdquo;, provided it containsnothing but endorsements of your Modified Version by variousparties&mdash;for example, statements of peer review or that the text hasbeen approved by an organization as the authoritative definition of astandard.You may add a passage of up to five words as a Front-Cover Text, and apassage of up to 25 words as a Back-Cover Text, to the end of the listof Cover Texts in the Modified Version.  Only one passage ofFront-Cover Text and one of Back-Cover Text may be added by (orthrough arrangements made by) any one entity.  If the Document alreadyincludes a cover text for the same cover, previously added by you orby arrangement made by the same entity you are acting on behalf of,you may not add another; but you may replace the old one, on explicitpermission from the previous publisher that added the old one.The author(s) and publisher(s) of the Document do not by this Licensegive permission to use their names for publicity for or to assert orimply endorsement of any Modified Version.</variablelist>
-        <variablelist>COMBINING DOCUMENTSYou may combine the Document with other documents released under thisLicense, under the terms defined in section 4 above for modifiedversions, provided that you include in the combination all of theInvariant Sections of all of the original documents, unmodified, andlist them all as Invariant Sections of your combined work in itslicense notice, and that you preserve all their Warranty Disclaimers.The combined work need only contain one copy of this License, andmultiple identical Invariant Sections may be replaced with a singlecopy.  If there are multiple Invariant Sections with the same name butdifferent contents, make the title of each such section unique byadding at the end of it, in parentheses, the name of the originalauthor or publisher of that section if known, or else a unique number.Make the same adjustment to the section titles in the list ofInvariant Sections in the license notice of the combined work.In the combination, you must combine any sections Entitled &ldquo;History&rdquo;in the various original documents, forming one section Entitled&ldquo;History&rdquo;; likewise combine any sections Entitled &ldquo;Acknowledgements&rdquo;,and any sections Entitled &ldquo;Dedications&rdquo;.  You must delete allsections Entitled &ldquo;Endorsements.&rdquo;</variablelist>
-        <variablelist>COLLECTIONS OF DOCUMENTSYou may make a collection consisting of the Document and other documentsreleased under this License, and replace the individual copies of thisLicense in the various documents with a single copy that is included inthe collection, provided that you follow the rules of this License forverbatim copying of each of the documents in all other respects.You may extract a single document from such a collection, and distributeit individually under this License, provided you insert a copy of thisLicense into the extracted document, and follow this License in allother respects regarding verbatim copying of that document.</variablelist>
-        <variablelist>AGGREGATION WITH INDEPENDENT WORKSA compilation of the Document or its derivatives with other separateand independent documents or works, in or on a volume of a storage ordistribution medium, is called an &ldquo;aggregate&rdquo; if the copyrightresulting from the compilation is not used to limit the legal rightsof the compilation's users beyond what the individual works permit.When the Document is included in an aggregate, this License does notapply to the other works in the aggregate which are not themselvesderivative works of the Document.If the Cover Text requirement of section 3 is applicable to thesecopies of the Document, then if the Document is less than one half ofthe entire aggregate, the Document's Cover Texts may be placed oncovers that bracket the Document within the aggregate, or theelectronic equivalent of covers if the Document is in electronic form.Otherwise they must appear on printed covers that bracket the wholeaggregate.</variablelist>
-        <variablelist>TRANSLATIONTranslation is considered a kind of modification, so you maydistribute translations of the Document under the terms of section 4.Replacing Invariant Sections with translations requires specialpermission from their copyright holders, but you may includetranslations of some or all Invariant Sections in addition to theoriginal versions of these Invariant Sections.  You may include atranslation of this License, and all the license notices in theDocument, and any Warranty Disclaimers, provided that you also includethe original English version of this License and the original versionsof those notices and disclaimers.  In case of a disagreement betweenthe translation and the original version of this License or a noticeor disclaimer, the original version will prevail.If a section in the Document is Entitled &ldquo;Acknowledgements&rdquo;,&ldquo;Dedications&rdquo;, or &ldquo;History&rdquo;, the requirement (section 4) to Preserveits Title (section 1) will typically require changing the actualtitle.</variablelist>
-        <variablelist>TERMINATIONYou may not copy, modify, sublicense, or distribute the Document exceptas expressly provided for under this License.  Any other attempt tocopy, modify, sublicense or distribute the Document is void, and willautomatically terminate your rights under this License.  However,parties who have received copies, or rights, from you under thisLicense will not have their licenses terminated so long as suchparties remain in full compliance.</variablelist>
-        <variablelist>FUTURE REVISIONS OF THIS LICENSEThe Free Software Foundation may publish new, revised versionsof the GNU Free Documentation License from time to time.  Such newversions will be similar in spirit to the present version, but maydiffer in detail to address new problems or concerns.  Seehttp://www.gnu.org/copyleft/.Each version of the License is given a distinguishing version number.If the Document specifies that a particular numbered version of thisLicense &ldquo;or any later version&rdquo; applies to it, you have the option offollowing the terms and conditions either of that specified version orof any later version that has been published (not as a draft) by theFree Software Foundation.  If the Document does not specify a versionnumber of this License, you may choose any version ever published (notas a draft) by the Free Software Foundation.</variablelist>
-      </varlistentry>
-      <bridgehead renderas="sect1">ADDENDUM: How to use this License for your documents</bridgehead>
-      <para>To use this License in a document you have written, include a copy of
-the License in the document and put the following copyright and
-license notices just after the title page:</para>
-      <programlisting>
-  Copyright (C)  <replaceable>year</replaceable>  <replaceable>your name</replaceable>.
-  Permission is granted to copy, distribute and/or modify this document
-  under the terms of the GNU Free Documentation License, Version 1.2
-  or any later version published by the Free Software Foundation;
-  with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-  Texts.  A copy of the license is included in the section entitled ``GNU
-  Free Documentation License''.
-</programlisting>
-      <para>If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
-replace the &ldquo;with&hellip;Texts.&rdquo; line with this:</para>
-      <programlisting>
-    with the Invariant Sections being <replaceable>list their titles</replaceable>, with
-    the Front-Cover Texts being <replaceable>list</replaceable>, and with the Back-Cover Texts
-    being <replaceable>list</replaceable>.
-</programlisting>
-      <para>If you have Invariant Sections without Cover Texts, or some other
-combination of the three, merge those two alternatives to suit the
-situation.</para>
-      <para>If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of
-free software license, such as the GNU General Public License,
-to permit their use in free software.</para>
-<!-- Local Variables: -->
-<!-- ispell-local-pdict: "ispell-dict" -->
-<!-- End: -->
-    </sect1>
-  </appendix>
-xreflabel="Index" id="Main-Index">
-    <para>Index
-This is the index of everything in this manual.  (Note that in some
-versions of the manual this is called &lsquo;<literal>Main Index</literal>&rsquo; to prevent it
-transforming into a page called <filename>index.html</filename> in the HTML version of
-the manual.  The complications that that caused were really odd.)</para>
-<tgroup>
-  <secondaryie>
-    <indexdiv>", see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>#, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>$, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>%, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>&amp;, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>', see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>+help, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>+mystery, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>+printflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>+traditional, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>+wimpmode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>,, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-@, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-b, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-c, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-d, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-F, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-f, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-g, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-H, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-h, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-help, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-hH, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-l, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-m, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-mystery, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-o, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-p, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-P, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-printflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-t, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-traditional, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-U, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-u, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-v, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-wimpmode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-x, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-X, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>-y, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>., see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>/, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>16 bit overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>32 bit overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>:, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>;, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>?, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>@, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>^, see </indexdiv></secondaryie></tgroup>
-<tgroup>A
-  <secondaryie>
-    <indexdiv>About this manual, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ABSTAIN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>abstain, at program start, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>abstain, during execution, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>ABSTAIN</literal>, nonexistent target, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ABSTAIN, self-abstaining, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>abstained state, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ABSTAINING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>add-without-carry, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>AGAIN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ampersand, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>and, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>and16, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>and32, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Arabic numberals, enabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>array, invalid dimension, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>array, out of bounds, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>array, wrong dimension, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>arrays, dimensioning, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>arrays, subscripting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>assigning to constants, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>assignment, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Atari syntax, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Atari, character set, see </indexdiv></secondaryie></tgroup>
-<tgroup>B
-  <secondaryie>
-    <indexdiv>backtracking, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Backtracking INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>backtracking, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>backtracking, enabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>backtracking, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>backtracking, out of memory, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Baudot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Baudot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>black lagoon, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>book, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>breakpoints, too many, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>bugs, reporting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>BUT, see </indexdiv></secondaryie></tgroup>
-<tgroup>C
-  <secondaryie>
-    <indexdiv>c, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C code, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C code, leaving in place, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C, stopping after C is generated, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C, within OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C-INTERCAL, distributing, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C-INTERCAL, I/O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C-INTERCAL, obtaining a copy, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C-INTERCAL, unpacking, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>C-INTERCAL, unzipping, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>c1&ndash;c9, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>calculate, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>CALCULATING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>calls, external, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>character sets, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>character sets, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>character sets, converting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>choicepoints, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>choicepoints, activating, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>choicepoints, creating, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>choicepoints, discarding, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>CLC-INTERCAL compatibility mode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>CLC-INTERCAL I/O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>clockface mode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>code generation, stopping at C code, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>COME FROM, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>COME FROM</literal>, ambiguity, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>COME FROM</literal>, multithreading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>COME FROM</literal>, no target, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>command line options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>COMMENT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>comment, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>COMMENTING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>COMMENTS, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>comments, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>compatibility, CLC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>compatibility, INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>compiling, <command>ick</command> itself, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>compiling, <acronym>INTERCAL</acronym> source code, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>config.sh, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>configdj.sh, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>configuring, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>connected threads, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>constant, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>constants, assigning to, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>controlled unary operator, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>converting between character sets, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>convickt, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>copying conditions, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>copyright, see </indexdiv></secondaryie></tgroup>
-<tgroup>D
-  <secondaryie>
-    <indexdiv>Debian, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debug options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, C code, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, flow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, internal errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, lexical analyser, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, multithreaded programs, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, optimizer, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, parser, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, runtime, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>debugging, yuk, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>dialect options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>dialects of syntax, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>dimensioning arrays, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>directory problems, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>directory problems, source file, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>distributing C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>DJGPP, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>DO, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>dormant thread, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>DOS, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>double-oh-seven, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>dumping core on error, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>duplicate line label, see </indexdiv></secondaryie></tgroup>
-<tgroup>E
-  <secondaryie>
-    <indexdiv>E000, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E017, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E079, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E099, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E111, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E123, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E127, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E127, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E129, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E139, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E182, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E197, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E200, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E222, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E240, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E241, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E252, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E256, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E256, avoiding, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E275, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E277, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E281, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E333, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E404, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E405, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E436, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E444, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E533, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E555, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E562, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E579, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E621, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E632, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E633, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E652, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E652, avoiding, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E666, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E774, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E774, disabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E777, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E778, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E778, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E810, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E811, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E888, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E991, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E993, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E995, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E997, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E999, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>E999, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ears, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ears, nesting limit, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>EBCDIC, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>embedded systems, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>end of file, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>environment variables, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>EOF, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>errors and warnings, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>examples, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>exclusive or, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>execution chance, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>exiting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>exor, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>expressions, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>expressions, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>external calls, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>external calls, to C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>extreme optimization, see </indexdiv></secondaryie></tgroup>
-<tgroup>F
-  <secondaryie>
-    <indexdiv>FDL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>flow control, INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>flow optimization, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>flow, printing, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>foreign functions, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>FORGET, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>FORGETTING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Free Documentation License, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>functions, OIL in C, see </indexdiv></secondaryie></tgroup>
-<tgroup>G
-  <secondaryie>
-    <indexdiv>generated programs, options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>GFDL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>GIVE UP, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>GNU Free Documentation License, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>GO AHEAD, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>GO AHEAD</literal>, no choicepoint, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>GO AHEAD</literal>, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>GO BACK, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>GO BACK</literal>, no choicepoint, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>GO BACK</literal>, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>goto, time-reversed, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>grouping rules, see </indexdiv></secondaryie></tgroup>
-<tgroup>H
-  <secondaryie>
-    <indexdiv>help with options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>hybrid, see </indexdiv></secondaryie></tgroup>
-<tgroup>I
-  <secondaryie>
-    <indexdiv>I/O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, Baudot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, CLC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, out of memory, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>I/O, PIC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, command line options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, errors and warnings, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, installing, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, invoking, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, not installating, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, uninstalling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, using without installation, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><command>ick</command>, warnings, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ick-0-28.tgz, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ick_ec.h, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ICK_EC_FUNC_END, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ICK_EC_FUNC_START, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ick_linelabel, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>idiom, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>idiom optimization, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><filename>idiotism.oil</filename>, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>IGNORE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>IGNORE</literal>/<literal>RETRIEVE</literal> interaction, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>IGNORING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>illegal array dimension, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>illegal line label value, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>illegal variable number, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>impossible reverse assignment, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>initial abstention, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, CLC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, EOF, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, in Arabic numerals, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>input, invalid, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, Debian, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, non-root, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, on DOS or Windows, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, simple, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, Ubuntu, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>installation, via autoconf and make, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>INTERCAL compilers, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>INTERCAL, syntax, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>INTERCAL-72 compatibility mode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>INTERCAL-72, I/O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>interleave, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>internal errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>internal errors, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>internal errors, dumping core, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>invalid array dimension, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>invalid line label value, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>invalid variable number, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>iselect, see </indexdiv></secondaryie></tgroup>
-<tgroup>L
-  <secondaryie>
-    <indexdiv>language-affecting options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Latin-1, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>lexical analyser, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>line label, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>line label, duplicate, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>line label, illegal value, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>line labels, C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>line number, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>live CD/USB stick, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>loops, entire program, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>loops, OIL, see </indexdiv></secondaryie></tgroup>
-<tgroup>M
-  <secondaryie>
-    <indexdiv>make, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>make install, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>makeick.bat, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>makeick.sh, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>making a live CD/USB stick, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>MAXTOFREE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>MAYBE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>MAYBE</literal>, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>mesh, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>microcontrollers, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>mingle, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>mingle, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, connected threads, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, enabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, out of memory, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>multithreading, separate threads, see </indexdiv></secondaryie></tgroup>
-<tgroup>N
-  <secondaryie>
-    <indexdiv>N'T, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>nesting limit, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>NEXT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>NEXT FROM, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>NEXT FROM</literal>, multithreading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>NEXT FROM</literal>, no target, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>NEXT stack, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>NEXT</literal>, nonexistent target, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>NEXT</literal>, stack overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>NEXTING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>no source file, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>non-INTERCAL-72 warning, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>non-root installation, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>NOT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>not installing, see </indexdiv></secondaryie></tgroup>
-<tgroup>O
-  <secondaryie>
-    <indexdiv>obtaining C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, basics, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, comments, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, example, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, execution, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, expressions, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, functions in C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, idiom groups, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, idioms, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, loops, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, operators, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, optimizing code, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, patterns, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, replacements, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, syntax, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>OIL, tips, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ONCE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>onespot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>onespot overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>onespot, overflow warning, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operand overloading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operand overloading, impossible, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operands, OIL, in patterns, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operands, OIL, in replacements, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operator, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>operators, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, control flow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, extreme, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, flow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, idioms, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimization, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Optimizer Idiom Language, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimizer options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>optimizer, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, debug, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, dialect, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, help, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, language-affecting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, optimizer, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, other, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, output, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, to generated programs, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>options, to <command>ick</command>, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>or, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>or16, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>or32, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>other languages, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>other languages, C, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>other options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of bounds, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of memory, backtracking, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of memory, during compile, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of memory, during <literal>STASH</literal>, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of memory, I/O, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>out of memory, multithreading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output options, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, C only, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, CLC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, in Arabic numerals, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>output, to standard output, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>overflow, over 16 bits, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>overflow, over 32 bits, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>overflow, over onespot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>overflow, over twospot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>overflow, warning, see </indexdiv></secondaryie></tgroup>
-<tgroup>P
-  <secondaryie>
-    <indexdiv>parser, debugging, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>patches, submitting, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>patterns, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>patterns, operands, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>PIC-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>PIC-INTERCAL, command line option, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>PIC-INTERCAL, unsupported command, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>PIN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>PIN</literal>, in a non-PIC program, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>PLEASE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>PLEASE</literal>, proportion required, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>politesse, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>portability, unary operators, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>positional precedence, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Princeton syntax, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Princeton syntax, option, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>profiling, see </indexdiv></secondaryie></tgroup>
-<tgroup>Q
-  <secondaryie>
-    <indexdiv>quitting, see </indexdiv></secondaryie></tgroup>
-<tgroup>R
-  <secondaryie>
-    <indexdiv>r, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>rabbit-ears, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>rabbit-ears, nesting limit, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>random bug, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>random bug, error message, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>READ OUT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>read-only variables, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>read-write variables, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>READING OUT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>REINSTATE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reinstate, at program start, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reinstate, during execution, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>REINSTATE, self-reinstating, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reinstated state, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>REINSTATING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>REINTSTATE</literal>, nonexistent target, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>releasing C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>REMEMBER, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>REMEMBERING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>replacements, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>replacements, operands, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reporting bugs, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>RESUME, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>RESUME</literal>, by 0, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>RESUMING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>RETRIEVE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>RETRIEVE</literal>, without stashing, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>RETRIEVE</literal>/<literal>IGNORE</literal> interaction, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>RETRIEVING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reverse assignment, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reverse assignment, error, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reverse assignment, impossible, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>reverse goto, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Roman numerals, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Roman numerals, disabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>runtime debugger, see </indexdiv></secondaryie></tgroup>
-<tgroup>S
-  <secondaryie>
-    <indexdiv>self-abstaining, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>self-reinstating, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>SENESTMAX, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>separate threads, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>setbitcount, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>sharkfin, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>sharkfin, in base 2, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>simple installation, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>skeleton file, directory problems, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>skeleton file, errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>slat, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>smudgeleft, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>smudgeright, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>spark, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>spark, nesting limit, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><filename>src/idiotism.oil</filename>, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stack overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stack, instruction pointer, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stack, NEXT, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stack, variable, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>standard output, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>STASH, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stash failure, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>stashes, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>STASHING, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>statement identifier, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>statements, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>statements, INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>SUB, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>submitting patches, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>subscripts, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>subtract-without-borrow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax error, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax error, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax error, serious, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, Atari, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, dialects, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, of OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, Princeton, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syntax, Princeton, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syslib, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syslib, directory problems, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>syslib, errors, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>system libary, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>system library, directory problems, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>system library, errors, see </indexdiv></secondaryie></tgroup>
-<tgroup>T
-  <secondaryie>
-    <indexdiv>tail, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>ternary, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Threaded INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, connected, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, dormant, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, in series, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, separate, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, unwoven, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>threading, woven, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>time-reversed goto, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>tips, OIL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>TriINTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>TriINTERCAL, operators in base 2, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>TRY AGAIN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>TRY AGAIN</literal>, not last, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>trying out <command>ick</command>, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Turing Tape, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>twospot, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>twospot overflow, see </indexdiv></secondaryie></tgroup>
-<tgroup>U
-  <secondaryie>
-    <indexdiv>Ubuntu, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unary binary logic, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unary operator, infix, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unary operator, prefix, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unary operators, portability, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>uninstalling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unpacking C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unwoven threads, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>unzipping C-INTERCAL, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>usage instructions, printing, see </indexdiv></secondaryie></tgroup>
-<tgroup>V
-  <secondaryie>
-    <indexdiv>V, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variable, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variable, illegal number, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, assignment, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, ignoring, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, limit, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, read-only, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, read-write, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, remembering, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>variables, stashes, see </indexdiv></secondaryie></tgroup>
-<tgroup>W
-  <secondaryie>
-    <indexdiv>W016, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W018, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W112, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W128, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W239, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W276, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W278, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W534, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>W622, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>warnings, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>warnings, enabling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>warnings, non-INTERCAL-72, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>what, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>WHILE, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv><literal>WHILE</literal>, not enabled, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>whirlpool, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>whirlpool, in base 2, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>wimpmode, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>Windows, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>woven threads, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>WRITE IN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>WRITING IN, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>wrong array dimension, see </indexdiv></secondaryie></tgroup>
-<tgroup>X
-  <secondaryie>
-    <indexdiv>x, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>x1&ndash;x9, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>xor, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>xor16, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>xor32, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>xselx, see </indexdiv></secondaryie></tgroup>
-<tgroup>Y
-  <secondaryie>
-    <indexdiv>yuk, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, breakpoint overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, command line option, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, commands, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, input overflow, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, profiling, see </indexdiv></secondaryie>
-  <secondaryie>
-    <indexdiv>yuk, too many breakpoints, see </indexdiv></secondaryie></tgroup></book><!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-indent-step:1
-sgml-indent-data:nil
-End:
--->

diff --git a/etc/splinttest.sh b/etc/splinttest.sh
deleted file mode 100755 (executable)
index 8860dcd..0000000
--- a/etc/splinttest.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#! /bin/sh
-[ -d ./src ] && cd src
-cd ../src
-echo '-*- compilation -*-' > ../splinttest.out
-splint -bugslimit 99 -redef -usevarargs +boolint +posixlib +voidabstract -I ../include -I ../temp `ls -1 *.c *.h | egrep -v 'wrap|pick|ick_ec'` >> ../splinttest.out

diff --git a/include/abcess.h b/include/abcess.h
index 15a9033eecde51c372a7954067e553579c61af03..e027d124d382cf24fb5d9033e3448104b855ba7c 100644 (file)
--- a/include/abcess.h
+++ b/include/abcess.h
@@ -97,6 +97,7 @@ extern int ick_mystery;
 
 /* AIS: More command-line options */
 extern int ick_wimp_mode;
+extern int ick_instapipe;
 
 /* AIS: Handle multiple COME FROMs aiming at the same line */
 extern int ick_multicome0(int errlineno, jmp_buf pc);
@@ -120,6 +121,20 @@ extern unsigned int ick_roll(unsigned int n);
 extern void ick_parseargs(int argc, char **argv);
 extern int ick_printflow;
 
+/* AIS: For the CREATE statement */
+typedef struct ick_tag_createdata ick_createdata;
+struct ick_tag_createdata
+{
+  int width;           /* 16 or 32 (maybe 0 will be allowed at some point) */
+  int isarray;         /* this and the previous determine what vartype it is */
+  unsigned short varnumber;
+                       /* 0 if not a variable, the var's number if it is */
+  ick_overop accessors;/* how to get and set this lvalue, or {0,0} */
+  unsigned long value; /* current value of the var or expression */
+};
+extern void ick_registercreation(char*,unsigned long);
+extern unsigned long ick_jicmatch(char*);
+
 /* AIS: Multithreading types and defines */
 #if MULTITHREAD != 0
 typedef struct tag_ickthread ickthread;
@@ -143,7 +158,7 @@ typedef struct tag_ickthread ickthread;
                   mechanism works.) This only applies to ickthreads that are
                   acting as choicepoints, not those acting as threads. */
   int ick_ccfc;  /* number of comefroms currently active */
-  unsigned ick_skipto; /* compucome line number */
+  long ick_skipto; /* compucome line number */
   jmp_buf ick_cjb; /* keeps track of compucomes */
   /*@partial@*/ /*@dependent@*/ ickthread* dsi; /* which thread's varforget and sb to use */
   /*@null@*/ /*@dependent@*/ ickthread* usesthis; /* for garbage collection purposes */
@@ -176,7 +191,7 @@ extern int hybridcount;
 extern int ick_oldabstain;
 extern int gonebackto;
 extern int ick_ccfc;
-extern unsigned ick_skipto;
+extern long ick_skipto;
 extern jmp_buf btjb;
 extern jmp_buf ick_cjb;
 
@@ -185,8 +200,8 @@ extern jmp_buf ick_cjb;
 #define MULTICOME ick_multicome0
 #endif /* MULTITHREAD */
 
-/* AIS: Used by the debugger, multithread code */
-#if (MULTITHREAD != 0) || (YUKDEBUG != 0)
+/* AIS: Used by the debugger, multithread code, external calls */
+#if (MULTITHREAD != 0) || (YUKDEBUG != 0) || defined(ICK_EC)
 extern ick_type16* ick_onespots;
 extern ick_bool* ick_oneforget;
 extern ick_type32* ick_twospots;

diff --git a/include/ick_ec.h b/include/ick_ec.h
index e8f5dd4ce0db78b6405297bbce543a0aaa194171..45f7cf201e6e0a2e3f0f83b2774ae6cfdec6574c 100644 (file)
--- a/include/ick_ec.h
+++ b/include/ick_ec.h
@@ -38,22 +38,27 @@ LICENSE TERMS
 
    To prevent this process running the program out of stack space (which would
    happen with a naive implementation if there were many COME FROMs from
-   inside the C program back to inside the C program), ick_checksuckpoint will
-   longjmp back to a previous incarnation of itself if doing so eliminates no
-   NEXT stack entries. This trick doesn't work with FORGET, though; instead
-   the stray C stack entries are eliminated at the next RESUME past them;
-   also, all but one of the entries can be eliminated at each line label if
-   there are more than one of them.
+   inside the C program back to inside the C program), all transitions but
+   NEXTs are done indirectly, by jumping back inside a relevant invocation of
+   ick_dogoto and changing its targets. (So effectively, to GOTO a particular
+   destination, you go back in time to the last time you NEXTed - or to
+   implement a FORGET, the last-but-n-time you NEXTed - and redo it with a
+   different target.)
 */
 
+#include <stdint.h>
+
 #define ICK_EC_FUNC_START(id)                    \
 ICK_EC_PP_0(id)                                  \
 void id(void)                                    \
 {                                                \
-  void* ick_local_rv = 0;                        \
+  void* ick_local_createdata =                   \
+    ick_global_createdata;                       \
   int ick_local_checkmode = ick_global_checkmode; \
-  jmp_buf ick_local_jmpbuf;                      \
-  setjmp(ick_local_jmpbuf);                      \
+  if(ick_global_checkmode==6)                    \
+  {                                              \
+    goto ick_l6_ICK_EC_PP_6;                     \
+  }                                              \
   if(ick_global_checkmode==2)                    \
   {                                              \
     goto ick_l2_ICK_EC_PP_2;                     \
@@ -63,39 +68,76 @@ void id(void)                                         \
   {                                              \
     goto ick_l1_ICK_EC_PP_1;                     \
   }                                              \
-  else
+  ick_local_checkmode=ick_global_checkmode=0;
 
 #define ick_linelabel(expr) ick_labeledblock(expr,0)
 
 #define ick_labeledblock(expr,block)                       \
   do {                                                     \
-    if(ick_forgetamount > 1)                               \
-    {                                                      \
-      ick_global_stackcleanup=1;                           \
-      ick_donext(expr,-1,1);                               \
-    }                                                      \
     if(0)                                                  \
     {                                                      \
     ick_l2_ICK_EC_PP_2: ;                                  \
       if(ick_global_linelabel != (expr) || (expr) > 65535)  \
        goto ick_l2_ICK_EC_PP_2;                            \
       ick_global_checkmode = 0;                                    \
-      if(ick_global_stackcleanup)                          \
-       ick_forget(1);                                      \
-      ick_global_stackcleanup = 0;                         \
     }                                                      \
     block ;                                                \
     ick_checksuckpoint(expr);                              \
   }                                                        \
   while(0)
 
+#define ick_linelabelnosp(expr)                                    \
+  do {                                                     \
+    if(0)                                                  \
+    {                                                      \
+    ick_l2_ICK_EC_PP_2: ;                                  \
+      if(ick_global_linelabel != (expr) || (expr) > 65535)  \
+       goto ick_l2_ICK_EC_PP_2;                            \
+      ick_global_checkmode = 0;                                    \
+    }                                                      \
+  }                                                        \
+  while(0)
+
+#define ick_linelabelnosp(expr)                                    \
+  do {                                                     \
+    if(0)                                                  \
+    {                                                      \
+    ick_l2_ICK_EC_PP_2: ;                                  \
+      if(ick_global_linelabel != (expr) || (expr) > 65535)  \
+       goto ick_l2_ICK_EC_PP_2;                            \
+      ick_global_checkmode = 0;                                    \
+    }                                                      \
+  }                                                        \
+  while(0)
+
+#define ick_forget(amount)                     \
+  do {                                         \
+    ick_scheduleforget(amount);                        \
+    ick_dogoto(ICK_EC_PP_3,-1,0);              \
+    ick_lose(IE778, -1, (char*) NULL);         \
+    return;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                \
+    if(ick_global_linelabel != ICK_EC_PP_3)    \
+      goto ick_l2_ICK_EC_PP_2;                 \
+    ick_global_checkmode = 0;                  \
+  } while(0)
+
+
+#define ick_startup(block)                     \
+  if(0)                                                \
+  {                                            \
+  ick_l6_ICK_EC_PP_6:                          \
+    block ;                                    \
+    goto ick_l6_ICK_EC_PP_6;                   \
+  }
+
 #define ick_comefrom(expr)                                      \
   if(0)                                                                 \
   {                                                             \
   ick_l1_ICK_EC_PP_1: ;                                                 \
     if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
     {                                                           \
-      if(ick_global_goto) ick_multicome0(-1,ick_local_jmpbuf);  \
+      if(ick_global_goto) ick_lose(ICK_IE555, -1, (char*)0);    \
       ick_global_goto = ICK_EC_PP_3;                            \
     }                                                           \
     goto ick_l1_ICK_EC_PP_1;                                    \
@@ -105,13 +147,33 @@ void id(void)                                       \
     ick_global_checkmode = 0;                                   \
   }
 
+#define ick_comefromif(expr,condition) \
+  ick_docomefromif(expr,-1,condition)
+
+#define ick_docomefromif(expr,lbl,condition)                    \
+  if(0)                                                                 \
+  {                                                             \
+  ick_l1_ICK_EC_PP_1: ;                                                 \
+    if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
+      if(condition)                                             \
+      {                                                                 \
+       if(ick_global_goto) ick_lose(ICK_IE555, lbl, (char*)0);  \
+       ick_global_goto = ICK_EC_PP_3;                           \
+      }                                                                 \
+    goto ick_l1_ICK_EC_PP_1;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                                 \
+    if(ick_global_linelabel != ICK_EC_PP_3)                     \
+      goto ick_l2_ICK_EC_PP_2;                                  \
+    ick_global_checkmode = 0;                                   \
+  }
+
 #define ick_nextfrom(expr)                                      \
   if(0)                                                                 \
   {                                                             \
   ick_l1_ICK_EC_PP_1: ;                                                 \
     if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
     {                                                           \
-      if(ick_global_goto) ick_multicome0(-1,ick_local_jmpbuf);  \
+      if(ick_global_goto) ick_lose(ICK_IE555, -1, (char*)0);    \
       ick_global_goto = ICK_EC_PP_3;                            \
       ick_global_checkmode = 3;                                         \
     }                                                           \
@@ -122,33 +184,108 @@ void id(void)                                      \
     ick_global_checkmode = 0;                                   \
   }
 
+#define ick_nextfromif(expr,condition) \
+  ick_docomefromif(expr,-1,condition)
+
+#define ick_donextfromif(expr,lbl,condition)                    \
+  if(0)                                                                 \
+  {                                                             \
+  ick_l1_ICK_EC_PP_1: ;                                                 \
+    if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
+      if(condition)                                             \
+      {                                                                 \
+       if(ick_global_goto) ick_lose(ICK_IE555, lbl, (char*)0);  \
+       ick_global_goto = ICK_EC_PP_3;                           \
+       ick_global_checkmode = 3;                                \
+      }                                                                 \
+    goto ick_l1_ICK_EC_PP_1;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                                 \
+    if(ick_global_linelabel != ICK_EC_PP_3)                     \
+      goto ick_l2_ICK_EC_PP_2;                                  \
+    ick_global_checkmode = 0;                                   \
+  }
+
+
 #define ICK_EC_FUNC_END                                \
   if(ick_local_checkmode) ick_resume(1);       \
 ick_l1_ICK_EC_PP_1: ;                          \
+ick_l6_ICK_EC_PP_6: ;                          \
 ick_l2_ICK_EC_PP_2: return;                    \
 }
 
 #define ick_next(label) do{                    \
     if((label)<=65535)                         \
-      ick_donext((label),-1,0);                        \
+      ick_dogoto((label),-1,1);                        \
+  } while(0)
+
+#define ick_goto(label) do{                    \
+    if((label)<=65535)                         \
+      ick_dogoto((label),-1,0);                        \
   } while(0)
 
 #define ick_resume(amount) ick_doresume((amount),-1)
 
 #define ick_return_or_resume() do{             \
-    ick_global_checkmode=5;                    \
+    if(ick_local_checkmode) ick_doresume(1,-1); \
     return;                                    \
   } while(0)
 
-/*@maynotreturn@*/ void ick_donext(unsigned long, int, int);
-void ick_forget(unsigned short amount);
-/*@noreturn@*/ void ick_doresume(unsigned short amount, int emitlineno);
-/*@maynortreturn@*/ void ick_checksuckpoint(unsigned long linelabel);
+/*@maynotreturn@*/ void ick_dogoto(unsigned long, int, int);
+void ick_scheduleforget(unsigned short);
+/*@noreturn@*/ void ick_doresume(unsigned short, int);
+/*@maynotreturn@*/ void ick_checksuckpoint(unsigned long);
+void ick_runstartups(void);
 
 void ick_allecfuncs(void); /* in generated program */
 
 extern int ick_global_checkmode;
-extern int ick_global_stackcleanup;
 extern unsigned long ick_global_linelabel;
 extern unsigned long ick_global_goto;
-extern int ick_forgetamount;
+extern void* ick_global_createdata;
+
+/* Variables. */
+typedef struct ick_ec_var_tag
+{
+  int ick_ec_vartype;
+  int ick_ec_extername;
+  int ick_ec_intername;
+} ick_ec_var;
+
+extern ick_ec_var ick_ec_vars[];
+
+#define ICK_EC_VARS_END 5
+
+uint16_t ick_getonespot(unsigned short);
+void ick_setonespot(unsigned short, uint16_t);
+uint32_t ick_gettwospot(unsigned short);
+void ick_settwospot(unsigned short, uint32_t);
+
+void ick_create(char*, unsigned long);
+
+/* For accessing the arguments to an ick_created command */
+int ick_c_i_width(int);
+int ick_c_i_isarray(int);
+unsigned short ick_c_i_varnumber(int);
+uint32_t ick_c_i_value(int);
+/* These require -a to work */
+uint32_t ick_c_i_getvalue(int);
+void ick_c_i_setvalue(int, uint32_t);
+
+#define ick_c_width(a) ick_c_i_width((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_isarray(a) ick_c_i_isarray((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_varnumber(a) ick_c_i_varnumber((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_value(a) ick_c_i_value((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_getvalue(a) ick_c_i_getvalue((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_setvalue(a,n) ick_c_i_setvalue((ick_global_createdata=ick_local_createdata,(a)),(n))
+
+/* Fragments of ick_lose.h, that don't impinge on unmangled namespace. */
+#define ICK_IE555 "555 FLOW DIAGRAM IS EXCESSIVELY CONNECTED\n\
+       ON THE WAY TO %d\n"
+#define ICK_IE778 "778 UNEXPLAINED COMPILER BUG\n\
+       ON THE WAY TO %d\n"
+
+extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s)
+#ifdef __GNUC__
+  __attribute__ ((noreturn))
+#endif
+;

diff --git a/include/ick_lose.h b/include/ick_lose.h
index 755b3e656ac6827b729dd84441625edac917736c..44165f12a7ae742965587c9cfb3862b431e9ac20 100644 (file)
--- a/include/ick_lose.h
+++ b/include/ick_lose.h
@@ -41,11 +41,11 @@
 /* An expression involves an unidentified variable. */
 #define IE200 "200 NOTHING VENTURED, NOTHING GAINED\n\
        ON THE WAY TO %d\n"
-/* An attempt has been made to give an ick_array a dimension of zero. */
+/* An attempt has been made to give an array a dimension of zero. */
 #define IE240 "240 ERROR HANDLER PRINTED SNIDE REMARK\n\
        ON THE WAY TO %d\n"
 /* Invalid dimensioning information was supplied
- * in defining or using an ick_array. */
+ * in defining or using an array. */
 #define IE241 "241 VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE\n\
        ON THE WAY TO %d\n"
 /* A 32-bit value has been assigned to a 16-bit variable. */
@@ -89,7 +89,7 @@
 /* Cannot find the magically included system library */
 #define IE127 "127 SAYING 'ABRACADABRA' WITHOUT A MAGIC WAND WON'T DO YOU ANY GOOD\n\
         ON THE WAY TO THE CLOSET\n"
-/* Out of ick_stash space */
+/* Out of stash space */
 #define IE222 "222 BUMMER, DUDE!\n\
        ON THE WAY TO %d\n"
 /* (AIS) Out of memory during I/O */
@@ -221,7 +221,7 @@
 /* (AIS) A line will inevitably cause an expression-reversal failure. */
 #define W278 "278 FROM A CONTRADICTION, ANYTHING FOLLOWS\n\
         ON THE WAY TO A HUGE DISASTER\n"
-       
+
 /* (AIS) The two following warnings are both compile-time traps for
    near-certain runtime errors. As such, they have similar numbers
    and similar messages. In fact, they're a shameless ripoff of the
@@ -237,7 +237,11 @@
 
 extern int ick_lineno;
 
-extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s);
+extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s)
+#ifdef __GNUC__
+  __attribute__ ((noreturn))
+#endif
+;
 
 extern void ick_lwarn(char *m, int n, /*@null@*/ char *s);
 

diff --git a/pit/CATALOG b/pit/CATALOG
index 9b8f0454ad02b6b45ac715631fdad1ef7f0375d3..cdb4a29e6319b77b88500765d47b054baa63e31c 100644 (file)
--- a/pit/CATALOG
+++ b/pit/CATALOG
@@ -128,6 +128,9 @@ by Alex Smith
   tests/whileadd.i    Adds two input numbers with a single WHILE statement\r
   tests/ignorret.i    Testing interactions of IGNORE and RETRIEVE\r
   tests/ignorret.doc  What ignorret does on several compilers\r
+  tests/normaldist.i  Checking the standard deviation of (1910)\r
+  tests/testcreate.i  A test for the CREATE statement\r
+  lib/syslibc.c              The INTERCAL base 2 syslib, optimised version in C\r
   sort.i              An insertion-sort program testing computed ABSTAIN\r
 \r
 by Malcom Ryan\r
@@ -135,6 +138,9 @@ by Malcom Ryan
   pass.i              A multithread program illustrating communications\r
                      between threads\r
 \r
+by Jeffrey Lee\r
+  interfunge.i        A Befunge-93 interpreter written in INTERCAL\r
+\r
 The programs test16bit.i, testarray.i, testcf.i, testlib2.i, mult.i,\r
 limits.{i,3i}, testops.{3i,5i}, testsplat.i, were all written by Louis\r
 Howell.  Of these, testcf.i might be considered an interesting\r

diff --git a/pit/lib/syslibc.c b/pit/lib/syslibc.c
new file mode 100644 (file)
index 0000000..4155fe1
--- /dev/null
+++ b/pit/lib/syslibc.c
@@ -0,0 +1,197 @@
+/*
+ * The INTERCAL system library, optimised version in C.
+ *
+ * This is provided as an example of how to write a C program
+ * that links to INTERCAL programs, to demonstrate the external
+ * call code.
+ *
+ * Written originally by Alex Smith, and released to the public
+ * domain. This library comes with NO WARRANTY.
+ */
+
+#include <ick_ec.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+/* This identifier name breaches the namespace rule that ick_ must be
+   avoided, but this library has to work with both other people's
+   INTERCAL programs and other people's C programs. So I've chosen an
+   identifier name which breaches the rules (so that it doesn't clash
+   with other people's C programs) but isn't used anywhere in the
+   compiler, and so doesn't clash with it either.
+*/
+
+static void errout(int routine, char* msg)
+{
+  fprintf(stderr,"C-INTERCAL system library: (%d): %s\n", routine, msg);
+  exit(EXIT_FAILURE);
+}
+
+ICK_EC_FUNC_START(ick_my_custom_syslib)
+{
+  register uint16_t os1, os2;
+  register uint32_t ts1, ts2;
+  static int seededyet = 0;
+
+  ick_linelabel(1000);
+  os1=ick_getonespot(1);
+  os2=ick_getonespot(2);
+  if(0xffff-os1<os2) errout(1000, "onespot overflow");
+  ick_setonespot(3,os1+os2);
+  ick_resume(1);
+  return; /* so the compiler knows the next line can't be reached from here */
+
+  ick_linelabel(1009);
+  os1=ick_getonespot(1);
+  os2=ick_getonespot(2);
+  ick_setonespot(4,1);
+  if(0xffff-os1<os2) ick_setonespot(4,2);
+  ick_setonespot(3,os1+os2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1010);
+  ick_setonespot(3,ick_getonespot(1)-ick_getonespot(2));
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1020);
+  ick_setonespot(1,ick_getonespot(1)+1U);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1030);
+  os1=ick_getonespot(1);
+  os2=ick_getonespot(2);
+  if(os1&&0xffff/os1<os2) errout(1030, "onespot overflow");
+  ick_setonespot(3,os1*os2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1039);
+  os1=ick_getonespot(1);
+  os2=ick_getonespot(2);
+  ick_setonespot(4,1);
+  if(os1&&0xffff/os1<os2) ick_setonespot(4,2);
+  ick_setonespot(3,os1*os2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1040);
+  os2=ick_getonespot(2);
+  if(!os2) errout(1040, "division by zero");
+  ick_setonespot(3,ick_getonespot(1)/os2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1050);
+  os1=ick_getonespot(1);
+  ts1=ick_gettwospot(1);
+  if(!os1) errout(1050, "division by zero");
+  ts1/=os1;
+  if(ts1>0xffffLU) errout(1050, "onespot overflow");
+  ick_setonespot(2,(uint16_t)ts1);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1500);
+  ts1=ick_gettwospot(1);
+  ts2=ick_gettwospot(2);
+  if(0xffffffffLU-ts1<ts2) errout(1500, "twospot overflow");
+  ick_settwospot(3,ts1+ts2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1509);
+  ts1=ick_gettwospot(1);
+  ts2=ick_gettwospot(2);
+  ick_setonespot(4,1);
+  if(0xffffffffLU-ts1<ts2) ick_setonespot(4,2);
+  ick_settwospot(3,ts1+ts2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1510);
+  ick_settwospot(3,ick_gettwospot(1)-ick_gettwospot(2));
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1520);
+  ick_settwospot(1,(((uint32_t)ick_getonespot(1))<<16)+ick_getonespot(2));
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1530);
+  ick_settwospot(1,ick_getonespot(1)*ick_getonespot(2));
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1540);
+  ts1=ick_gettwospot(1);
+  ts2=ick_gettwospot(2);
+  if(ts1&&0xfffffffflu/ts1<ts2) errout(1540, "twospot overflow");
+  ick_settwospot(3,ts1*ts2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1549);
+  ts1=ick_gettwospot(1);
+  ts2=ick_gettwospot(2);
+  ick_setonespot(4,1);
+  if(ts1&&0xfffffffflu/ts1<ts2) ick_setonespot(4,2);
+  ick_settwospot(3,ts1*ts2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1550);
+  ts2=ick_gettwospot(2);
+  if(!ts2) errout(1550, "division by zero");
+  ick_settwospot(3,ick_gettwospot(1)/ts2);
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1900);
+  if(!seededyet) srand(time(0));
+  seededyet=1;
+  ick_setonespot(1,rand()/(1+RAND_MAX/65536));
+  ick_resume(1);
+  return;
+
+  ick_linelabel(1910);
+  /* Here, we use the same algorithm as the original INTERCAL,
+     so as to produce similarly-distributed results.
+
+     If we add together 12 uniform random variables in the range #0 to
+     (.1 / 12), then the resulting random variable has a mean of (.1 /
+     2), and a variance of 12 times the original variance, which is
+     (((.1 * .1) / 144) / 12), giving a final variance of ((.1 * .1) /
+     144) and a final standard deviation of .1 / 12. */
+  if(!seededyet) srand(time(0));
+  seededyet=1;
+  os1=ick_getonespot(1);
+  os2 =rand()/(RAND_MAX/((os1   )/12));
+  os2+=rand()/(RAND_MAX/((os1+ 1)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 2)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 3)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 4)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 5)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 6)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 7)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 8)/12));
+  os2+=rand()/(RAND_MAX/((os1+ 9)/12));
+  os2+=rand()/(RAND_MAX/((os1+10)/12));
+  os2+=rand()/(RAND_MAX/((os1+11)/12));
+  ick_setonespot(2,os2);
+  ick_resume(1);
+  return;
+
+  /* Several existing INTERCAL programs rely on the routine (1001),
+     which is undocumented and therefore shouldn't be used. So as not
+     to break those programs, here it is: */
+  ick_linelabel(1001);
+  ick_resume(ick_getonespot(5));
+  return;
+
+}
+ICK_EC_FUNC_END

diff --git a/pit/lib/syslibc.doc b/pit/lib/syslibc.doc
new file mode 100644 (file)
index 0000000..764d699
--- /dev/null
+++ b/pit/lib/syslibc.doc
@@ -0,0 +1,29 @@
+Alex Smith, 26 March 2008
+
+syslibc.c is an example of a C program designed to be used with the
+INTERCAL external call code. It only attempts to emulate the base 2
+algorithms, but in a base 2 program it should be a valid drop-in
+replacement for the real system library.  (Don't forget to use the -eE
+options when linking this to an INTERCAL program; -e to allow C
+programs to be linked in, and -E to supress the 'real' syslib.)
+
+The library is designed foremost to ensure that all errors are checked
+(as they would be in the INTERCAL, although you get the error messages
+produced by C code), and secondarily for speed (it is substantially
+faster than the INTERCAL version of the system library, but that isn't
+particularly surprising).
+
+Note that some INTERCAL programs rely on undocumented features of the
+system library; I have implemented the commonly-used (1001), but some
+of the example programs (for instance primes.i) NEXT to other
+undocumented internal lines of syslib.i, and such programs will error
+out on the C version of the syslib.
+
+There are some situations in which the C program will cause errors,
+but the INTERCAL version wouldn't; remember that any attempt to alter
+or view an INTERCAL variable from C code causes an error if that
+variable doesn't exist in the INTERCAL program. Therefore, in order to
+use a particular routine, you should mention all the variables that
+are its inputs and outputs somewhere in your INTERCAL program; in
+particular, if you're using overflow-checked routines, make sure you
+mention .4 at least once in your program.

diff --git a/pit/tests/normaldist.i b/pit/tests/normaldist.i
new file mode 100644 (file)
index 0000000..b1dbb4a
--- /dev/null
+++ b/pit/tests/normaldist.i
@@ -0,0 +1,28 @@
+       PLEASE NOTE that this program checks the routine 1910 and calculates
+       its standard deviation; the output values should quickly converge to
+       around #10000 if that routine correctly follows the manual.
+       DO :3 <- #0
+       PLEASE DO .6 <- #0
+       DO COME FROM (20)
+       DO .1 <- #1200
+       DO (1910) NEXT
+       DO .1 <- #600
+(5)     DO (1010) NEXT
+       DO .1 <- .2
+       DO .2 <- #600
+       DO (1010) NEXT
+       DO COME FROM '.3~#2048'$#3
+       DO .1 <- .3
+       PLEASE DO .2 <- .3
+       DO (1530) NEXT
+       DO :2 <- :3
+       DO (1500) NEXT
+       DO .1 <- .6
+       PLEASE DO (1020) NEXT
+       DO .6 <- .1
+       DO :1 <- :3
+       DO :2 <- .1
+       PLEASE DO (1550) NEXT
+       DO READ OUT :3
+       DO :3 <- :1
+(20)   PLEASE DO NOTHING

diff --git a/pit/tests/testcreate.i b/pit/tests/testcreate.i
new file mode 100644 (file)
index 0000000..505549d
--- /dev/null
+++ b/pit/tests/testcreate.i
@@ -0,0 +1,13 @@
+       DO .3 <- #5
+       DO .4 <- #6
+       DO CREATE (5) SWITCH .1 WITH .2
+       DO SWITCH .3 WITH .4
+       DO READ OUT .3
+       DO READ OUT .4
+       PLEASE GIVE UP
+(5)    PLEASE STASH :1
+       DO :1 <- :1601
+       DO :1601 <- :1602
+       DO :1602 <- :1
+       DO RETRIEVE :1
+       PLEASE RESUME #1

diff --git a/splinttest.out b/splinttest.out
deleted file mode 120000 (symlink)
index 1d9c63f..0000000
--- a/splinttest.out
+++ /dev/null
@@ -1 +0,0 @@
-src/splinttest.out
\ No newline at end of file

diff --git a/src/abcess.h b/src/abcess.h
index 15a9033eecde51c372a7954067e553579c61af03..ba240912e48b122a51bef25eb19d89863e807581 100644 (file)
--- a/src/abcess.h
+++ b/src/abcess.h
@@ -97,6 +97,7 @@ extern int ick_mystery;
 
 /* AIS: More command-line options */
 extern int ick_wimp_mode;
+extern int ick_instapipe;
 
 /* AIS: Handle multiple COME FROMs aiming at the same line */
 extern int ick_multicome0(int errlineno, jmp_buf pc);
@@ -116,10 +117,28 @@ extern void ick_retrieve(void *to, unsigned int type, unsigned int index,
                         ick_bool forget, ick_overop* oo);
 extern unsigned int ick_roll(unsigned int n);
 
+/* AIS: Lose with IE277 */
+extern ick_type32 ick_ieg277(ick_type32);
+extern void ick_ies277(ick_type32, void(*)());
+
 /* defined in arrgghh.c */
 extern void ick_parseargs(int argc, char **argv);
 extern int ick_printflow;
 
+/* AIS: For the CREATE statement */
+typedef struct ick_tag_createdata ick_createdata;
+struct ick_tag_createdata
+{
+  int width;           /* 16 or 32 (maybe 0 will be allowed at some point) */
+  int isarray;         /* this and the previous determine what vartype it is */
+  unsigned short varnumber;
+                       /* 0 if not a variable, the var's number if it is */
+  ick_overop accessors;/* how to get and set this lvalue, or {0,0} */
+  unsigned long value; /* current value of the var or expression */
+};
+extern void ick_registercreation(char*,unsigned long);
+extern unsigned long ick_jicmatch(char*);
+
 /* AIS: Multithreading types and defines */
 #if MULTITHREAD != 0
 typedef struct tag_ickthread ickthread;
@@ -143,7 +162,7 @@ typedef struct tag_ickthread ickthread;
                   mechanism works.) This only applies to ickthreads that are
                   acting as choicepoints, not those acting as threads. */
   int ick_ccfc;  /* number of comefroms currently active */
-  unsigned ick_skipto; /* compucome line number */
+  long ick_skipto; /* compucome line number */
   jmp_buf ick_cjb; /* keeps track of compucomes */
   /*@partial@*/ /*@dependent@*/ ickthread* dsi; /* which thread's varforget and sb to use */
   /*@null@*/ /*@dependent@*/ ickthread* usesthis; /* for garbage collection purposes */
@@ -176,7 +195,7 @@ extern int hybridcount;
 extern int ick_oldabstain;
 extern int gonebackto;
 extern int ick_ccfc;
-extern unsigned ick_skipto;
+extern long ick_skipto;
 extern jmp_buf btjb;
 extern jmp_buf ick_cjb;
 
@@ -185,8 +204,8 @@ extern jmp_buf ick_cjb;
 #define MULTICOME ick_multicome0
 #endif /* MULTITHREAD */
 
-/* AIS: Used by the debugger, multithread code */
-#if (MULTITHREAD != 0) || (YUKDEBUG != 0)
+/* AIS: Used by the debugger, multithread code, external calls */
+#if (MULTITHREAD != 0) || (YUKDEBUG != 0) || defined(ICK_EC)
 extern ick_type16* ick_onespots;
 extern ick_bool* ick_oneforget;
 extern ick_type32* ick_twospots;

diff --git a/src/arrgghh.c b/src/arrgghh.c
index 5812118fa5b603c24bbc2c3b9ebac1a83147badc..c2caa95c3baae624703e34a1e155fc8b1e3ec51f 100644 (file)
--- a/src/arrgghh.c
+++ b/src/arrgghh.c
@@ -33,6 +33,7 @@ LICENSE TERMS
 int ick_traditional = 0;
 /*@=redef@*/
 int ick_wimp_mode = 0;
+int ick_instapipe = 0; /* AIS */
 int ick_printflow = 0; /* AIS */
 int ick_mystery = 0; /* AIS */
 
@@ -47,6 +48,7 @@ ick_parseargs(int argc, char **argv)
        "help",
        "wimpmode",
        "traditional",
+       "instapipe", /* AIS */
        "printflow", /* AIS */
        "mystery", /* AIS */
       };
@@ -54,6 +56,7 @@ ick_parseargs(int argc, char **argv)
        &helpflag,
        &ick_wimp_mode,
        &ick_traditional,
+       &ick_instapipe, /* AIS */
        &ick_printflow, /* AIS */
        &ick_mystery, /* AIS */
       };

diff --git a/src/cesspool.c b/src/cesspool.c
index 283c53e9c62030a8f7fa089da4aaa02be0a3cd40..fc91cd99240bdc6dbafc3b0c07fed8887077a94f 100644 (file)
--- a/src/cesspool.c
+++ b/src/cesspool.c
@@ -464,6 +464,7 @@ static void clcbinout(unsigned int type, ick_array* a)
   while(i--) if(tempcp[i] == '\0') tempcp[i]='\x1a';
   if(!ick_cesspoolout) ick_cesspoolout=stdout;
   fprintf(ick_cesspoolout,"%s\n",tempcp);
+  fflush(ick_cesspoolout);
   free(tempcp);
   free(buf);
 }
@@ -490,7 +491,8 @@ void ick_binin(unsigned int type, ick_array *a, ick_bool forget)
   if(ick_clcsem) {clcbinin(type, a, forget); return;} /* AIS */
 
   for (i = 0 ; i < a->dims[0] ; i++) {
-    v = ((c=fgetc(ick_cesspoolin)) == EOF) ? 256 : (c - lastin) % 256;
+    v = ((c=fgetc(ick_cesspoolin)) == EOF) ? 256 :
+      ((unsigned)c - lastin) % 256;
     lastin = c;
     if (!forget) {
       if (type == ick_TAIL)
@@ -524,7 +526,7 @@ void ick_binout(unsigned int type, ick_array *a)
     c = (c & 0x33) << 2 | (c & 0xcc) >> 2;
     c = (c & 0x55) << 1 | (c & 0xaa) >> 1;
     (void) fputc((int)c,ick_cesspoolout);
-    if (c == 10 /* \n in INTERCAL */)
+    if (c == 10 /* \n in INTERCAL */ || /* AIS */ ick_instapipe)
       (void) fflush(ick_cesspoolout);
   }
 }
@@ -859,4 +861,74 @@ int ick_multicome0(int errlineno, jmp_buf pc)
   /*@=unreachable@*/
 }
 
+/**********************************************************************
+ *
+ * AIS: The next two functions are mine, and handle CREATE statements.
+ *
+ **********************************************************************/
+
+struct ick_jictype
+{
+  /*@observer@*/ char* sig; /* a shallow copy of a constant string */
+  unsigned long target;
+  /*@null@*/ /*@only@*/ struct ick_jictype* next;
+};
+
+/*@null@*/ /*@only@*/ static struct ick_jictype* jiclist = NULL;
+
+/* Return a jic entry that matches the requested signature exactly,
+   creating one if there isn't one yet. */
+static struct ick_jictype* jicextract(/*@observer@*/ char* sig)
+{
+  struct ick_jictype* jicptr = jiclist;
+  while(jicptr)
+  {
+    if(strcmp(jicptr->sig,sig)==0) return jicptr;
+    if(jicptr->next != NULL) jicptr = jicptr->next;
+    else break;
+  }
+  if(!jicptr)
+  {
+    jiclist=malloc(sizeof *jiclist);
+    jicptr=jiclist;
+  }
+  else
+  {
+    jicptr->next=malloc(sizeof *jiclist);
+    jicptr=jicptr->next;
+  }
+  jicptr->next = NULL;
+  jicptr->sig = sig;
+  jicptr->target = 0;
+  return jicptr;
+}
+
+void ick_registercreation(char* sig, unsigned long target)
+{
+  jicextract(sig)->target=target;
+}
+
+unsigned long ick_jicmatch(char* sig)
+{
+  return jicextract(sig)->target;
+}
+
+/* AIS: Used by the JIC code to error out when attempting to access an array */
+ick_type32 ick_ieg277(ick_type32 ignored)
+{
+  /*@-noeffect@*/
+  (void) ignored;
+  /*@=noeffect@*/
+  ick_lose(IE277, ick_lineno, (char*) NULL);
+}
+
+void ick_ies277(ick_type32 ignored, void(*ignored2)())
+{
+  /*@-noeffect@*/
+  (void) ignored;
+  (void) ignored2;
+  /*@=noeffect@*/
+  ick_lose(IE277, ick_lineno, (char*) NULL);
+}
+
 /* cesspool.c ends here */

diff --git a/src/feh.h b/src/feh.h
index a1ba33af1db93c240b7d05802283c59e2e0b7a9e..4424b6efddd10f3c4f3dcbe3c2da45a283339588 100644 (file)
--- a/src/feh.h
+++ b/src/feh.h
@@ -32,4 +32,6 @@ extern char **enablers; /* AIS: so that there can be an element before the
                           -1, just to cause a bit more confusion) */
 extern assoc vartypes[];
 
+extern int useprintflow; /* AIS */
+
 /* feh.h ends here */

diff --git a/src/feh2.c b/src/feh2.c
index c0ec32e23a063faa622c857a7063c18ad361a93a..0442fdde4bb76a8bf9ce075b6791f43c124189c6 100644 (file)
--- a/src/feh2.c
+++ b/src/feh2.c
@@ -305,7 +305,7 @@ void typecast(node *np)
     else if (np->opcode == SELECT)
        np->width = np->rval->width;    /* n-bit select has an n-bit result */
     else if (np->opcode == SUB)
-       np->width = np->lval->width;    /* type of the ick_array */
+       np->width = np->lval->width;    /* type of the array */
     else if (np->opcode == SLAT || np->opcode == BACKSLAT)
       np->width = np->lval->width; /* AIS: \ and / return their left arg */
     /*@=nullderef@*/
@@ -369,6 +369,9 @@ void codecheck(void)
              if(notpast1900) coopt = 0;
            }
 
+           if (tp->u.target > 65535 && !tp->preproc) /* AIS */
+             ick_lose(IE197, tp - tuples + 1, (char*) NULL);
+
            for (up = tuples; up < tuples + ick_lineno; up++)
                if (tp->u.target == up->label)
                {
@@ -380,12 +383,16 @@ void codecheck(void)
            {
              /* AIS: Added the pickcompile check. Syslib has to be optimized
                 for PICs, so syslib.i isn't imported and so none of the lables
-                in it will appear in the program. */
-               if (tp->type == NEXT &&
+                in it will appear in the program. Also added the useickec
+                check, as that's another legitimate way for a NEXT to target
+                a nonexistent line label */
+               if (tp->type == NEXT && !useickec &&
                    (!pickcompile||tp->u.target<1000||tp->u.target>1999))
                    ick_lose(IE129, tp - tuples + 1, (char *)NULL);
                else if (tp->type == NEXT) /* AIS */
                {tp->nexttarget=0; continue;}
+               else if (useickec) /* AIS */
+                 continue;
                /* AIS: NEXTFROMLABEL's basically identical to COME_FROM */
                else if (tp->type == COME_FROM || tp->type == NEXTFROMLABEL)
                    ick_lose(IE444, tp - tuples + 1, (char *)NULL);
@@ -477,6 +484,7 @@ char *enablersm1[MAXTYPES+1] =
     "PREPROC", /* AIS: Nonexistent statement */
     "WHILE", /* AIS: statement WHILE statement */
     "TRY_AGAIN", /* AIS: Added TRY AGAIN */
+    "CREATE", /* AIS */
     "FROM", /* AIS: ABSTAIN expr FROM LABEL */
 };
 char** enablers = enablersm1+1;
@@ -509,6 +517,16 @@ assoc varstores[] =
     { 0,       (char *)NULL }
 };
 
+/* AIS: A demangled version */
+static assoc varstoresdem[] =
+{
+    { ick_ONESPOT,     "onespots" },
+    { ick_TWOSPOT,     "twospots" },
+    { ick_TAIL,        "tails" },
+    { ick_HYBRID,      "hybrids" },
+    { 0,       (char *)NULL }
+};
+
 static assoc typedefs[] =
 {
     { ick_ONESPOT,     "ick_type16" },
@@ -535,7 +553,8 @@ static assoc typedefs[] =
    explain ('e') command works. It's also included in the degenerated C
    code when the option -c is used, so the person looking at the code can
    debug both the INTERCAL and ick itself more effectively, and used by
-   -h to produce its optimizer-debug output. */
+   -h to produce its optimizer-debug output, and used to produce the variable
+   numbers used in ick_createdata. */
 
 unsigned long varextern(unsigned long intern, int vartype)
 {
@@ -1498,6 +1517,103 @@ void prexpr(node *np, FILE *fp, int freenode)
 }
 /*@=temptrans@*/ /*@=onlytrans@*/ /*@=compdestroy@*/ /*@=branchstate@*/
 
+/* By AIS: Helper function for prunknown */
+static int prunknownstr(node *np, FILE* fp)
+{
+  int i;
+  switch(np->opcode)
+  {
+  case INTERSECTION:
+    i=prunknownstr(np->lval, fp);
+    i+=prunknownstr(np->rval, fp);
+    return i;
+  case US_ID: (void) fputc((char)np->constant, fp); return 0;
+  case US_ELEM: (void) fputc(';', fp); return 1;
+  case US_SCALAR: (void) fputc('.', fp); return 1;
+  case US_ARRVAR: (void) fputc(',', fp); return 1;
+  case US_EXPR: (void) fputc('~', fp); return 1;
+  default: ick_lose(IE778, emitlineno, (char*) NULL);
+  }
+  /*@-unreachable@*/ return 0; /*@=unreachable@*/
+}
+
+/* By AIS: Helper function for prunknown */
+static void prunknowncreatedata(node *np, FILE* fp)
+{
+  unsigned long ve;
+  switch(np->opcode)
+  {
+  case INTERSECTION:
+    prunknowncreatedata(np->lval, fp);
+    prunknowncreatedata(np->rval, fp);
+    return;
+  case US_ID: return; /* nothing to do */
+  case US_SCALAR:
+    ve=varextern(np->rval->constant,np->rval->opcode);
+    fprintf(fp,"\t\t{%d,0,%lu,",np->rval->width,ve);
+    break;
+  case US_ARRVAR: /* an array doesn't itself have a value */
+    ve=varextern(np->rval->constant,np->rval->opcode);
+    fprintf(fp,"\t\t{%d,1,%lu,{ick_ieg277,ick_ies277},0},\n",np->rval->width,ve);
+    return;
+  case US_ELEM: /* these two cases are actually treated the same way, */
+  case US_EXPR: /* because expressions can be assigned to */
+    fprintf(fp,"\t\t{%d,0,0,",np->rval->width);
+    break;
+  default: ick_lose(IE778, emitlineno, (char*) NULL);
+  }
+  if(createsused)
+    fprintf(fp,"{ick_og%lx,ick_os%lx},",(unsigned long)np,(unsigned long)np);
+  else
+    fprintf(fp,"{0,0},");
+  prexpr(np->rval,fp,0);
+  fprintf(fp,"},\n");
+}
+
+/* This function by AIS. Print a check to see if a just-in-case compiled
+   statement actually has a meaning yet, or if we should error. */
+static void prunknown(node *np, FILE* fp)
+{
+  static long negcounter=-65538;
+  int i,j;
+  fprintf(fp,"\tif((ick_skipto=ick_jicmatch(\"");
+  i=prunknownstr(np, fp);
+  fprintf(fp, "\")))\n\t{\n\t    ick_createdata icd[]={\n");
+  prunknowncreatedata(np, fp);
+  fprintf(fp, "\t    };\n");
+  if(createsused)
+  {
+    j=i;
+    while(j--)
+      (void) fprintf(fp, "\t\t""ICKSTASH(ick_TWOSPOT, %lu, "
+                    "ick_twospots, ick_oo_twospots);\n"
+                    "\t\t""ick_oo_twospots[%lu]=icd[%d].accessors;\n",
+                    intern(ick_TWOSPOT,1601+j),
+                    intern(ick_TWOSPOT,1601+j),j);
+  }
+  if(useickec)
+  {
+    fprintf(fp,"\t\t""ick_global_createdata=icd;\n");
+    fprintf(fp,"\t\t""ick_dogoto(ick_skipto,ick_lineno,1);\n");
+  }
+  else
+  {
+    fprintf(fp,"\t\t""ick_pushnext(%ld); ick_skipto=-ick_skipto; goto top; "
+           "case %ld:;\n",negcounter,negcounter);
+    negcounter--;
+  }
+  if(createsused)
+  {
+    j=i;
+    while(j--)
+      (void) fprintf(fp, "\t\t""ICKRETRIEVE(ick_twospots, %lu, "
+                    "ick_TWOSPOT, ick_twoforget, ick_oo_twospots);\n",
+                    intern(ick_TWOSPOT,1601+j));
+
+  }
+  fprintf(fp, "\t} else\n");
+}
+
 /*@dependent@*/ static char *nice_text(char *texts[], int lines)
 {
 #define MAXNICEBUF     512
@@ -1617,10 +1733,10 @@ void emit(tuple *tn, FILE *fp)
     if (tn->label)
     {
       if(!useickec) /* AIS */
-       (void) fprintf(fp, "L%u:", tn->label);
+       (void) fprintf(fp, "case -%u: ; L%u:\n", tn->label, tn->label);
       else
        /* AIS: start one of ick_ec's labeled blocks. */
-       (void) fprintf(fp, "ick_labeledblock(%uU,({",tn->label);
+       (void) fprintf(fp, "ick_labeledblock(%uU,{",tn->label);
     }
     if (yydebug || compile_only)
     {
@@ -1904,7 +2020,7 @@ void emit(tuple *tn, FILE *fp)
       /* AIS: if using ickec, use its features for the next */
       if(useickec)
       {
-       (void) fprintf(fp,"\t""ick_donext(%uU,ick_lineno,0);\n",tn->u.target);
+       (void) fprintf(fp,"\t""ick_dogoto(%uU,ick_lineno,1);\n",tn->u.target);
        break;
       }
       /* Start of AIS optimization */
@@ -1976,10 +2092,10 @@ void emit(tuple *tn, FILE *fp)
                           nameof(np->opcode, varstores),
                           /* AIS */(opoverused&&(np->opcode==ick_ONESPOT||
                                                  np->opcode==ick_TWOSPOT)?
-                          "oo_":"0"),
+                          "ick_oo_":"0"),
                           /* AIS */(opoverused&&(np->opcode==ick_ONESPOT||
                                                  np->opcode==ick_TWOSPOT)?
-                          nameof(np->opcode, varstores):"0"));
+                          nameof(np->opcode, varstoresdem):"0"));
        break;
 
     case RETRIEVE:
@@ -1990,10 +2106,10 @@ void emit(tuple *tn, FILE *fp)
                           nameof(np->opcode, forgetbits),
                           /* AIS */(opoverused&&(np->opcode==ick_ONESPOT||
                                                  np->opcode==ick_TWOSPOT)?
-                          "oo_":"0"),
+                          "ick_oo_":"0"),
                           /* AIS */(opoverused&&(np->opcode==ick_ONESPOT||
                                                  np->opcode==ick_TWOSPOT)?
-                          nameof(np->opcode, varstores):"0"));
+                          nameof(np->opcode, varstoresdem):"0"));
 
        break;
 
@@ -2146,7 +2262,7 @@ void emit(tuple *tn, FILE *fp)
                             "\t""    if (linetype[i] == %s)\n", enablers[np->constant-GETS]);
            }
            (void) fprintf(fp,
-                          "\t""\tabstained[i] += j;\n");
+                          "\t""\tick_abstained[i] += j;\n");
        }
        break;
 
@@ -2161,22 +2277,26 @@ void emit(tuple *tn, FILE *fp)
       {
        if(tn->type == COMPUCOME)
        {
-         fprintf(fp,"\t""ick_comefrom(");
+         fprintf(fp,"\t""ick_docomefromif(");
          prexpr(tn->u.node, fp, 1);
-         fprintf(fp,");\n");
+         fprintf(fp,",ick_lineno,({int i=0;");
+         emit_guard(tn,fp); /* re-emit the guard */
+         fprintf(fp,"i=1;};i;}));\n");
          break;
        }
        else if(tn->type == NEXTFROMEXPR)
        {
-         fprintf(fp,"\t""ick_nextfrom(");
+         fprintf(fp,"\t""ick_donextfromif(");
          prexpr(tn->u.node, fp, 1);
-         fprintf(fp,");\n");
+         fprintf(fp,",ick_lineno,({int i=0;");
+         emit_guard(tn,fp); /* re-emit the guard */
+         fprintf(fp,"i=1;};i;}));\n");
          break;
        }
       }
       fprintf(fp,"\t""%s;} else goto CCF%d;\n",
-             multithread?"NEXTTHREAD":
-             "if(ick_printflow) printf(\"[%d]\",ick_lineno)",
+             multithread?"NEXTTHREAD":useprintflow?
+             "if(ick_printflow) printf(\"[%d]\",ick_lineno)":"",
              compucomecount);
       break;
 
@@ -2327,6 +2447,19 @@ void emit(tuple *tn, FILE *fp)
       (void) fprintf(fp,"(TRISB<<24) | (TRISA<<16) | (PORTB<<8) | PORTA;\n");
       break;
 
+    case CREATE: /* By AIS */
+      if(createsused == 0) goto splatme;
+      (void) fprintf(fp,"\t""ick_registercreation(\"");
+      prunknownstr(tn->u.node, fp);
+      (void) fprintf(fp,"\",%uU);\n",tn->u.target);
+      break;
+
+    case UNKNOWN: /* By AIS */
+      /* We generate a check to see if the unknown statement has gained a
+        meaning since it was compiled, or otherwise continue to the splattered
+        case. Not for PIC-INTERCAL, though. */
+      if(!pickcompile) prunknown(tn->u.node, fp);
+      /*@fallthrough@*/
     case SPLATTERED:
       /* AIS: The code previously here could access unallocated memory due to
         a bug if the comment was a COME FROM target. The problem is that
@@ -2334,6 +2467,7 @@ void emit(tuple *tn, FILE *fp)
         this one, but not always, and in this case the line after this one is
         always what we want, so I copied the relevant part of the emitlineno
         logic here to fix the bug. */
+    splatme:
       if (tn < tuples + ick_lineno - 1)
        dim = tn[1].ick_lineno - tn->ick_lineno;
       else
@@ -2354,14 +2488,26 @@ void emit(tuple *tn, FILE *fp)
       if(useickec) /* AIS */
       {
        if(tn->type == COME_FROM)
-         fprintf(fp, "\t""ick_comefrom(%u);\n", tn->u.target);
-       else
-         fprintf(fp, "\t""ick_nextfrom(%u);\n", tn->u.target);
-       break;
+       {
+         fprintf(fp,"\t""ick_docomefromif(%uU,ick_lineno,({int i=0;",
+                 tn->u.target);
+         emit_guard(tn,fp); /* re-emit the guard */
+         fprintf(fp,"i=1;};i;}));\n");
+         break;
+       }
+       else /* (tn->type == NEXTFROMLABEL) */
+       {
+         fprintf(fp,"\t""ick_donextfromif(%uU,ick_lineno,({int i=0;",
+                 tn->u.target);
+         emit_guard(tn,fp); /* re-emit the guard */
+         fprintf(fp,"i=1;};i;}));\n");
+         break;
+       }
       }
        (void) fprintf(fp, "if(0) {C%ld: %s;%s}\n", (long)(tn-tuples+1),
                       tn->type==NEXTFROMLABEL ? "ick_pushnext(truelineno+1)":"",
-                      multithread?" NEXTTHREAD;":" if(ick_printflow) printf(\"[%d]\",ick_lineno);");
+                      multithread?" NEXTTHREAD;":!useprintflow?""
+                      :" if(ick_printflow) printf(\"[%d]\",ick_lineno);");
        /* AIS: Changed so all COME_FROMs have unique labels even if two
           of them aim at the same line, and added the NEXT FROM case (which
           involves hiding COME FROM labels in an unreachable if()). */
@@ -2424,7 +2570,7 @@ void emit(tuple *tn, FILE *fp)
     /* AIS: The ickec version is very simple! We just finish the labeled
        block started at the start of the command. */
     if(tn->label && useickec)
-      (void) fprintf(fp, "}));\n");
+      (void) fprintf(fp, "});\n");
 
     /* AIS: We need to keep track of how many COME FROMs are aiming here
        at runtime, if we don't have the very simple situation of no
@@ -2511,11 +2657,11 @@ void emit(tuple *tn, FILE *fp)
     /* AIS: Now we've finished the statement, let's switch to the next
        thread in a multithread program. */
     if(multithread) (void) fputs("    NEXTTHREAD;\n", fp);
-    else
+    else if(useprintflow)
       (void) fputs("    if(ick_printflow) printf(\"[%d]\",ick_lineno);\n",fp);
 }
 
-/* AIS: Generate prototypes for slat expressions */
+/* AIS: Generate prototypes for slat expressions, args to UNKNOWN */
 void emitslatproto(FILE* fp)
 {
   node* np=firstslat;
@@ -2528,7 +2674,7 @@ void emitslatproto(FILE* fp)
   }
 }
 
-/* AIS: Generate bodies for slat expressions */
+/* AIS: Generate bodies for slat expressions, args to UNKNOWN */
 void emitslat(FILE* fp)
 {
   node* np=firstslat;

diff --git a/src/ick-wrap.c b/src/ick-wrap.c
index a83c64c9b489e2b53e1baa1e6f7d46ea21970886..f03e889e90c600cd64e998d6220740e61b8e8617 100644 (file)
--- a/src/ick-wrap.c
+++ b/src/ick-wrap.c
@@ -30,7 +30,7 @@ int ick_lineno;
 
 jmp_buf ick_cjb;
 int ick_ccfc;
-unsigned ick_skipto=0;
+long ick_skipto=0;
 $O
 char* ick_globalargv0;
 int ick_oldabstain;
@@ -48,7 +48,7 @@ int main(int argc, char *argv[])
 
     ick_next = calloc(80, sizeof *ick_next);
 #ifdef ICK_EC
-    ick_next_jmpbufs = malloc(80 * sizeof *ick_next_jmpbufs);
+    ick_next_jmpbufs = malloc(81 * sizeof *ick_next_jmpbufs);
 #endif
 $N
     ick_globalargv0=argv[0];
@@ -74,14 +74,16 @@ $N
 
     $F
 
-      /* degenerated code */
 #ifdef ICK_EC
-    ick_main();
+    ick_runstartups();
+    ick_next(0);
 }
 
 ICK_EC_FUNC_START(ick_main)
 {
+  ick_linelabelnosp(0);
 #endif
+      /* degenerated code */
  ick_restart:
  top:
     switch(ick_skipto)

diff --git a/src/ick.h b/src/ick.h
index 591036977b849ba664d5d99e1735747012c87a94..ce2d0f2aedb293211f102142c298aaeb005f9f04 100644 (file)
--- a/src/ick.h
+++ b/src/ick.h
@@ -43,7 +43,7 @@ typedef int ick_bool;
  * Maximum supported statement types; should be equal to (FROM - GETS + 1)
  * AIS: Changed this when I added new statements.
  */
-#define MAXTYPES       30
+#define MAXTYPES       31
 
 /* AIS: Maximum supported spark/ears nesting, divided by 32. The value given
    allows for 256 nested spark/ears groupings, which should be enough. */
@@ -58,7 +58,7 @@ typedef struct node_t
     unsigned long       optdata;        /* AIS: Temp used by the optimizer */
     int                        width;          /* is this 32-bit data? */
     struct node_t      *lval, *rval;   /* attached expression nodes */
-    struct node_t       *nextslat;      /* AIS: The ick_next node with a slat */
+    struct node_t       *nextslat;      /* AIS: The next node with a slat */
 } node;
 
 typedef struct tuple_t
@@ -71,9 +71,9 @@ typedef struct tuple_t
     ick_bool                maybe;          /* AIS: Where MAYBE details go when
                                           exechance has been parsed */
     ick_bool                abstainable;    /* AIS: Is it possible for this line to
-                                          be ick_abstained from? */
+                                          be abstained from? */
     ick_bool                initabstain;    /* AIS: Is this line initially
-                                          ick_abstained from? */
+                                          abstained from? */
     ick_bool                nextable;       /* AIS: Can this line be a NEXT
                                           target? */
     ick_bool                optversion;     /* AIS: Use an optimized version? (Only
@@ -164,6 +164,7 @@ extern int nextfromsused;  /* is NEXT FROM used? */
 extern int gerucomesused;  /* is COME FROM gerund used? */
 extern int opoverused;     /* is operand overloading used? */
 extern int useickec;       /* are external calls used? */
+extern int createsused;    /* are CREATEs used? */
 /*@null@*/ extern node* firstslat;    /* the ick_first node with a slat */
 /*@null@*/ extern node* prevslat;     /* the last node so far with a slat */
 extern int multithread;    /* is the program multithreaded? */

diff --git a/src/ick_ec.c b/src/ick_ec.c
index aed35d9e9689905c143158b1aa1ebe84f95c0ae4..0ba15bf7ec0de41556d74cecc156a21a8a1246cb 100644 (file)
--- a/src/ick_ec.c
+++ b/src/ick_ec.c
@@ -24,15 +24,15 @@ LICENSE TERMS
 
 /* Implement the INTERCAL flow control operators in C, except for ABSTAIN
    and REINSTATE. Worryingly, this is freestanding-legal and needs no C
-   headers other than setjmp.h. */
+   headers other than setjmp.h and stdint.h. (The printfs are just for
+   +printflow debug output and don't effect the code flow.) */
 
+#define ICK_EC 1
 #include "ick_lose.h"
 #include "abcess.h" /* must come before ick_ec.h */
 #include "ick_ec.h"
 #include <setjmp.h>
-
-static jmp_buf lastcspjb[ick_MAXNEXT];
-static int lastcspjbvalid[ick_MAXNEXT]={0};
+#include <stdint.h>
 
 /* Checkmode values, for reference:
  * 0: not using checkmode
@@ -41,58 +41,60 @@ static int lastcspjbvalid[ick_MAXNEXT]={0};
  * 3: NEXT FROM found
  * 4: no suitable target found
  * 5: do a resume(1) if this reaches ick_allecfuncs
+ * 6: starting up, run your init code
  */
 int ick_global_checkmode = 0;
-int ick_global_stackcleanup = 0;
 /* ick_global_linelabel's marked as volatile to avoid problems with
    optimisation of assignments to it near setjmps. */
 unsigned long ick_global_linelabel;
-int ick_forgetamount = 0;
+static int ick_forgetamount = 0;
 unsigned long ick_global_goto;
+void* ick_global_createdata;
 
-/* Clean cspjb data. */
-static void cleancspjb(void)
-{
-  int i=ick_MAXNEXT;
-  while(i-->ick_nextindex) lastcspjbvalid[i]=0;
-}
-
-/* Do a NEXT. */
-/*@maynotreturn@*/ void ick_donext(unsigned long linelabel,
-                                  int emitlineno,
-                                  int willforget)
+/* Do a NEXT or goto. Gotos don't work with an empty NEXT stack, but that's
+   trivial to correct by doing a NEXT at the start of the program. */
+/*@maynotreturn@*/ void ick_dogoto(unsigned long linelabel,
+                                  int emitlineno, int isnext)
 {
   /* OK, so auto is never necessary, but the point here is that this is being
      stored on the stack deliberately so that it can be recalled if this
      procedure is longjmped to. */
   auto volatile int nextlevel = ick_nextindex;
-  if(ick_printflow&&linelabel<=65535) printf("[next:%lu]",linelabel);
+  if(ick_printflow&&linelabel<=65535&&isnext)
+    printf("[next:%lu]",linelabel);
   ick_global_checkmode = 2; /* look for linelabels */
   ick_global_linelabel = linelabel;
   /* If there was a FORGET earlier, implement it now, by removing the relevant
      NEXT stack entries. Unfortunately, we can't remove them from the main C
-     stack if we care about the return address of this NEXT. */
-  if(ick_forgetamount)
+     stack if we care about the return address of this NEXT. If this is a GOTO
+     rather than a NEXT, it's safe to go back to the top NEXT on the NEXT stack
+     and redo it with a different target (because the return address will still
+     be correct), and all FORGETs work using an implied GOTO. (COME FROMs work
+     by telling the suckpoint to GOTO them.) */
+  if(!isnext)
   {
-    if(ick_printflow) printf("[doforget:%d]",ick_forgetamount);
-    nextlevel = ick_nextindex -= ick_forgetamount;
+    if(ick_printflow&&ick_forgetamount)
+      printf("[forget:%d]",ick_forgetamount);
+    else if(ick_printflow&&linelabel<=65535)
+      printf("[goto:%lu]",linelabel);
+    nextlevel = ick_nextindex -= ick_forgetamount + 1;
     ick_forgetamount = 0;
     if(ick_nextindex < 0) ick_nextindex = 0;
-    if(willforget) longjmp(ick_next_jmpbufs[ick_nextindex],2);
+    longjmp(ick_next_jmpbufs[ick_nextindex],2);
   }
-  /* longjmp return codes: 1 = resume, 2 = clean up stack */
+  else if(ick_nextindex==81)
+    ick_lose(IE123, emitlineno, (char*)NULL);
+  /* longjmp return codes: 1 = resume, 2 = redo to a different target */
   if(setjmp(ick_next_jmpbufs[ick_nextindex])==1)
   {
     /* Returning from the next. Clean up the next stack, just in
        case the callee didn't. */
     ick_nextindex = nextlevel;
-    cleancspjb();
     ick_global_checkmode=0;
     return;
   }
   ick_nextindex = nextlevel; /* in case we were longjmped to */
-  cleancspjb();
-  ick_next[ick_nextindex++] = 0;
+  ++ick_nextindex;
   ick_allecfuncs();
   /* If the checkmode is 4, we didn't find a target. */
   if(ick_global_checkmode == 4)
@@ -101,30 +103,35 @@ static void cleancspjb(void)
   ick_doresume(1,emitlineno);
 }
 
-/* Schedule a FORGET. This doesn't alter the NEXT stack immediately;
-   instead, the next RESUME or NEXT takes it into account. */
-void ick_forget(unsigned short amount)
+/* Schedule a FORGET. The actual FORGET is performed at the next GOTO,
+   which should happen immediately. */
+void ick_scheduleforget(unsigned short amount)
 {
-  if(ick_printflow) printf("[forget:%hu]",amount);
   ick_forgetamount += amount;
-  if(ick_forgetamount > ick_nextindex)
-    ick_forgetamount = ick_nextindex;
+  if(ick_forgetamount >= ick_nextindex)
+    ick_forgetamount = ick_nextindex-1;
 }
 
 /* Resume to a previous NEXT stack entry. */
 /*@noreturn@*/ void ick_doresume(unsigned short amount, int emitlineno)
 {
   if(ick_printflow) printf("[resume:%hu]",amount);
-  if(ick_printflow&&ick_forgetamount) printf("[doforget:%d]",ick_forgetamount);
+  if(ick_forgetamount) ick_lose(IE778, emitlineno, (char *)NULL);
   if(!amount) ick_lose(IE621, emitlineno, (char *)NULL);
-  amount += ick_forgetamount;
-  ick_forgetamount = 0;
   ick_nextindex -= amount;
-  if(ick_nextindex < 0)
+  if(ick_nextindex < 1) /* the very first NEXT can't be RESUMEd to */
     ick_lose(IE632, emitlineno, (char *)NULL);
   longjmp(ick_next_jmpbufs[ick_nextindex],1);
 }
 
+/* Run any ick_startup blocks. */
+void ick_runstartups(void)
+{
+  ick_global_checkmode = 6;
+  ick_allecfuncs();
+  ick_global_checkmode = 0;
+}
+
 /* Check to see if anything tries to steal control from a suckpoint.
  * This allows line labels > 65535, but bear in mind that such high
  * line labels cannot be COME FROM or NEXTed FROM or to by the user.
@@ -139,24 +146,116 @@ void ick_forget(unsigned short amount)
   ick_global_linelabel=linelabel;
   ick_allecfuncs();
   if(!ick_global_goto) {ick_global_checkmode=0; return;}
-  /* Cut out bits of stack that we'll never need. */
-  if(lastcspjbvalid[ick_nextindex]) longjmp(lastcspjb[ick_nextindex],1);
-  setjmp(lastcspjb[ick_nextindex]);
-  lastcspjbvalid[ick_nextindex]=1;
   /* If this was a COME FROM, goto it. */
   if(ick_global_checkmode == 1)
   {
     if(ick_printflow) printf("[comefrom:%lu]",ick_global_linelabel);
-    ick_global_checkmode = 2;
-    ick_global_linelabel = ick_global_goto;
-    ick_allecfuncs();
+    ick_dogoto(ick_global_goto,-1,0); /* GOTO */
   }
   else if(ick_global_checkmode == 3)
   {
     if(ick_printflow) printf("[nextfrom:%lu]",ick_global_linelabel);
-    ick_donext(ick_global_goto,-1,0);
+    ick_dogoto(ick_global_goto,-1,1); /* NEXT */
     return; /* we were RESUMEd to */
   }
   /* This line should be unreachable. */
   ick_lose(IE778, -1, (char *)NULL);
 }
+
+uint16_t ick_getonespot(unsigned short extername)
+{
+  int i=-1;
+  while(++i,1)
+  {
+    if(ick_ec_vars[i].ick_ec_vartype==ICK_EC_VARS_END) break;
+    if(ick_ec_vars[i].ick_ec_vartype==ick_ONESPOT)
+      if(ick_ec_vars[i].ick_ec_extername==extername)
+       return ick_onespots[ick_ec_vars[i].ick_ec_intername];
+  }
+  ick_lose(IE200,-1,(char*)NULL);
+}
+
+void ick_setonespot(unsigned short extername, uint16_t value)
+{
+  int i=-1;
+  while(++i,1)
+  {
+    if(ick_ec_vars[i].ick_ec_vartype==ICK_EC_VARS_END) break;
+    if(ick_ec_vars[i].ick_ec_vartype==ick_ONESPOT)
+      if(ick_ec_vars[i].ick_ec_extername==extername)
+      {
+       if(ick_oneforget[ick_ec_vars[i].ick_ec_intername]) return;
+       ick_onespots[ick_ec_vars[i].ick_ec_intername]=value;
+       return;
+      }
+  }
+  ick_lose(IE200,-1,(char*)NULL);
+}
+
+uint32_t ick_gettwospot(unsigned short extername)
+{
+  int i=-1;
+  while(++i,1)
+  {
+    if(ick_ec_vars[i].ick_ec_vartype==ICK_EC_VARS_END) break;
+    if(ick_ec_vars[i].ick_ec_vartype==ick_TWOSPOT)
+      if(ick_ec_vars[i].ick_ec_extername==extername)
+       return ick_twospots[ick_ec_vars[i].ick_ec_intername];
+  }
+  ick_lose(IE200,-1,(char*)NULL);
+}
+
+void ick_settwospot(unsigned short extername, uint32_t value)
+{
+  int i=-1;
+  while(++i,1)
+  {
+    if(ick_ec_vars[i].ick_ec_vartype==ICK_EC_VARS_END) break;
+    if(ick_ec_vars[i].ick_ec_vartype==ick_TWOSPOT)
+      if(ick_ec_vars[i].ick_ec_extername==extername)
+      {
+       if(ick_twoforget[ick_ec_vars[i].ick_ec_intername]) return;
+       ick_twospots[ick_ec_vars[i].ick_ec_intername]=value;
+       return;
+      }
+  }
+  ick_lose(IE200,-1,(char*)NULL);
+}
+
+/* Register a CREATE target. This is just a wrapper for
+   ick_registercreation that gets around scoping problems. */
+void ick_create(char* sig, unsigned long target)
+{
+  ick_registercreation(sig, target);
+}
+
+/* Accessor and mutator functions for CREATE data */
+int ick_c_i_width(int argpos)
+{
+  return ((ick_createdata*)ick_global_createdata)[argpos].width;
+}
+int ick_c_i_isarray(int argpos)
+{
+  return ((ick_createdata*)ick_global_createdata)[argpos].isarray;
+}
+unsigned short ick_c_i_varnumber(int argpos)
+{
+  return ((ick_createdata*)ick_global_createdata)[argpos].varnumber;
+}
+uint32_t ick_c_i_value(int argpos)
+{
+  return (uint32_t)(((ick_createdata*)ick_global_createdata)[argpos].value);
+}
+uint32_t ick_c_i_getvalue(int argpos)
+{
+  if(!(((ick_createdata*)ick_global_createdata)[argpos].accessors.get))
+    return ick_c_i_value(argpos);
+  return ((ick_createdata*)ick_global_createdata)[argpos].accessors.
+    get(ick_c_i_value(argpos));
+}
+void ick_c_i_setvalue(int argpos, uint32_t newval)
+{
+  if(((ick_createdata*)ick_global_createdata)[argpos].accessors.set)
+    ((ick_createdata*)ick_global_createdata)[argpos].accessors.
+      set(newval,NULL);
+}

diff --git a/src/ick_ec.h b/src/ick_ec.h
index 9fe5e52e3c0371d8b3f448a75fc289e5a959c35a..45f7cf201e6e0a2e3f0f83b2774ae6cfdec6574c 100644 (file)
--- a/src/ick_ec.h
+++ b/src/ick_ec.h
@@ -38,22 +38,27 @@ LICENSE TERMS
 
    To prevent this process running the program out of stack space (which would
    happen with a naive implementation if there were many COME FROMs from
-   inside the C program back to inside the C program), ick_checksuckpoint will
-   longjmp back to a previous incarnation of itself if doing so eliminates no
-   NEXT stack entries. This trick doesn't work with FORGET, though; instead
-   the stray C stack entries are eliminated at the next RESUME past them;
-   also, all but one of the entries can be eliminated at each line label if
-   there are more than one of them.
+   inside the C program back to inside the C program), all transitions but
+   NEXTs are done indirectly, by jumping back inside a relevant invocation of
+   ick_dogoto and changing its targets. (So effectively, to GOTO a particular
+   destination, you go back in time to the last time you NEXTed - or to
+   implement a FORGET, the last-but-n-time you NEXTed - and redo it with a
+   different target.)
 */
 
+#include <stdint.h>
+
 #define ICK_EC_FUNC_START(id)                    \
 ICK_EC_PP_0(id)                                  \
 void id(void)                                    \
 {                                                \
-  void* ick_local_rv = 0;                        \
+  void* ick_local_createdata =                   \
+    ick_global_createdata;                       \
   int ick_local_checkmode = ick_global_checkmode; \
-  jmp_buf ick_local_jmpbuf;                      \
-  setjmp(ick_local_jmpbuf);                      \
+  if(ick_global_checkmode==6)                    \
+  {                                              \
+    goto ick_l6_ICK_EC_PP_6;                     \
+  }                                              \
   if(ick_global_checkmode==2)                    \
   {                                              \
     goto ick_l2_ICK_EC_PP_2;                     \
@@ -69,33 +74,70 @@ void id(void)                                         \
 
 #define ick_labeledblock(expr,block)                       \
   do {                                                     \
-    if(ick_forgetamount > 1)                               \
-    {                                                      \
-      ick_global_stackcleanup=1;                           \
-      ick_donext(expr,-1,1);                               \
-    }                                                      \
     if(0)                                                  \
     {                                                      \
     ick_l2_ICK_EC_PP_2: ;                                  \
       if(ick_global_linelabel != (expr) || (expr) > 65535)  \
        goto ick_l2_ICK_EC_PP_2;                            \
       ick_global_checkmode = 0;                                    \
-      if(ick_global_stackcleanup)                          \
-       ick_forget(1);                                      \
-      ick_global_stackcleanup = 0;                         \
     }                                                      \
     block ;                                                \
     ick_checksuckpoint(expr);                              \
   }                                                        \
   while(0)
 
+#define ick_linelabelnosp(expr)                                    \
+  do {                                                     \
+    if(0)                                                  \
+    {                                                      \
+    ick_l2_ICK_EC_PP_2: ;                                  \
+      if(ick_global_linelabel != (expr) || (expr) > 65535)  \
+       goto ick_l2_ICK_EC_PP_2;                            \
+      ick_global_checkmode = 0;                                    \
+    }                                                      \
+  }                                                        \
+  while(0)
+
+#define ick_linelabelnosp(expr)                                    \
+  do {                                                     \
+    if(0)                                                  \
+    {                                                      \
+    ick_l2_ICK_EC_PP_2: ;                                  \
+      if(ick_global_linelabel != (expr) || (expr) > 65535)  \
+       goto ick_l2_ICK_EC_PP_2;                            \
+      ick_global_checkmode = 0;                                    \
+    }                                                      \
+  }                                                        \
+  while(0)
+
+#define ick_forget(amount)                     \
+  do {                                         \
+    ick_scheduleforget(amount);                        \
+    ick_dogoto(ICK_EC_PP_3,-1,0);              \
+    ick_lose(IE778, -1, (char*) NULL);         \
+    return;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                \
+    if(ick_global_linelabel != ICK_EC_PP_3)    \
+      goto ick_l2_ICK_EC_PP_2;                 \
+    ick_global_checkmode = 0;                  \
+  } while(0)
+
+
+#define ick_startup(block)                     \
+  if(0)                                                \
+  {                                            \
+  ick_l6_ICK_EC_PP_6:                          \
+    block ;                                    \
+    goto ick_l6_ICK_EC_PP_6;                   \
+  }
+
 #define ick_comefrom(expr)                                      \
   if(0)                                                                 \
   {                                                             \
   ick_l1_ICK_EC_PP_1: ;                                                 \
     if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
     {                                                           \
-      if(ick_global_goto) ick_multicome0(-1,ick_local_jmpbuf);  \
+      if(ick_global_goto) ick_lose(ICK_IE555, -1, (char*)0);    \
       ick_global_goto = ICK_EC_PP_3;                            \
     }                                                           \
     goto ick_l1_ICK_EC_PP_1;                                    \
@@ -105,13 +147,33 @@ void id(void)                                       \
     ick_global_checkmode = 0;                                   \
   }
 
+#define ick_comefromif(expr,condition) \
+  ick_docomefromif(expr,-1,condition)
+
+#define ick_docomefromif(expr,lbl,condition)                    \
+  if(0)                                                                 \
+  {                                                             \
+  ick_l1_ICK_EC_PP_1: ;                                                 \
+    if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
+      if(condition)                                             \
+      {                                                                 \
+       if(ick_global_goto) ick_lose(ICK_IE555, lbl, (char*)0);  \
+       ick_global_goto = ICK_EC_PP_3;                           \
+      }                                                                 \
+    goto ick_l1_ICK_EC_PP_1;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                                 \
+    if(ick_global_linelabel != ICK_EC_PP_3)                     \
+      goto ick_l2_ICK_EC_PP_2;                                  \
+    ick_global_checkmode = 0;                                   \
+  }
+
 #define ick_nextfrom(expr)                                      \
   if(0)                                                                 \
   {                                                             \
   ick_l1_ICK_EC_PP_1: ;                                                 \
     if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
     {                                                           \
-      if(ick_global_goto) ick_multicome0(-1,ick_local_jmpbuf);  \
+      if(ick_global_goto) ick_lose(ICK_IE555, -1, (char*)0);    \
       ick_global_goto = ICK_EC_PP_3;                            \
       ick_global_checkmode = 3;                                         \
     }                                                           \
@@ -122,15 +184,43 @@ void id(void)                                       \
     ick_global_checkmode = 0;                                   \
   }
 
+#define ick_nextfromif(expr,condition) \
+  ick_docomefromif(expr,-1,condition)
+
+#define ick_donextfromif(expr,lbl,condition)                    \
+  if(0)                                                                 \
+  {                                                             \
+  ick_l1_ICK_EC_PP_1: ;                                                 \
+    if(ick_global_linelabel == (expr) && (expr) <= 65535)       \
+      if(condition)                                             \
+      {                                                                 \
+       if(ick_global_goto) ick_lose(ICK_IE555, lbl, (char*)0);  \
+       ick_global_goto = ICK_EC_PP_3;                           \
+       ick_global_checkmode = 3;                                \
+      }                                                                 \
+    goto ick_l1_ICK_EC_PP_1;                                    \
+  ick_l2_ICK_EC_PP_2: ;                                                 \
+    if(ick_global_linelabel != ICK_EC_PP_3)                     \
+      goto ick_l2_ICK_EC_PP_2;                                  \
+    ick_global_checkmode = 0;                                   \
+  }
+
+
 #define ICK_EC_FUNC_END                                \
   if(ick_local_checkmode) ick_resume(1);       \
 ick_l1_ICK_EC_PP_1: ;                          \
+ick_l6_ICK_EC_PP_6: ;                          \
 ick_l2_ICK_EC_PP_2: return;                    \
 }
 
 #define ick_next(label) do{                    \
     if((label)<=65535)                         \
-      ick_donext((label),-1,0);                        \
+      ick_dogoto((label),-1,1);                        \
+  } while(0)
+
+#define ick_goto(label) do{                    \
+    if((label)<=65535)                         \
+      ick_dogoto((label),-1,0);                        \
   } while(0)
 
 #define ick_resume(amount) ick_doresume((amount),-1)
@@ -140,15 +230,62 @@ ick_l2_ICK_EC_PP_2: return;                       \
     return;                                    \
   } while(0)
 
-/*@maynotreturn@*/ void ick_donext(unsigned long, int, int);
-void ick_forget(unsigned short amount);
-/*@noreturn@*/ void ick_doresume(unsigned short amount, int emitlineno);
-/*@maynortreturn@*/ void ick_checksuckpoint(unsigned long linelabel);
+/*@maynotreturn@*/ void ick_dogoto(unsigned long, int, int);
+void ick_scheduleforget(unsigned short);
+/*@noreturn@*/ void ick_doresume(unsigned short, int);
+/*@maynotreturn@*/ void ick_checksuckpoint(unsigned long);
+void ick_runstartups(void);
 
 void ick_allecfuncs(void); /* in generated program */
 
 extern int ick_global_checkmode;
-extern int ick_global_stackcleanup;
 extern unsigned long ick_global_linelabel;
 extern unsigned long ick_global_goto;
-extern int ick_forgetamount;
+extern void* ick_global_createdata;
+
+/* Variables. */
+typedef struct ick_ec_var_tag
+{
+  int ick_ec_vartype;
+  int ick_ec_extername;
+  int ick_ec_intername;
+} ick_ec_var;
+
+extern ick_ec_var ick_ec_vars[];
+
+#define ICK_EC_VARS_END 5
+
+uint16_t ick_getonespot(unsigned short);
+void ick_setonespot(unsigned short, uint16_t);
+uint32_t ick_gettwospot(unsigned short);
+void ick_settwospot(unsigned short, uint32_t);
+
+void ick_create(char*, unsigned long);
+
+/* For accessing the arguments to an ick_created command */
+int ick_c_i_width(int);
+int ick_c_i_isarray(int);
+unsigned short ick_c_i_varnumber(int);
+uint32_t ick_c_i_value(int);
+/* These require -a to work */
+uint32_t ick_c_i_getvalue(int);
+void ick_c_i_setvalue(int, uint32_t);
+
+#define ick_c_width(a) ick_c_i_width((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_isarray(a) ick_c_i_isarray((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_varnumber(a) ick_c_i_varnumber((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_value(a) ick_c_i_value((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_getvalue(a) ick_c_i_getvalue((ick_global_createdata=ick_local_createdata,(a)))
+#define ick_c_setvalue(a,n) ick_c_i_setvalue((ick_global_createdata=ick_local_createdata,(a)),(n))
+
+/* Fragments of ick_lose.h, that don't impinge on unmangled namespace. */
+#define ICK_IE555 "555 FLOW DIAGRAM IS EXCESSIVELY CONNECTED\n\
+       ON THE WAY TO %d\n"
+#define ICK_IE778 "778 UNEXPLAINED COMPILER BUG\n\
+       ON THE WAY TO %d\n"
+
+extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s)
+#ifdef __GNUC__
+  __attribute__ ((noreturn))
+#endif
+;

diff --git a/src/ick_lose.h b/src/ick_lose.h
index 755b3e656ac6827b729dd84441625edac917736c..44165f12a7ae742965587c9cfb3862b431e9ac20 100644 (file)
--- a/src/ick_lose.h
+++ b/src/ick_lose.h
@@ -41,11 +41,11 @@
 /* An expression involves an unidentified variable. */
 #define IE200 "200 NOTHING VENTURED, NOTHING GAINED\n\
        ON THE WAY TO %d\n"
-/* An attempt has been made to give an ick_array a dimension of zero. */
+/* An attempt has been made to give an array a dimension of zero. */
 #define IE240 "240 ERROR HANDLER PRINTED SNIDE REMARK\n\
        ON THE WAY TO %d\n"
 /* Invalid dimensioning information was supplied
- * in defining or using an ick_array. */
+ * in defining or using an array. */
 #define IE241 "241 VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE\n\
        ON THE WAY TO %d\n"
 /* A 32-bit value has been assigned to a 16-bit variable. */
@@ -89,7 +89,7 @@
 /* Cannot find the magically included system library */
 #define IE127 "127 SAYING 'ABRACADABRA' WITHOUT A MAGIC WAND WON'T DO YOU ANY GOOD\n\
         ON THE WAY TO THE CLOSET\n"
-/* Out of ick_stash space */
+/* Out of stash space */
 #define IE222 "222 BUMMER, DUDE!\n\
        ON THE WAY TO %d\n"
 /* (AIS) Out of memory during I/O */
@@ -221,7 +221,7 @@
 /* (AIS) A line will inevitably cause an expression-reversal failure. */
 #define W278 "278 FROM A CONTRADICTION, ANYTHING FOLLOWS\n\
         ON THE WAY TO A HUGE DISASTER\n"
-       
+
 /* (AIS) The two following warnings are both compile-time traps for
    near-certain runtime errors. As such, they have similar numbers
    and similar messages. In fact, they're a shameless ripoff of the
@@ -237,7 +237,11 @@
 
 extern int ick_lineno;
 
-extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s);
+extern void /*@noreturn@*/ ick_lose(char *m, int n, /*@null@*/ char *s)
+#ifdef __GNUC__
+  __attribute__ ((noreturn))
+#endif
+;
 
 extern void ick_lwarn(char *m, int n, /*@null@*/ char *s);
 

diff --git a/src/idiotism.oil b/src/idiotism.oil
index 235ca30717d2ffa69a6d8a9b519d5546422a825c..4c5e1f3842ac45d28f772668684b67da5cd4ce5a 100644 (file)
--- a/src/idiotism.oil
+++ b/src/idiotism.oil
@@ -1,7 +1,7 @@
-; 
-; NAME 
+;
+; NAME
 ;     idiotism.oil -- optimizer idioms for C-INTERCAL
-; 
+;
 ; LICENSE TERMS
 ;     Copyright (C) 2007 Alex Smith
 ;
@@ -34,21 +34,21 @@
 
 ; Constant folding
 [minglefold]
-(#{1}1$#{1}2)->(#{ick_mingle(x1,x2)}0)
+(#{1}1$#{1}2)->(#{mingle(x1,x2)}0)
 [selectfold]
-(#{1}1~#{1}2)->(#{ick_iselect(x1,x2)}0)
+(#{1}1~#{1}2)->(#{iselect(x1,x2)}0)
 [and32fold]
-(&32 #{1}1)->(#{ick_and32(x1)}0)
+(&32 #{1}1)->(#{and32(x1)}0)
 [or32fold]
-(V32 #{1}1)->(#{ick_or32(x1)}0)
+(V32 #{1}1)->(#{or32(x1)}0)
 [xor32fold]
-(?32 #{1}1)->(#{ick_xor32(x1)}0)
-[and15fold]
-(&16 #{1}1)->(#{ick_and16(x1)}0)
-[or14fold]
-(V16 #{1}1)->(#{ick_or16(x1)}0)
-[xor14fold]
-(?16 #{1}1)->(#{ick_xor16(x1)}0)
+(?32 #{1}1)->(#{xor32(x1)}0)
+[and16fold]
+(&16 #{1}1)->(#{and16(x1)}0)
+[or16fold]
+(V16 #{1}1)->(#{or16(x1)}0)
+[xor16fold]
+(?16 #{1}1)->(#{xor16(x1)}0)
 ; C operations can, and should, be folded too
 [cfold]
 (#{1}1 & #{1}2)->(#{x1 & x2}0)
@@ -70,70 +70,70 @@
 ; Binary bitwise optimizations
 [cbinand]
 ((&32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->((_1 & _2) & #{ick_iselect(x3,1431655765LU)}0)
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->((_1 & _2) & #{iselect(x3,1431655765LU)}0)
 [cbinor]
 ((V32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->((_1 | _2) & #{ick_iselect(x3,1431655765LU)}0)
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->((_1 | _2) & #{iselect(x3,1431655765LU)}0)
 [cbinxor]
 ((?32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->((_1 ^ _2) & #{ick_iselect(x3,1431655765LU)}0)
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->((_1 ^ _2) & #{iselect(x3,1431655765LU)}0)
 ; Sometimes, an expanded output is wanted, optimizations happen in the wrong
 ; order, and we end up with & rather than ~ on the previous idiom. Correct
 ; such situations now.
 [cbinandnoselect]
 ((&32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->(#0 $ ((_1 & _2) & #{ick_iselect(x3,1431655765LU)}0))
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->(#0 $ ((_1 & _2) & #{iselect(x3,1431655765LU)}0))
 [cbinornoselect]
 ((V32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->(#0 $ ((_1 | _2) & #{ick_iselect(x3,1431655765LU)}0))
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->(#0 $ ((_1 | _2) & #{iselect(x3,1431655765LU)}0))
 [cbinxornoselect]
 ((?32(_{!(c&4294901760LU)}1$_{!(c&4294901760LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
-)->(#0 $ ((_1 ^ _2) & #{ick_iselect(x3,1431655765LU)}0))
-; Sometimes, there isn't even a ick_mingle...
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
+)->(#0 $ ((_1 ^ _2) & #{iselect(x3,1431655765LU)}0))
+; Sometimes, there isn't even a mingle...
 [cbinandnomingle]
 ((&32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) & _1) ~ _3)
 ((&32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) & _1) ~ _3)
 ((&32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) & _1) & _3)
 ((&32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) & _1) & _3)
 [cbinornomingle]
 ((V32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) | _1) ~ _3)
 ((V32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) | _1) ~ _3)
 ((V32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) | _1) & _3)
 ((V32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) | _1) & _3)
 [cbinxornomingle]
 ((?32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) ^ _1) ~ _3)
 ((?32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))~
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) ^ _1) ~ _3)
 ((?32(_{!(c&2863311530LU)}1|_{!(c&1431655765LU)}2))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) ^ _1) & _3)
 ((?32(_{!(c&1431655765LU)}2|_{!(c&2863311530LU)}1))&
- #{!(x&2863311530LU)&&ick_iselect(x,1431655765LU)==ick_xselx(ick_iselect(x,1431655765LU))}3
+ #{!(x&2863311530LU)&&iselect(x,1431655765LU)==xselx(iselect(x,1431655765LU))}3
 )->(((_2 >> #1) ^ _1) & _3)
 
 ; Bitwise complements. (The INTERCAL which ultimately leads to cases 3 and 4
@@ -151,10 +151,10 @@
 
 ; Selecting the rightmost bits of a number
 [xselpow2m1]
-(_1 ~ #{x==ick_xselx(x)}2)->(_1 & _2)
+(_1 ~ #{x==xselx(x)}2)->(_1 & _2)
 ; Selecting one bit from a number
 [xselpow2]
-(_1 ~ #{ick_xselx(x)==1}2)->(!(!(_1 & _2)))
+(_1 ~ #{xselx(x)==1}2)->(!(!(_1 & _2)))
 ; Selecting a number against itself and then selecting 1 from that
 [xselxsel1]
 ((_1~_1)~#1)->(!(!_1))
@@ -164,12 +164,12 @@
 (_{c==1}2&(_1~_1))->(_1 && _2)
 ; Selecting a number from a constant that's just below a power of 2
 [pow2m1selx]
-((#{x==ick_xselx(x)}1 ~ _2) ~ #1)->(!(!(_1 & _2)))
+((#{x==xselx(x)}1 ~ _2) ~ #1)->(!(!(_1 & _2)))
 ; Boolean-negating a select
 [notselect]
 (!(_1~_2))->(!(_1&_2))
 
-; Sometimes select and ick_mingle cancel each other out
+; Sometimes select and mingle cancel each other out
 [selectmingle1]
 ((_1~#2863311530)$_2)->((_1&#2863311530)|(#0$_2))
 [selectmingle2]
@@ -188,7 +188,7 @@
 ; Rightshift some of the bits
 [rshift]
 <#1-#31
-(_1~#{ick_xselx(x)<<r==x&&x}2)->((_1&_2)>>#{r}0)
+(_1~#{xselx(x)<<r==x&&x}2)->((_1&_2)>>#{r}0)
 >
 ; General 16-bit leftshifts
 ;
@@ -207,16 +207,16 @@
 <#0-#14
 ((_{c<=65535&&!(c&((1LU<<r)-1LU))}1$
   #{!(x&(4294967294LU<<r))}2)~#{!(x&(1431655765LU<<(r*2+2)))}3)
-->((((_1>>#{r}0)~#{ick_iselect(x3>>(r*2+1),1431655765LU)}0)
-    <<#{ick_setbitcount(x3&((2LU<<(r*2))-1))}0)|#{ick_iselect(ick_mingle(0,x2),x3)}0)
+->((((_1>>#{r}0)~#{iselect(x3>>(r*2+1),1431655765LU)}0)
+    <<#{setbitcount(x3&((2LU<<(r*2))-1))}0)|#{iselect(mingle(0,x2),x3)}0)
 (((_{c<=65535&&!(c&((1LU<<r)-1LU))}1|#{x<=65535&&!(c&~((1LU<<r)-1LU))}4)$
   #{!(x&(4294967294LU<<r))}2)~#{!(x&(1431655765LU<<(r*2+2)))}3)
-->((((_1>>#{r}0)~#{ick_iselect(x3>>(r*2+1),1431655765LU)}0)
-    <<#{ick_setbitcount(x3&((2LU<<(r*2))-1))}0)|#{ick_iselect(ick_mingle(x4,x2),x3)}0)
+->((((_1>>#{r}0)~#{iselect(x3>>(r*2+1),1431655765LU)}0)
+    <<#{setbitcount(x3&((2LU<<(r*2))-1))}0)|#{iselect(mingle(x4,x2),x3)}0)
 (((#{x<=65535&&!(c&~((1LU<<r)-1LU))}4|_{c<=65535&&!(c&((1LU<<r)-1LU))}1)$
   #{!(x&(4294967294LU<<r))}2)~#{!(x&(1431655765LU<<(r*2+2)))}3)
-->((((_1>>#{r}0)~#{ick_iselect(x3>>(r*2+1),1431655765LU)}0)
-    <<#{ick_setbitcount(x3&((2LU<<(r*2))-1))}0)|#{ick_iselect(ick_mingle(x4,x2),x3)}0)
+->((((_1>>#{r}0)~#{iselect(x3>>(r*2+1),1431655765LU)}0)
+    <<#{setbitcount(x3&((2LU<<(r*2))-1))}0)|#{iselect(mingle(x4,x2),x3)}0)
 >
 ; 32-bit leftshift by 1; there are 8 ways to write this.
 [lshift32by1]
@@ -260,8 +260,8 @@
 
 ; INTERCAL logical values are 1 and 2.
 [xorto1or2]
-((?32(_1$#1))&#3)->((_1&#1)+#1)
-((?32(_1$#2))&#3)->(#2-(_1&#1))
+((?32(_{!(c&4294901760LU)}1$#1))&#3)->((_1&#1)+#1)
+((?32(_{!(c&4294901760LU)}1$#2))&#3)->(#2-(_1&#1))
 
 ; Removing, combining and weakening unneeded C_ANDs
 [unneededand]
@@ -461,7 +461,7 @@
 ; A right-shift idiom in syslib that was written in an unneccessarily complex
 ; way, by doing the bits separately the same way as left-shifts have to be done
 ; (of course, select can right-shift by any difference without much trouble);
-; the ick_next idiom is a helper for that. Previous code produced a warning when
+; the next idiom is a helper for that. Previous code produced a warning when
 ; this idiom was used, but the optimizer has now been enhanced to the extent
 ; that it can deal with it without much special-casing, and therefore there's
 ; no way now to tell that that case is being used, so the warning has been
@@ -520,3 +520,7 @@
 ((!(_{c==1}1))+#1)->(#2-_1)
 [nullmingle]
 (#0$_{c==1}1)->(_1)
+; Thanks to Joris Huizer for suggesting the idea behind the next one;
+; this is a more general idiom than the suggested [triplenot].
+[redundantdoublenot]
+(!(!(_{c==1}1)))->(_1)
\ No newline at end of file

diff --git a/src/lexer.l b/src/lexer.l
index e4010be594747506d99f8b0bfc2b126ef346bb02..a5ff3b1c9899704ddf4d6e16d6616d0a6bfee937 100644 (file)
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -223,6 +223,7 @@ int getc(FILE *fp)
 
 W      [\ \t\n]*
 D      [0-9][\ \t\n0-9]*
+I       [A-Z]
 
 %%
 
@@ -389,7 +390,7 @@ DEINDERE{W}A{W}\({W}{D}\) |
 NEXT{W}FROM{W}\({W}{D}\) {/* AIS */ yylval.numval = myatoi(yytext);
                          return(NEXTFROMLABEL);}
 DEINDERE{W}A    |
-NEXT{W}FROM     {/* AIS: 'ick_next' is not a verb, so the Latin is invented */
+NEXT{W}FROM     {/* AIS: 'next' is not a verb, so the Latin is invented */
                  return(NEXTFROMEXPR);}
 DEINDENDUM     |
 NEXTING{W}FROM {/* AIS */ yylval.numval = NEXTFROMLABEL; return(GERUND);}
@@ -404,8 +405,8 @@ DEINDE              |
 NEXT           {stbeginline = 0; return(NEXT);}
 PROXIMANDUM    |
 NEXTING                {yylval.numval = NEXT; return(GERUND);}
-FROM            |
-A               {return(FROM);}
+FROM            {return(FROM); /* AIS: Latin is 'A', which confuses the rest
+                                  of the parser */}
 CONCEDERE      |
 DESPERARE      |
 GIVE{W}UP      {return(GIVE_UP);}
@@ -426,10 +427,16 @@ GOING{W}AHEAD   {yylval.numval = GO_AHEAD; return(GERUND);
                    there are no Latin gerunds around here. Besides, the Latin
                    'gerunds' look somewhat like gerundives to me, but that's
                    purely based on memory so I may be wrong. */}
+CREATE{W}\({W}{D}\)          |
+CONFICE{W}\({W}{D}\)         {yylval.numval = myatoi(yytext); return(CREATE);}
+CREATING        |
+CREATION        |
+CONFICENDUM     {yylval.numval = CREATE; return(GERUND);}
 
 \+             {return(INTERSECTION);}
 
 {W}            ;
+{I}             {/* AIS */ yylval.numval = *yytext; return(UNKNOWNID);}
 .              {yylval.numval = yytext[0]; /* AIS: The line below for debug */
  if(yydebug) fprintf(stdout, "yylex: bad char %#x\n",(unsigned char)yytext[0]);
                  return(BADCHAR);}

diff --git a/src/parser.y b/src/parser.y
index 6e32038048f1637e15dbf7657330b98d429e2c8d..03c73c2036742bb789db8e50d5369e96cd0b7a16 100644 (file)
--- a/src/parser.y
+++ b/src/parser.y
@@ -51,8 +51,11 @@ static int thisline; /* line number of beginning of current statement */
 
 extern int mark112;    /* AIS: Mark the tuple for W112 when it's created. */
 static int lineuid=65537; /* AIS: a line number not used anywhere else */
+static int cacsofar=0; /* AIS: Number of args in a CREATE statement */
 
-static tuple *splat(void);
+static tuple *splat(int);
+
+static tuple *prevtuple = NULL;
 
 #define GETLINENO                                      \
     {if (stbeginline < 0) thisline = -stbeginline;     \
@@ -92,10 +95,10 @@ static tuple *splat(void);
  * AIS: Note that although GETS is the lowest statement type (with index 0
  *     in feh2.c), UNKNOWN (i.e. a line that causes error 000) is an even
  *     lower statement type, with index -1. perpet.c uses indexes 1 higher.
- * AIS: Added FROM, MANYFROM, TRY_AGAIN, COMPUCOME, GERUCOME, WHILE, and
- *     three NEXT FROM cases. Also added PREPROC; this is for when the parser
- *      acts like a preprocessor, translating an INTERCAL statement into a
- *      sequence of INTERCAL statements with the same net effect.
+ * AIS: Added FROM, MANYFROM, TRY_AGAIN, COMPUCOME, GERUCOME, WHILE, three
+ *     NEXT FROM cases, and CREATE. Also added PREPROC; this is for when the
+ *      parser acts like a preprocessor, translating an INTERCAL statement into
+ *      a sequence of INTERCAL statements with the same net effect.
  * AIS: COME_FROM now merged with the label following it,
  *      to distinguish it from COMPUCOME, in the lexer. This changes
  *      the parser somewhat.
@@ -106,7 +109,9 @@ static tuple *splat(void);
 %token DISABLE ENABLE MANYFROM GIVE_UP READ_OUT WRITE_IN /* AIS: */PIN
 %token <numval> COME_FROM NEXTFROMLABEL
 %token NEXTFROMEXPR NEXTFROMGERUND COMPUCOME GERUCOME
-%token PREPROC WHILE TRY_AGAIN FROM
+%token PREPROC WHILE TRY_AGAIN
+%token <numval> CREATE
+%token FROM
 
 /* AIS: ONCE and AGAIN added, for multithread support; also, NOSPOT added,
    so that I can reserve _ for future use (it's nowhere in the grammar yet) */
@@ -134,11 +139,18 @@ static tuple *splat(void);
 %token AND OR XOR FIN WHIRL WHIRL2 WHIRL3 WHIRL4 WHIRL5
 %token REV_AND REV_OR REV_XOR REV_FIN
 %token REV_WHIRL REV_WHIRL2 REV_WHIRL3 REV_WHIRL4 REV_WHIRL5
+/* (AIS) Tokens for just-in-case compilation; UNKNOWNID is returned by the
+   lexer for unknown 'identifiers'. And yes, it does contain a number. */
+%token <numval> UNKNOWNID
+/* (AIS) Five possibilities for an unknown statement chain: identifiers,
+   scalars, arrays, array elements, and other expressions. */
+%token US_ID US_SCALAR US_ARRVAR US_ELEM US_EXPR
 
 %type <node> expr limexpr varlist variable constant lvalue inlist outlist
 %type <node> subscr byexpr scalar scalar2s ick_array initem outitem sublist
 %type <node> unambig limunambig subscr1 sublist1 oparray osubscr osubscr1
-%type <node> notanlvalue nlunambig lunambig
+%type <node> notanlvalue nlunambig lunambig unknownstatement unknownatom
+%type <node> unknownsin unknownaid
 %type <tuple> preproc perform mtperform
 %type <numval> please preftype
 
@@ -175,19 +187,28 @@ command   :    please mtperform
        |    LABEL please OHOHSEVEN mtperform
                {checklabel($1); $4->label = $1; $4->exechance = $2 * $3;}
        |    error
-               {ick_lose(IE017, iyylineno, (char *)NULL);}
+                {/* AIS: catch errors which occur after the end of a statement
+                   (highly likely when comments are being written, as the
+                   start of them will be parsed as an UNKNOWN) */
+                 yyerrok; yyclearin; cacsofar=0;
+                 if(prevtuple) {prevtuple->type=SPLATTERED; splat(0);}
+                 else splat(1); /* this is the first statement */
+               }
        ;
 /*
  * AIS: added for the ONCE/AGAIN qualifiers. It copies a pointer to the tuple,
  * so command will set the values in the original tuple via the copy.
+ * I also added prevtuple so that after-command splattering works.
  */
 
 mtperform :  preproc
-               {$1->onceagainflag = onceagain_NORMAL; $$ = $1;}
+               {$1->onceagainflag = onceagain_NORMAL; prevtuple = $$ = $1;}
          |  preproc ONCE
-               {NEWFANGLED {$1->onceagainflag = onceagain_ONCE; $$ = $1;}}
+               {NEWFANGLED {$1->onceagainflag = onceagain_ONCE;
+                            prevtuple = $$ = $1;}}
          |  preproc AGAIN
-               {NEWFANGLED {$1->onceagainflag = onceagain_AGAIN; $$ = $1;}}
+               {NEWFANGLED {$1->onceagainflag = onceagain_AGAIN;
+                            prevtuple = $$ = $1;}}
 
 /* AIS: Either we do a simple 'perform', or preprocessing is needed.
         I wrote all of this. The way the preprocessor works is to add a whole
@@ -254,7 +275,7 @@ perform :    lvalue GETS expr       {ACTION($$, GETS,      cons(GETS,$1,$3));}
        |    notanlvalue GETS expr %prec LOWPREC
          {/* AIS: This is for variableconstants, and an error otherwise.*/
           if(variableconstants) ACTION($$, GETS, cons(GETS,$1,$3))
-          else {yyclearin; $$=splat();}}
+            else {yyerrok; yyclearin; $$=splat(1);}}
        |    LABEL NEXT         {TARGET($$, NEXT,      $1);}
        |    FORGET expr        {ACTION($$, FORGET,    $2);}
        |    RESUME expr        {ACTION($$, RESUME,    $2);}
@@ -290,10 +311,56 @@ perform :    lvalue GETS expr     {ACTION($$, GETS,      cons(GETS,$1,$3));}
                                  nextfromsused=1;}
        |    NEXTFROMEXPR expr  {NEWFANGLED {ACTION($$,NEXTFROMEXPR,$2);
                                 compucomesused=1; nextfromsused=1;}}
-       |    BADCHAR            {yyclearin; $$ = splat();}
-       |    error              {yyclearin; $$ = splat();}
+/* AIS: CREATE takes an 'unknown statement' as a template */
+        |    CREATE unknownstatement {NEWFANGLED{ACTARGET($$,CREATE,$2,$1); cacsofar=0;}}
+/* AIS: Just-in-case compilation of unknown statements */
+        |    unknownstatement   {NEWFANGLED {ACTION($$,UNKNOWN,$1); cacsofar=0;}}
+/* AIS: Added the yyerrok */
+       |    BADCHAR            {yyclearin; yyerrok; $$ = splat(1); cacsofar=0;}
+        |    error             {yyclearin; yyerrok; $$ = splat(1); cacsofar=0;}
        ;
 
+/* AIS: Unknown statements. The rule here is that we can't have two non-ID
+   unknowns in a row, but two IDs in a row are acceptable. */
+unknownstatement : unknownatom {$$ = $1; intern(ick_TWOSPOT,cacsofar+++1601);}
+                | unknownsin unknownatom {$$=cons(INTERSECTION,$1,$2);
+                                          intern(ick_TWOSPOT,cacsofar+++1601);}
+                 | unknownsin {$$ = $1;}
+                ;
+
+unknownsin      : unknownaid {$$ = $1;}
+                | unknownstatement unknownaid {$$=cons(INTERSECTION,$1,$2);}
+
+/* Each of the possible unknown atoms, apart from arrays and IDs, generates
+   operand overloading info if CREATEs or external calls are used, so that
+   the implied overloading of a CREATE will work. */
+unknownatom      : subscr      {$$=cons(US_ELEM,0,$1);
+                                   if(createsused){
+                                     opoverused=1; if(!firstslat)
+                                      firstslat=$$; else
+                                      prevslat->nextslat=$$;
+                                    prevslat=$$;
+                                    $$->nextslat=0;}}
+                | scalar       {$$=cons(US_SCALAR,0,$1);
+                                   if(createsused){
+                                     opoverused=1; if(!firstslat)
+                                      firstslat=$$; else
+                                      prevslat->nextslat=$$;
+                                    prevslat=$$;
+                                    $$->nextslat=0;}}
+                | notanlvalue  {$$=cons(US_EXPR,0,$1);
+                                   if(createsused){
+                                     opoverused=1; if(!firstslat)
+                                      firstslat=$$; else
+                                      prevslat->nextslat=$$;
+                                    prevslat=$$;
+                                    $$->nextslat=0;}}
+                | ick_array    {$$=cons(US_ARRVAR,0,$1);}
+                ;
+
+unknownaid      : UNKNOWNID    {$$=newnode(); $$->opcode=US_ID; $$->constant=$1;}
+                ;
+
 /* gerund lists are used by ABSTAIN and REINSTATE */
 gerunds        :   GERUND
                {rlist = np = newnode(); np->constant = $1;}
@@ -550,7 +617,7 @@ eitherears  : OPENEARS ;
 
 %%
 
-static tuple *splat(void)
+static tuple *splat(int gentuple)
 /* try to recover from an invalid statement. */
 {
     tuple *sp;
@@ -563,8 +630,17 @@ static tuple *splat(void)
      * which we can do with a tricky flag on the lexer (re_send_token).
      */
 
+    if(re_send_token == ick_TRUE) /* By AIS */
+    {
+      /* We're still cleaning up from the previous error. */
+      return prevtuple;
+    }
+
     /* fprintf(stderr,"attempting to splat at line %d....\n",iyylineno); */
-    for(i = 0,re_send_token = ick_FALSE;;i++) {
+    /* AIS: Set the flag to true the first time round, false for subsequent
+       iterations. That way, if the error was triggered on a DO or label,
+       we use that token as the start of the next statement. */
+    for(i = 0,re_send_token = ick_TRUE;;i++,re_send_token = ick_FALSE) {
        tok = lexer();
        if (!tok)
        {
@@ -584,7 +660,8 @@ static tuple *splat(void)
      */
 
     /* generate a placeholder tuple for the text line */
-    TARGET(sp, SPLATTERED, 0);
+    if(gentuple /* AIS */) {TARGET(sp, SPLATTERED, 0); prevtuple=sp;}
+    else sp=NULL;
 
     return(sp);
 }

diff --git a/src/perpet.c b/src/perpet.c
index f2ef5aa33ee94cbb686211e5a3859292847acdbf..81d3290d7b698b80ea1f99a8681910a224ccdce0 100644 (file)
--- a/src/perpet.c
+++ b/src/perpet.c
@@ -59,7 +59,7 @@ LICENSE TERMS
 #define CC "gcc"
 #endif
 
-#define ARGSTRING "bcdefghlmoptuvxyCFHOPUX@"
+#define ARGSTRING "abcdefghlmoptuvwxyCEFHOPUX@"
 
 #ifdef USE_YYRESTART
 /* function supplied by lex */
@@ -78,10 +78,13 @@ ick_bool ick_traditional;   /* insist on strict INTERCAL-72 conformance */
 ick_bool nocompilerbug;        /* disable error IE774 */
 int yukdebug;           /* AIS: Use the yuk debugger. */
 int yukprofile;         /* AIS: Use the yuk profiler. */
+int useprintflow=0;     /* AIS: Add +printflow support. */
 extern int ick_coreonerr;   /* AIS: Dump core on IE778. (defined in ick_lose.c) */
 int multithread;        /* AIS: Allow multithreading and backtracking. */
 int variableconstants;  /* AIS: Allow anything on the left of an assignment. */
+int createsused=0;      /* AIS: Allow the use of CREATE. */
 int useickec;           /* AIS: Link together INTERCAL and C. */
+static int nosyslib=0;  /* AIS: Don't link syslib under any circumstances. */
 static int cdebug;      /* AIS: Pass -g to our C compiler, and leave C code. */
 int optdebug;           /* AIS: Debug the optimizer. Value is 0, 1, 2, or 3. */
 int flowoptimize;       /* AIS: Do flow optimizations (in INTERCAL!). */
@@ -89,7 +92,7 @@ int coopt;              /* AIS: The constant-output optimization. This should
                           mean that INTERCAL will beat any other language at
                           many benchmark programs (!) */
 extern int ick_printfopens; /* AIS: Print messages whenever attempting to open a
-                          file: from uncommon.c */
+                              file: from uncommon.c */
 extern int ick_checkforbugs;/* AIS: Try to find possible bugs in the source code */
 int pickcompile;        /* AIS: Compile for PIC? */
 /*@-exportlocal@*/      /* AIS: relevant to the lexer */
@@ -134,7 +137,7 @@ int ick_lineno;     /* after yyparse, this is the total number of statements */
 static int maxbase = 7;
 static int smallsizes[8] = {0, 0, 16, 10, 8, 6, 6, 5};
 static unsigned int maxsmalls[8] =
-  {0, 0, 65535, 59048, 65535, 15624, 46655, 16806};
+{0, 0, 65535, 59048, 65535, 15624, 46655, 16806};
 
 /*@observer@*/ static char *compiler;
 
@@ -183,72 +186,75 @@ static int myfgetc(FILE* in)
 
 static RETSIGTYPE abend(int signim)
 {
-    /*@-noeffect@*/ (void) signim; /*@=noeffect@*/
-    ick_lose(IE778, iyylineno, (char *)NULL);
+  /*@-noeffect@*/ (void) signim; /*@=noeffect@*/
+  ick_lose(IE778, iyylineno, (char *)NULL);
 }
 static void print_usage(char *prog, char *options)
 {
-    fprintf(stderr,"Usage: %s [-%s] <file> [<file> ...]\n",prog,options);
-    fprintf(stderr,"\t-b\t:reduce the probability of IE774 to zero\n");
-    fprintf(stderr,"\t-c\t:compile INTERCAL to C, but don't compile C\n");
-    fprintf(stderr,"\t-d\t:print yacc debugging information (implies -c)\n");
-    fprintf(stderr,"\t-e\t:link together INTERCAL and C files as one program\n");
-    fprintf(stderr,"\t\t (without this option, all INTERCAL files produce\n");
-    fprintf(stderr,"\t\t separate output files; with it, the first file given\n");
-    fprintf(stderr,"\t\t must be the only INTERCAL file) (prevents -mypPf)\n");
-    fprintf(stderr,"\t-t\t:ick_traditional mode, accept only INTERCAL-72\n");
-    fprintf(stderr,"\t-C\t:ick_clockface output (e.g. use IIII instead of IV)\n");
-    fprintf(stderr,"\t-O\t:optimize expresssions in generated code\n");
-    /* AIS: Changed the help message for the previous line (because the
-       function of -O has changed). I wrote the next group of options. */
-    fprintf(stderr,"\t-f\t:optimize control flow in generated code "
-           "(prevents -yp)\n");
+  fprintf(stderr,"Usage: %s [-%s] <file> [<file> ...]\n",prog,options);
+  fprintf(stderr,"\t-b\t:reduce the probability of IE774 to zero\n");
+  fprintf(stderr,"\t-c\t:compile INTERCAL to C, but don't compile C\n");
+  fprintf(stderr,"\t-d\t:print yacc debugging information (implies -c)\n");
+  fprintf(stderr,"\t-e\t:link together INTERCAL and C files as one program\n");
+  fprintf(stderr,"\t\t (without this option, all INTERCAL files produce\n");
+  fprintf(stderr,"\t\t separate output files; with it, the first file given\n");
+  fprintf(stderr,"\t\t must be the only INTERCAL file) (prevents -mypPf)\n");
+  fprintf(stderr,"\t-E\t:never include the system library (prevents -P)\n");
+  fprintf(stderr,"\t-t\t:ick_traditional mode, accept only INTERCAL-72\n");
+  fprintf(stderr,"\t-C\t:ick_clockface output (e.g. use IIII instead of IV)\n");
+  fprintf(stderr,"\t-O\t:optimize expresssions in generated code\n");
+  /* AIS: Changed the help message for the previous line (because the
+     function of -O has changed). I wrote the next group of options. */
+  fprintf(stderr,"\t-f\t:optimize control flow in generated code "
+         "(prevents -yp)\n");
 #ifdef HAVE_PROG_SH
 # ifdef HAVE_SYS_INTERPRETER
-    fprintf(stderr,"\t-F\t:optimize everything in generated code for\n"
-           "\t\tspeed, regardless of how slow the compiler becomes or how\n"
-           "\t\tlarge the object file becomes. Implies -fO, "
-           "prevents -cdeghpyH\n");
+  fprintf(stderr,"\t-F\t:optimize everything in generated code for\n"
+         "\t\t speed, regardless of how slow the compiler becomes or how\n"
+         "\t\t large the object file becomes. Implies -fO, "
+         "prevents -cdeghpyH\n");
 # else
-    fprintf(stderr,"\t-F\t:unsupported on computers without #! support\n");
+  fprintf(stderr,"\t-F\t:unsupported on computers without #! support\n");
 # endif
 #else
-    fprintf(stderr,"\t-F\t:unsupported on computers without sh or bash\n");
+  fprintf(stderr,"\t-F\t:unsupported on computers without sh or bash\n");
 #endif
-    fprintf(stderr,"\t-h\t:print optimizer debugging information "
-           "(implies -cO)\n");
-    fprintf(stderr,"\t-H\t:print verbose optimizer debugging information "
-           "(implies -cO)\n");
-    fprintf(stderr,"\t-hH\t:print optimizer debugging information in a\n"
-           "\t\tdifferent form (implies -cO)\n");
+  fprintf(stderr,"\t-h\t:print optimizer debugging information "
+         "(implies -cO)\n");
+  fprintf(stderr,"\t-H\t:print verbose optimizer debugging information "
+         "(implies -cO)\n");
+  fprintf(stderr,"\t-hH\t:print optimizer debugging information in a\n"
+         "\t\t different form (implies -cO)\n");
 #ifdef HAVE_UNISTD_H
-    fprintf(stderr,"\t-y\t:run the yuk debugger on the code (prevents -fme)\n");
-    fprintf(stderr,"\t-p\t:run the yuk profiler on the code (prevents -fme)\n");
+  fprintf(stderr,"\t-y\t:run the yuk debugger on the code (prevents -fme)\n");
+  fprintf(stderr,"\t-p\t:run the yuk profiler on the code (prevents -fme)\n");
 #else
-    fprintf(stderr,"\t-y\t:unsupported on computers without <unistd.h>\n");
-    fprintf(stderr,"\t-p\t:unsupported on computers without <unistd.h>\n");
+  fprintf(stderr,"\t-y\t:unsupported on computers without <unistd.h>\n");
+  fprintf(stderr,"\t-p\t:unsupported on computers without <unistd.h>\n");
 #endif
-    fprintf(stderr,"\t-m\t:allow multithreading and backtracking "
-           "(prevents -ype)\n");
-    fprintf(stderr,"\t-v\t:allow anything on the left of an assignment. This "
-           "is required\n\t\tif you want operand overloading to change "
-           "meshes.\n\t\t(prevents -fFOP)\n");
-    fprintf(stderr,"\t-P\t:compile PIC-INTERCAL rather than INTERCAL\n");
-    fprintf(stderr,"\t\t(prevents -mFvxe, implies -cfO)\n");
-    fprintf(stderr,"\t-o\t:output to stdout rather than .c (implies -c)\n");
-    fprintf(stderr,"\t-X\t:interpret ambiguous syntax as Princeton not\n"
-           "\t\tAtari (i.e. CLC-INTERCAL not C-INTERCAL)\n");
-    fprintf(stderr,"\t-x\t:use CLC-INTERCAL rules for I/O and abstaining\n"
-           "\t\tfrom a GIVE UP by label (prevents -P)\n");
-    fprintf(stderr,"\t-u\t:print a message whenever the compiler tries to "
-           "open a file\n");
-    fprintf(stderr,"\t-U\t:dump core on IE778 after printing an error\n");
-    fprintf(stderr,"\t-g\t:compile to both debuggable executable and C\n");
-    fprintf(stderr,"\t-l\t:attempt to report likely bugs "
-           "and nonportabilities (implies -O)\n");
-    /* AIS: End of options I added. */
-    fprintf(stderr,"\t<file>\tINTERCAL source file (use extension .i\n");
-    fprintf(stderr,"\t\tfor base 2 or .3i, etc., for base 3, etc.).\n");
+  fprintf(stderr,"\t-w\t:add support for the +printflow option\n");
+  fprintf(stderr,"\t-m\t:allow multithreading and backtracking\n"
+         "\t\t (prevents -ype, implies -w)\n");
+  fprintf(stderr,"\t-a\t:allow the use of CREATE (prevents -P)\n");
+  fprintf(stderr,"\t-v\t:allow anything on the left of an assignment. This "
+         "is required\n\t\t if you want operand overloading to change "
+         "meshes.\n\t\t (prevents -fFOP)\n");
+  fprintf(stderr,"\t-P\t:compile PIC-INTERCAL rather than INTERCAL\n");
+  fprintf(stderr,"\t\t (prevents -amFvxeE, implies -cfO)\n");
+  fprintf(stderr,"\t-o\t:output to stdout rather than .c (implies -c)\n");
+  fprintf(stderr,"\t-X\t:interpret ambiguous syntax as Princeton not\n"
+         "\t\t Atari (i.e. CLC-INTERCAL not C-INTERCAL)\n");
+  fprintf(stderr,"\t-x\t:use CLC-INTERCAL rules for I/O and abstaining\n"
+         "\t\t from a GIVE UP by label (prevents -P)\n");
+  fprintf(stderr,"\t-u\t:print a message whenever the compiler tries to "
+         "open a file\n");
+  fprintf(stderr,"\t-U\t:dump core on IE778 after printing an error\n");
+  fprintf(stderr,"\t-g\t:compile to both debuggable executable and C\n");
+  fprintf(stderr,"\t-l\t:attempt to report likely bugs "
+         "and nonportabilities (implies -O)\n");
+  /* AIS: End of options I added. */
+  fprintf(stderr,"\t<file>\tINTERCAL source file (use extension .i\n");
+  fprintf(stderr,"\t\tfor base 2 or .3i, etc., for base 3, etc.).\n");
 }
 
 /* AIS: Determine whether an environment variable exists (this is used to
@@ -266,1306 +272,1392 @@ int main(int argc, char *argv[])
   /*@-nestedextern@*/
   extern int   optind;         /* set by getopt */
   /*@=nestedextern@*/
-    char       buf[BUFSIZ], buf2[BUFSIZ], *chp, yukcmdstr[BUFSIZ], path[BUFSIZ];
-    tuple      *tp;
-    atom       *op;
-    int                c, i;
-    /*@-shadow@*/ /* no it doesn't, cesspool isn't linked to perpet */
-    char       *includedir, *libdir, *ick_datadir;
-    /*@=shadow@*/
-    /* AIS: removed getenv(), added ick_datadir */
-    char        *cooptsh; /* AIS */
-    FILE       *ifp, *ofp;
-    int                maxabstain, /* nextcount, AIS */ bugline;
-    ick_bool        needsyslib, firstfile;
-    int         oldoptind;
+  char buf[BUFSIZ], buf2[BUFSIZ], *chp, yukcmdstr[BUFSIZ], path[BUFSIZ];
+  tuple        *tp;
+  atom *op;
+  int          c, i;
+  /*@-shadow@*/ /* no it doesn't, cesspool isn't linked to perpet */
+  char *includedir, *libdir, *ick_datadir;
+  /*@=shadow@*/
+  /* AIS: removed getenv(), added ick_datadir */
+  char        *cooptsh; /* AIS */
+  FILE *ifp, *ofp;
+  int          maxabstain, /* nextcount, AIS */ bugline;
+  ick_bool        needsyslib, firstfile;
+  int         oldoptind;
 #ifdef HAVE_UNISTD_H
-    int         oldstdin; /* AIS: for keeping track of where stdin was */
+  int         oldstdin; /* AIS: for keeping track of where stdin was */
 #endif
 
-    if (!(includedir = getenv("ICKINCLUDEDIR")))
-      includedir = ICKINCLUDEDIR;
-    if (!(libdir = getenv("ICKLIBDIR")))
-      libdir = ICKLIBDIR;
-    if (!(ick_datadir = getenv("ICKDATADIR"))) /* AIS */
-      ick_datadir = ICKDATADIR;
+  if (!(includedir = getenv("ICKINCLUDEDIR")))
+    includedir = ICKINCLUDEDIR;
+  if (!(libdir = getenv("ICKLIBDIR")))
+    libdir = ICKLIBDIR;
+  if (!(ick_datadir = getenv("ICKDATADIR"))) /* AIS */
+    ick_datadir = ICKDATADIR;
 /*
   AIS: nothing actually uses this at the moment,
-       commenting it out for future use
+  commenting it out for future use
 
-    if (!(bindir = getenv("ICKBINDIR")))
-      bindir = ICKBINDIR;
+  if (!(bindir = getenv("ICKBINDIR")))
+  bindir = ICKBINDIR;
 */
-    if (!(compiler = getenv("CC")))
-      compiler = CC;
-
-    /* getopt is POSIX, and I provide my own version if the POSIX version
-       isn't found, so the unrecog warning is a false positive. */
-    /*@-unrecog@*/
-    while ((c = getopt(argc, argv, ARGSTRING)) != EOF)
-      /*@=unrecog@*/
+  if (!(compiler = getenv("CC")))
+    compiler = CC;
+
+  /* getopt is POSIX, and I provide my own version if the POSIX version
+     isn't found, so the unrecog warning is a false positive. */
+  /*@-unrecog@*/
+  while ((c = getopt(argc, argv, ARGSTRING)) != EOF)
+    /*@=unrecog@*/
+  {
+    switch (c)
     {
-       switch (c)
-       {
-       case 'b':
-           nocompilerbug = ick_TRUE;
-           break;
-
-       case 'c':
-           compile_only = ick_TRUE;
-           /* AIS */ coopt = ick_FALSE;
-           break;
-
-       case 'o': /* AIS */
-         compile_only = ick_TRUE;
-         outtostdout = ick_TRUE;
-         coopt = ick_FALSE;
-         break;
-
-       case 'd':
-           yydebug = compile_only = ick_TRUE;
-           /* AIS */ coopt = ick_FALSE;
-           break;
-
-       case 'e': /* AIS */
-         useickec = ick_TRUE;
-         multithread = pickcompile = coopt = yukdebug = yukprofile = ick_FALSE;
-         break;
-
-       case 'C':
-           ick_clockface = ick_TRUE;
-           break;
-
-       case 't':
-           ick_traditional = ick_TRUE;
-           if(multithread) ick_lose(IE111, 1, (char*) NULL); /* AIS */
-           if(pickcompile) ick_lose(IE111, 1, (char*) NULL); /* AIS */
-           break;
-
-       case 'O':
-           dooptimize = ick_TRUE;
-           variableconstants = ick_FALSE; /* AIS */
-           break;
-
-       case 'f': /* By AIS */
-         flowoptimize = ick_TRUE;
-         yukdebug = yukprofile = ick_FALSE;
-         variableconstants = ick_FALSE;
-         break;
-
-       case 'F': /* By AIS */
-         coopt = flowoptimize = dooptimize = ick_TRUE;
-         variableconstants = useickec = ick_FALSE;
-         yukdebug = yukprofile = yydebug = outtostdout =
-           compile_only = cdebug = ick_FALSE;
-         if(pickcompile) ick_lose(IE256, 1, (char*) NULL);
-         break;
-
-       case 'h': /* By AIS */
-         optdebug|=1;
-         compile_only=dooptimize=ick_TRUE;
-         coopt=ick_FALSE;
-         break;
-
-       case 'H': /* By AIS */
-         optdebug|=2;
-         compile_only=dooptimize=ick_TRUE;
-         coopt=ick_FALSE;
-         break;
-
-       case 'y': /* By AIS */
+    case 'b':
+      nocompilerbug = ick_TRUE;
+      break;
+
+    case 'c':
+      compile_only = ick_TRUE;
+      /* AIS */ coopt = ick_FALSE;
+      break;
+
+    case 'o': /* AIS */
+      compile_only = ick_TRUE;
+      outtostdout = ick_TRUE;
+      coopt = ick_FALSE;
+      break;
+
+    case 'd':
+      yydebug = compile_only = ick_TRUE;
+      /* AIS */ coopt = ick_FALSE;
+      break;
+
+    case 'e': /* AIS */
+      useickec = ick_TRUE;
+      multithread = pickcompile = coopt = yukdebug = yukprofile = ick_FALSE;
+      break;
+
+    case 'E': /* AIS */
+      nosyslib = ick_TRUE;
+      pickcompile = ick_FALSE;
+      break;
+
+    case 'C':
+      ick_clockface = ick_TRUE;
+      break;
+
+    case 't':
+      ick_traditional = ick_TRUE;
+      if(multithread) ick_lose(IE111, 1, (char*) NULL); /* AIS */
+      if(pickcompile) ick_lose(IE111, 1, (char*) NULL); /* AIS */
+      break;
+
+    case 'O':
+      dooptimize = ick_TRUE;
+      variableconstants = ick_FALSE; /* AIS */
+      break;
+
+    case 'f': /* By AIS */
+      flowoptimize = ick_TRUE;
+      yukdebug = yukprofile = ick_FALSE;
+      variableconstants = ick_FALSE;
+      break;
+
+    case 'F': /* By AIS */
+      coopt = flowoptimize = dooptimize = ick_TRUE;
+      variableconstants = useickec = ick_FALSE;
+      yukdebug = yukprofile = yydebug = outtostdout =
+       compile_only = cdebug = ick_FALSE;
+      if(pickcompile) ick_lose(IE256, 1, (char*) NULL);
+      break;
+
+    case 'h': /* By AIS */
+      optdebug|=1;
+      compile_only=dooptimize=ick_TRUE;
+      coopt=ick_FALSE;
+      break;
+
+    case 'H': /* By AIS */
+      optdebug|=2;
+      compile_only=dooptimize=ick_TRUE;
+      coopt=ick_FALSE;
+      break;
+
+    case 'y': /* By AIS */
 #ifdef HAVE_UNISTD_H
-         yukdebug=ick_TRUE;
-         multithread=flowoptimize=coopt=useickec=ick_FALSE;
+      yukdebug=ick_TRUE;
+      multithread=flowoptimize=coopt=useickec=ick_FALSE;
 #endif
-         break;
+      break;
 
-       case 'p': /* By AIS */
+    case 'p': /* By AIS */
 #ifdef HAVE_UNISTD_H
-         yukprofile=ick_TRUE;
-         multithread=flowoptimize=coopt=useickec=ick_FALSE;
+      yukprofile=ick_TRUE;
+      multithread=flowoptimize=coopt=useickec=ick_FALSE;
 #endif
-         break;
-
-       case 'm': /* By AIS */
-         multithread=ick_TRUE;
-         yukprofile=ick_FALSE;
-         yukdebug=ick_FALSE;
-         useickec=ick_FALSE;
-         if(ick_traditional) ick_lose(IE111, 1, (char*) NULL);
-         break;
-
-       case 'v': /* By AIS */
-         variableconstants=ick_TRUE;
-         dooptimize=ick_FALSE;
-         flowoptimize=ick_FALSE;
-         coopt=ick_FALSE;
-         pickcompile=ick_FALSE;
-         break;
-
-       case 'l': /* By AIS */
-         ick_checkforbugs=ick_TRUE;
-         dooptimize=ick_TRUE;
-         break;
-
-       case 'U': /* By AIS */
-         ick_coreonerr=ick_TRUE;
-         break;
-
-       case 'u': /* By AIS */
-         ick_printfopens=ick_TRUE;
-         break;
-
-       case 'P': /* By AIS */
-         pickcompile=ick_TRUE;
-         multithread=coopt=variableconstants=ick_FALSE;
-         ick_clcsemantics=useickec=ick_FALSE;
-         compile_only=ick_TRUE;
-         dooptimize=flowoptimize=ick_TRUE; /* needed for PICs */
-         break;
-
-       case 'X': /* By AIS */
-         clclex=ick_TRUE;
-         break;
-
-       case 'x': /* By AIS */
-         ick_clcsemantics=ick_TRUE;
-         pickcompile=ick_FALSE;
-         break;
-
-       case 'g': /* By AIS */
-         cdebug=ick_TRUE;
-         coopt=ick_FALSE;
-         break;
-
-       case '?':
-       default:
-       case '@':
-           print_usage(argv[0], ARGSTRING);
-           exit(EXIT_FAILURE);
-           /*@-unreachable@*/ break; /*@=unreachable@*/
-       }
+      break;
+
+    case 'w': /* By AIS */
+      useprintflow = ick_TRUE;
+      break;
+
+    case 'm': /* By AIS */
+      multithread=ick_TRUE;
+      yukprofile=ick_FALSE;
+      yukdebug=ick_FALSE;
+      useickec=ick_FALSE;
+      if(ick_traditional) ick_lose(IE111, 1, (char*) NULL);
+      break;
+
+    case 'a': /* By AIS */
+      createsused=ick_TRUE;
+      pickcompile=ick_FALSE;
+      break;
+
+    case 'v': /* By AIS */
+      variableconstants=ick_TRUE;
+      dooptimize=ick_FALSE;
+      flowoptimize=ick_FALSE;
+      coopt=ick_FALSE;
+      pickcompile=ick_FALSE;
+      break;
+
+    case 'l': /* By AIS */
+      ick_checkforbugs=ick_TRUE;
+      dooptimize=ick_TRUE;
+      break;
+
+    case 'U': /* By AIS */
+      ick_coreonerr=ick_TRUE;
+      break;
+
+    case 'u': /* By AIS */
+      ick_printfopens=ick_TRUE;
+      break;
+
+    case 'P': /* By AIS */
+      pickcompile=ick_TRUE;
+      multithread=coopt=variableconstants=createsused=ick_FALSE;
+      ick_clcsemantics=useickec=nosyslib=ick_FALSE;
+      compile_only=ick_TRUE;
+      dooptimize=flowoptimize=ick_TRUE; /* needed for PICs */
+      break;
+
+    case 'X': /* By AIS */
+      clclex=ick_TRUE;
+      break;
+
+    case 'x': /* By AIS */
+      ick_clcsemantics=ick_TRUE;
+      pickcompile=ick_FALSE;
+      break;
+
+    case 'g': /* By AIS */
+      cdebug=ick_TRUE;
+      coopt=ick_FALSE;
+      break;
+
+    case '?':
+    default:
+    case '@':
+      print_usage(argv[0], ARGSTRING);
+      exit(EXIT_FAILURE);
+      /*@-unreachable@*/ break; /*@=unreachable@*/
     }
+  }
 
-    (void) signal(SIGSEGV, abend);
+  (void) signal(SIGSEGV, abend);
 #ifdef SIGBUS
-    (void) signal(SIGBUS, abend);
+  (void) signal(SIGBUS, abend);
 #endif /* SIGBUS */
     
-    if (!nocompilerbug) {
+  if (!nocompilerbug) {
 #ifdef USG
-       srand48(time(NULL) + getpid());
+    srand48(time(NULL) + getpid());
 #else
-       srand((unsigned)time(NULL));
+    srand((unsigned)time(NULL));
 #endif /* UNIX */
-    }
+  }
 
-    /* AIS: New function for enhanced file-finding */
-    ifp = ick_findandfopen(pickcompile?PSKELETON:SKELETON,
-                      ick_datadir, "r", argv[0]);
-    if(!ifp) ick_lose(IE999, 1, (char *)NULL);
+  /* AIS: New function for enhanced file-finding */
+  ifp = ick_findandfopen(pickcompile?PSKELETON:SKELETON,
+                        ick_datadir, "r", argv[0]);
+  if(!ifp) ick_lose(IE999, 1, (char *)NULL);
 
-    /* now substitute in tokens in the skeleton */
+  /* now substitute in tokens in the skeleton */
 
-    /* AIS: This doesn't actually seem to do anything, and buf is
-       uninitialised at this point, so it's actually dangerous
-       because it's undefined behaviour.
-       buf[strlen(buf) - 2] = '\0'; */
+  /* AIS: This doesn't actually seem to do anything, and buf is
+     uninitialised at this point, so it's actually dangerous
+     because it's undefined behaviour.
+     buf[strlen(buf) - 2] = '\0'; */
 
-    /* AIS: Save the old stdin, if we can */
+  /* AIS: Save the old stdin, if we can */
 #ifdef HAVE_UNISTD_H
-    oldstdin=dup(0);
+  oldstdin=dup(0);
 #endif
 
-    oldoptind=optind; /* AIS */
-    for (firstfile = ick_TRUE; optind < argc; optind++, firstfile = ick_FALSE)
+  oldoptind=optind; /* AIS */
+  for (firstfile = ick_TRUE; optind < argc; optind++, firstfile = ick_FALSE)
+  {
+    /* AIS: Read as binary to pick up Latin-1 and UTF-8 better */
+    if (/* AIS */ strrchr(argv[optind],'.') != NULL &&
+      freopen(argv[optind], "rb", stdin) == (FILE *)NULL)
+      ick_lose(IE777, 1, (char *)NULL);
+    else
     {
-      /* AIS: Read as binary to pick up Latin-1 and UTF-8 better */
-       if (freopen(argv[optind], "rb", stdin) == (FILE *)NULL)
-           ick_lose(IE777, 1, (char *)NULL);
-       else
+      /* strip off the file extension */
+      if(!(chp = strrchr(argv[optind],'.')))
+      {
+       if(useickec && firstfile == ick_FALSE) /* By AIS */
        {
-           /* strip off the file extension */
-           if(!(chp = strrchr(argv[optind],'.')))
-           {
-               ick_lose(IE998, 1, (char *)NULL);
-           }
-           *chp++ = '\0';
+         /* the filename indicates a request for an expansion library,
+            along the same lines as CLC-INTERCAL's preloads. Search for
+            it in the usual places, then make a copy in a temp directory
+            and substitute that on the command line. */
+         char* tempfn="%s.c";
+         FILE* fromcopy;
+         FILE* tocopy;
+         int c2;
+#ifndef HAVE_SNPRINTF
+         (void) sprintf(buf2, "%s.c", argv[optind]);
+#else
+         (void) snprintf(buf2, sizeof buf2, "%s.c", argv[optind]);
+#endif
+         fromcopy = ick_findandfopen(buf2,ick_datadir,"rb",argv[0]);
+         if(!fromcopy) /* same error as for syslib */
+           ick_lose(IE127, 1, (char*) NULL);
+#if __DJGPP__
+         /* Look for a temp directory to store a copy of the C file,
+            the resulting .cio, .o files, etc. */
+         if(isenv("TMP")) tempfn="/dev/env/TMP/%s.c";
+         if(isenv("TEMP")) tempfn="/dev/env/TEMP/%s.c";
+         if(isenv("TMPDIR")) tempfn="/dev/env/TMPDIR/%s.c";
+         if(isenv("ICKTEMP")) tempfn="/dev/env/ICKTEMP/%s.c";
+#else
+         tempfn="/tmp/%s.c"; /* always valid on POSIX */
+#endif
+         /*@-formatconst@*/ /* all possibilities are fine */
+#ifndef HAVE_SNPRINTF
+         (void) sprintf(buf2, tempfn, argv[optind]);
+#else
+         (void) snprintf(buf2, sizeof buf2, tempfn, argv[optind]);
+#endif
+         /*@=formatconst@*/
+         if((tocopy = fopen(buf2,"wb")) == NULL)
+           ick_lose(IE888, 1, (char*) NULL);
 
-           if(useickec && (!strcmp(chp,"c") || !strcmp(chp,"cio"))) /* AIS */
-           {
-             break; /* don't process C or cio files further yet */
-           }
+         for(;;)
+         {
+           c2=fgetc(fromcopy);
+           if(c2==EOF) break;
+           (void) fputc(c2,tocopy);
+         }
+         (void) fclose(fromcopy); (void) fclose(tocopy);
+         /*@+onlytrans@*/
+         /* this is a memory leak that will need sorting out later,
+            thus the explicit turn-warning-on */
+         argv[optind]=malloc(sizeof(buf2)+1);
+         /*@=onlytrans@*/
+         if(!(argv[optind]))
+           ick_lose(IE888, 1, (char*) NULL);
+         strcpy(argv[optind],buf2);
+         *(strrchr(argv[optind],'.')) = '\0';
+         continue;
+       }
 
-           if(useickec && firstfile == ick_FALSE) /* AIS */
-             ick_lose(IE998, 1, (char *)NULL);
-
-           /* wwp: reset the base variables to defaults, because if the  */
-           /* sourcefile has extension .i they will not be reset in the  */
-           /* following chunk of code. but i don't want to modify the    */
-           /* following chunk of code because i think it is very clever; */
-           /* grabs the base on the ick_first pass, then validates the rest  */
-           /* of the extension on the second.                            */
-           ick_Base = DEFAULT_BASE;
-           ick_Small_digits = DEFAULT_SMALL_DIGITS;
-           ick_Large_digits = DEFAULT_LARGE_DIGITS;
-           ick_Max_small = (unsigned)DEFAULT_MAX_SMALL;
-           ick_Max_large = (unsigned)DEFAULT_MAX_LARGE;
-
-           /* determine the file type from the extension */
-           while (strcmp(chp,"i"))
-           {
-             ick_Base = (int)strtol(chp,&chp,10);
-               if (ick_Base < 2 || ick_Base > maxbase)
-                   ick_lose(IE998, 1, (char *)NULL);
-               else if (ick_traditional && ick_Base != 2)
-                   ick_lose(IE111, 1, (char *)NULL);
-               else if (pickcompile && ick_Base != 2)
-                   ick_lose(IE256, 1, (char *)NULL); /* AIS */
-               ick_Small_digits = smallsizes[ick_Base];
-               ick_Large_digits = 2 * ick_Small_digits;
-               ick_Max_small = maxsmalls[ick_Base];
-               if (ick_Max_small == 0xffff)
-                 ick_Max_large = (unsigned)0xffffffffLU;
-               else
-                   ick_Max_large = (ick_Max_small + 1) * (ick_Max_small + 1) - 1;
-           }
+       ick_lose(IE998, 1, (char *)NULL);
+      }
+      *chp++ = '\0';
 
-           /* zero out tuple and oblist storage */
-           treset();
-           politesse = 0;
-            /* JH: default to no op-overusage and no computed come from */
-            opoverused = 0;
-            compucomesused = compucomecount = 0;
+      if(useickec && (!strcmp(chp,"c") || !strcmp(chp,"cio"))) /* AIS */
+      {
+       if(firstfile != ick_FALSE) /* need exactly 1 INTERCAL file */
+         ick_lose(IE998, 1, (char *)NULL);
+       break; /* don't process C or cio files further yet */
+      }
 
-           /* reset the lex/yacc environment */
-           if (!firstfile)
-           {
+      if(useickec && firstfile == ick_FALSE) /* AIS */
+       ick_lose(IE998, 1, (char *)NULL);
+
+      /* wwp: reset the base variables to defaults, because if the  */
+      /* sourcefile has extension .i they will not be reset in the  */
+      /* following chunk of code. but i don't want to modify the    */
+      /* following chunk of code because i think it is very clever; */
+      /* grabs the base on the ick_first pass, then validates the rest  */
+      /* of the extension on the second.                            */
+      ick_Base = DEFAULT_BASE;
+      ick_Small_digits = DEFAULT_SMALL_DIGITS;
+      ick_Large_digits = DEFAULT_LARGE_DIGITS;
+      ick_Max_small = (unsigned)DEFAULT_MAX_SMALL;
+      ick_Max_large = (unsigned)DEFAULT_MAX_LARGE;
+
+      /* determine the file type from the extension */
+      while (strcmp(chp,"i"))
+      {
+       ick_Base = (int)strtol(chp,&chp,10);
+       if (ick_Base < 2 || ick_Base > maxbase)
+         ick_lose(IE998, 1, (char *)NULL);
+       else if (ick_traditional && ick_Base != 2)
+         ick_lose(IE111, 1, (char *)NULL);
+       else if (pickcompile && ick_Base != 2)
+         ick_lose(IE256, 1, (char *)NULL); /* AIS */
+       ick_Small_digits = smallsizes[ick_Base];
+       ick_Large_digits = 2 * ick_Small_digits;
+       ick_Max_small = maxsmalls[ick_Base];
+       if (ick_Max_small == 0xffff)
+         ick_Max_large = (unsigned)0xffffffffLU;
+       else
+         ick_Max_large = (ick_Max_small + 1) * (ick_Max_small + 1) - 1;
+      }
+
+      /* zero out tuple and oblist storage */
+      treset();
+      politesse = 0;
+      /* JH: default to no op-overusage and no computed come from */
+      opoverused = 0;
+      compucomesused = compucomecount = 0;
+      gerucomesused = 0; /* AIS: you forgot this one */
+      /* AIS: ensure that at least one variable exists, to prevent
+        NULL pointers later on */
+      (void) intern(ick_ONESPOT, 1); /* mention .1 */
+
+      /* reset the lex/yacc environment */
+      if (!firstfile)
+      {
 #ifdef NEED_YYRESTART
-             yyrestart(stdin);
+       yyrestart(stdin);
 #endif /* NEED_YYRESTART */
-             iyylineno = 1;
-           }
+       iyylineno = 1;
+      }
 
-           /* compile tuples from current input source */
-           (void) yyparse();
+      /* compile tuples from current input source */
+      (void) yyparse();
 
-           if(variableconstants)
-           {
-             /* AIS: Up to 4 extra meshes may be needed by feh.c. */
-             (void) intern(MESH, 0xFFFFFFFFLU);
-             (void) intern(MESH, 0xFFFFLU);
-             (void) intern(MESH, 0xAAAAAAAALU);
-             (void) intern(MESH, 0x55555555LU);
-           }
+      if(variableconstants)
+      {
+       /* AIS: Up to 4 extra meshes may be needed by feh.c. */
+       (void) intern(MESH, 0xFFFFFFFFLU);
+       (void) intern(MESH, 0xFFFFLU);
+       (void) intern(MESH, 0xAAAAAAAALU);
+       (void) intern(MESH, 0x55555555LU);
+      }
 
 
-           /*
-            * Miss Manners lives.
-            */
-           if (ick_lineno > 2)
-           {
-               if (politesse == 0 || (ick_lineno - 1) / politesse >= 5)
-                   ick_lose(IE079, iyylineno, (char *)NULL);
-               else if (ick_lineno / politesse < 3)
-                   ick_lose(IE099, iyylineno, (char *)NULL);
-           }
+      /*
+       * Miss Manners lives.
+       */
+      if (ick_lineno > 2)
+      {
+       if (politesse == 0 || (ick_lineno - 1) / politesse >= 5)
+         ick_lose(IE079, iyylineno, (char *)NULL);
+       else if (ick_lineno / politesse < 3)
+         ick_lose(IE099, iyylineno, (char *)NULL);
+      }
 
-           /*
-            * check if we need to magically include the system library
-            */
+      /*
+       * check if we need to magically include the system library
+       */
+      needsyslib = ick_FALSE;
+      if(!pickcompile) /* AIS: We never need syslib when compiling
+                         for PIC, because it's preoptimized. */
+      {
+       for (tp = tuples; tp->type; tp++)
+       {
+         /*
+          * If some label in the (1000)-(2000) range is defined,
+          * then clearly the syslib is already there, so we
+          * can stop searching and won't need the syslib.
+          */
+         if (tp->label >= 1000 && tp->label <= 1999) {
            needsyslib = ick_FALSE;
-           if(!pickcompile) /* AIS: We never need syslib when compiling
-                               for PIC, because it's preoptimized. */
-           {
-             for (tp = tuples; tp->type; tp++)
-             {
-               /*
-                * If some label in the (1000)-(2000) range is defined,
-                * then clearly the syslib is already there, so we
-                * can stop searching and won't need the syslib.
-                */
-               if (tp->label >= 1000 && tp->label <= 1999) {
-                 needsyslib = ick_FALSE;
-                 break;
-               }
-               /*
-                * If some label in the (1000)-(2000) range is being
-                * called, we might need the system library.
-                */
-               if (tp->type == NEXT && tp->u.target >= 1000 &&
-                   tp->u.target <= 1999)
-                 needsyslib = ick_TRUE;
-             }
-           }
-           if ( needsyslib ) { /* AIS: modified to use ick_findandfreopen */
-             if (ick_Base == 2)    /* see code for opening the skeleton */
+           break;
+         }
+         /*
+          * If some label in the (1000)-(2000) range is being
+          * called, we might need the system library.
+          */
+         if (tp->type == NEXT && tp->u.target >= 1000 &&
+             tp->u.target <= 1999)
+           needsyslib = ick_TRUE;
+       }
+      }
+      if(nosyslib) needsyslib = ick_FALSE; /* AIS */
+      if (needsyslib)
+      { /* AIS: modified to use ick_findandfreopen */
+       if (ick_Base == 2)    /* see code for opening the skeleton */
 #ifndef HAVE_SNPRINTF
-               (void) sprintf(buf2, "%s.i", SYSLIB);
+         (void) sprintf(buf2, "%s.i", SYSLIB);
 #else
-             (void) snprintf(buf2, sizeof buf2, "%s.i", SYSLIB);
+       (void) snprintf(buf2, sizeof buf2, "%s.i", SYSLIB);
 #endif
-             else
+       else
 #ifndef HAVE_SNPRINTF
-               (void) sprintf(buf2, "%s.%di", SYSLIB, ick_Base);
+         (void) sprintf(buf2, "%s.%di", SYSLIB, ick_Base);
 #else
-             (void) snprintf(buf2, sizeof buf2, "%s.%di", SYSLIB, ick_Base);
+       (void) snprintf(buf2, sizeof buf2, "%s.%di", SYSLIB, ick_Base);
 #endif
-             if (ick_findandfreopen(buf2, ick_datadir, "r", argv[0], stdin) == NULL)
-               ick_lose(IE127, 1, (char*) NULL);
+       if (ick_findandfreopen(buf2, ick_datadir, "r", argv[0], stdin) == NULL)
+         ick_lose(IE127, 1, (char*) NULL);
 #ifdef USE_YYRESTART
-             yyrestart(stdin);
+       yyrestart(stdin);
 #endif /* USE_YYRESTART */
-             (void) yyparse();
-             textlinecount=iyylineno;
-           }
+       (void) yyparse();
+       textlinecount=iyylineno;
+      }
 
-           /*
-            * Now propagate type information up the expression tree.
-            * We need to do this because the unary-logical operations
-            * are sensitive to the type widths of their operands, so
-            * we have to generate different code depending on the
-            * deducible type of the operand.
-            */
-           for (tp = tuples; tp->type; tp++)
-           {
-               if (tp->type == GETS || tp->type == RESIZE
-                   || tp->type == WRITE_IN || tp->type == READ_OUT
-                   || tp->type == FROM || tp->type == MANYFROM
-                   || tp->type == FORGET || tp->type == RESUME
-                   || tp->type == COMPUCOME)
-                 typecast(tp->type == MANYFROM ? tp->u.node->lval : tp->u.node);
-               if (tp->type == WRITE_IN) coopt = 0; /* AIS: may as well do
-                                                       this here */
-           }
+      /*
+       * Now propagate type information up the expression tree.
+       * We need to do this because the unary-logical operations
+       * are sensitive to the type widths of their operands, so
+       * we have to generate different code depending on the
+       * deducible type of the operand.
+       */
+      for (tp = tuples; tp->type; tp++)
+      {
+       if (tp->type == GETS || tp->type == RESIZE
+           || tp->type == WRITE_IN || tp->type == READ_OUT
+           || tp->type == FROM || tp->type == MANYFROM
+           || tp->type == FORGET || tp->type == RESUME
+           || tp->type == COMPUCOME || tp->type == UNKNOWN)
+         typecast(tp->type == MANYFROM ? tp->u.node->lval : tp->u.node);
+       if (tp->type == WRITE_IN) coopt = 0; /* AIS: may as well do
+                                               this here */
+      }
+
+      codecheck();     /* check for compile-time errors */
+      /* AIS: And importantly, sort out line number references */
 
-           codecheck();        /* check for compile-time errors */
-           /* AIS: And importantly, sort out line number references */
-
-           /* perform optimizations */
-           if (dooptimize)
-               for (tp = tuples; tp->type; tp++)
-               {
-                 /* AIS: Allow breaching of the only specification on tuples
-                    at this point; I've checked that tuples isn't reallocated
-                    during the block, so this is fine. */
-                 /*@-onlytrans@*/
-                 optuple = tp;
-                 /*@=onlytrans@*/
-                 if (tp->type == GETS || tp->type == RESIZE
-                     || tp->type == FORGET || tp->type == RESUME
-                     || tp->type == FROM || tp->type == COMPUCOME)
-                   optimize(tp->u.node);
-                 if (tp->type == MANYFROM) optimize(tp->u.node->lval);
-               } /* AIS: Added FROM and MANYFROM support. */
-
-           /* AIS: perform flow optimizations */
-           if (flowoptimize) optimizef();
-
-           /* decide if and where to place the compiler bug */
+      /* perform optimizations */
+      if (dooptimize)
+       for (tp = tuples; tp->type; tp++)
+       {
+         /* AIS: Allow breaching of the only specification on tuples
+            at this point; I've checked that tuples isn't reallocated
+            during the block, so this is fine. */
+         /*@-onlytrans@*/
+         optuple = tp;
+         /*@=onlytrans@*/
+         if (tp->type == GETS || tp->type == RESIZE
+             || tp->type == FORGET || tp->type == RESUME
+             || tp->type == FROM || tp->type == COMPUCOME)
+           optimize(tp->u.node);
+         if (tp->type == MANYFROM) optimize(tp->u.node->lval);
+       } /* AIS: Added FROM and MANYFROM support. */
+
+      /* AIS: perform flow optimizations */
+      if (flowoptimize) optimizef();
+
+      /* decide if and where to place the compiler bug */
 #ifdef USG
-           if (!nocompilerbug && lrand48() % 10 == 0)
-               bugline = (int)(lrand48() % ick_lineno);
+      if (!nocompilerbug && lrand48() % 10 == 0)
+       bugline = (int)(lrand48() % ick_lineno);
 #else
-           if (!nocompilerbug && rand() % 10 == 0)
-               bugline = rand() % ick_lineno;
+      if (!nocompilerbug && rand() % 10 == 0)
+       bugline = rand() % ick_lineno;
 #endif
-           else
-               bugline = -1;
-
-           /* set up the generated C output file name */
-           (void) strcpy(buf, argv[optind]);
-           (void) strcat(buf, ".c");
-           /* AIS: ofp holds fopened storage if !outtostdout, and local-copy
-              storage if outtostdout, and this is not a bug, although it
-              confuses Splint. */
-           /*@-branchstate@*/
-           if(outtostdout) ofp=stdout; /* AIS */
-           else if((ofp = ick_debfopen(buf, "w")) == (FILE *)NULL)
-               ick_lose(IE888, 1, (char *)NULL);
-           /*@=branchstate@*/
-
-           (void) fseek(ifp,0L,0);     /* rewind skeleton file */
-
-           /* AIS: Before changing argv[0], locate coopt.sh. */
-           cooptsh = ick_findandtestopen("coopt.sh", ick_datadir, "rb", argv[0]);
-           /* AIS: and calculate yukcmdstr. */
+      else
+       bugline = -1;
+
+      /* set up the generated C output file name */
+      (void) strcpy(buf, argv[optind]);
+      (void) strcat(buf, ".c");
+      /* AIS: ofp holds fopened storage if !outtostdout, and local-copy
+        storage if outtostdout, and this is not a bug, although it
+        confuses Splint. */
+      /*@-branchstate@*/
+      if(outtostdout) ofp=stdout; /* AIS */
+      else if((ofp = ick_debfopen(buf, "w")) == (FILE *)NULL)
+       ick_lose(IE888, 1, (char *)NULL);
+      /*@=branchstate@*/
+
+      (void) fseek(ifp,0L,0);  /* rewind skeleton file */
+
+      /* AIS: Before changing argv[0], locate coopt.sh. */
+      cooptsh = ick_findandtestopen("coopt.sh", ick_datadir, "rb", argv[0]);
+      /* AIS: and calculate yukcmdstr. */
 #ifndef HAVE_SNPRINTF
-           (void) sprintf(yukcmdstr,"%s" EXEEXT " %s %s",
-                   argv[optind],ick_datadir,argv[0]);
+      (void) sprintf(yukcmdstr,"%s%s" EXEEXT " %s %s",
+                    strchr(argv[optind],'/')||strchr(argv[optind],'\\')?
+                    "":"./",argv[optind],ick_datadir,argv[0]);
 #else
-           (void) snprintf(yukcmdstr, sizeof yukcmdstr, "%s" EXEEXT " %s %s",
-                   argv[optind], ick_datadir, argv[0]);
+      (void) snprintf(yukcmdstr, sizeof yukcmdstr, "%s%s" EXEEXT " %s %s",
+                    strchr(argv[optind],'/')||strchr(argv[optind],'\\')?
+                    "":"./",argv[optind],ick_datadir,argv[0]);
 #endif
 
-           /* AIS: Remove the filename from argv[0], leaving only a directory.
-              If this would leave it blank, change argv[0] to '.'.
-              This is so gcc can find the includes/libraries the same way that
-              ick_findandfreopen does. */
-            /* JH: use a copy of argv[0] for the path, to ensure argv[0] is
-             * available for the next round
-             */
-            strcpy(path,argv[0]);
-           if(strchr(path,'/')) *(strrchr(path,'/')) = '\0';
-           else strcpy(path,".");
+      /* AIS: Remove the filename from argv[0], leaving only a directory.
+        If this would leave it blank, change argv[0] to '.'.
+        This is so gcc can find the includes/libraries the same way that
+        ick_findandfreopen does. */
+      /* JH: use a copy of argv[0] for the path, to ensure argv[0] is
+       * available for the next round
+       */
+      strcpy(path,argv[0]);
+      if(strchr(path,'/')) *(strrchr(path,'/')) = '\0';
+      else strcpy(path,".");
 
 #ifndef HAVE_SNPRINTF
-           (void) sprintf(buf2,
+      (void) sprintf(buf2,
+#if 0
+                    0); /* unconfuse Emacs' autoindenter */
+#endif
 #else
-            (void) snprintf(buf2, sizeof buf2,
+      (void) snprintf(buf2, sizeof buf2,
 #endif
-                          "%s %s%s-I%s -I%s -I%s/../include -L%s -L%s -L%s/../lib -O%c -o %s"
+                     "%s %s%s-I%s -I%s -I%s/../include -L%s -L%s -L%s/../lib -O%c -o %s"
 #ifdef __DJGPP__
-                          EXEEXT " -lick%s%s","",
+                     EXEEXT " -lick%s%s","",
 #else
-                          EXEEXT " -lick%s%s",compiler,
-#endif
-                          buf, yukdebug||yukprofile?" -lyuk ":" ",
-                          includedir, path, path, libdir, path, path,
-                          coopt?'3':'2', /* AIS: If coopting, optimize as much as possible */
-                          argv[optind], multithread?"mt":"", cdebug?" -g":"");
-           /* AIS: Possibly link in the debugger yuk and/or libickmt.a here. */
-           /* AIS: Added -g support. */
-           /* AIS: Added argv[0] (now path) to the -I, -L settings. */
-
-           textlinecount=0; /* AIS: If there are no files, there's
-                               no need to free any textlines */
-           while ((c = myfgetc(ifp)) != EOF)
-             if (c != (int)'$')
-                   (void) fputc(c, ofp);
-               else switch(myfgetc(ifp))
-               {
-               case 'A':       /* source name stem */
-                   (void) fputs(argv[optind], ofp);
-                   break;
-
-               case 'B':       /* # of statements */
-                   (void) fprintf(ofp, "%d", ick_lineno);
-                   break;
-
-               case 'C':       /* initial abstentions */
-                 /* AIS: Modified to check for coopt, pickcompile */
-                   maxabstain = 0;
-                   for (tp = tuples; tp->type; tp++)
-                       if (((tp->exechance <= 0 || tp->exechance >= 101)
-                            && tp - tuples + 1 > maxabstain)
-                           || coopt || pickcompile)
-                           maxabstain = tp - tuples + 1;
-                   if (maxabstain)
-                   {
-                       if(!pickcompile) (void) fprintf(ofp, " = {");
-                       for (tp = tuples; tp < tuples + maxabstain; tp++)
-                       {
-                           if(tp->exechance != 100 && tp->exechance != -100)
-                           { /* AIS: The double-oh-seven operator prevents
-                                coopt working. However, syslib contains a
-                                double-oh-seven. feh.c has checked that that
-                                isn't referenced; if it isn't, we can allow
-                                one double-oh-seven if syslib was
-                                automagically inclulded. */
-                             if(needsyslib) needsyslib = 0; else coopt = 0;
-                           }
-                           if(!pickcompile)
-                           {
-                             if (tp->exechance > 0)
-                             {
-                               (void) fprintf(ofp, "0, ");
-                               tp->initabstain=0; /* AIS: -f might not be
-                                                     given, so we can't rely
-                                                     on dekludge.c doing
-                                                     this */
-                             }
-                             else {
-                               (void) fprintf(ofp, "1, ");
-                               tp->exechance = -tp->exechance;
-                               tp->initabstain=1; /* AIS: As above */
-                               /* AIS: If the line was ick_abstained, we need to
-                                  swap ONCEs and AGAINs on it round, to suit
-                                  the code degenerator. */
-                               if(tp->onceagainflag == onceagain_ONCE)
-                                 tp->onceagainflag = onceagain_AGAIN;
-                               else if(tp->onceagainflag == onceagain_AGAIN)
-                                 tp->onceagainflag = onceagain_ONCE;
-                             }
-                             if(tp->exechance >= 101)
-                             {
-                               /* AIS: This line has a MAYBE */
-                               tp->maybe = 1;
-                               tp->exechance /= 100;
-                             }
-                             else tp->maybe = 0;
-                           }
-                           else /* AIS: hardcoded abstain bits for PICs */
-                           {
-                             if(!tp->abstainable) continue;
-                             if(tp->exechance > 0)
-                               (void) fprintf(ofp, "ICK_INT1 ICKABSTAINED(%d)=0;\n",tp-tuples);
-                             else
-                               (void) fprintf(ofp, "ICK_INT1 ICKABSTAINED(%d)=1;\n",tp-tuples);
-                           }
-                       }
-                       if(!pickcompile) (void) fprintf(ofp, "}");
-                   }
-                   break;
-
-               case 'D':       /* linetypes ick_array for abstention handling */
-                   maxabstain = 0;
-                   for (tp = tuples; tp->type; tp++)
-                       if (tp->type == ENABLE || tp->type == DISABLE || tp->type == MANYFROM)
-                           maxabstain++;
-                   if (maxabstain || /* AIS */ gerucomesused)
-                   {
-                     /* AIS: Changed to use enablersm1 */
-                     /*(void) fprintf(ofp, "#define UNKNOWN\t\t0\n");*/
-                       i = 0;
-                       for (;i < (int)(sizeof(enablersm1)/sizeof(char *));i++)
-                           (void) fprintf(ofp,
-                                          "#define %s\t%d\n",
-                                          enablersm1[i], i);
-
-                       (void) fprintf(ofp, "int linetype[] = {\n");
-                       for (tp = tuples; tp->type; tp++)
-                         if(tp->ppnewtype) /* AIS */
-                           (void) fprintf(ofp,"    %s,\n",
-                                          enablers[tp->ppnewtype - GETS]);
-                         else if(tp->preproc) /* AIS */
-                           (void) fprintf(ofp,"    PREPROC,\n");
-                         else if (tp->type >= GETS && tp->type <= FROM)
-                            /* AIS: FROM added */
-                               (void) fprintf(ofp,
-                                              "    %s,\n",
-                                              enablers[tp->type - GETS]);
-                           else
-                               (void) fprintf(ofp, "    UNKNOWN,\n");
-                       (void) fprintf(ofp, "};\n");
-                   }
-                   break;
-
-               case 'E':       /* extern to intern map */
-                 if(!pickcompile)
-                 {
-                   (void) fprintf(ofp,"int ick_Base = %d;\n",ick_Base);
-                   (void) fprintf(ofp,"int ick_Small_digits = %d;\n",
-                                  ick_Small_digits);
-                   (void) fprintf(ofp,"int ick_Large_digits = %d;\n",
-                                  ick_Large_digits);
-                   (void) fprintf(ofp,"unsigned int ick_Max_small = 0x%x;\n",
-                                  ick_Max_small);
-                   (void) fprintf(ofp,"unsigned int ick_Max_large = 0x%x;\n",
-                                  ick_Max_large);
-                   if (yukprofile || yukdebug || multithread)
-                   { /* AIS: yuk.c, multithreading require all these to exist */
-                     if(!nonespots) nonespots = 1;
-                     if(!ntwospots) ntwospots = 1;
-                     if(!ntails) ntails = 1;
-                     if(!nhybrids) nhybrids = 1;
-                   }
-                   else if(opoverused)
-                   {
-                     /* AIS: The operand-overloading code requires onespot and
-                        twospot variables to exist. */
-                     if(!nonespots) nonespots = 1;
-                     if(!ntwospots) ntwospots = 1;
-                   }
-                   /* AIS:I de-staticed all these so they could be accessed by
-                      yuk and cesspool, and added all the mentions of yuk and
-                      multithread. Then I changed it so the variables would be
-                      allocated dynamically, to speed up multithreading. (It's
-                      an O(1) change to the speed of ordinary programs, so I
-                      thought I could get away with it. The order is wrt the
-                      number of lines in the program. The change is O(n) wrt
-                      the number of variables, but again I hope that doesn't
-                      matter, and I won't get the entire INTERCAL community
-                      angry with me for daring to implement an extension that
-                      slows down existing programs.) */
-                   if (variableconstants) /* AIS */
-                   {
-                     int temp=0;
-                     (void) fprintf(ofp, "ick_type32 meshes[%d] = {",nmeshes);
-                     while(temp<nmeshes)
-                     {
-                       (void) fprintf(ofp, "%luLU, ", varextern((unsigned long)temp,MESH));
-                       temp++;
-                     }
-                     (void) fprintf(ofp, "};\n");
-                   }
-
-                   if (nonespots)
-                   {
-                       (void) fprintf(ofp,
-                                      "ick_type16* ick_onespots;\n");
-                       (void) fprintf(ofp,
-                                      "ick_bool* ick_oneforget;\n");
-                       if(yukprofile || yukdebug)
-                       {
-                         (void) fprintf(ofp,
-                                        "ick_type16 oneold[%d];\n",
-                                        nonespots);
-                         (void) fprintf(ofp,
-                                        "signed char onewatch[%d];\n",
-                                        nonespots);
-                       }
-                       if(multithread)
-                       {
-                         (void) fprintf(ofp,
-                                        "int onespotcount = %d;\n",
-                                        nonespots);
-                       }
-                       if(opoverused) /* AIS */
-                       {
-                         int temp=nonespots;
-                         (void) fprintf(ofp,
-                                        "ick_overop* ick_oo_onespots;\n");
-                         while(temp--)
-                           (void) fprintf(ofp,
-"ick_type32 og1spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_onespots[%d];\n}\n"
-"void os1spot%d(ick_type32 val, void(*f)())\n{\n  (void)f;\n  ick_assign((void*)"
-"(ick_onespots+%d), ick_ONESPOT, ick_oneforget[%d], val);\n}\n",temp,temp,temp,temp,temp);
-                       }
-                       else if(multithread)
-                         (void) fprintf(ofp, "ick_overop* ick_oo_onespots=0;\n");
-                   }
-                   if (ntwospots)
-                   {
-                       (void) fprintf(ofp,
-                                      "ick_type32* ick_twospots;\n");
-                       (void) fprintf(ofp,
-                                      "ick_bool* ick_twoforget;\n");
-                       if(yukprofile || yukdebug)
-                       {
-                         (void) fprintf(ofp,
-                                        "ick_type32 twoold[%d];\n",
-                                        ntwospots);
-                         (void) fprintf(ofp,
-                                        "signed char twowatch[%d];\n",
-                                        ntwospots);
-                       }
-                       if(multithread)
-                       {
-                         (void) fprintf(ofp,
-                                        "int twospotcount = %d;\n",
-                                        ntwospots);
-                       }
-                       if(opoverused) /* AIS */
-                       {
-                         int temp=ntwospots;
-                         (void) fprintf(ofp,
-                                        "ick_overop* ick_oo_twospots;\n");
-                         while(temp--)
-                           (void) fprintf(ofp,
-"ick_type32 og2spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_twospots[%d];\n}\n"
-"void os2spot%d(ick_type32 val, void(*f)())\n{\n  (void)f;\n  ick_assign((void*)"
-"(ick_twospots+%d), ick_TWOSPOT, ick_twoforget[%d], val);\n}\n",temp,temp,temp,temp,temp);
-                       }
-                       else if(multithread)
-                         (void) fprintf(ofp, "ick_overop* ick_oo_twospots=0;\n");
-                   }
-                   if (ntails)
-                   {
-                       (void) fprintf(ofp,
-                                      "ick_array* ick_tails;\n");
-                       (void) fprintf(ofp,
-                                      "ick_bool* ick_tailforget;\n");
-                       if(multithread)
-                       {
-                         (void) fprintf(ofp,
-                                        "int tailcount = %d;\n",
-                                        ntails);
-                       }
-                   }
-                   if (nhybrids)
-                   {
-                       (void) fprintf(ofp,
-                                      "ick_array* ick_hybrids;\n");
-                       (void) fprintf(ofp,
-                                      "ick_bool* ick_hyforget;\n");
-                       if(multithread)
-                       {
-                         (void) fprintf(ofp,
-                                        "int hybridcount = %d;\n",
-                                        nhybrids);
-                       }
-                   }
-                   if (yydebug || compile_only)
-                   {
-                     assert(oblist != NULL);
-                     for (op = oblist; op < obdex; op++)
-                       if(op->type!=MESH) /* AIS: Added this check */
-                         (void) fprintf(ofp, " /* %s %lu -> %lu */\n",
-                                        nameof(op->type, vartypes),
-                                        op->extindex,
-                                        op->intindex);
-                   }
-                   if (yukdebug || yukprofile)
-                   { /* AIS: drop intern to extern map into the program */
-                     (void) fprintf(ofp, "\nyukvar yukvars[]={\n");
-                     assert(oblist != NULL);
-                     for (op = oblist; op < obdex; op++)
-                       if(op->type!=MESH) /* AIS: Added this check */
-                         (void) fprintf(ofp,"    {%s,%lu,%lu},\n",
-                                        nameof(op->type, vartypes),
-                                        op->extindex,
-                                        op->intindex);
-                     (void) fprintf(ofp,"    {YUKEND,0,0}};\n");
-                   }
-                 }
-                 else
-                 {
-                   /* Compiling for PIC */
-                   /* Arrays not supported on PICs */
-                   if(ntails || nhybrids)
-                     ick_lose(IE256, iyylineno, (char*) NULL);
-                   /* and neither are variable constants */
-                   if(variableconstants)
-                     ick_lose(IE256, iyylineno, (char*) NULL);
-                   assert(oblist != NULL);
-                   for (op = oblist; op < obdex; op++)
-                   {
-                     (void) fprintf(ofp, " /* %s %lu -> %lu */\n",
-                                    nameof(op->type, vartypes),
-                                    op->extindex,
-                                    op->intindex);
-                     (void) fprintf(ofp, "#define %s%lu %s[%lu]\n",
-                                    nameof(op->type, vartypes),
-                                    op->extindex,
-                                    nameof(op->type, varstores),
-                                    op->intindex);
-                     if(op->ignorable)
-                       (void) fprintf(ofp, "ICK_INT1 ignore%s%lu = 0;\n",
-                                      nameof(op->type, varstores),
-                                      op->intindex);
-                   }
-                   (void) fprintf(ofp, "#include \"pick1.h\"\n");
-                   if(nonespots)
-                   {
-                     (void) fprintf(ofp,
-                                    "ICK_INT16 ick_onespots[%d];\n"
-                                    "ICK_INT16 onespotsstash[%d];\n",
-                                    nonespots,
-                                    nonespots);
-                     if(opoverused) /* AIS */
-                     {
-                       int temp=nonespots;
-                       (void) fprintf(ofp,"ick_overop* ick_oo_onespots;\n");
-                       while(temp--)
-                         (void) fprintf(ofp,
-"ick_type32 og1spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_onespots[%d];\n}\n"
-"void os1spot%d(ick_type32 val,void(*f)())\n{\n  (void)f;\n  if(!ignoreonespots%d)"
-" ick_onespots[%d]=val;\n}\n",temp,temp,temp,temp,temp);
-                     }
-                   }
-                   if(ntwospots)
-                   {
-                     (void) fprintf(ofp,
-                                    "ICK_INT32 ick_twospots[%d];\n"
-                                    "ICK_INT32 twospotsstash[%d];\n",
-                                    ntwospots,
-                                    ntwospots);
-                     if(opoverused) /* AIS */
-                     {
-                       int temp=ntwospots;
-                       (void) fprintf(ofp,"ick_overop* ick_oo_twospots;\n");
-                       while(temp--)
-                         (void) fprintf(ofp,
-"ick_type32 og2spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_twospots[%d];\n}\n"
-"void os2spot%d(ick_type32 val,void(*f)())\n{\n  (void)f;\n  if(!ignoretwospots%d)"
-" ick_twospots[%d]=val;\n}\n",temp,temp,temp,temp,temp);
-                     }
-                   }
-                   (void) fprintf(ofp, "#include \"pick2.h\"\n");
-                 }
-                 break;
-
-               case 'F':       /* set options from command line */
-                   if (ick_clockface)
-                       (void) fprintf(ofp, "ick_clockface(ick_TRUE);\n");
-                   if (ick_clcsemantics) /* AIS */
-                     (void) fprintf(ofp, "ick_setclcsemantics(ick_TRUE);\n");
-                   break;
-
-               case 'G':       /* degenerated code */
-                   for (tp = tuples, i = 0; tp->type; tp++, i++)
-                   {
-                       emit(tp, ofp);
-                       if (i == bugline)
-                           (void) fprintf(ofp, "    ick_lose(IE774, ick_lineno, "
-                                               "(char *)NULL);\n");
-                   }
-                   break;
-
-               case 'H':       /* COMPUCOME, and dispatching for resumes */
-                 /* AIS: Added COMPUCOME here. This line must be fully guarded
-                   to prevent a longjmp to an uninitialised buffer (it's
-                   guarded by a ick_lose() in ick-wrap.c.) Also checks for
-                   multithread; programs that mix normal and computed COME
-                   FROM need to use the same conventions for both, so even
-                   if no computed COME FROMs are used, the normal ones need
-                   this line so that COME FROMs can be handled consistently.*/
-                   if(compucomesused || multithread)
-                   {
-                     (void) fprintf(ofp, "CCFL: ; CCF%d: longjmp(ick_cjb,1);\n",
-                                    compucomecount);
-                   }
-#if 0
-                   /* AIS: This section is no longer used, because a switch
-                      is used inline instead of using gotos into the code. */
-                   nextcount = 0;
-                   for (tp = tuples; tp->type; tp++)
-                       if (tp->type == NEXT)
-                           nextcount++;
-                   if (nextcount)
-                   {
-                       (void) fputs("/* generated switch for resumes */",ofp);
-                       (void) fputs("top:\n    switch(ick_skipto)\n    {\n", ofp);
-                       for (tp = tuples; tp->type; tp++)
-                           if (tp->type == NEXT)
-                               (void) fprintf(ofp,
-                                              "\tcase %d: goto N%d; break;\n",
-                                              (int)(tp-tuples+1), (int)(tp-tuples+1));
-                       (void) fprintf(ofp, "    }");
-                   }
+                     EXEEXT " -lick%s%s",compiler,
 #endif
-                   break;
-
-               case 'J':       /* # of source file lines */
-                   (void) fprintf(ofp, "%d", iyylineno);
-                   break;
-
-               case 'K':       /* AIS: yuk information (or not) */
-                 if(yukdebug||yukprofile)
-                 {
-                   (void) fprintf(ofp, "#include \"yuk.h\"\n\n");
-                   (void) fprintf(ofp, "char* textlines[] = {\n");
-                   emittextlines(ofp); /* from feh.c */
-                   (void) fprintf(ofp, "\"\"};\n\n");
-                   (void) fprintf(ofp, "char* yukexplain[] = {\n");
-                   for (tp = tuples; tp->type; tp++)
-                   {
-                     if (tp->type == GETS || tp->type == FORGET || tp->type == RESUME
-                         || tp->type == FROM || tp->type == COMPUCOME
-                         || tp->type == MANYFROM)
-                     {
-                       (void) fprintf(ofp, "\"");
-                       explexpr(tp->type == MANYFROM ? tp->u.node->lval :
-                                tp->type == GETS ? tp->u.node->rval : tp->u.node, ofp);
-                       (void) fprintf(ofp, "\",\n");
-                     }
-                     else (void) fprintf(ofp, "0,");
-                   }
-                   (void) fprintf(ofp, "0};\n\n");
-                   (void) fprintf(ofp, "int lineofaboff[] = {\n");
-                   for (tp = tuples; tp->type; tp++)
-                   {
-                     fprintf(ofp,"%d,",tp->ick_lineno);
-                   }
-                   (void) fprintf(ofp, "-1};\n\n");
-                   (void) fprintf(ofp, "int yukopts = %d;\n", yukprofile+yukdebug*2);
-                   (void) fprintf(ofp, "yptimer ypexectime[%d];\n", ick_lineno);
-                   (void) fprintf(ofp, "ypcounter ypexecount[%d];\n",ick_lineno);
-                   (void) fprintf(ofp, "ypcounter ypabscount[%d];\n",ick_lineno);
-                 }
-                 break;
-
-               case 'L': /* AIS: increase Emacs compatibility */
-                 (void) fprintf(ofp,
-                                "/* -*- mode:c; compile-command:\"%s%s%s\" -*- */",
+                     buf, yukdebug||yukprofile?" -lyuk ":" ",
+                     includedir, path, path, libdir, path, path,
+                     coopt?'3':'2', /* AIS: If coopting, optimize as much as possible */
+                     argv[optind], multithread?"mt":"", cdebug?" -g":"");
+      /* AIS: Possibly link in the debugger yuk and/or libickmt.a here. */
+      /* AIS: Added -g support. */
+      /* AIS: Added argv[0] (now path) to the -I, -L settings. */
+                    
+      textlinecount=0; /* AIS: If there are no files, there's
+                         no need to free any textlines */
+      while ((c = myfgetc(ifp)) != EOF)
+       if (c != (int)'$')
+         (void) fputc(c, ofp);
+       else switch(myfgetc(ifp))
+            {
+            case 'A':  /* source name stem */
+              (void) fputs(argv[optind], ofp);
+              break;
+
+            case 'B':  /* # of statements */
+              (void) fprintf(ofp, "%d", ick_lineno);
+              break;
+
+            case 'C':  /* initial abstentions */
+              /* AIS: Modified to check for coopt, pickcompile */
+              maxabstain = 0;
+              for (tp = tuples; tp->type; tp++)
+                if (((tp->exechance <= 0 || tp->exechance >= 101)
+                     && tp - tuples + 1 > maxabstain)
+                    || coopt || pickcompile)
+                  maxabstain = tp - tuples + 1;
+              if (maxabstain)
+              {
+                if(!pickcompile) (void) fprintf(ofp, " = {");
+                for (tp = tuples; tp < tuples + maxabstain; tp++)
+                {
+                  if(tp->exechance != 100 && tp->exechance != -100)
+                  { /* AIS: The double-oh-seven operator prevents
+                       coopt working. However, syslib contains a
+                       double-oh-seven. feh.c has checked that that
+                       isn't referenced; if it isn't, we can allow
+                       one double-oh-seven if syslib was
+                       automagically inclulded. */
+                    if(needsyslib) needsyslib = 0; else coopt = 0;
+                  }
+                  if(!pickcompile)
+                  {
+                    if (tp->exechance > 0)
+                    {
+                      (void) fprintf(ofp, "0, ");
+                      tp->initabstain=0; /* AIS: -f might not be
+                                            given, so we can't rely
+                                            on dekludge.c doing
+                                            this */
+                    }
+                    else {
+                      (void) fprintf(ofp, "1, ");
+                      tp->exechance = -tp->exechance;
+                      tp->initabstain=1; /* AIS: As above */
+                      /* AIS: If the line was ick_abstained, we need to
+                         swap ONCEs and AGAINs on it round, to suit
+                         the code degenerator. */
+                      if(tp->onceagainflag == onceagain_ONCE)
+                        tp->onceagainflag = onceagain_AGAIN;
+                      else if(tp->onceagainflag == onceagain_AGAIN)
+                        tp->onceagainflag = onceagain_ONCE;
+                    }
+                    if(tp->exechance >= 101)
+                    {
+                      /* AIS: This line has a MAYBE */
+                      tp->maybe = 1;
+                      tp->exechance /= 100;
+                    }
+                    else tp->maybe = 0;
+                  }
+                  else /* AIS: hardcoded abstain bits for PICs */
+                  {
+                    if(!tp->abstainable) continue;
+                    if(tp->exechance > 0)
+                      (void) fprintf(ofp, "ICK_INT1 ICKABSTAINED(%d)=0;\n",tp-tuples);
+                    else
+                      (void) fprintf(ofp, "ICK_INT1 ICKABSTAINED(%d)=1;\n",tp-tuples);
+                  }
+                }
+                if(!pickcompile) (void) fprintf(ofp, "}");
+              }
+              break;
+
+            case 'D':  /* linetypes ick_array for abstention handling */
+              maxabstain = 0;
+              for (tp = tuples; tp->type; tp++)
+                if (tp->type == ENABLE || tp->type == DISABLE || tp->type == MANYFROM)
+                  maxabstain++;
+              if (maxabstain || /* AIS */ gerucomesused)
+              {
+                /* AIS: Changed to use enablersm1 */
+                /*(void) fprintf(ofp, "#define UNKNOWN\t\t0\n");*/
+                i = 0;
+                for (;i < (int)(sizeof(enablersm1)/sizeof(char *));i++)
+                  (void) fprintf(ofp,
+                                 "#define %s\t%d\n",
+                                 enablersm1[i], i);
+
+                (void) fprintf(ofp, "int linetype[] = {\n");
+                for (tp = tuples; tp->type; tp++)
+                  if(tp->ppnewtype) /* AIS */
+                    (void) fprintf(ofp,"    %s,\n",
+                                   enablers[tp->ppnewtype - GETS]);
+                  else if(tp->preproc) /* AIS */
+                    (void) fprintf(ofp,"    PREPROC,\n");
+                  else if (tp->type >= GETS && tp->type <= FROM)
+                    /* AIS: FROM added */
+                    (void) fprintf(ofp,
+                                   "    %s,\n",
+                                   enablers[tp->type - GETS]);
+                  else
+                    /* AIS: I didn't change this code, but relied on
+                       it when implementing just-in-case compilation;
+                       SPLATTERED and UNKNOWN (the two types of
+                       syntax error, unsalvageable and salvageable
+                       respectively) both become UNKNOWN in the
+                       linetypes array. */
+                    (void) fprintf(ofp, " UNKNOWN,\n");
+                (void) fprintf(ofp, "};\n"); } break;
+
+            case 'E':  /* extern to intern map */
+              if(!pickcompile)
+              {
+                (void) fprintf(ofp,"int ick_Base = %d;\n",ick_Base);
+                (void) fprintf(ofp,"int ick_Small_digits = %d;\n",
+                               ick_Small_digits);
+                (void) fprintf(ofp,"int ick_Large_digits = %d;\n",
+                               ick_Large_digits);
+                (void) fprintf(ofp,"unsigned int ick_Max_small = 0x%x;\n",
+                               ick_Max_small);
+                (void) fprintf(ofp,"unsigned int ick_Max_large = 0x%x;\n",
+                               ick_Max_large);
+                if (yukprofile || yukdebug || multithread || useickec)
+                { /* AIS: yuk.c, multithreading require all these to exist */
+                  if(!nonespots) nonespots = 1;
+                  if(!ntwospots) ntwospots = 1;
+                  if(!ntails) ntails = 1;
+                  if(!nhybrids) nhybrids = 1;
+                }
+                else if(opoverused)
+                {
+                  /* AIS: The operand-overloading code requires onespot and
+                     twospot variables to exist. */
+                  if(!nonespots) nonespots = 1;
+                  if(!ntwospots) ntwospots = 1;
+                }
+                /* AIS:I de-staticed all these so they could be accessed by
+                   yuk and cesspool, and added all the mentions of yuk and
+                   multithread. Then I changed it so the variables would be
+                   allocated dynamically, to speed up multithreading. (It's
+                   an O(1) change to the speed of ordinary programs, so I
+                   thought I could get away with it. The order is wrt the
+                   number of lines in the program. The change is O(n) wrt
+                   the number of variables, but again I hope that doesn't
+                   matter, and I won't get the entire INTERCAL community
+                   angry with me for daring to implement an extension that
+                   slows down existing programs.) */
+                if (variableconstants) /* AIS */
+                {
+                  int temp=0;
+                  (void) fprintf(ofp, "ick_type32 meshes[%d] = {",nmeshes);
+                  while(temp<nmeshes)
+                  {
+                    (void) fprintf(ofp, "%luLU, ", varextern((unsigned long)temp,MESH));
+                    temp++;
+                  }
+                  (void) fprintf(ofp, "};\n");
+                }
+
+                if (nonespots)
+                {
+                  (void) fprintf(ofp,
+                                 "ick_type16* ick_onespots;\n");
+                  (void) fprintf(ofp,
+                                 "ick_bool* ick_oneforget;\n");
+                  if(yukprofile || yukdebug)
+                  {
+                    (void) fprintf(ofp,
+                                   "ick_type16 oneold[%d];\n",
+                                   nonespots);
+                    (void) fprintf(ofp,
+                                   "signed char onewatch[%d];\n",
+                                   nonespots);
+                  }
+                  if(multithread)
+                  {
+                    (void) fprintf(ofp,
+                                   "int onespotcount = %d;\n",
+                                   nonespots);
+                  }
+                  if(multithread || opoverused) /* AIS */
+                  {
+                    int temp=nonespots;
+                    (void) fprintf(ofp,
+                                   "ick_overop* ick_oo_onespots = 0;\n");
+                    if(opoverused)
+                      while(temp--)
+                        (void) fprintf(ofp,
+                                       "ick_type32 og1spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_onespots[%d];\n}\n"
+                                       "void os1spot%d(ick_type32 val, void(*f)())\n{\n  (void)f;\n  ick_assign((void*)"
+                                       "(ick_onespots+%d), ick_ONESPOT, ick_oneforget[%d], val);\n}\n",temp,temp,temp,temp,temp);
+                  }
+                }
+                if (ntwospots)
+                {
+                  (void) fprintf(ofp,
+                                 "ick_type32* ick_twospots;\n");
+                  (void) fprintf(ofp,
+                                 "ick_bool* ick_twoforget;\n");
+                  if(yukprofile || yukdebug)
+                  {
+                    (void) fprintf(ofp,
+                                   "ick_type32 twoold[%d];\n",
+                                   ntwospots);
+                    (void) fprintf(ofp,
+                                   "signed char twowatch[%d];\n",
+                                   ntwospots);
+                  }
+                  if(multithread)
+                  {
+                    (void) fprintf(ofp,
+                                   "int twospotcount = %d;\n",
+                                   ntwospots);
+                  }
+                  if(multithread || opoverused) /* AIS */
+                  {
+                    int temp=ntwospots;
+                    (void) fprintf(ofp,
+                                   "ick_overop* ick_oo_twospots = 0;\n");
+                    if(opoverused)
+                      while(temp--)
+                        (void) fprintf(ofp,
+                                       "ick_type32 og2spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_twospots[%d];\n}\n"
+                                       "void os2spot%d(ick_type32 val, void(*f)())\n{\n  (void)f;\n  ick_assign((void*)"
+                                       "(ick_twospots+%d), ick_TWOSPOT, ick_twoforget[%d], val);\n}\n",temp,temp,temp,temp,temp);
+                  }
+                }
+                if (ntails)
+                {
+                  (void) fprintf(ofp,
+                                 "ick_array* ick_tails;\n");
+                  (void) fprintf(ofp,
+                                 "ick_bool* ick_tailforget;\n");
+                  if(multithread)
+                  {
+                    (void) fprintf(ofp,
+                                   "int tailcount = %d;\n",
+                                   ntails);
+                  }
+                }
+                if (nhybrids)
+                {
+                  (void) fprintf(ofp,
+                                 "ick_array* ick_hybrids;\n");
+                  (void) fprintf(ofp,
+                                 "ick_bool* ick_hyforget;\n");
+                  if(multithread)
+                  {
+                    (void) fprintf(ofp,
+                                   "int hybridcount = %d;\n",
+                                   nhybrids);
+                  }
+                }
+                if (yydebug || compile_only)
+                {
+                  assert(oblist != NULL);
+                  for (op = oblist; op < obdex; op++)
+                    if(op->type!=MESH) /* AIS: Added this check */
+                      (void) fprintf(ofp, " /* %s %lu -> %lu */\n",
+                                     nameof(op->type, vartypes),
+                                     op->extindex,
+                                     op->intindex);
+                }
+                if (yukdebug || yukprofile)
+                { /* AIS: drop intern to extern map into the program */
+                  (void) fprintf(ofp, "\nyukvar yukvars[]={\n");
+                  assert(oblist != NULL);
+                  for (op = oblist; op < obdex; op++)
+                    if(op->type!=MESH) /* AIS: Added this check */
+                      (void) fprintf(ofp,"    {%s,%lu,%lu},\n",
+                                     nameof(op->type, vartypes),
+                                     op->extindex,
+                                     op->intindex);
+                  (void) fprintf(ofp,"    {YUKEND,0,0}};\n");
+                }
+                else if(useickec)
+                { /* AIS: likewise, but with different identifiers */
+                  (void) fprintf(ofp, "\nick_ec_var ick_ec_vars[]={\n");
+                  assert(oblist != NULL);
+                  for (op = oblist; op < obdex; op++)
+                    if(op->type!=MESH)
+                      (void) fprintf(ofp,"    {%s,%lu,%lu},\n",
+                                     nameof(op->type, vartypes),
+                                     op->extindex,
+                                     op->intindex);
+                  (void) fprintf(ofp,"    {ICK_EC_VARS_END,0,0}};\n");
+                }
+              }
+              else
+              {
+                /* Compiling for PIC */
+                /* Arrays not supported on PICs */
+                if(ntails || nhybrids)
+                  ick_lose(IE256, iyylineno, (char*) NULL);
+                /* and neither are variable constants */
+                if(variableconstants)
+                  ick_lose(IE256, iyylineno, (char*) NULL);
+                assert(oblist != NULL);
+                for (op = oblist; op < obdex; op++)
+                {
+                  (void) fprintf(ofp, " /* %s %lu -> %lu */\n",
+                                 nameof(op->type, vartypes),
+                                 op->extindex,
+                                 op->intindex);
+                  (void) fprintf(ofp, "#define %s%lu %s[%lu]\n",
+                                 nameof(op->type, vartypes),
+                                 op->extindex,
+                                 nameof(op->type, varstores),
+                                 op->intindex);
+                  if(op->ignorable)
+                    (void) fprintf(ofp, "ICK_INT1 ignore%s%lu = 0;\n",
+                                   nameof(op->type, varstores),
+                                   op->intindex);
+                }
+                (void) fprintf(ofp, "#include \"pick1.h\"\n");
+                if(nonespots)
+                {
+                  (void) fprintf(ofp,
+                                 "ICK_INT16 ick_onespots[%d];\n"
+                                 "ICK_INT16 onespotsstash[%d];\n",
+                                 nonespots,
+                                 nonespots);
+                  if(opoverused) /* AIS */
+                  {
+                    int temp=nonespots;
+                    (void) fprintf(ofp,"ick_overop* ick_oo_onespots;\n");
+                    while(temp--)
+                      (void) fprintf(ofp,
+                                     "ick_type32 og1spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_onespots[%d];\n}\n"
+                                     "void os1spot%d(ick_type32 val,void(*f)())\n{\n  (void)f;\n  if(!ignoreonespots%d)"
+                                     " ick_onespots[%d]=val;\n}\n",temp,temp,temp,temp,temp);
+                  }
+                }
+                if(ntwospots)
+                {
+                  (void) fprintf(ofp,
+                                 "ICK_INT32 ick_twospots[%d];\n"
+                                 "ICK_INT32 twospotsstash[%d];\n",
+                                 ntwospots,
+                                 ntwospots);
+                  if(opoverused) /* AIS */
+                  {
+                    int temp=ntwospots;
+                    (void) fprintf(ofp,"ick_overop* ick_oo_twospots;\n");
+                    while(temp--)
+                      (void) fprintf(ofp,
+                                     "ick_type32 og2spot%d(ick_type32 t)\n{\n  (void)t;\n  return ick_twospots[%d];\n}\n"
+                                     "void os2spot%d(ick_type32 val,void(*f)())\n{\n  (void)f;\n  if(!ignoretwospots%d)"
+                                     " ick_twospots[%d]=val;\n}\n",temp,temp,temp,temp,temp);
+                  }
+                }
+                (void) fprintf(ofp, "#include \"pick2.h\"\n");
+              }
+              break;
+
+            case 'F':  /* set options from command line */
+              if (ick_clockface)
+                (void) fprintf(ofp, "ick_clockface(ick_TRUE);\n");
+              if (ick_clcsemantics) /* AIS */
+                (void) fprintf(ofp, "ick_setclcsemantics(ick_TRUE);\n");
+              break;
+
+            case 'G':  /* degenerated code */
+              for (tp = tuples, i = 0; tp->type; tp++, i++)
+              {
+                emit(tp, ofp);
+                if (i == bugline)
+                  (void) fprintf(ofp, "    ick_lose(IE774, ick_lineno, "
+                                 "(char *)NULL);\n");
+              }
+              break;
+
+            case 'H':  /* COMPUCOME, and dispatching for resumes */
+              /* AIS: Added COMPUCOME here. This line must be fully guarded
+                 to prevent a longjmp to an uninitialised buffer (it's
+                 guarded by a ick_lose() in ick-wrap.c.) Also checks for
+                 multithread; programs that mix normal and computed COME
+                 FROM need to use the same conventions for both, so even
+                 if no computed COME FROMs are used, the normal ones need
+                 this line so that COME FROMs can be handled consistently.*/
+              if(compucomesused || multithread)
+              {
+                (void) fprintf(ofp, "CCFL: ; CCF%d: longjmp(ick_cjb,1);\n",
+                               compucomecount);
+              }
+              break;
+
+            case 'J':  /* # of source file lines */
+              (void) fprintf(ofp, "%d", iyylineno);
+              break;
+
+            case 'K':       /* AIS: yuk information (or not) */
+              if(yukdebug||yukprofile)
+              {
+                (void) fprintf(ofp, "#include \"yuk.h\"\n\n");
+                (void) fprintf(ofp, "char* textlines[] = {\n");
+                emittextlines(ofp); /* from feh.c */
+                (void) fprintf(ofp, "\"\"};\n\n");
+                (void) fprintf(ofp, "char* yukexplain[] = {\n");
+                for (tp = tuples; tp->type; tp++)
+                {
+                  if (tp->type == GETS || tp->type == FORGET || tp->type == RESUME
+                      || tp->type == FROM || tp->type == COMPUCOME
+                      || tp->type == MANYFROM)
+                  {
+                    (void) fprintf(ofp, "\"");
+                    explexpr(tp->type == MANYFROM ? tp->u.node->lval :
+                             tp->type == GETS ? tp->u.node->rval : tp->u.node, ofp);
+                    (void) fprintf(ofp, "\",\n");
+                  }
+                  else (void) fprintf(ofp, "0,");
+                }
+                (void) fprintf(ofp, "0};\n\n");
+                (void) fprintf(ofp, "int lineofaboff[] = {\n");
+                for (tp = tuples; tp->type; tp++)
+                {
+                  fprintf(ofp,"%d,",tp->ick_lineno);
+                }
+                (void) fprintf(ofp, "-1};\n\n");
+                (void) fprintf(ofp, "int yukopts = %d;\n", yukprofile+yukdebug*2);
+                (void) fprintf(ofp, "yptimer ypexectime[%d];\n", ick_lineno);
+                (void) fprintf(ofp, "ypcounter ypexecount[%d];\n",ick_lineno);
+                (void) fprintf(ofp, "ypcounter ypabscount[%d];\n",ick_lineno);
+              }
+              break;
+
+            case 'L': /* AIS: increase Emacs compatibility */
+              (void) fprintf(ofp,
+                             "/* -*- mode:c; compile-command:\"%s%s%s\" -*- */",
 #ifdef __DJGPP__
-                                compiler," ",
+                             compiler," ",
 #else
-                                "","",
+                             "","",
 #endif
-                                buf2);
-                 break;
-
-               case 'M': /* AIS: place new features defines in program */
-                 /* This is needed even in a non-multithread program, to let
-                    the header files know it's non-multithread */
-                 (void) fprintf(ofp, "#define MULTITHREAD %d\n", multithread);
-                 /* Likewise, to let the header files know whether it
-                    overloads operands (I don't think this is used at
-                    the moment, though) */
-                 (void) fprintf(ofp, "#define OPOVERUSED %d\n",opoverused);
-                 /* and whether to use the ICK_EC code */
-                 if(useickec)
-                   (void) fprintf(ofp, "#define ICK_EC 1\n");
-                 break;
-
-               case 'N':       /* allocate variables */
-                   /* AIS:I de-staticed all these so they could be accessed by
-                      yuk and cesspool, and added all the mentions of yuk and
-                      multithread. Then I changed it so the variables would be
-                      allocated dynamically, to speed up multithreading (it's
-                      an O(1) change to the speed of ordinary programs, so I
-                      thought I could get away with it). At this point, the
-                      'E' case must already have been done. calloc sets all
-                      the integer values to 0, as before. In the case of
-                      arrays, it will not zero pointers, but the number-of-
-                      dimensions value will become 0, which can serve as a
-                      'deallocated' flag. */
-                   if (nonespots)
-                   {
-                     if(!pickcompile) /* AIS */
-                     {
-                       (void) fprintf(ofp,
-                                      "    ick_onespots = calloc("
-                                      "%d, sizeof *ick_onespots);\n",
-                                      nonespots);
-                       (void) fprintf(ofp,
-                                      "    ick_oneforget = calloc("
-                                      "%d, sizeof *ick_oneforget);\n",
-                                      nonespots);
-                     }
-                     if(opoverused)
-                     {
-                       int temp=nonespots;
-                       (void) fprintf(ofp,
-"    ick_oo_onespots=malloc(%d*sizeof*ick_oo_onespots);\n",temp);
-                       while(temp--)
-                         (void) fprintf(ofp,
-"    ick_oo_onespots[%d].get=og1spot%d;\n    ick_oo_onespots[%d].set=os1spot%d;\n",
-                                        temp,temp,temp,temp);
-                     }
-                   }
-                   if (ntwospots)
-                   {
-                     if(!pickcompile)
-                     {
-                       (void) fprintf(ofp,
-                                      "    ick_twospots = calloc("
-                                      "%d, sizeof *ick_twospots);\n",
-                                      ntwospots);
-                       (void) fprintf(ofp,
-                                      "    ick_twoforget = calloc("
-                                      "%d, sizeof *ick_twoforget);\n",
-                                      ntwospots);
-                     }
-                     if(opoverused)
-                     {
-                       int temp=ntwospots;
-                       (void) fprintf(ofp,
-"    ick_oo_twospots=malloc(%d*sizeof*ick_oo_twospots);\n",temp);
-                       while(temp--)
-                         (void) fprintf(ofp,
-"    ick_oo_twospots[%d].get=og2spot%d;\n    ick_oo_twospots[%d].set=os2spot%d;\n",
-                                        temp,temp,temp,temp);
-                     }
-                   }
-                   if (ntails&&!pickcompile)
-                   {
-                       (void) fprintf(ofp,
-                                      "    ick_tails = calloc("
-                                      "%d, sizeof *ick_tails);\n",
-                                      ntails);
-                       (void) fprintf(ofp,
-                                      "    ick_tailforget = calloc("
-                                      "%d, sizeof *ick_tailforget);\n",
-                                      ntails);
-                   }
-                   if (nhybrids&&!pickcompile)
-                   {
-                       (void) fprintf(ofp,
-                                      "    ick_hybrids = calloc("
-                                      "%d, sizeof *ick_hybrids);\n",
-                                      nhybrids);
-                       (void) fprintf(ofp,
-                                      "    ick_hyforget = calloc("
-                                      "%d, sizeof *ick_hyforget);\n",
-                                      nhybrids);
-                   }
-                   break;
-               case 'O': /* AIS; for GERUCOME and operand overloading */
-                 if(gerucomesused || nextfromsused)
-                   fprintf(ofp,"unsigned truelineno = 0;\n");
-                 if(opoverused)
-                   fprintf(ofp,"%s trueval;\n",
-                           pickcompile?"ICK_INT32":"ick_type32");
-                 break;
-               case 'P': /* AIS: for operand overloading */
-                 if(opoverused)
-                   emitslatproto(ofp);
-                 break;
-               case 'Q': /* AIS: for operand overloading */
-                 if(opoverused)
-                   emitslat(ofp);
-                 break;
-               }
-
-           if(!outtostdout) (void) fclose(ofp);
+                             buf2);
+              break;
+
+            case 'M': /* AIS: place new features defines in program */
+              /* This is needed even in a non-multithread program, to let
+                 the header files know it's non-multithread */
+              (void) fprintf(ofp, "#define MULTITHREAD %d\n", multithread);
+              /* Likewise, to let the header files know whether it
+                 overloads operands (I don't think this is used at
+                 the moment, though) */
+              (void) fprintf(ofp, "#define OPOVERUSED %d\n",opoverused);
+              /* and whether to use the ICK_EC code */
+              if(useickec)
+                (void) fprintf(ofp, "#define ICK_EC 1\n");
+              break;
+
+            case 'N':  /* allocate variables */
+              /* AIS:I de-staticed all these so they could be accessed by
+                 yuk and cesspool, and added all the mentions of yuk and
+                 multithread. Then I changed it so the variables would be
+                 allocated dynamically, to speed up multithreading (it's
+                 an O(1) change to the speed of ordinary programs, so I
+                 thought I could get away with it). At this point, the
+                 'E' case must already have been done. calloc sets all
+                 the integer values to 0, as before. In the case of
+                 arrays, it will not zero pointers, but the number-of-
+                 dimensions value will become 0, which can serve as a
+                 'deallocated' flag. */
+              if (nonespots)
+              {
+                if(!pickcompile) /* AIS */
+                {
+                  (void) fprintf(ofp,
+                                 "    ick_onespots = calloc("
+                                 "%d, sizeof *ick_onespots);\n",
+                                 nonespots);
+                  (void) fprintf(ofp,
+                                 "    ick_oneforget = calloc("
+                                 "%d, sizeof *ick_oneforget);\n",
+                                 nonespots);
+                }
+                if(opoverused)
+                {
+                  int temp=nonespots;
+                  (void) fprintf(ofp,
+                                 "    ick_oo_onespots=malloc(%d*sizeof*ick_oo_onespots);\n",temp);
+                  while(temp--)
+                    (void) fprintf(ofp,
+                                   "    ick_oo_onespots[%d].get=og1spot%d;\n    ick_oo_onespots[%d].set=os1spot%d;\n",
+                                   temp,temp,temp,temp);
+                }
+              }
+              if (ntwospots)
+              {
+                if(!pickcompile)
+                {
+                  (void) fprintf(ofp,
+                                 "    ick_twospots = calloc("
+                                 "%d, sizeof *ick_twospots);\n",
+                                 ntwospots);
+                  (void) fprintf(ofp,
+                                 "    ick_twoforget = calloc("
+                                 "%d, sizeof *ick_twoforget);\n",
+                                 ntwospots);
+                }
+                if(opoverused)
+                {
+                  int temp=ntwospots;
+                  (void) fprintf(ofp,
+                                 "    ick_oo_twospots=malloc(%d*sizeof*ick_oo_twospots);\n",temp);
+                  while(temp--)
+                    (void) fprintf(ofp,
+                                   "    ick_oo_twospots[%d].get=og2spot%d;\n    ick_oo_twospots[%d].set=os2spot%d;\n",
+                                   temp,temp,temp,temp);
+                }
+              }
+              if (ntails&&!pickcompile)
+              {
+                (void) fprintf(ofp,
+                               "    ick_tails = calloc("
+                               "%d, sizeof *ick_tails);\n",
+                               ntails);
+                (void) fprintf(ofp,
+                               "    ick_tailforget = calloc("
+                               "%d, sizeof *ick_tailforget);\n",
+                               ntails);
+              }
+              if (nhybrids&&!pickcompile)
+              {
+                (void) fprintf(ofp,
+                               "    ick_hybrids = calloc("
+                               "%d, sizeof *ick_hybrids);\n",
+                               nhybrids);
+                (void) fprintf(ofp,
+                               "    ick_hyforget = calloc("
+                               "%d, sizeof *ick_hyforget);\n",
+                               nhybrids);
+              }
+              break;
+            case 'O': /* AIS; for GERUCOME and operand overloading */
+              if(gerucomesused || nextfromsused)
+                fprintf(ofp,"unsigned truelineno = 0;\n");
+              if(opoverused)
+                fprintf(ofp,"%s trueval;\n",
+                        pickcompile?"ICK_INT32":"ick_type32");
+              break;
+            case 'P': /* AIS: for operand overloading */
+              if(opoverused)
+                emitslatproto(ofp);
+              break;
+            case 'Q': /* AIS: for operand overloading */
+              if(opoverused)
+                emitslat(ofp);
+              break;
+            }
+
+      if(!outtostdout) (void) fclose(ofp);
 
 #ifndef __DJGPP__
-           /* OK, now sic the C compiler on the results */
-           if (!compile_only&&!yukdebug&&!yukprofile&&!useickec)
-           {
-             /* AIS: buf2 now assigned elsewhere so $L works */
-             (void) system(buf2);
-             /* AIS: no unlink if cdebug */ if(!cdebug) (void) unlink(buf);
-           }
-           else if(!compile_only&&!useickec)
-           { /* AIS: run, then delete all output but yuk.out */
-             /* Note that the output must be deleted for copyright
-                reasons (so as not to GPL a non-GPL file automatically) */
-             (void) system(buf2);
+      /* OK, now sic the C compiler on the results */
+      if (!compile_only&&!yukdebug&&!yukprofile&&!useickec)
+      {
+       /* AIS: buf2 now assigned elsewhere so $L works */
+       (void) system(buf2);
+       /* AIS: no unlink if cdebug */ if(!cdebug) (void) unlink(buf);
+      }
+      else if(!compile_only&&!useickec)
+      { /* AIS: run, then delete all output but yuk.out */
+       /* Note that the output must be deleted for copyright
+          reasons (so as not to GPL a non-GPL file automatically) */
+       (void) system(buf2);
 #ifdef HAVE_UNISTD_H
-             (void) dup2(oldstdin,0); /* restore stdin */
+       (void) dup2(oldstdin,0); /* restore stdin */
 #endif
-             (void) system(yukcmdstr);
-             (void) unlink(buf);
-             (void) unlink(argv[optind]);
-           }
+       (void) system(yukcmdstr);
+       (void) unlink(buf);
+       (void) unlink(argv[optind]);
+      }
 #else /* we are using DJGPP */
-           /* OK, now sic the C compiler on the results */
-           if (!compile_only&&!useickec)
-           {
-             /* AIS: buf2 now assigned elsewhere so $L works */
-             /* AIS: This changes somewhat for DJGPP, due to the
-                command-line cap. It creates a temporary file
-                with the arguments needed to give gcc. */
-             FILE* rsp;
-             /* Use current dir as temp if needed */
-             char* tempfn="gcc @ickgcc.rsp";
-             /* Four tries are used to find a temp directory.
-                ICKTEMP is the preferred environment variable to check;
-                if, as expected, this isn't set, try TMPDIR (which DJGPP
-                sets to its own temp directory, at least when running under
-                 bash), TEMP and TMP (in that order). DJGPP offers /dev/env
-                as a method of accessing environment variables in filenames.*/
-             if(isenv("TMP")) tempfn="gcc @/dev/env/TMP/ickgcc.rsp";
-             if(isenv("TEMP")) tempfn="gcc @/dev/env/TEMP/ickgcc.rsp";
-             if(isenv("TMPDIR")) tempfn="gcc @/dev/env/TMPDIR/ickgcc.rsp";
-             if(isenv("ICKTEMP")) tempfn="gcc @/dev/env/ICKTEMP/ickgcc.rsp";
-             rsp=ick_debfopen(tempfn+5,"w");
-             fprintf(rsp,"%s\n",buf2);
-             fclose(rsp);
-             system(tempfn);
-             remove(tempfn+5);
-             if(yukdebug || yukprofile)
-             {
+      /* OK, now sic the C compiler on the results */
+      if (!compile_only&&!useickec)
+      {
+       /* AIS: buf2 now assigned elsewhere so $L works */
+       /* AIS: This changes somewhat for DJGPP, due to the
+          command-line cap. It creates a temporary file
+          with the arguments needed to give gcc. */
+       FILE* rsp;
+       /* Use current dir as temp if needed */
+       char* tempfn="gcc @ickgcc.rsp";
+       /* Four tries are used to find a temp directory.
+          ICKTEMP is the preferred environment variable to check;
+          if, as expected, this isn't set, try TMPDIR (which DJGPP
+          sets to its own temp directory, at least when running under
+          bash), TEMP and TMP (in that order). DJGPP offers /dev/env
+          as a method of accessing environment variables in filenames.*/
+       if(isenv("TMP")) tempfn="gcc @/dev/env/TMP/ickgcc.rsp";
+       if(isenv("TEMP")) tempfn="gcc @/dev/env/TEMP/ickgcc.rsp";
+       if(isenv("TMPDIR")) tempfn="gcc @/dev/env/TMPDIR/ickgcc.rsp";
+       if(isenv("ICKTEMP")) tempfn="gcc @/dev/env/ICKTEMP/ickgcc.rsp";
+       rsp=ick_debfopen(tempfn+5,"w");
+       fprintf(rsp,"%s\n",buf2);
+       fclose(rsp);
+       system(tempfn);
+       remove(tempfn+5);
+       if(yukdebug || yukprofile)
+       {
 #ifdef HAVE_UNISTD_H
-               dup2(oldstdin,0); /* restore stdin */
+         dup2(oldstdin,0); /* restore stdin */
 #endif
 #ifndef HAVE_SNPRINTF
-               sprintf(buf2,"%s" EXEEXT,argv[optind]);
+         sprintf(buf2,"%s" EXEEXT,argv[optind]);
 #else
-               snprintf(buf2,"%s" EXEEXT,argv[optind]);
+         snprintf(buf2,"%s" EXEEXT,argv[optind]);
 #endif
-               system(yukcmdstr);
-               remove(buf);
-               remove(buf2);
-             }
-             else if(!cdebug)
-             {
-               remove(buf);
-             }
-           }
+         system(yukcmdstr);
+         remove(buf);
+         remove(buf2);
+       }
+       else if(!cdebug)
+       {
+         remove(buf);
+       }
+      }
 #endif
 #ifdef HAVE_PROG_SH
 # ifdef HAVE_SYS_INTERPRETER
-           if(coopt) /* AIS */
-           {
-             /* The constant-output optimizer is a form of post-processor.
-                IMPORTANT NOTE: This MUST NOT be run if the input program
-                takes any input or is affected in any way by the state of
-                the system, as the degenerated program may be wrong. At the
-                moment, the only INTERCAL command that takes input is
-                WRITE IN. Double-oh-sevens screw this up, too. */
-             if(cooptsh)
-             {
+      if(coopt) /* AIS */
+      {
+       /* The constant-output optimizer is a form of post-processor.
+          IMPORTANT NOTE: This MUST NOT be run if the input program
+          takes any input or is affected in any way by the state of
+          the system, as the degenerated program may be wrong. At the
+          moment, the only INTERCAL command that takes input is
+          WRITE IN. Double-oh-sevens screw this up, too. */
+       if(cooptsh)
+       {
 #ifndef HAVE_SNPRINTF
-               (void) sprintf(buf2,"sh %s %s", cooptsh, argv[optind]);
+         (void) sprintf(buf2,"sh %s %s", cooptsh, argv[optind]);
 #else
-               (void) snprintf(buf2, sizeof buf2,
-                               "sh %s %s", cooptsh, argv[optind]);
+         (void) snprintf(buf2, sizeof buf2,
+                         "sh %s %s", cooptsh, argv[optind]);
 #endif
-               (void) system(buf2); /* replaces the output executable if
-                                       neccesary */
-             }
-           }
+         (void) system(buf2); /* replaces the output executable if
+                                 neccesary */
+       }
+      }
 # endif
 #endif
-       }
     }
-    (void) fclose(ifp);
+  }
+  (void) fclose(ifp);
 
-    if(!compile_only && useickec) /* AIS */
-    {
-      FILE* cioin;
-      FILE* cioallec;
-      char* buf2ptr;
-      long remspace;
-      char* tempfn="ickectmp.c";
+  if(!compile_only && useickec) /* AIS */
+  {
+    FILE* cioin;
+    FILE* cioallec;
+    char* buf2ptr;
+    long remspace;
+    char* tempfn="ickectmp.c";
 #if __DJGPP__
-      /* Look for a temp directory, as above. */
-      if(isenv("TMP")) tempfn="/dev/env/TMP/ickectmp.c";
-      if(isenv("TEMP")) tempfn="/dev/env/TEMP/ickectmp.c";
-      if(isenv("TMPDIR")) tempfn="/dev/env/TMPDIR/ickectmp.c";
-      if(isenv("ICKTEMP")) tempfn="/dev/env/ICKTEMP/ickectmp.c";
+    /* Look for a temp directory, as above. */
+    if(isenv("TMP")) tempfn="/dev/env/TMP/ickectmp.c";
+    if(isenv("TEMP")) tempfn="/dev/env/TEMP/ickectmp.c";
+    if(isenv("TMPDIR")) tempfn="/dev/env/TMPDIR/ickectmp.c";
+    if(isenv("ICKTEMP")) tempfn="/dev/env/ICKTEMP/ickectmp.c";
 #else
-      tempfn="/tmp/ickectmp.c"; /* always a valid temporary folder on POSIX */
+    tempfn="/tmp/ickectmp.c"; /* always a valid temporary folder on POSIX */
 #endif
-      cioallec=ick_debfopen(tempfn,"w");
-      if(cioallec == NULL)
-       ick_lose(IE888, -1, (char*) NULL);
-      (void) fprintf(cioallec,"void ick_doresume(unsigned short,int);\n");
-      (void) fprintf(cioallec,"extern int ick_global_checkmode;\n");
-      (void) fprintf(cioallec,"void ick_allecfuncs(void)\n{\n");
-
-      /* Here, we run the C preprocessor on the files in question, then our
-        own preprocessor, and finally link all the files together into one
-        executable. */
-      for(optind=oldoptind; optind < argc; optind++)
-      {
+    cioallec=ick_debfopen(tempfn,"w");
+    if(cioallec == NULL)
+      ick_lose(IE888, -1, (char*) NULL);
+    (void) fprintf(cioallec,"void ick_doresume(unsigned short,int);\n");
+    (void) fprintf(cioallec,"extern int ick_global_checkmode;\n");
+    (void) fprintf(cioallec,"void ick_allecfuncs(void)\n{\n");
+
+    /* Here, we run the C preprocessor on the files in question, then our
+       own preprocessor, and finally link all the files together into one
+       executable. */
+    for(optind=oldoptind; optind < argc; optind++)
+    {
 #ifndef HAVE_SNPRINTF
-       (void) sprintf(buf2,
-#else
-       (void) snprintf(buf2, sizeof buf2,
-#endif
-                       "%s -E -I%s -I%s -I%s/../include %s.c > %s.cio",
-                       compiler, includedir, path, path, argv[optind], argv[optind]);
+      (void) sprintf(buf2,
 #if 0
-         ); /* for Emacs' autoindenter */
+       ); /* for Emacs' autoindenter */
 #endif
-       if(argv[optind][strlen(argv[optind])+2]=='\0' /* it was a .c or .i file */
-          ||argv[optind][strlen(argv[optind])+3]!='o') /* it was a .2-7i file */
-         (void) system(buf2); /* run the C preprocessor */
-         buf2ptr = strrchr(buf2,'>'); /* get the .cio's filename */
-         cioin=NULL;
-       /* Do our preprocessing, by editing the file in place using rb+. */
-       if(buf2ptr != NULL && buf2ptr[1] != '\0' && buf2ptr[2] != '\0')
-         cioin=ick_debfopen(buf2ptr+2,"rb+");
-       if(cioin)
+#else
+      (void) snprintf(buf2, sizeof buf2,
+#endif
+                     "%s -E -I%s -I%s -I%s/../include %s.c > %s.cio",
+                     compiler, includedir, path, path, argv[optind], argv[optind]);
+      if(argv[optind][strlen(argv[optind])+2]=='\0' /* it was a .c or .i file */
+        ||argv[optind][strlen(argv[optind])+3]!='o') /* it was a .2-7i file */
+       (void) system(buf2); /* run the C preprocessor */
+      buf2ptr = strrchr(buf2,'>'); /* get the .cio's filename */
+      cioin=NULL;
+      /* Do our preprocessing, by editing the file in place using rb+. */
+      if(buf2ptr != NULL && buf2ptr[1] != '\0' && buf2ptr[2] != '\0')
+       cioin=ick_debfopen(buf2ptr+2,"rb+");
+      if(cioin)
+      {
+       int inchar=fgetc(cioin);
+       int toparencount=0;
+       /* The ppnums are replacements for strings in the .cio file.
+          The choice of 65538 means that we don't clash with any
+          line numbers in the program, but do clash with the other
+          C-INTERCAL preprocessor (that handles WHILE); that isn't a
+          problem because external calls are inconsistent with
+          multithreading anyway. */
+       long ppnum1=65538L*2L;
+       long ppnum2=65538L*2L;
+       long ppnum3=65538L*2L;
+       long ppnum6=65538L*2L;
+       long ciopos=0L;
+       /*@+charintliteral@*/ /* literal chars are ints */
+       while(inchar != EOF)
        {
-         int inchar=fgetc(cioin);
-         int toparencount=0;
-         /* The ppnums are replacements for strings in the .cio file.
-            The choice of 65538 means that we don't clash with any
-            line numbers in the program, but do clash with the other
-            C-INTERCAL preprocessor (that handles WHILE); that isn't a
-            problem because external calls are inconsistent with
-            multithreading anyway. */
-         long ppnum1=65538L*2L;
-         long ppnum2=65538L*2L;
-         long ppnum3=65538L*2L;
-         long ciopos=0L;
-         /*@+charintliteral@*/ /* literal chars are ints */
-         while(inchar != EOF)
+         if(inchar=='I')
          {
-           if(inchar=='I')
+           /* Look for the ICK_EC_PP_ string that indicates preprocessing
+              is needed. This method of doing it works as long as the
+              ICK_EC_PP_ string is never preceded by something which looks
+              like part of the same string, but luckily, it never is. */
+           if((inchar=fgetc(cioin))!='C') continue;
+           if((inchar=fgetc(cioin))!='K') continue;
+           if((inchar=fgetc(cioin))!='_') continue;
+           if((inchar=fgetc(cioin))!='E') continue;
+           if((inchar=fgetc(cioin))!='C') continue;
+           if((inchar=fgetc(cioin))!='_') continue;
+           if((inchar=fgetc(cioin))!='P') continue;
+           if((inchar=fgetc(cioin))!='P') continue;
+           if((inchar=fgetc(cioin))!='_') continue;
+           inchar=fgetc(cioin);
+           toparencount=0;
+           if(inchar=='0')
            {
-             /* Look for the ICK_EC_PP_ string that indicates preprocessing
-                is needed. This method of doing it works as long as the
-                ICK_EC_PP_ string is never preceded by something which looks
-                like part of the same string, but luckily, it never is. */
-             if((inchar=fgetc(cioin))!='C') continue;
-             if((inchar=fgetc(cioin))!='K') continue;
-             if((inchar=fgetc(cioin))!='_') continue;
-             if((inchar=fgetc(cioin))!='E') continue;
-             if((inchar=fgetc(cioin))!='C') continue;
-             if((inchar=fgetc(cioin))!='_') continue;
-             if((inchar=fgetc(cioin))!='P') continue;
-             if((inchar=fgetc(cioin))!='P') continue;
-             if((inchar=fgetc(cioin))!='_') continue;
-             inchar=fgetc(cioin);
-             toparencount=0;
-             if(inchar=='0')
-             {
-               fprintf(cioallec,"#define X ");
-               while(fputc(fgetc(cioin),cioallec) != ')') toparencount++;
-             }
-             (void) fseek(cioin,ciopos,SEEK_SET);
-             switch(inchar)
-             {
-             case '0': /* a function exists */
-               fprintf(cioin,"            ");
-               fprintf(cioallec,"\nvoid X(void); X();\n"
-                       "if(ick_global_checkmode==5) ick_doresume(1,-1);\n");
-               while(toparencount--) (void) fputc(' ',cioin);
-               break;
-             case '1':
-               fprintf(cioin,"%-11ld",ppnum1++/2);
-               break;
-             case '2':
-               fprintf(cioin,"%-11ld",ppnum2++/2);
-               break;
-             case '3':
-               fprintf(cioin,"%-11ld",ppnum3++/2);
-               break;
-             case '4':
-               fprintf(cioin,"%-11d",optind);
-               break;
-             default:
-               ick_lose(IE778, -1, (char*) NULL);
-             }
-             (void) fseek(cioin,0L,SEEK_CUR); /* synch the file */
+             fprintf(cioallec,"#undef X\n");
+             fprintf(cioallec,"#define X ");
+             while(fputc(fgetc(cioin),cioallec) != ')') toparencount++;
            }
-           ciopos=ftell(cioin);
-           inchar=fgetc(cioin);
+           (void) fseek(cioin,ciopos,SEEK_SET);
+           switch(inchar)
+           {
+           case '0': /* a function exists */
+             fprintf(cioin,"            ");
+             fprintf(cioallec,"\nvoid X(void); X();\n"
+                     "if(ick_global_checkmode==5) ick_doresume(1,-1);\n");
+             while(toparencount--) (void) fputc(' ',cioin);
+             break;
+           case '1':
+             fprintf(cioin,"%-11ld",ppnum1++/2);
+             break;
+           case '2':
+             fprintf(cioin,"%-11ld",ppnum2++/2);
+             break;
+           case '3':
+             fprintf(cioin,"%-11ld",ppnum3++/2);
+             break;
+           case '4':
+             fprintf(cioin,"%-11d",optind);
+             break;
+           case '6':
+             fprintf(cioin,"%-11ld",ppnum6++/2);
+             break;
+           default:
+             ick_lose(IE778, -1, (char*) NULL);
+           }
+           (void) fseek(cioin,0L,SEEK_CUR); /* synch the file */
          }
-         /*@=charintliteral@*/
-         (void) fclose(cioin);
+         ciopos=ftell(cioin);
+         inchar=fgetc(cioin);
        }
+       /*@=charintliteral@*/
+       (void) fclose(cioin);
       }
-      fprintf(cioallec,"if(ick_global_checkmode==2)\n");
-      fprintf(cioallec,"  ick_global_checkmode=4;\n");
-      fprintf(cioallec,"};\n");
-      (void) fclose(cioallec);
-
-      /* This command line needs some explanation, and is specific to gcc and
-        GNU ld. The -x causes gcc to interpret the .cio files as C; the
-        -Wl,-z,muldefs is an instruction to GNU ld, telling it to link in the
-        first main found and ignore the others.  (That way, there can be a
-        main function in each .cio, but the .cios can be linked in any order,
-        with the right main function foremost each time.)
-      */
+    }
+    fprintf(cioallec,"if(ick_global_checkmode==2)\n");
+    fprintf(cioallec,"  ick_global_checkmode=4;\n");
+    fprintf(cioallec,"};\n");
+    (void) fclose(cioallec);
+
+    /* This command line needs some explanation, and is specific to gcc and
+       GNU ld. The -x causes gcc to interpret the .cio files as C; the
+       -Wl,-z,muldefs is an instruction to GNU ld, telling it to link in the
+       first main found and ignore the others.  (That way, there can be a
+       main function in each .cio, but the .cios can be linked in any order,
+       with the right main function foremost each time.)
+    */
 #ifdef HAVE_SNPRINTF
-      (void) snprintf(buf2, sizeof buf2,
+    (void) snprintf(buf2, sizeof buf2,
 #else
-      (void) sprintf(buf2,
+                   (void) sprintf(buf2,
 #endif
-             "%s -L%s -L%s -L%s/../lib -O2 -o %s" EXEEXT
-              "%s -Wl,-z,muldefs -x c %s", compiler, libdir,
-             path, path, argv[oldoptind], cdebug?" -g":"", tempfn);
+                                  "%s -L%s -L%s -L%s/../lib -O2 -o %s" EXEEXT
+                                  "%s -Wl,-z,muldefs -x c %s", compiler, libdir,
+                                  path, path, argv[oldoptind], cdebug?" -g":"", tempfn);
 #if 0
-       ); /* for Emacs' autoindenter */
+      ); /* for Emacs' autoindenter */
 #endif
-      remspace = (long)(sizeof buf2 - strlen(buf2) - 1);
-      for(optind=oldoptind; optind < argc; optind++)
-      {
-       remspace -= strlen(argv[optind]) - 5; /* 5 for <space>.cio */
-       if(remspace <= 0)
-         ick_lose(IE666, -1, (char*)NULL);
-       strcat(buf2," ");
-       strcat(buf2,argv[optind]);
-       strcat(buf2,".cio");
-      }
-      remspace -= strlen(" -lickec");
+    remspace = (long)(sizeof buf2 - strlen(buf2) - 1);
+    for(optind=oldoptind; optind < argc; optind++)
+    {
+      remspace -= strlen(argv[optind]) - 5; /* 5 for <space>.cio */
       if(remspace <= 0)
        ick_lose(IE666, -1, (char*)NULL);
-      strcat(buf2," -lickec");
-      (void) system(buf2);
+      strcat(buf2," ");
+      strcat(buf2,argv[optind]);
+      strcat(buf2,".cio");
     }
+    remspace -= strlen(" -lickec");
+    if(remspace <= 0)
+      ick_lose(IE666, -1, (char*)NULL);
+    strcat(buf2," -lickec");
+    (void) system(buf2);
+    (void) remove(tempfn);
+  }
 
-    /* AIS: Free malloc'd memory. */
-    if(textlines)
-    {
-      /* Marking what textlines points to as only would be the 'right'
-        way to do this (because it is only), but I can't figure out the
-        syntax to do it, so instead I'm supressing the warning that comes
-        up because it isn't marked as only. */
-      /*@-unqualifiedtrans@*/
-      while(textlinecount--) free(textlines[textlinecount]);
-      free(textlines);
-      /*@=unqualifiedtrans@*/
-    }
+  /* AIS: Free malloc'd memory. */
+  if(textlines)
+  {
+    /* Marking what textlines points to as only would be the 'right'
+       way to do this (because it is only), but I can't figure out the
+       syntax to do it, so instead I'm supressing the warning that comes
+       up because it isn't marked as only. */
+    /*@-unqualifiedtrans@*/
+    while(textlinecount--) free(textlines[textlinecount]);
+    free(textlines);
+    /*@=unqualifiedtrans@*/
+  }
 
 #ifdef HAVE_UNISTD_H
-    (void) close(oldstdin); /* AIS */
+  (void) close(oldstdin); /* AIS */
 #endif
-    /* This point is the very end of the program. So it's correct for
-       normal DO NOT FREE UNDER ANY CIRCUMSTANCES globals to be free
-       at this point, so supressing the warning given as a result. */
-    /*@-globstate@*/
-    return 0;
-    /*@=globstate@*/
+  /* This point is the very end of the program. So it's correct for
+     normal DO NOT FREE UNDER ANY CIRCUMSTANCES globals to be free
+     at this point, so supressing the warning given as a result. */
+  /*@-globstate@*/
+  return 0;
+  /*@=globstate@*/
 }
 
 /* perpet.c ends here */

diff --git a/src/splinttest.out b/src/splinttest.out
deleted file mode 100644 (file)
index 96019e5..0000000
--- a/src/splinttest.out
+++ /dev/null
@@ -1,11 +0,0 @@
--*- compilation -*-
-yuk.h:21:14: Variable textlines redeclared with inconsistent type (arrays and
-                pointers are not identical in variable declarations): char * []
-  A function, variable or constant is redefined with a different type. (Use
-  -incondefs to inhibit warning)
-   ick.h:141:26: Previous declaration of textlines: char **
-dekludge.c:101:5: Function exported but not used outside dekludge: abstainmatch
-  A declaration is exported, but not used outside this module. Declaration can
-  use static qualifier. (Use -exportlocal to inhibit warning)
-   dekludge.c:113:1: Definition of abstainmatch
-

diff --git a/src/uncommon.c b/src/uncommon.c
index b182d60cf468b498b43372f5107296530151934c..ed3dfb6fe664d4ed0319b60c93278c201235fb54 100644 (file)
--- a/src/uncommon.c
+++ b/src/uncommon.c
@@ -97,9 +97,9 @@ int ick_printfopens=0;
 
 /* AIS: The same, looking for an executable */
 /*@observer@*/ /*@null@*/ char* ick_findandtestopen(/*@observer@*/ char* file,
-                                                    /*@observer@*/ char* guessdir,
-                                                    /*@observer@*/ char* mode,
-                                                    /*@observer@*/ char* argv0)
+                                                   /*@observer@*/ char* guessdir,
+                                                   /*@observer@*/ char* mode,
+                                                   /*@observer@*/ char* argv0)
 {
   static char buf2[BUFSIZ];
   /*@observer@*/ static char *fileiter;