This is usually not caught. Some words perform checks, e.g., the control
flow words, and issue a ABORT" or -12 THROW (Argument type
mismatch).

attempting to obtain the execution token of a word with undefined execution semantics:

-14 throw (Interpreting a compile-only word). In some cases, you
get an execution token for compile-only-error (which performs a
-14 throw when executed).

dividing by zero:

On some platforms, this produces a -10 throw (Division by
zero); on other systems, this typically results in a -55 throw
(Floating-point unidentified fault).

insufficient data stack or return stack space:

Depending on the operating system, the installation, and the invocation
of Gforth, this is either checked by the memory management hardware, or
it is not checked. If it is checked, you typically get a -3 throw
(Stack overflow), -5 throw (Return stack overflow), or -9
throw (Invalid memory address) (depending on the platform and how you
achieved the overflow) as soon as the overflow happens. If it is not
checked, overflows typically result in mysterious illegal memory
accesses, producing -9 throw (Invalid memory address) or
-23 throw (Address alignment exception); they might also destroy
the internal data structure of ALLOCATE and friends, resulting in
various errors in these words.

insufficient space for loop control parameters:

Like other return stack overflows.

insufficient space in the dictionary:

If you try to allot (either directly with allot, or indirectly
with ,, create etc.) more memory than available in the
dictionary, you get a -8 throw (Dictionary overflow). If you try
to access memory beyond the end of the dictionary, the results are
similar to stack overflows.

interpreting a word with undefined interpretation semantics:

For some words, we have defined interpretation semantics. For the
others: -14 throw (Interpreting a compile-only word).

modifying the contents of the input buffer or a string literal:

These are located in writable memory and can be modified.

overflow of the pictured numeric output string:

-17 throw (Pictured numeric ouput string overflow).

parsed string overflow:

PARSE cannot overflow. WORD does not check for overflow.

producing a result out of range:

On two's complement machines, arithmetic is performed modulo
2**bits-per-cell for single arithmetic and 4**bits-per-cell for double
arithmetic (with appropriate mapping for signed types). Division by
zero typically results in a -10 throw (divide by zero) or
-55 throw (floating point unidentified fault). Overflow on
division may result in these errors or in -11 throw (result out
of range). Gforth-fast may silently produce bogus results on
division overflow or division by zero. Convert and
>number currently overflow silently.

reading from an empty data or return stack:

The data stack is checked by the outer (aka text) interpreter after
every word executed. If it has underflowed, a -4 throw (Stack
underflow) is performed. Apart from that, stacks may be checked or not,
depending on operating system, installation, and invocation. If they are
caught by a check, they typically result in -4 throw (Stack
underflow), -6 throw (Return stack underflow) or -9 throw
(Invalid memory address), depending on the platform and which stack
underflows and by how much. Note that even if the system uses checking
(through the MMU), your program may have to underflow by a significant
number of stack items to trigger the reaction (the reason for this is
that the MMU, and therefore the checking, works with a page-size
granularity). If there is no checking, the symptoms resulting from an
underflow are similar to those from an overflow. Unbalanced return
stack errors can result in a variety of symptoms, including -9 throw
(Invalid memory address) and Illegal Instruction (typically -260
throw).

unexpected end of the input buffer, resulting in an attempt to use a zero-length string as a name:

Create and its descendants perform a -16 throw (Attempt to
use zero-length string as a name). Words like ' probably will not
find what they search. Note that it is possible to create zero-length
names with nextname (should it not?).

>IN greater than input buffer:

The next invocation of a parsing word returns a string with length 0.

RECURSE appears after DOES>:

Compiles a recursive call to the defining word, not to the defined word.

argument input source different than current input source for RESTORE-INPUT:

-12 THROW. Note that, once an input file is closed (e.g., because
the end of the file was reached), its source-id may be
reused. Therefore, restoring an input source specification referencing a
closed file may lead to unpredictable results instead of a -12
THROW.

In the future, Gforth may be able to restore input source specifications
from other than the current input source.

data space containing definitions gets de-allocated:

Deallocation with allot is not checked. This typically results in
memory access faults or execution of illegal instructions.

data space read/write with incorrect alignment:

Processor-dependent. Typically results in a -23 throw (Address
alignment exception). Under Linux-Intel on a 486 or later processor with
alignment turned on, incorrect alignment results in a -9 throw
(Invalid memory address). There are reportedly some processors with
alignment restrictions that do not report violations.

data space pointer not properly aligned, ,, C,:

Like other alignment errors.

less than u+2 stack items (PICK and ROLL):

Like other stack underflows.

loop control parameters not available:

Not checked. The counted loop words simply assume that the top of return
stack items are loop control parameters and behave accordingly.

most recent definition does not have a name (IMMEDIATE):

abort" last word was headerless".

name not defined by VALUE used by TO:

-32 throw (Invalid name argument) (unless name is a local or was
defined by CONSTANT; in the latter case it just changes the constant).

name not found (', POSTPONE, ['], [COMPILE]):

-13 throw (Undefined word)

parameters are not of the same type (DO, ?DO, WITHIN):

Gforth behaves as if they were of the same type. I.e., you can predict
the behaviour by interpreting all parameters as, e.g., signed.