Next: Warnings, Up: Errors and Warnings [Index]
This is a list of the error messages that might be produced during the compilation or execution of an INTERCAL program.
This is an unusual error; it’s what’s printed when a
syntax error is encounted at runtime, in a situation in which it
would be executed. (An ABSTAIN
ed syntax error, for
instance, would not be executed; this is one of the mechanisms
available for writing comments.) The text of the error message is
simply the statement that couldn’t be decoded.
DO YOU EXPECT ME TO FIGURE THIS OUT?
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.
PROGRAMMER IS INSUFFICIENTLY POLITE
The balance between various statement identifiers is important. If
less than approximately one fifth of the statement identifiers used
are the polite versions containing PLEASE
, that causes
this error at compile time.
PROGRAMMER IS OVERLY POLITE
Of course, the same problem can happen in the other direction; this error is caused at compile time if more than about one third of the statement identifiers are the polite form.
COMMUNIST PLOT DETECTED, COMPILER IS SUICIDING
This error happens when you give the -t option (see -t) but you use a language construct that wasn’t available in INTERCAL-72. If this happens, then either there’s a mistake in the program that prevents it being INTERCAL-72 or you shouldn’t be compiling it as INTERCAL-72 in the first place.
PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
There is a hard limit of 80 NEXT
s at a time; this is
to discourage excessive use of NEXTING
for things like
recursion. (Recursive programs are entirely legal; you simply have
to figure out how to do it with computed COME FROM
instead. (For the record, it is possible. (Using lots of nested
brackets when talking about recursion is great (yay!).))) Another
problem with writing the source code that can cause this error is a
failure to properly FORGET
the entry on the
NEXT
stack created when trying to simulate a goto.
SAYING ’ABRACADABRA’ WITHOUT A MAGIC WAND WON’T DO YOU ANY GOOD
Your program asked to include a system library (by specifying a line number in a magic range without including a line with that number), but due to installation problems the compiler couldn’t find the system library to include. You could try using the -u (see -u) option to see where the compiler’s looking; that may give you an idea of where you need to copy the system library so that the compilation will work. This error happens at compile time and doesn’t give a next command line number.
PROGRAM HAS GOTTEN LOST
This error happens at compile time when the compiler can’t
figure out where a NEXT
command is actually aiming
(normally due to a typo in either the line label given or the line
label on the line aimed for). The logic behind this error means
that the next line to be executed is unknown (after all,
that’s the whole point of the error) and is therefore not
given. The -e command-line option (see -e) makes this error into a run-time
error, because it allows NEXT
commands to dynamically
change targets at runtime, as well as line labels to dynamically
change values, and thus the error is impossible to detect at
compile time.
I WASN’T PLANNING TO GO THERE ANYWAY
This error happens at compile time when an ABSTAIN
or
REINSTATE
references a non-existent target line. This
generally happens for much the same reasons as E129 (see E129).
YOU MUST LIKE THIS LABEL A LOT!
At present, it’s impossible to have more than one line with
the same line number. That would make NEXT
act too
much like COME FROM
in reverse to be interesting. This
error happens at compile time. (For inconsistency, it is
possible to have multiple lines with the same number as long as at
most one of them is in an INTERCAL program (the
others have to be in programs in other languages included via the
external calls system). The resulting behaviour is entirely
inconsistent with the rest of the language, though, for what I hope
are obvious reasons.)
SO! 65535 LABELS AREN’T ENOUGH FOR YOU?
Legal values for line labels are 1 to 65535 (certain subranges are reserved for system and expansion libraries). This error comes up if you use nonpositive or twospot values for a line label.
NOTHING VENTURED, NOTHING GAINED
You used a variable that isn’t actually in your program. Failing that (which, contrary to previous versions of this manual, is indeed possible in the present version of C-INTERCAL, although I’m not telling how; a hint: what mechanism in C-INTERCAL allows for a computed variable number?), you specified an illegal number for a variable (legal numbers are positive and onespot). This error happens at compile time, at least for illegal variable numbers.
BUMMER, DUDE!
In INTERCAL, you’re allowed to
STASH
as much as you like; this makes the language
Turing-complete and allows for unlimited recursion when combined
with computed COME FROM
in the right way.
Unfortunately, real computers aren’t so idealised; if you
manage to write a program so memory-intensive that the computer
runs out of memory to store stashes, it causes this error at
runtime. To fix this error, you either have to simplify the program
or upgrade your computer’s memory, and even then that will
only help to some extent.
ERROR HANDLER PRINTED SNIDE REMARK
Arrays have to be large enough to hold at least one element; you tried to dimension an array which isn’t large enough to hold any data. This error happens at run time.
VARIABLES MAY NOT BE STORED IN WEST HYPERSPACE
This error happens at run time when the subscripts given to an
array are inconsistent with the way the array was dimensioned,
either because there were the wrong number of subscripts or because
a subscript was too large to fit in the array. It can also happen
when a multidimensional array is given to a command, such as
WRITE IN
, that expects it to be monodimensional.
I’VE FORGOTTEN WHAT I WAS ABOUT TO SAY
This run-time error message is caused by the compiler running out of memory whilst trying to do I/O; at present, it can only happen during CLC-INTERCAL-style I/O.
THAT’S TOO HARD FOR MY TINY BRAIN
Some commands simply aren’t available in PIC-INTERCAL. I mean, PICs generally have less than a kilobyte of memory; you’re not going to be able to use some of the more confusing language features with that sort of resource limitation. The solution is to replace the affected command, or to not give the -P option (see -P) if you didn’t mean to compile as PIC-INTERCAL in the first place.
DON’T BYTE OFF MORE THAN YOU CAN CHEW
This error happens when there is an attempt to store a twospot value in a onespot variable. The actual size of the value is what matters when counting its spots; so you can store the output of a mingle in a onespot variable if it happens to be less than or equal to 65535, for instance. (This is not necessarily the case in versions of INTERCAL other than C-INTERCAL, though, so you have to be careful with portability when doing this.)
YOU CAN ONLY DISTORT THE LAWS OF MATHEMATICS SO FAR
Reverse assignments are not always mathematically possible. Also, sometimes they require changing the value of a constant; this is only legal if you specifically specified that it was legal by using the -v option. In the case of an impossible reverse assignment (including a situation in which operand overloading causes a reverse assignment to happen), this error happens at runtime.
This error can also come up when a scalar variable is overloaded to an array (which doesn’t make sense, but could happen if someone exploited bugs in the CREATE statement (see CREATE)), and an attempt is made to read or assign to that variable. (Subscripting a scalar variable is a syntax error, so there is no use for doing such an overload anyway.)
THAT MUCH QUOTATION AMOUNTS TO PLAGIARISM
There is a limit of 3200 on the number of nested spark/ears groups
allowed. If you somehow manage to exceed that limit, that will
cause this error. Try breaking the expression up into smaller
expressions. (The limit is trivial to increase by changing
SENESTMAX
in ick.h; if you ever actually
come across a program that hits the limit but wasn’t designed
to, just email the maintainer to request a higher limit.)
YOU CAN’T HAVE EVERYTHING, WHERE WOULD YOU PUT IT?
Your program references so many variables that the compiler couldn’t cope. This error is unlikely to ever happen; if it does, try reducing the number of variables you use by combining some into arrays. This is a compile-time error.
THAT’S TOO COMPLEX FOR ME TO GRASP
This is another compile-time error that’s unlikely to ever happen; this one signifies the compiler itself running out of memory trying to compile your program. The only solutions to this are to simplify your program, or to make more memory available to the compiler.
I’M ALL OUT OF CHOICES!
Your program asked that a choicepoint be backtracked to or removed, but there aren’t any choicepoints at the moment. This runtime error usually indicates a logic mistake in your program. In backtracking programs translated from other backtracking languages, this indicates that the program has failed.
PROGRAM REJECTED FOR MENTAL HEALTH REASONS
Your program used a construct that only makes sense when
multithreading or backtracking (WHILE
,
MAYBE
, GO BACK
, or GO
AHEAD
), but you didn’t specify the -m
option (see -m). If you meant
to write a multithreaded or backtracking program, just give that
option; if you didn’t, be careful what words you use in
comments! This error happens at compile-time.
THROW STICK BEFORE RETRIEVING!
In order to RETRIEVE
a variable, it has to be
STASH
ed first; if it isn’t, then this error
happens at runtime.
IT CAME FROM BEYOND SPACE
A COME FROM
aiming at a line label — as opposed
to a computed COME FROM
, which is allowed to be
pointing at a nonexistent line — must point to a valid line
label. The same applies to NEXT FROM
. This error
happens at compile time if a nonexistent line label is found in one
of these contexts.
YOU WANT MAYBE WE SHOULD IMPLEMENT 64-BIT VARIABLES?
This error is like E275 (see E275), but applies when an attempt is made at runtime to store a threespot value (or even a fourspot or morespot value) in a twospot variable, or a threespot or greater value is produced as an intermediate during a calculation (for instance by a mingle operation). No values above twospot are allowed at any point during an INTERCAL program; if you want to process higher numbers, you have to figure out a different way of storing them.
BETTER LATE THAN NEVER
Oops! The compiler just noticed that it had a buffer overflow. (Normally programs catch buffer overflows before they happen; C-INTERCAL catches them just afterwards instead.) This only happens on systems which don’t have a modern C standard library. Try using shorter or fewer filenames on the command line, to reduce the risk of such an overflow.
FLOW DIAGRAM IS EXCESSIVELY CONNECTED
Aiming two COME FROM
s at the same line only makes
sense in a multithreaded program. In a non-multithread program,
doing that will cause this error at compile time (if neither
COME FROM
is computed) or at run time (if the command
that has just finished running is simultaneously the target of two
or more COME FROM
s). This either indicates an error in
your program or that you’ve forgotten to use the
-m option (see -m) if you are actually trying to
split the program into two threads.
I DO NOT COMPUTE
The program asked for input, but for some reason it wasn’t
available. (This is a runtime error, obviously.) The error may
happen because the input is being piped in from a command or file
which has reached end-of-file, or because the user typed
CTRL-D
(UNIX/Linux) or CTRL-Z (DOS/Windows) while the program was trying to
WRITE IN
some data.
WHAT BASE AND/OR LANGUAGE INCLUDES string?
When reading spelt-out-digit input, the input didn’t seem to be a valid digit in English, Sanskrit, Basque, Tagalog, Classical Nahuatl, Georgian, Kwakiutl, Volapük, or Latin. This seems to have languages covered pretty well; what on earth were you using, or did you just make a spelling mistake?
ERROR TYPE 621 ENCOUNTERED
The compiler encountered error E621 (see E621).
This happens at runtime when the program requests that no entries
are removed from the NEXT
stack (which is possible),
but that the last entry removed should be jumped to (which given
the circumstances isn’t, because no entries were removed).
THE NEXT STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
When an attempt is made to RESUME
past the end of the
NEXT
stack, the program ends; however, this cause the
program to end in a manner other than via GIVE UP
or
DON'T TRY AGAIN
, so an error message must be printed,
and this is that error message.
PROGRAM FELL OFF THE EDGE
You can’t just let execution run off the end of the program.
At least, that is, if it doesn’t end with TRY
AGAIN
. An attempt to do that causes this error at runtime.
Note that if your program references the system library, then it
counts as being appended to your program and so the program will
run into the first line of the system library rather than cause
this error. As it happens, the first line of the system library is
a syntax error, so doing this will cause E000 (see E000) with the error text ‘PLEASE KNOCK
BEFORE ENTERING’. There isn’t a next statement
to be executed with E633, so the next statement won’t be
given in the error message.
HOW DARE YOU INSULT ME!
The PIN
command doesn’t make much sense for
anything bigger than a PIC; using it in a
non-PIC program causes this error at
compile-time. Try using the normal input and output mechanisms
instead. This error may also be a clue that you are trying to
compile a PIC-INTERCAL program without giving the
-P option (see -P).
COMPILER HAS INDIGESTION
There isn’t a limit on the length of an input program other than your computer’s memory; if your computer does run out of memory during compilation, it causes this error. This error can also be caused if too many input files are specified on the command line; if you suspect this is the problem, split the compilation into separate compilations if you can, or otherwise you may be able to concatenate together your input files into larger but fewer files. Yet another potential cause of this error is if a line in an input program is too long; sensible line-wrapping techniques are encouraged.
RANDOM COMPILER BUG
No compiler is perfect; sometimes errors just happen at random. In this case, the random error is E774. If you don’t like the idea that your program may be shot down by a random compiler bug, or you are doing something important, you can use the -b option (see -b) to prevent this bug happening. (You may wonder why this bug is in there at all if it’s so easily prevented. The answer is that such a bug was present in the original INTERCAL-72 compiler, which also had an option to turn the bug off. It’s also a reward for people who actually read the manual.)
A SOURCE IS A SOURCE, OF COURSE, OF COURSE
You specified a file to compile on the command line, but the compiler couldn’t find or couldn’t open it. This is almost certainly because you made a typo specifying the file.
UNEXPLAINED COMPILER BUG
This should never come up, either at compile time or at run time. It could come up at either when an internal check by the compiler or the runtime libraries realises that something has gone badly wrong; mistakes happen, and in such cases the mistake will have been detected. (If this happens at compile time you can use the -U option (see -U) to cause the compiler to send an abort signal – which normally causes a core dump – when the error happens, to help debug what’s causing it.) More often, this error comes up when the operating system has noticed something impossible, like an attempt to free allocated memory twice or to write to a null pointer, and tells the compiler an error has occured, in which case the same response of putting up this error happens. The point is that in all cases this error 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 it and send a bug report (see Reporting Bugs).
ARE ONE-CHARACTER COMMANDS TOO SHORT FOR YOU?
This is a debug-time error caused when you give too much input to the debugger when all it wanted was to know what you wanted to do next.
PROGRAM IS TOO BADLY BROKEN TO RUN
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 a debug-time error.
I HAVE NO FILE AND I MUST SCREAM
The output file couldn’t be written, maybe because the disk is full or because there’s already a read-only file with the same name. This is a compile-time error.
HELLO? CAN ANYONE GIVE ME A HAND HERE?
This error occurs at compile-time if a file type was requested for which the required libraries are unavailable. (Support for Funge does not ship with the compiler; instead, you need to generate the library yourself from the cfunge sources. For more information, see Creating the Funge-98 Library.)
FLAG ETIQUETTE FAILURE BAD SCOUT NO BISCUIT
This error occurs at runtime if an INTERCAL program was passed an unknown option flag.
YOU HAVE TOO MUCH ROPE TO HANG YOURSELF
There is no limit on the number of threads or choicepoints that you can have in a multithreaded or backtracking program (in a program that isn’t multithreaded or backtracking, these are obviously limited to 1 and 0 respectively). However, your computer may not be able to cope; if it runs out of memory in the multithreader, it will cause this error at runtime.
I GAVE UP LONG AGO
TRY AGAIN
has to be the last command in a program, if
it’s there at all; you can’t even follow it by
comments, not even if you know in advance that they won’t be
REINSTATE
d. This error happens at compile time if a
command is found after a TRY AGAIN
.
NOCTURNAL EMISSION, PLEASE LAUNDER SHEETS IMMEDIATELY
This error should never happen, and if it does indicates a compiler bug. It means the emitter function in the code degenerator has encountered an unknown opcode. Please send a copy of the program that triggered it to the INTERCAL maintainers.
DO YOU REALLY EXPECT ME TO HAVE IMPLEMENTED THAT?
Some parts of the code haven’t been written yet. There ought to be no way to cause those to actually run; however, if you do somehow find a way to cause them to run, they will cause this error at compile time.
ILLEGAL POSSESSION OF A CONTROLLED UNARY OPERATOR
Some operators (such as whirlpool (@
) and sharkfin
(^
)) only make sense in TriINTERCAL
programs, and some have a minimum base in which they make sense.
This error happens at compile-time if you try to use an operator
that conflicts with the base you’re in (such as using
TriINTERCAL operators in an
INTERCAL program in the default base 2).
EXCUSE ME, YOU MUST HAVE ME CONFUSED WITH SOME OTHER COMPILER
This error occurs just before compile-time if a file is encountered on the command line that C-INTERCAL doesn’t recognise. (If this error occurs due to a ‘.a’, ‘.b98’, ‘.c’, ‘.c99’, or ‘.c11’ file, then you forgot to enable the external calls system using -e (see -e).)
NO SKELETON IN MY CLOSET, WOE IS ME!
The skeleton file ick-wrap.c or pickwrap.c is needed to be able to compile INTERCAL to C. If the compiler can’t find it, it will give this error message. This indicates a problem with the way the compiler has been installed; try using the -u option (see -u) to find out where it’s looking (you may be able to place a copy of the skeleton file in one of those places).
Next: Warnings, Up: Errors and Warnings [Index]