Google
 

Trailing-Edge - PDP-10 Archives - decuslib10-04 - 43,50322/tabcon.doc
Click 43,50322/tabcon.doc to see without markup as text/plain
There are no other files named tabcon.doc in the archive.








                   UCI LISP MANUAL


                         by

                  Robert J. Bobrow
                  Richard R. Burton
                  Jeffrey M. Jacobs
                    Daryle Lewis

























































                               Table of Contents



          Introduction                                                0. 0



          Debugging Facilities                                        1. 1
                  Introduction                                        1. 1
                  Temporarily Interrupting a Computation              1. 5
                  BREAK1 - The Function that Supervises all
                   Breaks                                             1. 6
                  What You Can Do In a Break                          1. 8
                     Break Commands                                   1. 8
                          Leaving a break with a value
                           (OK,GO,EVAL,FROM?)                         1. 8
                          Correction of UNBOUND ATOM and
                           UNDEFINED FUNCTION errors (>, USE)         1. 9
                          Aborting to Higher Breaks or the Top
                           Level (^, ^^)                              1.10
                     Examining and Modifying the Context of
                      a Break                                         1.11
                          Searching for a Context on the Stack        1.11
                          Editing a Form on the Context Stack         1.12
                          Evaluating a Form in a Higher Context       1.12
                          Backtrace Commands
                           Printing the Functions, Forms and Variable
                           Bindings on the Context Stack              1.15
                  Breakmacros
                          User Defined Break Commands                 1.17
                  How to Use the Break Package                        1.18
                          Setting a Break to Investigate a Function   1.18
                          Tracing the Execution  of Functions         1.19
                          Setting a Break INSIDE a Function           1.19
                          Removing Breaks and Traces                  1.21
                          Using BREAK0 Directly to Obtain
                           Special Effects from the
                           Break Package                              1.23
                  Error Package - Getting  Automatic Breaks
                   When Errors Occur                                  1.24
                  Summary of Break Commands                           1.25
























          The LISP Editor                                             2. 1
                  Introduction                                        2. 2
                  Commands for the New User                           2.10
                  Attention Changing Commands                         2.15
                          Local Attention Changing Commands           2.16
                          Commands That Search                        2.22
                                  Search Algorithm                    2.24
                                  Search Commands                     2.26
                                  Location Specification              2.30
                          Commands That Save and Restore the
                                  Edit Chain                          2.36
                  Commands That Modify Structure                      2.38
                          Implementation of Structure
                                  Modification Commands               2.39
                          The A, B, : Commands                        2.41
                          Form Oriented Editing and
                                  the Role of UP                      2.45
                          Extract and Embed                           2.46
                          The MOVE Command                            2.50
                          Commands That "Move Parentheses"            2.54
                          TO and THRU                                 2.57
                  Commands That Print                                 2.62
                  Commands That Evaluate                              2.63
                  Commands That Test                                  2.66
                  Macros                                              2.68
                  Miscellaneous Commands                              2.71
                  Editdefault                                         2.78
                  Editor Functions                                    2.80



          Extended Interpretation of LISP Forms                       3. 1
                  Evaluation of Sequences of Forms
                          Extended LAMBDA Expressions                 3. 1
                          The Functions PROG1 and PROGN               3. 2
                  Conditional Evaluation of Forms - SELECTQ           3. 3
                  Changes to the Handling of Errors                   3. 4
                  Miscellania - APPLY#,  NILL                         3. 5




























          Extensions to the Standard Input/Output Functions           4. 1
                  Project-Programmer Numbers for Disk I/O             4. 1
                  Saving Function Definitions, etc. on Disk Files     4. 1
                  Reading Files Back In                               4. 1. 1
                  Reading Directories                                 4. 1. 2
                  File Manipulation                                   4. 1. 4
                  Queuing Files                                       4. 1. 7
                  Recovery from QMANGR Errors                         4. 1. 10
                  Printing Circular or Deeply Nested Lists            4. 2
                  Spacing Control - TAB                               4. 2
                  "Pretty Printing" Function Definitions and
                   S-Expressions                                      4. 3
                  Reading Whole Lines                                 4. 4
                  Teletype and Prompt Character Control Functions     4. 5
                  Read Macros - Extending the  LISP READ Routine      4. 6
                          Functions for Defining Read Macros          4. 6
                          Using Read Macros                           4. 7
                  Modifying the READ Control Table                    4. 8
                  Reading without Interning                           4. 9



          New Functions on S-Expressions                              5. 1
                  S-Expression Building Functions                     5. 1
                  S-Expression Transforming Functions                 5. 3
                  S-Expression Modifying Functions                    5. 4
                  Mapping Functions with Several Arguments            5. 5
                  Mapping Functions which use NCONC                   5. 6
                  S-Expression Searching and Substitution Functions   5. 7
                  Efficiently Working with Atoms as Character Strings 5. 9



          New Predicates                                              6. 1
                  Data Type Predicates                                6. 1
                  Alphabetic Ordering Predicate                       6. 2
                  Predicates That Return Useful Non-NIL Values        6. 3
                  Other Predicates                                    6. 4



          New Numeric Functions                                       7. 1
                  Minimum and Maximum                                 7. 1
                  FORTRAN Functions in LISP                           7. 2






















          Functions for the System Builder                            8. 1
                  Loading Compiled Code into the High Segment         8. 1
                  The Compiler and LAP                                8. 2
                          Special Variables                           8. 2
                          Removing Excess Entry Points                8. 2
                  Miscellaneous Useful Functions                      8. 3
                  Initial System Generation                           8. 4



          The LISP Evaluation Context Stack                           9. 1
                  The Contents of the Context Stack                   9. 1
                  Examining the Context Stack                         9. 2
                  Controlling Evaluation Context                      9. 4



          Storage Allocation                                         10. 1
          Contiguous Blocks of Storage                                11. 1



          Index                                                   INDEX. 1