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.

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.

Too many variables

LispMe can address at most 256 variables in a single environment frame and a maximum of 64 nested frames. You are very unlikely to hit this limit, but if you do, please send a mail.

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.

Can't call transcendental functions without MathLib

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.

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

Can't create session name

The database for the new session name couldn't be created. There are several reasons for that, which are indicated within this error message: