All Manuals > LispWorks User Guide and Reference Manual

NextPrevTopIndex

Contents

Preface

1 Starting LispWorks

1.1 The usual way to start LispWorks

1.2 Passing arguments to LispWorks

1.2.1 Saving a new image

1.2.2 Saving a console mode image

1.2.3 Bypassing initialization files

1.2.4 Other command line options

1.3 Starting the LispWorks Graphical IDE

1.4 Using LispWorks with SLIME

1.4.1 Using the Professional/Enterprise Editions with SLIME

1.4.2 Using the Personal Edition with SLIME

1.5 Quitting LispWorks

2 The Listener

2.1 First use of the listener

2.2 Standard listener commands

2.2.1 Standard top-level loop commands

2.2.2 Examples

2.3 The listener prompt

3 The Debugger

3.1 Entering the REPL debugger

3.2 Simple use of the REPL debugger

3.3 The stack in the debugger

3.4 REPL debugger commands

3.4.1 Backtracing

3.4.2 Moving around the stack

3.4.3 Miscellaneous commands

3.4.4 Leaving the debugger

3.4.5 Example debugging session

3.5 Debugger troubleshooting

3.6 Debugger control variables

3.7 Remote debugging

3.7.1 Simple usage

3.7.1.1 Using the IDE as the TCP server

3.7.1.2 Using the client as the TCP server

3.7.2 The client side of remote debugging

3.7.3 The IDE side of remote debugging

3.7.3.1 Accessing client side objects on the IDE side

3.7.3.2 Controlling the client side from the IDE side

3.7.4 Troubleshooting

3.7.4.1 Failing to open connections

3.7.4.2 The Inspector does not show slots in a remote object

3.7.5 Advanced usage - multiple connections

3.7.5.1 Client side connection management

3.7.5.2 IDE side connection management

3.7.5.3 Common (both IDE and client) connection functions

4 The REPL Inspector

4.1 Describe

4.2 Inspect

4.3 Inspection modes

4.3.1 Hash table inspection modes

5 The Trace Facility

5.1 Simple tracing

5.2 Tracing options

5.2.1 Evaluating forms on entry to and exit from a traced function

5.2.2 Evaluating forms without printing results

5.2.3 Using the debugger when tracing

5.2.4 Entering stepping mode

5.2.5 Configuring function entry and exit information

5.2.6 Directing trace output

5.2.7 Restricting tracing

5.2.8 Storing the memory allocation made during a function call

5.2.9 Tracing functions from inside other functions

5.3 Example

5.4 Tracing methods

5.5 Tracing subfunctions

5.5.1 Notes on subfunction names

5.6 Trace variables

5.7 Troubleshooting tracing

5.7.1 Excessive output

5.7.2 Missing output

5.7.2.1 Compiled code may not call the functions you expect

5.7.2.2 trace works on function names, not function objects

6 The Advice Facility

6.1 Defining advice

6.2 Combining the advice

6.2.1 :before and :after advice

6.2.2 :around advice

6.3 Removing advice

6.4 Advice for macros and methods

6.5 Advising subfunctions

6.5.1 Notes on subfunction names

6.6 Examples

6.7 Advice functions and macros

7 Dspecs: Tools for Handling Definitions

7.1 Dspecs

7.2 Forms of dspecs

7.2.1 Canonical dspecs

7.3 Dspec namespaces

7.3.1 Dspec classes

7.3.1.1 Complete example of a top-level dspec class

7.3.1.2 Example of subclassing

7.3.2 Dspec aliases

7.4 Types of relations between definitions

7.4.1 Functionally equivalent definers

7.4.2 Grouping subdefinitions together

7.4.3 Distributed definitions

7.5 Details of built-in dspec classes and aliases

7.5.1 Function dspecs

7.5.2 CLOS dspec classes

7.5.3 Part Classes

7.5.4 Foreign callable dspecs

7.6 Subfunction dspecs

7.7 Tracking definitions

7.7.1 Locations

7.7.2 Recording definitions and redefinition checking

7.7.2.1 Use of record-definition

7.7.2.2 Protecting packages

7.7.3 Source level debugging and stepping

7.8 Finding locations

7.9 Users of location information

7.9.1 Finding definitions in the LispWorks editor

7.9.2 Using pre-defined form parsers

7.9.3 The editor's implicit form parser

7.9.4 Reusing form parsers

7.9.5 Example: defcondition

7.9.6 Example: my-defmethod

8 Action Lists

8.1 Defining action lists and actions

8.2 Exception handling variables

8.3 Other variables

8.4 Diagnostic utilities

8.5 Examples

8.6 Standard Action Lists

9 The Compiler

9.1 Compiling a function

9.2 Compiling a source file

9.3 Compiling a form

9.4 How the compiler works

9.5 Compiler control

9.5.1 Examples of compiler control

9.6 Declare, proclaim, and declaim

9.6.1 Naming conventions

9.7 Optimizing your code

9.7.1 Compiler optimization hints

9.7.2 Fast integer arithmetic

9.7.3 Floating point optimization

9.7.4 Tail call optimization

9.7.5 Usage of special variables

9.7.5.1 Finding symbols to declare

9.7.5.2 Coalesce multiple special bindings

9.7.6 Stack allocation of objects with dynamic extent

9.7.7 Inlining foreign slot access

9.7.8 Built-in optimization of remove-duplicates and delete-duplicates

9.8 Compiler parameters affecting LispWorks

10 Code Coverage

10.1 Using Code Coverage

10.1.1 Compiling the code to record code coverage information

10.1.2 Loading the code

10.1.3 Exercising the code

10.1.4 Displaying the results

10.2 Manipulating code coverage data

10.3 Preventing code generation for some forms

10.4 Code coverage and multithreading

10.5 Counting overflow

10.6 Memory usage and code speed

10.7 Understanding the code coverage output

10.7.1 Eliminated forms

10.7.2 Displaying counters

10.7.3 Function forms where the function is not actually called

10.7.4 Partially hidden

10.8 Coloring code that has changed

11 Memory Management

11.1 Introduction

11.2 Guidance for control of the memory management system

11.2.1 General guidance

11.2.2 Short-lived data

11.2.3 Long-lived data

11.2.4 Permanent data

11.3 Memory Management in 32-bit LispWorks

11.3.1 Generations

11.3.2 Allocation of objects

11.3.2.1 Allocation of static objects

11.3.2.2 Allocation in different generations

11.3.3 GC operations

11.3.4 Garbage collection strategy

11.3.5 Memory layout

11.3.5.1 Linux

11.3.5.2 FreeBSD

11.3.5.3 x86/x64 Solaris

11.3.5.4 Windows and Macintosh

11.3.5.5 AIX

11.3.6 Approaching the memory limit

11.3.7 Overflow

11.3.8 Behavior of generation 1

11.3.9 Behavior of generation 2

11.3.10 Forcing expansion

11.3.11 Controlling Fragmentation

11.3.12 Summary of garbage collection symbols

11.3.12.1 Determining memory usage

11.3.12.2 Allocating in specific generations

11.3.12.3 Controlling a specific generation

11.3.12.4 Controlling the garbage collector

11.4 Memory Management in 64-bit LispWorks

11.4.1 General organization of memory

11.4.2 Segments and Allocation Types

11.4.3 Garbage Collection Operations

11.4.4 Generation Management

11.4.5 Tuning the garbage collector

11.4.5.1 Interface for tuning the GC

11.5 The Mobile GC

11.5.1 Mobile GC changes to common functions and macros

11.5.2 Mobile GC technical details

11.5.2.1 Objects alive at delivery time

11.5.2.2 Objects allocated at run time

11.5.2.3 Special considerations for the Mobile GC

11.5.3 Tuning memory management in the Mobile GC

11.5.3.1 Response to low memory

11.5.3.2 Preventing/reducing GC of generation 2

11.6 Common Memory Management Features

11.6.1 Timing the garbage collector

11.6.2 Reducing image size

11.6.3 Allocation of interned symbols and packages

11.6.4 Allocation of stacks

11.6.5 Mapping across all objects

11.6.6 Special actions

11.6.7 Garbage collection of foreign objects

11.6.8 Freeing of objects by the GC

11.6.9 Assisting the garbage collector

11.6.9.1 Breaking pointers from older objects

12 The Profiler

12.1 What the profiler does

12.2 Setting up the profiler

12.3 Running the profiler

12.3.1 Using the macro profile

12.3.2 Programmatic control of profiling

12.4 Profiler output

12.4.1 Interpretation of profiling results

12.4.2 Displaying parts of the tree

12.5 Profiling pitfalls

12.6 Profiling and garbage collection

12.7 Profiler tree file format

12.7.1 Parsing the file

12.7.2 Viewing the file as text

13 Customization of LispWorks

13.1 Introduction

13.1.1 Pre-loading code

13.1.2 Loading code at start up

13.1.3 Specific customizations

13.2 Configuration and initialization files

13.2.1 Configuration files

13.2.2 Initialization files

13.3 Saving a LispWorks image

13.3.1 The configuration file

13.3.2 The save-image script

13.3.3 Save your new image

13.3.4 Use your new image

13.3.5 Saving a non-GUI image with multiprocessing enabled

13.3.6 Code signing in saved images

13.3.6.1 Signing your development image

13.3.6.2 Signing in the distributed LispWorks executable

13.3.6.3 Signing your runtime application

13.4 Saved sessions

13.4.1 The default session

13.4.2 What is saved and what is not saved

13.4.3 Saving a session programmatically

13.4.3.1 Save Session actions

13.4.3.2 Non-IDE interfaces

13.4.4 Saving a session using the IDE

13.5 Load and open your files on startup

13.6 Customizing the editor

13.6.1 Controlling appearance of found definitions

13.6.2 Specifying the number of editor windows

13.6.3 Binding commands to keystrokes

13.7 Finding source code

13.8 Controlling redefinition warnings

13.9 Specifying the initial working directory

13.10 Using ! for :redo

13.11 Customizing LispWorks for use with your own code

13.11.1 Preloading selected modules

13.11.2 Creating packages

13.12 Structure printing

13.13 Configuring the printer

13.13.1 PPD file details

14 LispWorks as a dynamic library

14.1 Introduction

14.2 Creating a dynamic library

14.2.1 C functions provided by the system

14.2.2 C functions provided by the application

14.2.3 Example

14.3 Initialization of the dynamic library

14.3.1 Automatic initialization

14.3.2 Initialization via InitLispWorks

14.4 Relocation

14.5 Multiprocessing in a dynamic library

14.6 Unloading a dynamic library

15 Java interface

15.1 Types and conversion between Lisp and Java

15.1.1 Mapping of Java primitive types to and from Lisp types

15.1.2 java.lang.String

15.1.3 Java non-primitive objects

15.2 Calling from Lisp to Java

15.2.1 Importing classes

15.2.2 Defining specific callers

15.2.3 Verifying callers

15.2.4 Calling methods without defining callers

15.2.5 Actual Java call

15.3 Calling from Java to Lisp

15.3.1 Direct calls

15.3.2 Using proxies

15.4 Working with Java arrays

15.4.1 Accessing a single element

15.4.2 Making Java arrays

15.4.3 Multiple access functions

15.5 Initialization of the Java interface

15.6 Utilities and administration

15.7 Loading a LispWorks dynamic library into Java

15.8 CLOS partial integration

15.9 Java interface performance issues

16 Android interface

16.1 Delivering for Android

16.2 Directories on Android

16.3 The Othello demo for Android

16.3.1 Creating an Android project

16.3.1.1 Othello project in Eclipse (with ADT)

16.3.1.2 Othello project in Android studio

16.3.2 Delivering LispWorks to the project

16.3.3 Running the application

16.3.3.1 The Lisp Panel screen

16.3.3.2 Prepared forms

16.3.4 Lisp interface usage in the Java code

16.3.4.1 Class Othello

16.3.4.2 Class LispPanel

16.3.4.3 Class MyApplication

16.3.4.4 Class LispWorksRuntimeDemo

16.3.4.5 Class History

16.3.4.6 Class SquareLayout

16.3.5 Java and Android interface in the Lisp code

17 iOS interface

17.1 Delivering for iOS

17.2 Initializing LispWorks

17.3 Using Objective-C from Lisp

17.4 Limitations of the iOS Runtime

17.5 The Othello demo for iOS

17.5.1 Notes about the Xcode project

17.5.2 The Othello game

17.5.3 The Lisp evaluation pane

17.5.4 Notes about the Lisp code

17.6 The Mobile GC

18 The Metaobject Protocol

18.1 Metaobject features incompatible with AMOP

18.1.1 Instance Structure Protocol

18.1.2 Method Metaobjects

18.1.3 Method Lambdas

18.1.4 Method Functions

18.1.5 EQL specializers

18.1.6 Generic Function Invocation Protocol

18.1.7 Method combinations

18.1.8 Compatible metaclasses

18.1.9 Inheritance Structure of Metaobject Classes

18.2 Metaobject features additional to AMOP

18.2.1 Computing the effective method function

18.3 Common problems when using the MOP

18.3.1 Inheritance across metaclasses

18.3.2 Accessors not using structure instance protocol

18.3.3 The MOP in delivered images

18.4 Implementation of virtual slots

19 Multiprocessing

19.1 Introduction to processes

19.2 Processes basics

19.2.1 Creating a process

19.2.2 Finding out about processes

19.2.3 Multiprocessing

19.2.3.1 Starting multiprocessing interactively

19.2.3.2 Multiprocessing on startup

19.2.3.3 Running your own processes on startup

19.3 Atomicity and thread-safety of the LispWorks implementation

19.3.1 Immutable objects

19.3.2 Mutable objects supporting atomic access

19.3.3 Mutable objects not supporting atomic access

19.3.4 Making an object's contents accessible to other threads

19.3.4.1 Ways to guarantee the visibility of stores

19.3.4.2 Special care for macros and accessors that may themselves allocate

19.3.5 Ensuring stores are visible to other threads

19.3.5.1 An example to consider the issues

19.3.5.2 The general solution using a lock

19.3.5.3 An alternative solution using globally-accessible

19.3.5.4 An alternative solution using ensure-stores-after-stores

19.3.5.5 Destructive macros and accessors that allocate internally

19.3.5.6 Miscellaneous notes

19.3.6 Issues with order of memory accesses

19.3.7 Single-thread context arrays and hash-tables

19.4 Locks

19.4.1 Recursive and sharing locks

19.4.2 Querying locks

19.4.3 Guarantees and limitations when locking and unlocking

19.5 Modifying a hash table with multiprocessing

19.6 Process Waiting and communication between processes

19.6.1 Specific Process Wait functions

19.6.2 Generic Process Wait functions

19.6.3 Communication between processes and synchronization

19.6.4 Synchronization

19.7 Synchronization between threads

19.7.1 Condition variables

19.7.2 Synchronization barriers

19.7.3 Counting semaphores

19.8 Killing a process, interrupts and blocking interrupts

19.8.1 Killing a process

19.8.2 Interrupting a process

19.8.3 Blocking interrupts

19.8.4 Old interrupt blocking APIs removed

19.8.4.1 Atomic increment

19.8.4.2 Atomic push/pop

19.8.4.3 Atomic push/delete

19.8.4.4 Atomic plist update

19.8.4.5 Atomic update of a data structure

19.8.4.6 Atomic access to a cache in a hash table

19.9 Timers

19.9.1 Timers and multiprocessing

19.9.2 Input and output for timer functions

19.10 Process properties

19.11 Other processes functions

