The Advanced User's Guide
*all-processes*
*all-symbols-exclusions*
*ansi-c*
*autoload-verbose*
*cpp-arguments*
*cpp-command*
*current-process*
*default-archive-directories*
*default-make-package-use-list*
*enter-top-level-hook*
*error-output*
*ignore-binary-dependencies*
*ignore-extra-right-parens*
*inhibit-scheduling*
*initial-io* [1] [2]
*initial-process*
*keyboard-interrupt-process*
*lisp-symbol-to-foreign-string-method*
*load-binary-pathname-types*
*load-if-source-newer*
*load-if-source-only*
*load-pathname*
*load-source-pathname-types*
*make-linker-name*
*package*
changing the setting from within an initialization file
*pointer-to-character-becomes-string*
*prefer-multidimensional-arrays*
*print-structure*
*prompt*
*quitting-lisp*
*record-source-files*
*redefinition-action*
*scheduling-quantum*
*source-pathname*
*style-warnings*
*terse-redefinitions*
-e -eval -l -load -n -no-init-file -q -quit
absolute pathnames
activate-process
active processes
adjoin-to-weak-set
advice
adding
describing
removing
Advice Facility
adding advice [1] [2]
calling advised functions
compiled advice
continuations
describing levels of advice
examples
nesting advice
pieces of advice
removing advice [1] [2]
advice-continue
advised functions
calling
alignment requirements
modulus
remainder
alive processes
*all-processes*
*all-symbols-exclusions*
*ansi-c*
apply-advice-continue
arglist declarations
arrays
displaced
floating-point
I/O
optimizing in compiled code
packed
assq
*autoload-verbose*
autoloadablep
autoloading
autoloadable constructs
functional interface
functions
loaded definitions
loading messages
bignump
binary files
creating
loading
Bourne Shell
scripts
setting environment variables from
buffer-ref
buffered interface [1] [2]
buffer
checking out buffers
index
limit
buffers, I/O
byte-specifier-p
C programs
passing data to Lisp
passing Lisp data to
C-Shell
setting environment variables from
C-to-FFI Facility
call discipline
calling conventions
case
compiling
catch
change-memory-management
character types
check-stack-remaining
clear-input
clear-output
clear-resource
CLOS extensions
compile-all-dispatch-code
list-all-classes
precompile-generic-functions
trace-method
undefmethod
untrace-method
CLOS optimizations
clos package
clos-internals package
close-all-files
command-line arguments
accessing
evaluating forms
loading initialization files
loading options
processing
terminating Lisp
command-line-argument
compilation mode
selecting
compile
compile-all-dispatch-code
compile-file
compiled code
debugging
efficiency of
interpreted code vs.
safety of
size of
speed of
compiled-function-p
Compiler
and ephemeral garbage collection
checking arguments
checking read access
checking write access
development mode of [1] [2]
in-line coding
keyword arguments for
messages and warnings
optimization reports [1] [2]
production mode of [1] [2]
tail merging
compiler macros
compiler-options
compiling
arrays
case macros
constant forms
files
fixnum operations
floating-point operations
functions
in-line functions
macros
methods
recursive functions
composite stream
constant folding
constants
compiling
syntactic descriptions
continuations
conventions
notational
copy-foreign-pointer
*cpp-arguments*
*cpp-command*
current process, suspending
*current-process*
customization
autoloading [1] [2] [3] [4]
changing the prompt
command-line arguments
controlling startup
environment variables [1] [2]
initialization files [1] [2]
Lisp image pathname
memory management parameters
moving in the file system
prompt string
saving a Lisp image [1] [2]
setting working directory
startup function
deactivate-process
dead processes
deadlocks
debugging
compiled code
dynamic-extent declarations
special variables
tail calls
debugging multiple processes
binding streams
breakpoints in the initial I/O stream
communication streams
controlling terminal
disabling a process
dynamic evaluation of standard streams
I/O
initial I/O stream
keyboard interrupts
using the same stream
decache-eval
declarations
arglist
dynamic-extent
ftype [1] [2] [3]
global [1] [2]
ignore
inline
local [1] [2]
making
notinline
optimize
restrictive-ftype [1] [2] [3]
special
type
type-reduce
declare
def-compiler-macro
def-foreign-callable [1] [2]
def-foreign-function [1] [2]
def-foreign-struct
def-foreign-synonym-type
defadvice
*default-archive-directories*
*default-make-package-use-list*
define-autoload
define-c-callable
define-c-function
define-foreign-symbol
define-fortran-function
define-function
define-macro
defined-foreign-type-p
definitions
source file
defmacro-autoload
defpackage
additional keyword option
defsubst
defun-autoload
delete-defstruct
delete-finalization-registration
delete-from-weak-set
delq
demos
optimizing
deposit-byte
describe-advice
destructuring-bind
development mode of Compiler
optimizations in
selecting [1] [2]
directory
sorted pathnames
working
disable-stack-lists [1] [2]
disassemble
discard-source-file-info
disksave
and finalization
and foreign pointers
displaced-array-p
do-present-symbols
dynamic garbage collection
and memory management
dynamic-extent declarations
debugging
enable-stack-lists [1] [2]
enabled-floating-point-traps
ensure-autoloaded
*enter-top-level-hook*
environment variables
accessing [1] [2]
Lisp
operating system
error output
error-checking code
*error-output*
eval-when
examples
representations of
extensions
allowing interrupts
CLOS
deferred interrupts
deferring interrupts
defining functions
defining macros
deleting list items
deleting structures
destructuring lists
displaced arrays
exclusive or
extracting bits from integers
floating-point error conditions
floating-point traps
hash tables
input/output
load facility
miscellaneous
parsing lambda expressions
pathname ordering
pathname specification
predicates for type checking
reexpanding function bodies
replacing bits in integers
reversing lists
searching lists
timing
extract-stream-handle
extract-stream-handles
extreme-float-p
fast I/O
extracting stream handles
making Lisp streams
fast-read-byte
fast-read-char
fast-unread-char
fast-write-byte
fast-write-char
fast-write-string
file handles [1] [2] [3]
file links
file system
moving in
file-position
files
closing
compiling
initialization [1] [2]
opening
pathnames
finalization
and disksave
registering objects for
removing objects from finalization queues
finalization queues [1] [2]
creating
emptying
registering objects for
removing objects from
returning an element from
testing if empty
finalization-queue-empty-p
finalization-queue-p
fixnum
arithmetic
integers
fixnump
floating-point arrays
floating-point contagion
numerical equality comparisons
floating-point format
floating-point numbers
component extraction
contagion
error conditions [1] [2]
extreme
packed arrays
precision
rounding mode
signed-magnitude representation
trapping conditions
foreign callback mechanism
foreign files
loading [1] [2]
loading restrictions
Foreign Function Interface
alignment requirements
backward compatibility
C programs
C-to-FFI Facility
callback mechanism [1] [2] [3]
calling foreign functions [1] [2]
copying foreign strings
creating foreign structures
creating synonym types
defined foreign types
defining foreign functions [1] [2] [3]
defining foreign structures
derived types
dynamic linking
evaluating foreign pointers
examples
foreign pointer information [1] [2]
foreign storage
foreign structure types
foreign type information
foreign types
foreign variable information
foreign variables
FORTRAN programs
freeing foreign pointers
loading code into Lisp address space
loading foreign files [1] [2]
loading foreign libraries [1] [2]
making foreign pointers
malloc foreign pointer
manipulating types
Pascal programs
passing C data to Lisp
passing foreign types
passing FORTRAN data to Lisp
passing Lisp data to C
passing Lisp data to FORTRAN
passing Lisp data to Pascal
passing Pascal data to Lisp
predefined data types
primitive data types
primitive structure types
recursive types
removing foreign types
restrictions with foreign loader
stationary objects
structure types
synonym types
typed objects
undefined foreign symbols
uninterned symbols
unions
writable objects
foreign functions
defining
examples
type checking
foreign libraries
loading [1] [2]
loading restrictions
foreign pointer objects
foreign pointers
copying
evaluating
freeing storage
in saved images
information about
making
malloc
size of storage pointed to
foreign storage
foreign strings
copying
foreign structures
creating
defining
examples of defining
primitive data types
foreign symbols
undefined names
foreign types
alignment requirements
call discipline
defined
derived
information about
modulus
named
passing
remainder
removing
size of
foreign variables
information about
foreign-address-of
foreign-aref
foreign-pointer-address
foreign-pointer-p
foreign-pointer-type
foreign-size-of
foreign-string-value
foreign-type-modulus
foreign-type-remainder
foreign-type-size
foreign-typep
foreign-undefined-symbol-names
foreign-value
foreign-variable-address
foreign-variable-p
foreign-variable-pointer
FORTRAN programs
passing data to Lisp
passing Lisp data to
free-foreign-pointer
ftype declarations [1] [2] [3]
functions
calling
compiling
defining
optional parameters
parameters
redefining
redefinition warnings
reexpanding bodies of
rest parameters
syntactic descriptions
generic functions
calling
syntactic descriptions
get-input-buffer
get-input-buffer-no-hang
get-output-buffer
get-source-file
get-stack-remaining
global declarations
global values [1] [2]
global variables
syntactic descriptions
hash tables
weak
hash-table-rehash-size
hash-table-rehash-threshold
hash-table-size
hash-table-test
hash-tables
accessor functions
creating
rehashing
home package
idle process
IEEE standard
ignore declarations
*ignore-binary-dependencies*
*ignore-extra-right-parens*
in-line coding
inactive processes
inherited symbols
*inhibit-scheduling*
*initial-io* [1] [2]
*initial-process*
initialization files
loading
inline declarations
input/output
array I/O [1] [2]
buffered interface [1] [2] [3]
clearing input or output streams
closing a file
control variables for streams
extensions
extracting stream handles
fast I/O
forcing output [1] [2]
ignoring extra parentheses
implementation choices
lowest level stream [1] [2]
making Lisp streams
opening files
positionable files
printing structures
integer-decode-float
integers
extracting bits
replacing bit fields
interrupt characters
interrupt process
interrupt-process
interruptions
allowing
inhibiting
interrupts
allowing
deferred
deferring
keyboard [1] [2]
interrupts-deferred-p
keyboard interrupts [1] [2] *keyboard-interrupt-process* keyword package kill-process
lambda expressions
parsing
lcl package
length
let-globally
lexical closures
process communication with
lexical variables
with multiple processes
liquid
liquid package
liquid-common-lisp package
liquid-runtime-support package
Lisp
loading Lisp files [1] [2]
multitasking in
passing data to C
passing data to FORTRAN
passing data to Pascal
pathnames of images
quitting
representations of
saving images [1] [2] [3]
Lisp images
saving
lisp package
Lisp streams
making
lisp-image-name
*lisp-symbol-to-foreign-string-method*
list-all-classes
list-finalization-queue
list-nreverse
list-reverse
list-weak-set
lists
deleting items
destructuring
reversing
searching
load [1] [2] [3]
load facility
default values [1] [2]
loading binary files
loading files
loading source files
*load-binary-pathname-types*
load-byte
load-foreign-files
load-foreign-libraries
*load-if-source-newer*
*load-if-source-only*
*load-pathname*
*load-source-pathname-types*
loading restrictions
local declarations
locally
long-site-name
loop package
lrs package
machine-type
machine-version
macros
compiling
defining
redefining
syntactic descriptions
make-finalization-queue
make-foreign-pointer
make-hash-table
additional keyword argument
make-instance
optimizing
*make-linker-name*
make-lisp-stream [1] [2]
make-process
make-resource
make-weak-set
malloc-foreign-pointer
member-of-weak-set
memory management
and dynamic garbage collection
keyword options
UNIX tools
memq
method combination optimization
methods
compiling
modulus
most-negative-fixnum
most-positive-fixnum
multitasking
after saving an image
process property list
process switching
Multitasking Facility
activating and deactivating processes
allowing interruptions
allowing scheduling
an application
blocking a process
communication streams
creating a process
current process
debugging in
dynamic stack list allocation
error handling
examples
global data structures
global values [1] [2] [3]
global variables
identifying a process
inhibiting interruptions
inhibiting scheduling [1] [2]
initial I/O stream
initial process
interrupting a process
keyboard interrupts [1] [2] [3]
killing a process
lexical variables
locks
nonlocal control transfer
process data structures
process information [1] [2]
process list
process state
processes
quitting Lisp [1] [2]
remaining stack space [1] [2]
restarting a process
resuming a process
running concurrent processes
scheduling
scheduling quantum
special issues
special variables
stream conflict, preventing
suspending a process
symbol bindings
using the initial I/O stream
named foreign types
predefined types
primitive types
structure types
synonym types
notinline declaration
objects
finding definitions of
open
keyword options
open coding
optimization declarations
and equivalent keyword settings
compilation-speed
safety
space
speed
optimization reports
disabling
enabling
optimize declarations
optimizing
array access
CLOS
compiled code
demos
fixnum operations
floating-point operations
make-instance
method combination
recursive functions
slot-value
optional parameter
*package*
changing the setting from within an initialization file
package cell
packages
accessible symbols
clos
clos-internals
current package
excluding symbols from searches
extensions
file in a package
home package
inherited symbols
interpreted vs. compiled code
iterating over present symbols
lcl
liquid
liquid-common-lisp
liquid-runtime-support
lisp
loop
lrs
make-package
owned symbols
present symbols
qualifying symbols
sys
system
use lists
user
windows
packed arrays
parameters
optional
rest
parentheses
ignoring extras
parse-body
Pascal programs
passing data to Lisp
passing Lisp data to
pathname-lessp
pathnames
absolute
of files being loaded
ordering
relative
specifying
PC logging
results of
starting
stopping
pipes
*pointer-to-character-becomes-string*
pointers, weak
pop-finalization-queue
precompile-generic-functions
predefined data types
predicates
type-checking
*prefer-multidimensional-arrays*
primitive data types
foreign structures
*print-structure*
process-active-p
process-alive-p
process-allow-schedule
process-in-the-debugger-p
process-initial-arguments
process-initial-function
process-interruptions
process-lock
process-name
process-plist
process-resume-functions
process-state
process-suspend-functions
process-unlock
process-wait
process-wait-arguments
process-wait-forever
process-wait-function
process-wait-with-timeout
process-whostate
processes
activating and deactivating
active
alive
blocking
creating
current
current, suspending the
dead
deadlocked
debugging
dynamic allocation of stack lists
global values
identifying
idle
inactive
information about
inhibiting scheduling
initial
interaction of
interrupting [1] [2]
interruptions
keyboard interrupts [1] [2]
killing
list of
locks
printing information about
property list
quit
restarting
resuming
running concurrently
scheduling [1] [2] [3] [4]
state [1] [2]
stream conflict, preventing
suspending
switching
understanding streams
unwinding the stack
using the same stream
vs. operating system process
processp
proclaim
proclamation
production mode of Compiler
selecting [1] [2]
*prompt*
prompt
changing
Lisp
string
quit *quitting-lisp*
ratiop
read-array
record-source-file
*record-source-files*
recursive types
redefining
redefinition warnings
*redefinition-action*
register-for-finalization-queue
register-lisp-function
registered-for-finalization-queue-p
rehash
rehashing
relative pathnames
remainder
remove-advice
report-compiler-options
reset-compiler-options
Resource Facility
allocating objects from a resource
clearing resources
creating resources
deallocating objects from a resource
examples
isomorphic objects
objects in use [1] [2]
using resources
resource-allocate
resource-deallocate
resources
allocating objects [1] [2]
clearing
creating
deallocating objects
isomorphic objects
using
rest parameter
restart function
restart-process
restrictive-ftype declarations [1] [2]
return [1] [2]
return-input-buffer
return-output-buffer
round-robin scheduling
round-to-single-precision
run-program [1] [2]
difference from Foreign Function Interface
error output
examples
keyword options
pipes
shell scripts
standard input streams
standard output streams
safety declarations
and equivalent keyword settings
saving Lisp images
scheduler
scheduler cycle
scheduling
allowing
inhibiting
scheduling quantum
*scheduling-quantum*
sequencep
set, weak
adding to
creating
removing from
set-disksave-parameters
sets, weak
shell scripts
short-site-name
show-processes
sigalrm signals, avoiding
signed magnitude representation
simple-array-p
simple-bit-array-p
slot-value
optimizing
slots
software-version
Source File Recording Facility
enabling and disabling [1] [2]
examples
object definitions
recording names
source files
definitions
discarding information
enabling and disabling recording
loading [1] [2]
locating objects in
recording names
truename
*source-pathname*
special declarations
special variables
debugging
dynamic binding
global values
with multiple processes
speed declarations
and equivalent keyword settings
stack lists
definition of
dynamic allocation of [1] [2] [3]
with multiple processes
stack space
checking
remaining
start-pc-logging
startup
command-line processing
controlling [1] [2]
default function
invoking functions
stationary objects
stationary-object-p
stop-pc-logging
stream handles
extracting
streams
breakpoints
clearing input or output
forcing output
initial I/O [1] [2] [3]
lowest level
standard input
standard output
synonym
string-output-stream-p
string-stream-p
structure types
structures
deleting
printing
*style-warnings*
summarize-pc-logging
supported-floating-point-conditions
suspending the current process
symbol-dynamically-boundp
symbol-global-boundp
symbol-global-value
symbol-process-boundp
symbol-process-value
symbol-value
symbols
accessible
bindings
excluding from package searches
external
global values [1] [2]
interned
present [1] [2]
synonym types
creating
syntactic descriptions
constants
functions
global variables
macros
sys package
system package
tail calls
debugging
definition of
tail merging
*terse-redefinitions*
the
throw
time1
trace-method
translate-c-file
translating from C to Lisp [1] [2]
type checking
with foreign functions
type declarations
type propagation
type-of
type-reduce declarations
type-specific operations
type-specifier-p
typed objects in Lisp
typed-foreign-aref
uncompile
undef-compiler-macro
undefine-foreign-type
undefmethod
underlying-stream
unintern-foreign-symbol
uninterned symbols
unions
forming in the Foreign Function Interface
UNIX
setting environment variables from
UNIX programs
error output from
examples of calling from Lisp
exit status
output from [1] [2]
running from Lisp [1] [2]
unproclaim
untrace-method
unwinding the stack
user package
using-initial-io
using-resource
variables
creating and binding
wait functions
weak hash tables
weak pointers
weak sets [1] [2]
adding to
creating
removing from
weak-set-p
windows package
with-buffered-terminal-output
with-compiler-options
with-deferred-warnings
with-floating-point-traps
with-interruptions-allowed
with-interruptions-inhibited
with-interrupts-allowed
with-interrupts-deferred
with-keyboard-interrupt
with-keyboard-interrupt-process
with-open-file
with-process-lock
with-scheduling-allowed
with-scheduling-inhibited
with-static-area
working-directory
writable objects
writable-object-p
write
write-array
xor
Generated with Harlequin WebMaker