The User's Guide

Glossary

abort restart options

Debugger options that abort the current evaluation.

backtrace

In the Debugger, a display of the sequence of function calls from the current function to the bottom of the stack.

catch

A special form used withthrow to transfer control to a destination determined by the dynamic environment.

CLOS

Common Lisp Object System. An object-oriented system that uses objects to model real-world concepts

Compiler

A program that transforms Lisp expressions into native machine code.

condition

A data structure that represents the state of an exceptional situation, a situation that deviates from normal program behavior.

consing

The creation of Lisp objects in dynamic or ephemeral space.

continue restart options

Debugger options that continue the current evaluation.

Debugger

A programming tool that allows you to interactively examine and modify Lisp programs.

development mode

The default mode of the Compiler. In this mode, the Compiler compiles code quickly and safely, but does not perform many optimizations.

dynamic context markers

Portions of the stack that contain information forcatch special forms, special bindings, andunwind-protect forms.

Dynamic Garbage Collector

A stop-and-copy compacting garbage collector that reclaims storage in the dynamic space.

Ephemeral Garbage Collector

A lifetime-based garbage collector that reclaims storage in the ephemeral space.

ephemeral levels

Portions of ephemeral storage in which user-defined Lisp objects are allocated when ephemeral garbage collection is enabled.

error

An exceptional situation that prevents a program from executing normally without some form of intervention.

evaluation

Lisp's process of determining the value of an object and returning that value.

evaluator

See interpreter.

exceptional situations

Deviations from the normal or expected behavior of a program.

fixnum

An integer of typefixnum, that is, small integers that can be directly represented as machine integers.

foreign areas

Memory storage areas that are used by programs written in languages other than Lisp.

Foreign Function Interface

A facility for loading code that is written in computer languages other than Lisp into the Lisp environment, for creating Lisp functions to call non-Lisp code, and for converting information provided by Lisp functions to a format that can be used in a foreign environment.

foreign functions

Functions written in computer languages other than Lisp.

foreign pointers

Lisp objects that represent foreign data objects; their structures are defined by the macrodef-foreign-struct.

garbage collection

Reclaiming memory storage space by eliminating Lisp objects that are no longer used.

global variable

A dynamically scoped variable that can be referenced by any function.

heap

An area of dynamic storage in which user-created Lisp objects are allocated and deallocated.

Inspector

A debugging tool that allows you to interactively examine and modify the components of a Lisp object.

interpreter

The part of the Lisp system that evaluates Lisp expressions.

keyword

A symbol preceded by a colon (:mode,:value, and so forth).

local variable

A variable that can only be referenced at the textual location of the code that creates it.

Multitasking Facility

A scheme for scheduling execution time among multiple processes that are running concurrently in the same Lisp environment.

optional parameter

A symbol that is not required for a function to work properly; in the syntactic description, the symbol&optional precedes the optional parameter.

package

A Common Lisp object that specifies a mapping between print name strings and symbols.

parameter

A symbol whose value is determined by the arguments that you supply when you invoke a function.

pointer

The stored address of a Lisp object.

process

A program in execution.

production mode

In this mode, the Compiler focuses on producing heavily optimized code. Compiling takes longer than in development mode.

program

A sequence of expressions composed of function calls.

read-eval-print loop

The routine in which Lisp reads the expression typed at the Lisp prompt, evaluates the expression, and prints the result on the terminal.

reader

The part of the Lisp system that reads input in the read-eval-print loop and parses it.

recursion

A control structure in Lisp in which a function calls itself.

rest parameter

A construct that allows a function to have an unspecified number of arguments; it is indicated by the symbol&rest in the syntactic description.

restart options

In the Debugger, ways to proceed from an incomplete evaluation.

semi-spaces

Two available dynamic storage spaces where user-defined Lisp objects are stored when dynamic garbage collection is enabled.

slots

The fixed number of named components of a structure or data type.

special variable

A variable that is used in aspecial declaration and that has dynamic scope.

stack

An area in memory where function calls and their arguments are stored during an evaluation.

stack frame

A portion of the stack that contains information about a single function call and the function's arguments.

Stepper

A debugging tool that interactively steps through the evaluation of an expression.

syntax

Standardized grammatical rules and patterns.

tag

The argument to a catch.

throw

A special form used withcatch to transfer control to a destination determined by the dynamic environment.

toggle

To turn a mode or condition on or off.

top level

The state in which Lisp displays a prompt and is ready for new commands.

Tracer

A debugging tool that traces calls to specified functions and displays the functions' arguments and return values.

trap on exit

In the Debugger, an event that suspends execution of a function immediately after the function returns.

unwinding the stack

In the Debugger, returning to the dynamic environment for a particular location in the stack; this action restores the global value of any special variable that has been bound in the current process.

Generated with Harlequin WebMaker