19.11.1 Process Priorities

19.11.1.1 Process priorities in SMP LispWorks

19.11.1.2 Process priorities in non-SMP LispWorks

19.11.2 Accessing symbol values across processes

19.11.3 Stopping and unstopping processes

19.12 Native threads and foreign code

19.12.1 Native threads on Windows, Mac OS X, Linux, x86/x64 Solaris, FreeBSD and AIX

19.12.2 Native threads on other platforms

19.12.3 Foreign callbacks on threads not created by Lisp

19.12.3.1 Performance considerations for foreign threads

19.13 Low level operations

19.13.1 Low level atomic operations

19.13.2 Aids for implementing modification checks

19.13.2.1 Example modification check

19.13.3 Ensuring order of memory between operations in different threads

19.13.3.1 Example of ensuring order of memory

20 Common Defsystem and ASDF

20.1 Introduction

20.2 Defining a system

20.2.1 DEFSYSTEM syntax

20.2.2 DEFSYSTEM options

20.2.3 DEFSYSTEM members

20.2.4 DEFSYSTEM rules

20.2.5 Examples

20.3 Using ASDF

20.3.1 Bypassing the supplied version of ASDF

20.3.2 Using ASDF in the LispWorks IDE

21 The Parser Generator

21.1 Introduction

21.2 Grammar rules

21.2.1 Example

21.2.2 Combined rules

21.2.3 Resolving ambiguities

21.3 Functions defined by defparser

21.4 Error handling

21.5 Interface to lexical analyzer

21.6 Example

22 Dynamic Data Exchange

22.1 Introduction

22.1.1 Types of transaction

22.1.2 Conversations, servers, topics, and items

22.1.3 Advise loops

22.1.4 Execute transactions

22.2 Client interface

22.2.1 Opening and closing conversations

22.2.2 Automatically managed conversations

22.2.3 Advise loops

22.2.3.1 Example advise loop

22.2.4 Request and poke transactions

22.2.5 Execute transactions

22.3 Server interface

22.3.1 Starting a DDE server

22.3.2 Handling poke and request transactions

22.3.3 Topics

22.3.3.1 General topics

22.3.3.2 Dispatching topics

22.3.3.3 The system topic

23 Common SQL

23.1 Introduction

23.1.1 Overview

23.1.2 Supported databases

23.2 Initialization

23.2.1 Initialization steps

23.2.2 Database libraries

23.2.3 General database connection and disconnection

23.2.3.1 Connection example

23.2.4 Connecting to Oracle

23.2.5 Connecting to ODBC

23.2.5.1 Connecting to ODBC using a string

23.2.5.2 Connecting to ODBC using a plist

23.2.6 Connecting to MySQL

23.2.6.1 Connecting to MySQL using a string

23.2.6.2 Connecting to MySQL using a plist

23.2.6.3 Locating the MySQL client library

23.2.6.4 Special instructions for MySQL on Mac OS X

23.2.7 Connecting to PostgreSQL

23.2.7.1 Connecting to PostgreSQL using a string

23.2.7.2 Connecting to PostgreSQL using a plist

23.2.7.3 Escaping and standard_conforming_strings

23.2.8 Connecting to SQLite.

23.2.8.1 Locating the SQLite client library

23.2.8.2 SQLite string encoding

23.2.8.3 SQLite connection keywords

23.3 Functional interface

23.3.1 Functional Data Manipulation Language (FDML)

23.3.1.1 Querying

23.3.1.2 Modification

23.3.1.3 Caching of table queries

23.3.1.4 Transaction handling

23.3.1.5 Iteration

23.3.1.6 Specifying SQL directly

23.3.1.7 Building vendor-specific SQL

23.3.2 Functional Data Definition Language (FDDL)

23.3.2.1 Querying the schema

23.3.2.2 FDDL Querying example

23.3.2.3 Modification

23.4 Object oriented interface

23.4.1 Object oriented/relational model

23.4.1.1 Inheritance for View Classes

23.4.2 Object-Oriented Data Definition Language (OODDL)

23.4.2.1 Example View Class definition

23.4.3 Object-Oriented Data Manipulation Language (OODML)

23.4.3.1 Examples

23.4.3.2 Iteration

23.4.3.3 Garbage collection of view instances

23.5 Symbolic SQL syntax

23.5.1 The "[...]" Syntax

23.5.1.1 Enclosing database identifiers

23.5.1.2 Specifying the type of retrieved values.

23.5.1.3 Symbolic expression of SQL operators

23.5.1.4 Calling database functions

23.5.1.5 Enclosing a SQL expression directly

23.5.1.6 SQL string literals

23.5.2 Programmatic interface

23.5.2.1 Examples

23.5.3 Utilities

23.6 Working with date fields

23.6.1 Testing date values

23.6.2 DATE returned as universal time

23.6.2.1 Timezone of returned DATEs

23.6.3 DATE returned as string

23.6.4 Using universal time format

23.7 SQL I/O recording

23.8 Error handling in Common SQL

23.8.1 SQL condition classes

23.8.2 Database error accessors

23.9 Using MySQL

23.9.1 Connection specification

23.9.2 Case of table names and database names

23.9.3 Encoding (character sets in MySQL).

23.9.4 SQL mode

23.9.5 Meaning of the :owner argument to select

23.9.6 Special considerations for iteration functions and macros

23.9.6.1 Fetching multiple records

23.9.6.2 Aborting queries which fetch many records

23.9.7 Table types

23.9.8 Rollback errors

23.9.9 Types of values returned from queries

23.9.10 Autocommit

23.10 Using Oracle

23.10.1 Connection specification

23.10.2 Setting connection parameters

23.11 Oracle LOB interface

23.11.1 Introduction

23.11.1.1 Retrieving LOB locators

23.11.1.2 Operating on LOB locators

23.11.1.3 Inserting empty LOBs

23.11.2 Retrieving Lob Locators

23.11.3 Locking

23.11.4 Retrieving LOB Locators as streams

23.11.5 Attaching a stream to a LOB locator

23.11.6 Interactions with foreign calls

23.11.7 Determining the type of a LOB

23.11.8 Reading and writing from and to LOBs

23.11.9 The LOB functions

23.11.9.1 Querying functions

23.11.9.2 LOB management functions

23.11.9.3 Modifying LOBs

23.11.9.4 File operations

23.11.9.5 Direct I/O

23.11.9.6 Temporary LOBs

23.11.9.7 Control of buffering

23.11.10 Fetching the contents of the LOBs directly

23.12 Using ODBC

23.12.1 Configuring unixODBC

23.12.2 Loading unixODBC

23.12.3 External format for ODBC strings

23.12.4 Using non-ASCII strings on Microsoft SQL Server

23.13 Using SQLite

23.13.1 Connecting to SQLite

23.13.2 Types of retrieved fields in queries

23.13.3 Tables containing a uniform type per column

23.13.4 Reading from blobs using a handle (sqlite-raw-blob) and modifying blobs (sqlite-blob)

23.13.5 Values in Insert and Update.

23.13.6 Accessing ATTACHed databases

24 User Defined Streams

24.1 Introduction

24.2 An illustrative example of user defined streams

24.2.1 Defining a new stream class

24.2.2 Recognizing the stream element type

24.2.3 Stream directionality

24.2.4 Stream input

24.2.5 Stream output

24.2.6 Instantiating the stream

25 TCP and UDP socket communication and SSL

25.1 Running a server that accepts connections

25.2 Connecting to a server

25.2.1 Examples

25.3 Specifying the target for connecting and binding a socket

25.4 Information about IP addresses

25.5 Waiting on a socket stream

25.6 Special considerations

25.6.1 IPv6 on Mac OS X

25.6.2 IPv6 on Windows XP

25.7 Asynchronous I/O

25.7.1 The wait-state-collection API

25.7.2 The Async-I/O-State API

