Back to index
LispMe Error Messages
When a syntax error is found during loading a memo, you go back to
the load dialog. Now you can use the
Edit button to jump directly to the
offending source text to correct your mistake.
The LispMe reader encountered an invalid character.
The LispMe reader encountered a token that cannot start a valid
symbolic expression. This also happens, when the expression to be read
is empty.
More than one dot . occurred in a list, or more than
one expression is written after the dot. Make sure that you
didn't put a space into a floating point constant.
A single token (a symbol, number or string) must not contain more than
256 characters.
The LispMe reader encountered an invalid floating point constant.
Possible reasons are:
- neither a digit or + or - after the e
in the exponent part
- not a digit after the e and sign
in the exponent part
- not a digit after the decimal point
The LispMe reader encountered an invalid complex number.
Possible reasons are:
- You forgot the i after the imaginary part
- You didn't put a space between two real numbers, so LispMe
tried to interpret the second as the imaginary part of a complex.
This error occurres, when there's an illegal character after
the hash sign # in a constant. The only allowed #
constants are
- #f the constant false
- #t the constant true
- #n the non-printing value
- #(, introducing a vector.
- #\, introducing a character constant.
Additionally, this error is raised when in a string containing
hex escape sequences #hh one of the characters
h is not a hexadecimal digit.
When writing a string constant, you forgot the closing double quote
". Perhaps you wanted to include a " in the
string and forgot to escape it with \. Or the last char
in the string is a \ and you forgot to escape it, resulting
in an escaped double quote.
LispMe for PalmOS1 doesn't support real numbers, however
the parser recognizes them. Make sure that every numeric constant
you enter is integer and in the range [-16384 ... 16383] (15 bit
signed integer)
LispMe for PalmOS1 doesn't support complex numbers, however
the parser recognizes them. Make sure that every numeric constant
you enter is integer and in the range [-16384 ... 16383] (15 bit
signed integer)
Compiler Errors
When a memo is syntactically correct, no more source positions are
recorded. So, if there's a compiler error, LispMe hasn't enough
information to find the offending position in the source text. Thus when
pressing the
Edit button after an unsuccessfull
load, you simply go to the beginning of the selected memo.
The given name is not defined in the lexical environment. Check for
a spelling error or for having loaded all required memos.
The number of arguments for the noted special form or built-in
procedure is wrong.
expr was found, when there was a variable name expected in
the special forms
define,
let,
letrec, or
set!.
The head (variable binding list) in a
let or
letrec form is
not a proper list.
A variable binding in the head of a
let or
letrec form is
not a two-element list (var expr).
The argument list for the
lambda special
form has not one the three allowed shapes. This also applies to
the second form of define.
An expression list in a function call is not a proper list.
A variable name to be bound occurred twice in a
lambda-,
let- or
letrec-binding
list. Also when the same toplevel name is defined twice in a
loaded memo.
An expression sequence in the body of a
begin-,
cond-,
lambda-,
let- or
letrec-form is
empty. It must contain at least one expression.
A define expression is not
allowed in this context. Definitions must appear before all other
expressions in an expression sequence.
A definition (see define)
has not of one of the allowed shapes.
A memo to be loaded must consist of a sequence of
define forms. No other
expressions are allowed.
A case or
cond
clause is not of the form
(guard expr1 expr2 ...).
An expression to be compiled is too deeply nested. To avoid stack
overflow (and thus a Fatal Error) in the compiler, this message is
displayed. Try to simplify your code by using helper functions for
example.
For technical reasons, compilation can't be interrupted by the
Break button. So, to avoid infinite
loops while compiling, there are two fixed limits for expanding a
macro (which indeed calls the VM for its duty):
- The number of VM steps for a single expansion. This is 1600,
which should suffice to distinguish between sensible macros
and non-termination.
- The number of macro expansion during a single compilation. This
is 200 which should also suffice.
If you should encounter a situation where these limits are too tight,
please send me an email including
the code you tried to compile, but watch out for non-terminating macros
like (macro (defunct x) x) before.
One of the special forms
unquote or
unquote-splicing
appeared outside of the special form
quasiquote or the
nesting depth of quasiquote expressions has reached zero by outer
unquotes.
unquote-splicing
didn't appear in a list or a vector template, so there wouldn't be a
valid context into which the resulting list could be spliced.
Runtime Errors
This is the classical runtime type error. This error is also raised, when
a number is to large to be coerced to an integer by
integer
A lexical closure expecting n arguments was called with a
wrong number of arguments, namely m. The actual argument list
is printed in this error message as expr.
Caused by integer and floating point division.
During evaluation of the local definitions in a
letrec form, the
value of one of the variables just being bound was accessed. An access
to the value of any variable in the binding list will cause this error
while the expressions to initialize these variables are evaluated.
These variables may be used inside a
lambda or
delay special form, as
in this case their value will not be needed during evaluation of these
forms.
All of the guards in a cond
form evaluated to false or the value of the expression
in a case
form is not in any of the constant lists. Both cases can only happen,
when the else keyword is absent.
The given expression is not a valid index for the string or vector.
The two objects compared by one of the procedures
< <= > >=
have non-compatible types.
The drawing pattern *pat*
is not one of the allowed values.
The mathematics library MathLib.prc (included in this package) has not
been installed, so calls to transcendental functions like
sin fail. The functions
needing MathLib are marked in the
Catalog of Language Elements.
The result of an arithmetic operation is not in the allowed range
for integers [-16384 ... 16383]
The parameter parm is invalid for the built-in
procedure proc. Have a look at the catalog for valid arguments.
A new memo can't be created for output. Probably there's not enough
memory left on your Pilot.
The memo to be opened for input can't be found. Look for a spelling
error in the memo name (this is always the first line of the memo).
A memo which is currently open (either for reading or writing) has
been deleted. Just simply don't do that!
LispMe can't resize the memo to append the output. Probably there's
not enough memory left on your Pilot.
The LispMe virtual machine (VM) encountered an illegal opcode. This is
a severe internal error produced by a buggy LispMe compiler
(you should never see this error message),
so please send mail to me with a
report what caused this message.
However, if you got this error by messing around with the list returned
by disasm, this is
your own fault, so don't blame me.
Memory Errors
There's not enough memory for a new symbol to be allocated. Symbols are
not garbage collected, so this error may occur if you loaded and popped
several different memos, as all symbols used so far accumulate in the
atom space. So use the command Reset Heap,
or if this doesn't help, increase the atom size via the
Preferences dialog.
The heap memory used for pairs and strings is exhausted and even
garbage collection cannot reclain sufficient space.
Look for non-terminating recursion or try to increase heap size via the
Preferences dialog.
The memory used for floating point values is exhausted and even
garbage collection cannot reclain sufficient space.
Try to increase FP size via the
Preferences dialog.
This message can have three causes:
- reading a deeply nested list (about 30 levels deep)
- compiling a very complex expression
- garbage-collecting a deeply nested list (about 50 levels)
All these things are done internally by recursive functions consuming
some of the (very limited!) Pilot hardware stack. To avoid overwriting
memory and crashing your machine, a stack check caused this error.
Don't confuse this with recursive functions in LispMe itself, they
don't use the hardware stack but the heap, so a non-terminating
(non-tail) recursion in LispMe causes
this error.
You may sometimes get this error when loading a memo (the compiler
needs some stack) and a garbage collection is invoked (needing further
stack). Tap Cancel in this case and invoke
Menu/View/Memory usage, which forces a garbage collection and
try to load the memo again.
An attempt to resize the memory block for heap, atoms, reals or output
failed. You might not have enough free memory or your memory is too
fragmented. The previous memory size is used.
A pointer in the LispMe heap has an invalid type tag. This is
a severe internal error produced by a buggy LispMe compiler or VM
(you should never see this error message),
so please send mail to me with a
report what caused this message.
Others Errors
The stack of loaded memos or entered definitions (see ...) is already
empty, you can't pop anymore.
You pressed the break button to
interrupt a running evaluation. The interrupted process cannot be
resumed.
This error (notice User Error in the title bar) is generated by
a call to the error
procedure. The text printed in the message box is the argument to
error.
To be able to load a memo containing
LispMe source code, you have to create a category named LISP
(case doesn't matter) in the MemoPad application. LispMe expects all
source memos in this category.
You haven't created a memo in the LISP category yet.
You installed LispMe for PalmOS2 (lispme20.prc) on a Pilot running
PalmOS1 (Pilot 1000, Pilot 5000) You need PalmOS2 (PalmPilot, Palm III
or an
upgraded older Pilot) to run this version of LispMe. This message
box can't be tapped away, instead you should go to the Memory application,
delete LispMe and install LispMe for PalmOS1 (lispme10.prc).
Warnings and user queries
This message box (notice User message in the title bar)
is generated by
a call to the message
procedure. The text printed in the message box is the argument to
message.
Tap OK to re-initialize LispMe memory. All loaded memos and other
data will be cleared and you'll have a virgin heap.
Tap Cancel if you selected
Reset Heap by accident,
Your current evaulation created a lot of output (either by
display or
write, or by a long
return value). In any case, all output not fitting into the selected
Output Size, will be omitted and the last character visible in the
output field will be a ... to indicate truncation.
Fatal Errors
OK, these errors are not fatal for your Pilot, but for LispMe. LispMe
can't continue to work when one of these errors occurred.
Can't create LispMe DB
When starting LispMe the first time, it tries to create its database
containing heap etc. memory. When this fails, LispMe can't work. You
should delete some applications or databases to have more memory or
use a defragmentation tool if your memory is too fragmented.
LispMe DB inconsistent
The memory sizes stored in LispMe's preferences doesn't match the
actual sizes found in the database. You either messed around with the
DB using other programs or didn't delete LispMe first when upgrading
from an earlier version. Just delete and re-install LispMe.
No memoDB?
The MemoPad database was not found. Now this is very strange...