Back to index

LispMe Error Messages

Syntax Errors

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.

Invalid char

The LispMe reader encountered an invalid character.

Invalid symbolic expression

The LispMe reader encountered a token that cannot start a valid symbolic expression. This also happens, when the expression to be read is empty.

Multiple dots in list

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.

Max. token length exceeded

A single token (a symbol, number or string) must not contain more than 256 characters.

Invalid real number

The LispMe reader encountered an invalid floating point constant. Possible reasons are:

Invalid complex number

The LispMe reader encountered an invalid complex number. Possible reasons are:

Invalid # constant

This error occurres, when there's an illegal character after the hash sign # in a constant. The only allowed # constants are Additionally, this error is raised when in a string containing hex escape sequences #hh one of the characters h is not a hexadecimal digit.

Unterminated string

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.

Real numbers not supported in this version (PalmOS1 only)

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)

Complex numbers not supported in this version (PalmOS1 only)

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.

Undefined name

The given name is not defined in the lexical environment. Check for a spelling error or for having loaded all required memos.

Wrong number of arguments

The number of arguments for the noted special form or built-in procedure is wrong.

expr is not a symbol

expr was found, when there was a variable name expected in the special forms define, let, letrec, or set!.

Invalid let list

The head (variable binding list) in a let or letrec form is not a proper list.

Invalid let binding

A variable binding in the head of a let or letrec form is not a two-element list (var expr).

Invalid lambda args

The argument list for the lambda special form has not one the three allowed shapes. This also applies to the second form of define.

Improper argument list

An expression list in a function call is not a proper list.

Duplicate name

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.

Empty expression sequence

An expression sequence in the body of a begin-, cond-, lambda-, let- or letrec-form is empty. It must contain at least one expression.

Definition in invalid context

A define expression is not allowed in this context. Definitions must appear before all other expressions in an expression sequence.

Invalid definition

A definition (see define) has not of one of the allowed shapes.

Not only 'define' expressions in loaded memo

A memo to be loaded must consist of a sequence of define forms. No other expressions are allowed.

Invalid case/cond clause

A case or cond clause is not of the form (guard expr1 expr2 ...).

Expression too complex

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.

Macro too complex

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): 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.

unquote(-splicing) invalid outside of quasiquote

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 allowed in list or vector template only

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

expr is not a type

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

Function expected n arguments, but got m as follows: expr

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.

Division by zero

Caused by integer and floating point division.

Sucked into black hole

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.

No matching case/cond clause

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.

Invalid index

The given expression is not a valid index for the string or vector.

Non matching types in comparison

The two objects compared by one of the procedures < <= > >= have non-compatible types.

Invalid pattern

The drawing pattern *pat* is not one of the allowed values.

Can't call transcendental functions without MathLib (PalmOS2/3 only)

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.

Number too big for integer (PalmOS1 only)

The result of an arithmetic operation is not in the allowed range for integers [-16384 ... 16383]

Invalid parameter parm for proc

The parameter parm is invalid for the built-in procedure proc. Have a look at the catalog for valid arguments.

Can't create memo

A new memo can't be created for output. Probably there's not enough memory left on your Pilot.

Memo not found

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).

Memo associated with port vanished

A memo which is currently open (either for reading or writing) has been deleted. Just simply don't do that!

Can't write to memo

LispMe can't resize the memo to append the output. Probably there's not enough memory left on your Pilot.

Illegal opcode

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

Atom space exhausted

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.

Heap exhausted

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.

FP storage exhausted (PalmOS2/3 only)

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.

Recursion too deep

This message can have three causes: 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.

Couldn't change ... size

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.

Invalid pointer

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

No more sources to pop

The stack of loaded memos or entered definitions (see ...) is already empty, you can't pop anymore.

Execution interrupted

You pressed the break button to interrupt a running evaluation. The interrupted process cannot be resumed.

User error: ...

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.

No memo category LISP defined

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.

No memo in category LISP found

You haven't created a memo in the LISP category yet.

LispMe needs PalmOS Version 2.0 at least (PalmOS2/3 only)

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

User message: ...

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.

Zap all LispMe memory?

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,

Output too long - truncated

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...