25.7.3 Writing callbacks in Asynchronous I/O operations

25.7.4 Asynchronous I/O and multiprocessing

25.8 Using SSL

25.8.1 Obtaining and installing the OpenSSL library

25.8.1.1 Installing the OpenSSL library on Solaris

25.8.1.2 How LispWorks locates the OpenSSL libraries

25.8.2 Creating a stream with SSL

25.8.3 Using Asynchronous I/O with SSL

25.8.4 Keyword arguments for use with SSL

25.8.5 Attaching SSL to an existing socket

25.8.6 OpenSSL interface

25.8.6.1 OpenSSL constants

25.8.6.2 Naming conventions for direct OpenSSL calls

25.8.6.3 Mapping C names to Lisp names

25.8.6.4 Mapping Lisp names to C names

25.8.7 Direct calls to OpenSSL

25.8.8 Using SSL objects directly

25.8.9 Initialization

25.8.10 Errors in SSL

25.8.11 Examples of using the socket stream SSL interface

25.9 Socket streams with Java sockets and SSL on Android

25.9.1 Android-specific points

26 Internationalization: characters, strings and encodings

26.1 Introduction

26.2 Unicode support

26.3 Character and String types

26.3.1 Character types

26.3.2 Compatibility notes

26.3.3 Character Syntax

26.3.4 Compatibility notes

26.3.5 String types

26.3.5.1 String types at run time

26.3.5.2 String types at compile time

26.4 String accessors

26.5 String Construction

26.5.1 Default string construction

26.5.2 String construction with known type

26.5.3 Controlling string construction

26.5.4 String construction on Windows systems

26.6 External Formats

26.7 16-bit External formats guide

26.7.1 Unicode

26.7.2 UTF-16

26.7.3 BMP

26.8 External Formats and File Streams

26.8.1 Complete external format ef-specs

26.8.2 Using complete external formats

26.8.3 Guessing the external format

26.8.3.1 Example of using UTF-8 by default

26.8.3.2 Example of using UTF-8 if possible

26.8.4 External formats and stream-element-type

26.8.5 External formats and the LispWorks Editor

26.8.6 Byte Order Mark

26.9 External Formats and the Foreign Language Interface

26.10 Unicode character and string functions

26.10.1 Unicode case insensitive character comparison

26.10.2 Unicode case insensitive string comparison

26.10.3 Unicode character predicates

27 LispWorks' Operating Environment

27.1 The Operating System

27.2 Site Name

27.3 The Lisp Image

27.4 The Command Line

27.4.1 Command Line Arguments

27.4.2 Accessing environment variables

27.5 Address Space and Image Size

27.5.1 Size of real memory

27.5.2 Layout of memory

27.5.3 Reporting current allocation

27.6 Startup relocation

27.6.1 How to relocate LispWorks

27.6.2 Startup relocation of 32-bit LispWorks

27.6.3 Startup relocation of 64-bit LispWorks

27.6.3.1 Linux

27.6.3.2 SPARC Solaris

27.6.3.3 Windows, Macintosh and AIX

27.7 Calling external programs

27.7.1 Interpreting the exit status

27.8 Snapshot debugging of startup errors

27.9 System message log

27.10 Exit status

27.11 Creating a new executable with code preloaded

27.12 User Preferences

27.12.1 Location of persistent settings

27.12.2 Accessing persistent settings

27.12.3 Example using user preferences

27.13 File system interface

27.13.1 Fast access to files in a directory

27.14 Special locations in the file system

27.14.1 The home directory

27.14.2 Special Folders

27.14.3 Temp files

27.15 Accessing the Windows registry

27.16 Pathname comparison on Mac OS X

28 Miscellaneous Utilities

28.1 Object addresses and memory

28.2 Optimized integer arithmetic and integer vector access

28.2.1 Typed aref vectors

28.2.2 Fast 32-bit arithmetic

28.2.2.1 Optimized and unoptimized INT32 code

28.2.2.2 The INT32 API

28.2.2.3 INT32 Optimization

28.2.3 Fast 64-bit arithmetic

28.2.3.1 Optimized and unoptimized INT64 code

28.2.3.2 The INT64 API

28.2.3.3 INT64 Optimization

28.2.4 Integer vector access

28.3 Transferring large amounts of data

28.4 Rings

28.5 Conditional throw and checking for catch in the dynamic environment

28.6 Checking for a dynamic binding

29 64-bit LispWorks

29.1 Introduction

29.2 Heap size

29.3 Architectural constants

29.4 Speed

29.5 Memory Management and cl:room

29.6 Greater allocation expected in 64-bit LispWorks

29.7 Float types

29.8 External libraries

30 Self-contained examples

30.1 COMM examples

30.1.1 SSL examples

30.1.2 Asynchronous I/O examples

30.2 Streams examples

30.3 DDE examples

30.4 Parser generator examples

30.5 Examples for save-image in a Mac OS X application bundle

30.6 Miscellaneous examples

31 The CLOS Package

break-new-instances-on-access

break-on-access

class-extra-initargs

compute-class-potential-initargs

compute-discriminating-function

compute-effective-method-function-from-classes

copy-standard-object

funcallable-standard-object

process-a-class-option

process-a-slot-option

replace-standard-object

set-clos-initarg-checking

set-make-instance-argument-checking

slot-boundp-using-class

slot-makunbound-using-class

slot-value-using-class

trace-new-instances-on-access

trace-on-access

unbreak-new-instances-on-access

unbreak-on-access

untrace-new-instances-on-access

untrace-on-access

32 The COMM Package

accept-tcp-connections-creating-async-io-states

accepting-handle

accepting-handle-collection

accepting-handle-name

accepting-handle-local-port

accepting-handle-socket

accepting-handle-user-info

apply-in-wait-state-collection-process

async-io-state

async-io-state-abort

async-io-state-abort-and-close

async-io-state-address

async-io-state-attach-ssl

async-io-state-buffered-data-length

async-io-state-ctx

async-io-state-detach-ssl

async-io-state-collection

async-io-state-discard

async-io-state-finish

async-io-state-get-buffered-data

async-io-state-handshake

async-io-state-max-read

async-io-state-name

async-io-state-object

async-io-state-old-length

async-io-state-peer-address

async-io-state-read-buffer

async-io-state-read-status

async-io-state-write-status

async-io-state-read-timeout

async-io-state-write-timeout

async-io-state-read-with-checking

async-io-state-receive-message

async-io-state-send-message

async-io-state-send-message-to-address

async-io-state-ssl

async-io-state-ssl-side

async-io-state-write-buffer

async-io-state-user-info

attach-ssl

call-wait-state-collection

close-accepting-handle

close-async-io-state

close-wait-state-collection

create-and-run-wait-state-collection

create-async-io-state

create-async-io-state-and-connected-tcp-socket

create-async-io-state-and-connected-udp-socket

create-async-io-state-and-udp-socket

connect-to-tcp-server

destroy-ssl

destroy-ssl-ctx

detach-ssl

do-rand-seed

ensure-ssl

get-default-local-ipv6-address

get-host-entry

get-ip-default-zone-id

get-service-entry

get-socket-address

get-socket-peer-address

get-verification-mode

ip-address-string

ipv6-address

ipv6-address-p

ipv6-address-scope-id

ipv6-address-string

make-ssl-ctx

loop-processing-wait-state-collection

make-wait-state-collection

open-tcp-stream

open-tcp-stream-using-java

openssl-version

parse-ipv6-address

pem-read

read-dhparams

replace-socket-stream-socket

server-terminate

set-verification-mode

set-ssl-ctx-dh

set-ssl-ctx-options

set-ssl-ctx-password-callback

set-ssl-library-path

socket-error

socket-stream

socket-stream-address

socket-stream-ctx

socket-stream-handshake

socket-stream-peer-address

socket-stream-shutdown

socket-stream-ssl

socket-stream-ssl-side

