[
Top
]
[
Contents
]
[
Index
]
[
?
]
Table of Contents
1. "Introduction"
1.1 "General Information"
1.2 "Structure of the Manual"
1.3 "Notational Conventions and Helpful Notes"
2. Primitive Object Types
2.1 "Data Types"
2.2 Predicates
3. "Evaluation"
3.1 Variables
3.2 Functions
3.3 "Some Functions and Special Forms"
3.4 Multiple Values
4. Flow of Control
4.1 "Conditionals"
4.2 "Iteration"
4.3 "Non-Local Exits"
4.4 "Mapping"
5. "Manipulating List Structure"
5.1 "Conses"
5.2 "Lists"
5.3 "Alteration of List Structure"
5.4 "Cdr-Coding"
5.5 "Tables"
5.6 Lists as Tables
5.7 Association Lists
5.8 Property Lists
5.9 Hash Tables
5.9.1 Hashing on Eq
5.9.2 Hashing on Equal
5.9.3 Hash Tables and the Garbage Collector
5.9.4 Hash Primitive
5.10 "Sorting"
5.11 Resources
6. "Symbols"
6.1 "The Value Cell"
6.2 "The Function Cell"
6.3 "The Property List"
6.4 "The Print Name"
6.5 The Package Cell
6.6 Creating Symbols
7. "Numbers"
7.1 "Numeric Predicates"
7.2 Numeric Comparisons
7.3 "Arithmetic"
7.4 Transcendental Functions
7.5 Numeric Type Conversions
7.6 "Logical Operations on Numbers"
7.7 "Byte Manipulation Functions"
7.8 "Random Numbers"
7.9 "24-Bit Numbers"
7.10 "Double-Precision Arithmetic"
8. "Arrays"
8.1 "Extra Features of Arrays"
8.2 "Basic Array Functions"
8.3 Getting Information About an Array
8.4 Changing the Size of an Array
8.5 Arrays Overlaid With Lists
8.6 Adding to the End of an Array
8.7 Copying an Array
8.8 Matrices and Systems of Linear Equations
8.9 Planes
8.10 "Maclisp Array Compatibility"
9. "Arrays"
9.1 "Extra Features of Arrays"
9.2 "Basic Array Functions"
9.3 Getting Information About an Array
9.4 Changing the Size of an Array
9.5 Arrays Overlaid With Lists
9.6 Adding to the End of an Array
9.7 Copying an Array
9.8 Matrices and Systems of Linear Equations
9.9 Planes
9.10 "Maclisp Array Compatibility"
10. "Strings"
10.1 "Characters"
10.2 Upper and Lower Case Letters
10.3 Basic String Operations
10.4 "String Searching"
10.5 I/O to Strings
10.6 "Maclisp-Compatible Functions"
11. "Strings"
11.1 "Characters"
11.2 Upper and Lower Case Letters
11.3 Basic String Operations
11.4 "String Searching"
11.5 I/O to Strings
11.6 "Maclisp-Compatible Functions"
12. Functions
12.1 What Is a Function?
12.2 Function Specs
12.3 Simple Function Definitions
12.4 Operations the User Can Perform on Functions
12.5 Kinds of Functions
12.5.1 "Interpreted Functions"
12.5.2 "Compiled Functions"
12.5.3 "Other Kinds of Functions"
12.6 Function-Defining Special Forms
12.7 Lambda-List Keywords
12.8 How Programs Manipulate Definitions
12.9 How Programs Examine Functions
12.10 "Encapsulations"
12.10.1 "Rename-Within Encapsulations"
13. Functions
13.1 What Is a Function?
13.2 Function Specs
13.3 Simple Function Definitions
13.4 Operations the User Can Perform on Functions
13.5 Kinds of Functions
13.5.1 "Interpreted Functions"
13.5.2 "Compiled Functions"
13.5.3 "Other Kinds of Functions"
13.6 Function-Defining Special Forms
13.7 Lambda-List Keywords
13.8 How Programs Manipulate Definitions
13.9 How Programs Examine Functions
13.10 "Encapsulations"
13.10.1 "Rename-Within Encapsulations"
14. "Closures"
14.1 "What a Closure Is"
14.2 "Examples of the Use of Closures"
14.3 Closure-Manipulating Functions
14.4 "Entities"
15. "Stack Groups"
15.1 Resuming of Stack Groups
15.2 Stack Group States
15.3 Stack Group Functions
15.4 Input/Output in Stack Groups
15.5 An Example of Stack Groups
16. "Stack Groups"
16.1 Resuming of Stack Groups
16.2 Stack Group States
16.3 Stack Group Functions
16.4 Input/Output in Stack Groups
16.5 An Example of Stack Groups
17. "Stack Groups"
17.1 Resuming of Stack Groups
17.2 Stack Group States
17.3 Stack Group Functions
17.4 Input/Output in Stack Groups
17.5 An Example of Stack Groups
18. "Locatives"
18.1 "Cells and Locatives"
18.2 "Functions That Operate on Locatives"
19. "Subprimitives"
19.1 Data Types
19.2 Forwarding
19.3 Pointer Manipulation
19.4 Analyzing Structures
19.5 Creating Objects
19.6 Locking Subprimitive
19.7 I/O Device Subprimitives
19.8 Special Memory Referencing
19.9 Storage Layout Definitions
19.10 Function-Calling Subprimitives
19.11 Lambda-Binding Subprimitive
19.12 The Paging System
19.13 Closure Subprimitives
19.14 Microcode Variables
19.15 Meters
20. "Subprimitives"
20.1 Data Types
20.2 Forwarding
20.3 Pointer Manipulation
20.4 Analyzing Structures
20.5 Creating Objects
20.6 Locking Subprimitive
20.7 I/O Device Subprimitives
20.8 Special Memory Referencing
20.9 Storage Layout Definitions
20.10 Function-Calling Subprimitives
20.11 Lambda-Binding Subprimitive
20.12 The Paging System
20.13 Closure Subprimitives
20.14 Microcode Variables
20.15 Meters
21. "Areas"
21.1 Area Functions and Variables
21.2 Interesting Areas
22. "The Compiler"
22.1 "The Basic Operations of the Compiler"
22.2 "How to Invoke the Compiler"
22.3 "Input to the Compiler"
22.4 "Compiler Declarations"
22.5 Controlling Compiler Warnings
22.6 "Compiler Source-Level Optimizers"
22.7 "Files that Maclisp Must Compile"
22.8 Putting Data in QFASL Files
23. "Macros"
23.1 "Introduction to Macros"
23.2 "Aids for Defining Macros"
23.2.1 "Defmacro"
23.2.2 "Backquote"
23.3 Substitutable Functions
23.4 Hints to Macro Writers
23.4.1 Name Conflicts
23.4.2 prog-context Conflicts
23.4.3 Macros Expanding into Many Forms
23.4.4 Macros that Surround Code
23.4.5 Multiple and Out-of-order Evaluation
23.4.6 Nesting Macros
23.4.7 Functions Used During Expansion
23.5 "Aids for Debugging Macros"
23.6 "Displacing Macros"
23.7 "Advanced Features of Defmacro"
23.8 "Functions to Expand Macros"
23.9 Generalized Variables
24. "Introduction"
25. "Clauses"
25.1 "Iteration-Driving Clauses"
25.2 "Bindings"
25.3 "Entrance and Exit"
25.4 "Side Effects"
25.5 "Values"
25.6 "Endtests"
25.7 "Aggregated Boolean Tests"
25.8 "Conditionalization"
25.9 "Miscellaneous Other Clauses"
26. "Loop Synonyms"
27. "Data Types"
28. "Destructuring"
29. "The Iteration Framework"
30. "Iteration Paths"
30.1 "Pre-Defined Paths"
30.1.1 "The Interned-Symbols Path"
30.1.2 "Sequence Iteration"
30.2 "Defining Paths"
30.2.1 "An Example Path Definition"
31. "Defstruct"
31.1 "Introduction to Structure Macros"
31.2 "How to Use Defstruct"
31.3 "Options to Defstruct"
31.4 "Using the Constructor and Alterant Macros"
31.4.1 Constructor Macros
31.4.2 By-position Constructor Macros
31.4.3 Alterant Macros
31.5 "Byte Fields"
31.6 "Grouped Arrays"
31.7 Named Structures
31.8 The si:defstruct-description Structure
31.9 Extensions to Defstruct
31.9.1 An Example
31.9.2 Syntax of defstruct-define-type
31.9.3 Options to defstruct-define-type
32. Objects, Message Passing, and Flavors
32.1 Introduction
32.2 Objects
32.3 Modularity
32.4 Generic Operations
32.5 Generic Operations in Lisp
32.6 Simple Use of Flavors
32.7 Mixing Flavors
32.8 Flavor Functions
32.9 Defflavor Options
32.10 Flavor Families
32.11 Vanilla Flavor
32.12 Method Combination
32.13 Implementation of Flavors
32.13.1 Order of Definition
32.13.2 Changing a Flavor
32.13.3 Restrictions
32.14 Entities
32.15 Useful Editor Commands
32.16 Property List Messages
33. "The I/O System"
33.1 "The Character Set"
33.2 "Printed Representation"
33.2.1 "What the Printer Produces"
33.2.2 "What The Reader Accepts"
33.2.3 "Macro Characters"
33.2.4 "Sharp-sign Abbreviations"
33.2.5 Special Character Names
33.2.6 "The Readtable"
33.3 "Input Functions"
33.4 "Output Functions"
33.5 "Rubout Handling"
33.6 The :read and :print Stream Operations
33.7 "Accessing Files"
33.7.1 Loading Files
33.7.2 File Property Lists
33.7.3 File Stream Operations
33.8 Accessing Directories
34. Naming of Files
34.1 Pathnames
34.2 Defaults and Merging
34.3 Generic Pathnames
34.4 Pathname Functions
34.5 Pathname Messages
34.6 Host File Systems Supported
34.6.1 ITS
34.6.2 TOPS-20 (Twenex), Tenex, and VMS.
34.6.3 Unix pathnames
34.6.4 Lisp Machine File Systems
34.6.5 Logical Pathnames
34.7 Hosts
34.7.1 Parsing Hostnames
34.7.2 Host Object Messages
34.8 Maclisp Conversion
34.9 Examples
35. "Packages"
35.1 "The Need for Multiple Contexts"
35.2 "The Organization of Name Spaces"
35.3 "Shared Programs"
35.4 "Declaring Packages"
35.5 "Packages and Writing Code"
35.6 "Shadowing"
35.7 "Packages and Interning"
35.8 "Status Information"
35.9 "Packages, Loading, and Compilation"
35.10 "Subpackages"
35.11 "Initialization of the Package System"
35.12 "Initial Packages"
35.13 "Multiple Instantiations of a Program"
36. Maintaining Large Systems
36.1 Defining a System
36.2 Transformations
36.3 Making a System
36.4 Adding New Keywords to make-system
36.5 Adding New Options for defsystem
36.6 More Esoteric Transformations
37. Maintaining Large Systems
37.1 Defining a System
37.2 Transformations
37.3 Making a System
37.4 Adding New Keywords to make-system
37.5 Adding New Options for defsystem
37.6 More Esoteric Transformations
37.7 The Patch Facility
37.7.1 Defining a System
37.7.2 Patch files
37.7.3 Loading Patches
37.7.4 Making Patches
37.7.5 System Status
37.8 Saving New Versions: Disk Partitions
37.8.1 Concepts
37.8.2 Manipulating the Label
37.8.3 Updating Software
37.8.4 Installing New Software
37.8.5 Installing New Microcode
38. Processes
38.1 The Scheduler
38.2 Locks
38.3 Creating a Process
38.4 Process Messages
38.4.1 Process Attributes
38.4.2 Run and Arrest Reasons
38.4.3 Bashing the Process
38.5 Process Flavors
38.6 Other Process Functions
39. Processes
39.1 The Scheduler
39.2 Locks
39.3 Creating a Process
39.4 Process Messages
39.4.1 Process Attributes
39.4.2 Run and Arrest Reasons
39.4.3 Bashing the Process
39.5 Process Flavors
39.6 Other Process Functions
40. Errors and Debugging
40.1 The Error System
40.1.1 Conditions
40.1.2 Error Conditions
40.1.3 Signalling Errors
40.1.4 Standard Condition Names
40.1.5 "Errset"
40.2 The Debugger
40.2.1 Entering the Debugger
40.2.2 How to Use the Debugger
40.2.3 "Debugger Commands"
40.2.4 "Summary of Commands"
41. Errors and Debugging
41.1 The Error System
41.1.1 Conditions
41.1.2 Error Conditions
41.1.3 Signalling Errors
41.1.4 Standard Condition Names
41.1.5 "Errset"
41.2 The Debugger
41.2.1 Entering the Debugger
41.2.2 How to Use the Debugger
41.2.3 "Debugger Commands"
41.2.4 "Summary of Commands"
42. Errors and Debugging
42.1 The Error System
42.1.1 Conditions
42.1.2 Error Conditions
42.1.3 Signalling Errors
42.1.4 Standard Condition Names
42.1.5 "Errset"
42.2 The Debugger
42.2.1 Entering the Debugger
42.2.2 How to Use the Debugger
42.2.3 "Debugger Commands"
42.2.4 "Summary of Commands"
43. Errors and Debugging
43.1 The Error System
43.1.1 Conditions
43.1.2 Error Conditions
43.1.3 Signalling Errors
43.1.4 Standard Condition Names
43.1.5 "Errset"
43.2 The Debugger
43.2.1 Entering the Debugger
43.2.2 How to Use the Debugger
43.2.3 "Debugger Commands"
43.2.4 "Summary of Commands"
43.3 Tracing Function Execution
43.4 Advising a Function
43.4.1 Designing the Advice
43.4.2 :around Advice
43.4.3 Advising One Function Within Another
43.5 Stepping Through an Evaluation
43.6 "Evalhook"
43.7 "The MAR"
43.8 Variable Monitoring
44. How to Read Assembly Language
44.1 Introduction
44.2 A More Advanced Example
44.3 The Rest of the Instructions
44.4 Function Entry
44.5 Special Class IV Instructions
44.6 Estimating Run Time
45. "Querying the User"
46. Initializations
46.1 System Initialization Lists
47. Dates and Times
47.1 Getting and Setting the Time
47.1.1 Elapsed Time in 60ths of a Second
47.1.2 Elapsed Time in Microseconds
47.2 Printing Dates and Times
47.3 Reading Dates and Times
47.4 Time Conversions
47.5 Internal Functions
48. "Miscellaneous Useful Functions"
48.1 Poking Around in the Lisp World
48.2 Utility Programs
48.3 "The Lisp Top Level"
48.4 The Garbage Collector
48.5 "Logging In"
48.6 Dribble Files
48.7 Status and SStatus
Index
This document was generated by
Brad Parker
on
June, 13 2006
using
texi2html