ssl-cipher-pointer

ssl-cipher-pointer-stack

ssl-closed

ssl-condition

ssl-ctx-pointer

ssl-error

ssl-failure

ssl-new

ssl-pointer

ssl-x509-lookup

start-up-server

start-up-server-and-mp

string-ip-address

switch-open-tcp-stream-with-ssl-to-java

wait-for-wait-state-collection

wait-state-collection

wait-state-collection-stop-loop

with-noticed-socket-stream

33 The COMMON-LISP Package

apropos

apropos-list

base-string

simple-base-string

close

coerce

compile

compile-file

concatenate

declaim

declare

defclass

defpackage

describe

directory

disassemble

documentation

double-float

*features*

input-stream-p

interactive-stream-p

load-logical-pathname-translations

long-float

long-site-name

loop

make-array

make-hash-table

make-instance

make-sequence

make-string

make-string-output-stream

map

merge

open

open-stream-p

output-stream-p

proclaim

restart-case

room

short-float

short-site-name

simple-string

single-float

software-type

software-version

*standard-input*

*standard-output*

*trace-output*

*error-output*

*query-io*

*debug-io*

step

stream-element-type

string

time

trace

truename

untrace

update-instance-for-different-class

update-instance-for-redefined-class

with-output-to-string

34 The COMPILER Package

deftransform

35 The DBG Package

close-remote-debugging-connection

configure-remote-debugging-spec

create-client-remote-debugging-connection

create-ide-remote-debugging-connection

*debug-print-length*

*debug-print-level*

*default-client-remote-debugging-server-port*

*default-ide-remote-debugging-server-port*

ensure-remote-debugging-connection

executable-log-file

*hidden-packages*

ide-attach-remote-output-stream

ide-connect-remote-debugging

ide-eval-form-in-remote

ide-funcall-in-remote

ide-set-remote-symbol-value

ide-find-remote-debugging-connection

ide-set-default-remote-debugging-connection

ide-list-remote-debugging-connections

ide-open-a-listener

log-bug-form

logs-directory

output-backtrace

*print-binding-frames*

*print-catch-frames*

*print-handler-frames*

*print-invisible-frames*

*print-open-frames*

*print-restart-frames*

remote-debugging-connection

client-remote-debugging

ide-remote-debugging

remote-debugging-connection-add-close-cleanup

remote-debugging-connection-remove-close-cleanup

remote-debugging-connection-name

remote-debugging-connection-peer-address

remote-debugging-stream-peer-address

remote-inspect

remote-object-p

remote-object-connection

set-debugger-options

set-default-remote-debugging-connection

set-remote-debugging-connection

start-client-remote-debugging-server

start-ide-remote-debugging-server

start-remote-listener

*terminal-debugger-block-multiprocessing*

with-debugger-wrapper

with-remote-debugging-connection

with-remote-debugging-spec

36 The DSPEC Package

*active-finders*

at-location

canonicalize-dspec

def

define-dspec-alias

define-dspec-class

define-form-parser

discard-source-info

dspec-class

*dspec-classes*

dspec-defined-p

dspec-definition-locations

dspec-equal

dspec-name

dspec-primary-name

dspec-progenitor

dspec-subclass-p

dspec-undefiner

find-dspec-locations

find-name-locations

get-form-parser

local-dspec-p

location

name-defined-dspecs

name-definition-locations

name-only-form-parser

object-dspec

parse-form-dspec

record-definition

*record-source-files*

*redefinition-action*

replacement-source-form

save-tags-database

single-form-form-parser

single-form-with-options-form-parser

traceable-dspec-p

tracing-enabled-p

tracing-state

37 The EXTERNAL-FORMAT Package

:bmp

:bmp-native

:bmp-reversed

:unicode

:utf-16

:utf-16be

:utf-16le

:utf-16-native

:utf-16-reversed

:utf-32

:utf-32le

:utf-32be

:utf-32-native

:utf-32-reversed

char-external-code

decode-external-string

encode-lisp-string

external-format-error

external-format-foreign-type

external-format-type

find-external-char

valid-external-format-p

38 The HCL Package

add-code-coverage-data

reverse-subtract-code-coverage-data

subtract-code-coverage-data

destructive-add-code-coverage-data

destructive-subtract-code-coverage-data

destructive-reverse-subtract-code-coverage-data

add-special-free-action

add-symbol-profiler

allocation-in-gen-num

analysing-special-variables-usage

android-build-value

android-funcall-in-main-thread

android-funcall-in-main-thread-list

android-get-current-activity

*android-main-process-for-testing*

android-main-thread-p

any-capi-window-displayed-p

array-single-thread-p

array-weak-p

augment-environment

avoid-gc

*background-input*

*background-output*

*background-query-io*

binds-who

block-promotion

building-universal-intermediate-p

calls-who

cd

change-directory

check-fragmentation

clean-down

clean-generation-0

clear-code-coverage

reset-code-coverage

restore-code-coverage-data

code-coverage-data

code-coverage-data-generate-coloring-html

code-coverage-data-generate-statistics

code-coverage-file-stats

code-coverage-set-editor-colors

code-coverage-set-editor-default-data

code-coverage-set-html-background-colors

collect-generation-2

collect-highest-generation

*compiler-break-on-error*

compile-file-if-needed

copy-code-coverage-data

copy-current-code-coverage

load-code-coverage-data

save-code-coverage-data

save-current-code-coverage

copy-to-weak-simple-vector

create-macos-application-bundle

create-temp-file

open-temp-file

create-universal-binary

current-function-name

current-stack-length

date-string

declaration-information

*default-package-use-list*

*default-profiler-collapse*

*default-profiler-cutoff*

*default-profiler-limit*

*default-profiler-sort*

defglobal-parameter

defglobal-variable

define-declaration

delete-advice

delivered-image-p

deliver-to-android-project

*disable-trace*

do-profiling

editor-color-code-coverage

enlarge-generation

enlarge-static

ensure-hash-entry

error-situation-forms

expand-generation-1

extend-current-stack

extended-time

fasl-error

fast-directory-files

fdf-handle-directory-p

fdf-handle-directory-string

fdf-handle-last-access

fdf-handle-last-modify

fdf-handle-link-p

fdf-handle-size

fdf-handle-writable-p

file-string

file-writable-p

filter-code-coverage-data

find-object-size

find-throw-tag

finish-heavy-allocation

flag-not-special-free-action

flag-special-free-action

function-information

get-code-coverage-delta

reset-code-coverage-snapshot

set-code-coverage-snapshot

gc-generation

gc-if-needed

generate-code-coverage

get-default-generation

get-gc-parameters

get-temp-directory

get-working-directory

gethash-ensuring

*handle-existing-defpackage*

*handle-old-in-package*

*handle-old-in-package-used-as-make-package*

hash-table-weak-kind

load-data-file

*load-fasl-or-lisp-file*

make-ring

make-unlocked-queue

unlocked-queue-read

unlocked-queue-peek

unlocked-queue-ready

unlocked-queue-send

unlocked-queue-count

unlocked-queue-size

map-code-coverage-data

map-ring

mark-and-sweep

*max-trace-indent*

merge-code-coverage-data

destructive-merge-code-coverage-data

modify-hash

normal-gc

*packages-for-warn-on-redefinition*

parse-float

position-in-ring

position-in-ring-forward

print-profile-list

*print-string*

profile

*profiler-threshold*

*profile-symbol-list*

profiler-tree-from-function

profiler-tree-to-function

reduce-memory

references-who

remove-special-free-action

remove-symbol-profiler

reset-profiler

reset-ring

ringp

ring-length

ring-name

ring-pop

ring-push

ring-ref

rotate-ring

safe-format-to-string

safe-format-to-limited-string

safe-prin1-to-string

safe-princ-to-string

save-argument-real-p

save-current-profiler-tree

save-current-session

save-image

save-image-with-bundle

save-universal-from-script

set-array-single-thread-p

set-array-weak

set-default-generation

set-gc-parameters

set-hash-table-weak

set-minimum-free-space

set-process-profiling

set-profiler-threshold

set-promotion-count

set-system-message-log

set-up-profiler

sets-who

source-debugging-on-p

start-gc-timing

stop-gc-timing

get-gc-timing

start-profiling

string-trim-whitespace

stop-profiling

sweep-all-objects

switch-static-allocation

*symbol-alloc-gen-num*

symbol-dynamically-bound-p

throw-if-tag-found

toggle-source-debugging

total-allocation

*traced-arglist*

*traced-results*

*trace-indent-width*

*trace-level*

*trace-print-circle*

*trace-print-length*

*trace-print-level*

*trace-print-pretty*

*trace-verbose*

try-compact-in-generation

try-move-in-generation

undefine-declaration

unlocked-queue

unwind-protect-blocking-interrupts

unwind-protect-blocking-interrupts-in-cleanups

variable-information

who-binds

who-calls

who-references

who-sets

with-code-coverage-generation

with-ensuring-gethash

with-hash-table-locked

with-heavy-allocation

with-output-to-fasl-file

dump-form

dump-forms-to-file

with-ring-locked

without-code-coverage

write-string-with-properties

39 The LINK-LOAD Package

break-on-unresolved-functions

foreign-symbol-address

get-foreign-symbol

lisp-name-to-foreign-name

read-foreign-modules

40 The LISPWORKS Package

8-bit-string

16-bit-string

append-file

appendf

*autoload-asdf-integration*

base-character

base-character-p

base-char-p

base-char-code-limit

base-string-p

simple-base-string-p

bmp-char

bmp-char-p

bmp-string

simple-bmp-string

bmp-string-p

simple-bmp-string-p

*browser-location*

call-next-advice

choose-unicode-string-hash-function

compile-system

concatenate-system

copy-file

count-regexp-occurrences

current-pathname

defadvice

*default-action-list-sort-time*

*default-character-element-type*

define-action

define-action-list

defsystem

*defsystem-verbose*

delete-directory

deliver

*describe-length*

*describe-level*

*describe-print-length*

*describe-print-level*

dll-quit

dotted-list-length

dotted-list-p

do-nothing

*enter-debugger-directly*

environment-variable

errno-value

example-file

example-compile-file

example-edit-file

example-load-binary-file

execute-actions

extended-char

extended-character

extended-character-p

extended-char-p

*external-formats*

false

file-directory-p

find-regexp-in-string

function-lambda-list

get-inspector-values

sort-inspector-p

get-unix-error

*grep-command*

*grep-command-format*

*grep-fixed-args*

*handle-existing-action-in-action-list*

*handle-existing-action-list*

*handle-missing-action-list*

*handle-missing-action-in-action-list*

*handle-warn-on-redefinition*

hardcopy-system

*init-file-name*

*inspect-through-gui*

lisp-image-name

*lispworks-directory*

load-all-patches

load-system

make-unregistered-action-list

make-mt-random-state

mt-random

*mt-random-state*

mt-random-state

mt-random-state-p

pathname-location

precompile-regexp

print-actions

print-action-lists

*print-command*

*print-nickname*

*prompt*

push-end

push-end-new

quit

rebinding

regexp-find-symbols

remove-advice

removef

*require-verbose*

rotate-byte

round-to-single-precision

sbchar

sequencep

set-default-character-element-type

set-quit-when-no-windows

simple-char

simple-char-p

split-sequence

split-sequence-if

split-sequence-if-not

start-tty-listener

stchar

string-append

string-append*

structurep

text-string

simple-text-string

text-string-p

simple-text-string-p

true

undefine-action

undefine-action-list

unicode-alpha-char-p

unicode-alphanumeric-p

unicode-both-case-p

unicode-char-equal

unicode-char-not-equal

unicode-char-greaterp

unicode-char-lessp

unicode-char-not-greaterp

unicode-char-not-lessp

unicode-lower-case-p

unicode-string-equal

unicode-string-not-equal

unicode-string-greaterp

unicode-string-lessp

unicode-string-not-greaterp

unicode-string-not-lessp

unicode-upper-case-p

user-preference

when-let

when-let*

whitespace-char-p

with-action-item-error-handling

with-action-list-mapping

with-unique-names

41 The LW-JI Package

call-java-method

call-java-method-error

catching-java-exceptions

catching-exceptions-bind

check-lisp-calls-initialized

create-instance-from-jobject

create-instance-jobject-list

create-instance-jobject

create-java-object

create-java-object-error

default-constructor-arguments

default-name-constructor

define-field-accessor

define-java-caller

define-java-constructor

define-java-callers

define-lisp-proxy

ensure-lisp-classes-from-tree

ensure-supers-contain-java.lang.object

field-access-exception

field-exception

find-java-class

format-to-java-host

generate-java-class-definitions

get-host-java-virtual-machine

get-java-virtual-machine

get-jobject

ensure-is-jobject

get-primitive-array-region

set-primitive-array-region

get-superclass-and-interfaces-tree

import-java-class-definitions

init-java-interface

setup-java-interface-callbacks

intern-and-export-list

jaref

java-array-element-type

java-array-error

java-array-indices-error

java-array-length

java-array-simple-error

java-bad-jobject

java-definition-error

java-class-error

java-method-error

java-field-error

java-exception

java-field-setting-error

java-id-exception

java-instance-without-jobject-error

java-interface-error

java-low-level-exception

java-method-exception

java-normal-exception

java-not-a-java-object-error

java-not-an-array-error

*java-null*

java-object-array-element-type

java-objects-eq

java-out-of-bounds-error

java-storing-wrong-type-error

java-primitive-array-element-type

java-serious-exception

java-type-to-lisp-array-type

lisp-array-type-to-java-type

java-vm-poi

jboolean

jbyte

jchar

jdouble

jfloat

jint

jlong

jshort

jni-env-poi

jobject

jobject-class-name

jobject-ensure-global

jobject-of-class-p

jobject-p

jobject-pretty-class-name

jobject-string

jobject-to-lisp

jvref

lisp-java-instance-p

lisp-to-jobject

make-java-array

make-java-instance

make-lisp-proxy

make-lisp-proxy-with-overrides

map-java-object-array

primitive-array-to-lisp-array

lisp-array-to-primitive-array

read-java-field

checked-read-java-field

set-java-field

check-java-field

java-field-class-name-for-setting

record-java-class-lisp-symbol

report-error-to-java-host

reset-java-interface-for-new-jvm

send-message-to-java-host

setup-deliver-dynamic-library-for-java

setup-field-accessor

setup-java-caller

setup-java-constructor

setup-lisp-proxy

standard-java-object

throw-an-exception

*to-java-host-stream*

*to-java-host-stream-no-scroll*

verify-java-caller

verify-java-callers

verify-lisp-proxy

verify-lisp-proxies

write-java-class-definitions-to-file

write-java-class-definitions-to-stream

42 Java classes and methods

com.lispworks.LispCalls

com.lispworks.LispCalls.callIntV

com.lispworks.LispCalls.callIntA

com.lispworks.LispCalls.callDoubleV

com.lispworks.LispCalls.callDoubleA

com.lispworks.LispCalls.callObjectV

com.lispworks.LispCalls.callObjectA

com.lispworks.LispCalls.callVoidV

com.lispworks.LispCalls.callVoidA

com.lispworks.LispCalls.checkLispSymbol

com.lispworks.LispCalls.createLispProxy

com.lispworks.LispCalls.waitForInitialization

43 Android Java classes and methods

com.lispworks.Manager

com.lispworks.Manager.init

com.lispworks.Manager.status

com.lispworks.Manager.init_result_code

com.lispworks.Manager.mInitErrorString

com.lispworks.Manager.loadLibrary

com.lispworks.Manager.LispErrorReporter

com.lispworks.Manager.setErrorReporter

com.lispworks.Manager.LispGuiErrorReporter

com.lispworks.Manager.setGuiErrorReporter

com.lispworks.Manager.clearBugFormLogs

com.lispworks.Manager.mMaxErrorLogsNumber

com.lispworks.Manager.showBugFormLogs

com.lispworks.Manager.addMessage

com.lispworks.Manager.mMessagesMaxLength

com.lispworks.Manager.setMessageHandler

com.lispworks.Manager.MessageHandler

com.lispworks.Manager.setTextView

com.lispworks.Manager.getClassLoader

com.lispworks.Manager.getApplicationContext

com.lispworks.Manager.setCurrentActivity

com.lispworks.BugFormLogsList

com.lispworks.BugFormViewer

44 The MP Package

allowing-block-interrupts

any-other-process-non-internal-server-p

barrier

barrier-arriver-count

barrier-block-and-wait

barrier-change-count

barrier-count

barrier-disable

barrier-enable

barrier-name

barrier-pass-through

barrier-unblock

barrier-wait

change-process-priority

condition-variable

condition-variable-broadcast

condition-variable-signal

condition-variable-wait

condition-variable-wait-count

*current-process*

current-process-block-interrupts

current-process-in-cleanup-p

current-process-kill

current-process-pause

current-process-send

current-process-set-terminate-method

current-process-unblock-interrupts

debug-other-process

*default-process-priority*

ensure-process-cleanup

find-process-from-name

funcall-async

funcall-async-list

general-handle-event

get-current-process

get-process

get-process-private-property

initialize-multiprocessing

*initial-processes*

last-callback-on-thread

list-all-processes

lock

lock-and-condition-variable-broadcast

lock-and-condition-variable-signal

lock-and-condition-variable-wait

lock-locked-p

lock-owned-by-current-process-p

lock-recursive-p

lock-recursively-locked-p

lock-name

lock-owner

mailbox

mailbox-count

mailbox-empty-p

mailbox-full-p

mailbox-not-empty-p

mailbox-peek

mailbox-read

mailbox-reader-process

mailbox-send

mailbox-send-limited

mailbox-size

mailbox-wait

mailbox-wait-for-event

*main-process*

make-barrier

make-condition-variable

make-lock

make-mailbox

make-named-timer

make-semaphore

make-timer

map-all-processes

map-all-processes-backtrace

map-process-backtrace

map-processes

notice-fd

process-alive-p

process-all-events

process-allow-scheduling

process-arrest-reasons

process-break

process-continue

process-exclusive-lock

process-exclusive-unlock

process-idle-time

*process-initial-bindings*

process-internal-server-p

process-interrupt

process-interrupt-list

process-join

process-kill

process-lock

process-mailbox

process-name

process-p

process-plist

process-poke

process-priority

process-private-property

process-property

process-reset

process-run-function

process-run-reasons

process-run-time

process-send

process-sharing-lock

process-sharing-unlock

process-stop

process-stopped-p

process-terminate

process-unlock

process-unstop

process-wait

process-wait-for-event

process-wait-function

process-wait-local

process-wait-local-with-periodic-checks

process-wait-local-with-timeout

process-wait-local-with-timeout-and-periodic-checks

process-wait-with-timeout

process-whostate

processes-count

pushnew-to-process-private-property

pushnew-to-process-property

ps

remove-from-process-private-property

remove-from-process-property

remove-process-private-property

remove-process-property

schedule-timer

schedule-timer-milliseconds

schedule-timer-relative

schedule-timer-relative-milliseconds

semaphore

semaphore-acquire

semaphore-count

semaphore-name

semaphore-release

semaphore-wait-count

set-funcall-async-limit

simple-lock-and-condition-variable-wait

symeval-in-process

timer-expired-p

timer-name

unnotice-fd

unschedule-timer

wait-processing-events

with-exclusive-lock

with-interrupts-blocked

with-lock

with-sharing-lock

without-interrupts

without-preemption

yield

45 The PARSERGEN Package

defparser

46 The SERIAL-PORT Package

open-serial-port

close-serial-port

get-serial-port-state

serial-port

read-serial-port-char

read-serial-port-string

serial-port-input-available-p

set-serial-port-state

wait-serial-port-state

write-serial-port-char

write-serial-port-string

47 The SQL Package

accepts-n-syntax

add-sql-stream

attribute-type

cache-table-queries

*cache-table-queries-default*

commit

connect

*connect-if-exists*

connected-databases

create-index

create-table

create-view

create-view-from-class

database-name

decode-to-db-standard-date

decode-to-db-standard-timestamp

encode-db-standard-date

encode-db-standard-timestamp

*default-database*

*default-database-type*

*default-update-objects-max-len*

def-view-class

delete-instance-records

delete-records

delete-sql-stream

destroy-prepared-statement

disable-sql-reader-syntax

disconnect

do-query

drop-index

drop-table

drop-view

drop-view-from-class

enable-sql-reader-syntax

execute-command

find-database

initialize-database-type

*initialized-database-types*

insert-records

instance-refreshed

list-attribute-types

list-attributes

list-classes

list-sql-streams

list-tables

lob-stream

locally-disable-sql-reader-syntax

locally-enable-sql-reader-syntax

loop

map-query

*mysql-library-directories*

*mysql-library-path*

*mysql-library-sub-directories*

ora-lob-append

ora-lob-assign

ora-lob-char-set-form

ora-lob-char-set-id

ora-lob-close

ora-lob-copy

ora-lob-create-empty

ora-lob-create-temporary

ora-lob-disable-buffering

ora-lob-element-type

ora-lob-enable-buffering

ora-lob-env-handle

ora-lob-erase

ora-lob-file-close

ora-lob-file-close-all

ora-lob-file-exists

ora-lob-file-get-name

ora-lob-file-is-open

ora-lob-file-open

ora-lob-file-set-name

ora-lob-flush-buffer

ora-lob-free

ora-lob-free-temporary

ora-lob-get-buffer

ora-lob-get-chunk-size

ora-lob-get-length

ora-lob-internal-lob-p

ora-lob-is-equal

ora-lob-is-open

ora-lob-is-temporary

ora-lob-load-from-file

ora-lob-lob-locator

ora-lob-locator-is-init

ora-lob-open

ora-lob-read-buffer

ora-lob-read-into-plain-file

ora-lob-read-foreign-buffer

ora-lob-svc-ctx-handle

ora-lob-trim

ora-lob-write-buffer

ora-lob-write-from-plain-file

ora-lob-write-foreign-buffer

p-oci-env

p-oci-file

p-oci-lob-locator

p-oci-lob-or-file

p-oci-svc-ctx

prepare-statement

prepared-statement

print-query

query

reconnect

restore-sql-reader-syntax-state

rollback

select

set-prepared-statement-variables

simple-do-query

sql

sql-connection-error

sql-database-data-error

sql-database-error

*sql-enlarge-static*

sql-expression

sql-expression-object

sql-fatal-error

sqlite-blob

sqlite-last-insert-rowid

sqlite-open-blob

sqlite-close-blob

sqlite-blob-p

sqlite-blob-length

replace-from-sqlite-blob

replace-into-sqlite-blob

sqlite-reopen-blob

sqlite-raw-blob

sqlite-raw-blob-p

sqlite-raw-blob-valid-p

sqlite-raw-blob-length

sqlite-raw-blob-ref

copy-from-sqlite-raw-blob

replace-from-sqlite-raw-blob

*sql-libraries*

*sql-loading-verbose*

sql-operation

sql-operator

sql-recording-p

sql-stream

sql-temporary-error

sql-timeout-error

sql-user-error

standard-db-object

start-sql-recording

status

stop-sql-recording

string-needs-n-prefix

string-prefix-with-n-if-needed

table-exists-p

update-instance-from-records

update-objects-joins

update-records

update-records-from-instance

update-record-from-slot

update-slot-from-record

*use-n-syntax-for-non-ascii-strings*

with-sqlite-blob

with-transaction

48 The STREAM Package

buffered-stream

fundamental-binary-input-stream

fundamental-binary-output-stream

fundamental-binary-stream

fundamental-character-input-stream

fundamental-character-output-stream

fundamental-character-stream

fundamental-input-stream

fundamental-output-stream

fundamental-stream

stream-advance-to-column

stream-check-eof-no-hang

stream-clear-input

stream-clear-output

stream-file-position

stream-fill-buffer

stream-finish-output

stream-flush-buffer

stream-force-output

stream-fresh-line

stream-line-column

stream-listen

stream-output-width

stream-peek-char

stream-read-buffer

stream-read-byte

stream-read-char

stream-read-char-no-hang

stream-read-line

stream-read-sequence

stream-read-timeout

stream-start-line-p

stream-terpri

stream-unread-char

stream-write-buffer

stream-write-byte

stream-write-char

stream-write-sequence

stream-write-string

with-stream-input-buffer

with-stream-output-buffer

49 The SYSTEM Package

allocated-in-its-own-segment-p

apply-with-allocation-in-gen-num

approaching-memory-limit

atomic-decf

atomic-incf

atomic-exchange

atomic-fixnum-decf

atomic-fixnum-incf

atomic-pop

atomic-push

augmented-string

simple-augmented-string

augmented-string-p

simple-augmented-string-p

*binary-file-type*

*binary-file-types*

call-system

call-system-showing-output

cdr-assoc

*check-network-server*

coerce-to-gesture-spec

compare-and-swap

copy-preferences-from-older-version

count-gen-num-allocation

*debug-initialization-errors-in-snap-shot*

default-eol-style

*default-stack-group-list-length*

define-atomic-modify-macro

define-top-loop-command

detect-eol-style

detect-japanese-encoding-in-file

detect-unicode-bom

detect-utf32-bom

detect-utf8-bom

*directory-link-transparency*

ensure-loads-after-loads

ensure-memory-after-store

ensure-stores-after-memory

ensure-stores-after-stores

*extended-spaces*

*file-encoding-detection-algorithm*

file-encoding-resolution-error

*file-eol-style-detection-algorithm*

*filename-pattern-encoding-matches*

find-encoding-option

find-filename-pattern-encoding-match

gen-num-segments-fragmentation-state

generation-number

gesture-spec-accelerator-bit

gesture-spec-caps-lock-bit

gesture-spec-control-bit

gesture-spec-hyper-bit

gesture-spec-meta-bit

gesture-spec-shift-bit

gesture-spec-super-bit

gesture-spec-data

gesture-spec-modifiers

gesture-spec-p

gesture-spec-to-character

get-file-stat

get-folder-path

get-maximum-allocated-in-generation-2-after-gc

get-user-profile-directory

globally-accessible

guess-external-format

immediatep

in-static-area

int32

int32*

int32+

int32-

int32/

+int32-0+

+int32-1+

int32-1+

int32-1-

int32/=

int32<

int32<=

int32=

int32>

int32>=

int32<<

int32>>

int32-aref

int32-logand

int32-logandc1

int32-logandc2

int32-logbitp

int32-logeqv

int32-logior

int32-lognand

int32-lognor

int32-lognot

int32-logorc1

int32-logorc2

int32-logtest

int32-logxor

int32-minusp

int32-plusp

int32-zerop

int32-to-int64

int32-to-integer

int64

int64*

int64+

int64-

int64/

+int64-0+

+int64-1+

int64-1+

int64-1-

int64/=

int64<

int64<=

int64=

int64>

int64>=

int64<<

int64>>

int64-aref

int64-logand

int64-logandc1

int64-logandc2

int64-logbitp

int64-logeqv

int64-logior

int64-lognand

int64-lognor

int64-lognot

int64-logorc1

int64-logorc2

int64-logtest

int64-logxor

int64-minusp

int64-plusp

int64-zerop

int64-to-int32

int64-to-integer

integer-to-int32

integer-to-int64

*line-arguments-list*

load-data-file

locale-file-encoding

low-level-atomic-place-p

make-current-allocation-permanent

make-gesture-spec

make-object-permanent

make-permanent-simple-vector

make-simple-int32-vector

make-simple-int64-vector

make-stderr-stream

make-typed-aref-vector

map-environment

marking-gc

memory-growth-margin

merge-ef-specs

mobile-gc-p

mobile-gc-sweep-objects

object-address

object-pointer

octet-ref

base-char-ref

open-pipe

open-url

package-flagged-p

pipe-close-connection

pipe-exit-status

pipe-kill-process

pointer-from-address

print-pretty-gesture-spec

*print-symbols-using-bars*

product-registry-path

release-object-and-nullify

room-values

run-shell-command

safe-locale-file-encoding

set-approaching-memory-limit-callback

set-automatic-gc-callback

set-blocking-gen-num

set-default-segment-size

set-delay-promotion

set-expected-allocation-in-generation-2-after-gc

set-file-dates

set-generation-2-gc-options

set-gen-num-gc-threshold

set-maximum-memory

set-maximum-segment-size

set-memory-check

set-memory-exhausted-callback

set-promote-generation-1

set-reserved-memory-policy

set-signal-handler

set-spare-keeping-policy

set-split-promotion

set-static-segment-size

set-temp-directory

setup-atomic-funcall

*sg-default-size*

simple-int32-vector

simple-int32-vector-length

simple-int32-vector-p

simple-int64-vector

simple-int64-vector-length

simple-int64-vector-p

*specific-valid-file-encodings*

specific-valid-file-encoding

*stack-overflow-behaviour*

staticp

storage-exhausted

sweep-gen-num-objects

typed-aref

wait-for-input-streams

wait-for-input-streams-returning-first

with-modification-change

with-modification-check-macro

with-other-threads-disabled

50 Miscellaneous WIN32 symbols

canonicalize-sid-string

connect-to-named-pipe

dismiss-splash-screen

impersonating-named-pipe-client

impersonating-user

known-sid-integer-to-sid-string

*latin-1-code-pages*

long-namestring

*multibyte-code-page-ef*

named-pipe-stream-name

open-named-pipe-stream

record-message-in-windows-event-log

security-description-string-for-open-named-pipe

set-application-themed

short-namestring

sid-string-to-user-name

str

lpcstr

lpstr

tstr

lpctstr

lptstr

wstr

lpcwstr

lpwstr

user-name-to-sid-string

wait-for-connection

with-windows-event-log-event-source

51 The Windows registry API

close-registry-key

collect-registry-subkeys

collect-registry-values

create-registry-key

delete-registry-key

enum-registry-value

open-registry-key

query-registry-key-info

query-registry-value

registry-key-exists-p

registry-value

set-registry-value

with-registry-key

52 The DDE client interface

dde-advise-start

dde-advise-start*

dde-advise-stop

dde-advise-stop*

dde-client-advise-data

dde-connect

dde-disconnect

dde-execute

dde-execute*

dde-execute-command

dde-execute-command*

dde-execute-string

dde-execute-string*

dde-item

dde-item*

dde-poke

dde-poke*

dde-request

dde-request*

define-dde-client

with-dde-conversation

53 The DDE server interface

dde-server-poke

dde-server-request

dde-server-topic

dde-server-topics

dde-system-topic

dde-topic

dde-topic-items

define-dde-dispatch-topic

define-dde-server

define-dde-server-function

start-dde-server

54 Dynamic library C functions

InitLispWorks

LispWorksDlsym

LispWorksState

SimpleInitLispWorks

QuitLispWorks

Index


LispWorks User Guide and Reference Manual - 20 Sep 2017

NextPrevTopIndex