---                                                           ---

PAGE 1     COVER


















     *      *    * *      *  ******   ******       ******* 
     *      *   ** *      * *        *      *      *      *
     *      *  * * *      * *        *      *      *      *
     *      * *  * *      * *        *      *      *      *
     *      **   * *      * *        *      *      *      *
     ********    * *      *  ******  *******  **** ******* 
     *     **    * *      *        * *             *      *
     *    * *    * *      *        * *             *      *
     *   ********* *      *        * *             *      *
     *  *   *    * *      *        * *             *      *
     * *    *    * ****** *  ******  *             ******* 


                             THE REFERENCE MANUAL
































---                                                           ---

PAGE 2     COVER














            IF MANY FAULTES IN THIS BOOK YOU FYNDE,
               YET THINK NOT THE CORRECTORS BLYNDE;
            IF ARGOS HEERE HYMSELFE HAD BEENE
               HE SHOULD PERCHANCE NOT ALL HAVE SEENE.
                               RICHARD SHACKLOCK...1565



















                                     FIRST PRINTING  2 DEC 1980
                                     LAST REVISED   20 FEB 1983
     THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE
     WITHOUT NOTICE AND SHOULD NOT BE CONSTRUED AS A
     COMMITIMENT BY Yasuyuki Kinoshita. Yasuyuki Kinoshita
     ASSUMES NO RESPONSIBILITY FOR ANY ERRORS THAT MAY
     APPEAR IN THIS DOCUMENT.
     THE SOFTWARE DESCRIBED IN THIS DOCUMENT IS FURNISHED
     UNDER A LICENSE AND MAY ONLY BE USED OR COPIED
     IN ACCORDANCE WITH THE TERMS OF SUCH LISENCE.
     NO RESPONSIBILITY ASSUMED FOR THE USE OR RELIABILITY
     OF SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY
     Yasuyuki Kinoshita OR ITS AFFILIATED COMPANIES.
       COPYRIGHT (C) 1982 BY Yasuyuki Kinoshita
       COPYRIGHT (C) 1982 BY Hashimoto-lab, University of Electro-Communications
     PRINTED IN TOKYO JAPAN





---                                                           ---

PAGE 3     TABLE OF CONTENTS


                  -----TABLE OF CONTENTS-----
SECTION     TITLE                                        PAGE
    <1>     OVERVIEW                                       4
              INTRODUCTION TO LISP
    <2>     HALISP-B SYSTEM                                5
              HALISP-B
              SYSTEM REQUIREMENTS
              GETTING STARTED
              START UP FILE                                7
              SPECIAL CONTROL KEYS
    <3>     SYNTACTIC DEFINITIONS                          8
              HALISP SYNTAX
              READ MACRO                                  10
              QUASI-QUOTE READ MACRO                      11
    <4>     FUNCTION DEFINITION                           13
              FUNCTION TYPES
              DEFINITION OF THE FUNCTION
              MACRO FACILITY                              14
              DEFINITION AUTO LOADING MECHANISM           15
    <5>     BUILT-IN FUNCTIONS                            16
              ARGUMENTS NOTATION
              FUNCTION NOTATION
              BUILT-IN FUNCTIONS AND MACROS
                [1] ELEMENTARY FUNCTIONS AND PREDICATES   16
                [2] LIST MANIPULATION FUNCTIONS           22
                [3] EVALUATION SEQUENCE CONTROL FUNCTIONS 27
                [4] PROPERTY LIST MANIPULATION FUNCTIONS  34
                [5] MAP FUNCTIONS                         36
                [6] ARITHMETIC FUNCTIONS AND PREDICATES   40
                [7] INPUT/OUTPUT FUNCTIONS                44
                [8] DEBUGGING FUNCTIONS                   50
                [9] FUNCTION DEFINITION FUNCTIONS         51
                [10] DATA TYPE & STORE MACRO              53
                [11] SYSTEM SWITCHES AND MISCELLANEOUS    54
                [12] PRIMITIVES FOR COMPILER              60
                [13] SPECIAL DEVICE FUNCTIONS             60
                [14] SYSTEM CONSTANTS AND INDICATORS      61
    <6>     ERROR FUNCTION                                62
              IMPLEMENTATION OF ERROR RECOVERING
              DEFINITION OF THE TYPICAL ERROR FUNCTION
              EXAMPLES OF ERROR RECOVERING                63
    <7>     FUNCTION TRACER                               65
              DEFINITION OF THE TYPICAL TRACER FUNCTION
APPENDICES  APPENDIX A: FATAL ERRORS                      66
            APPENDIX B: DATA DRIVEN PROGRAMMING           67
            APPENDIX C: DEBUGGING                         70
            APPENDIX D: VIRTUAL FUNCTION TECHNIQUE        //
            APPENDIX E: RESTRICTIONS                      72
            APPENDIX F: SPECIAL LAMBDA BINDER             72
            APPENDIX G: MEMORY MAP                        73
            APPENDIX H: TYPICAL DEFINITIONS OF BUIT-IN'S  --



---                                                           ---

PAGE 4     OVERVIEW


  <1> OVERVIEW
--INTRODUCTION TO LISP--
  LISP IS SIMPLE AND DIFFICULT, ELEGANT AND AD HOC; IT IS
A BEAUTIFUL BLEND OF FORESIGHT AND FORTUITY. LISP IS A
PROGRAMMING LANGUAGE, OFTEN CHARACTERIZED AS A SPECIAL PURPOSE
LIST-PROCESSING LANGUAGE. BUT LISP IS NO MORE A SPECIAL PURPOSE
PROGRAMMING LANGUAGE THAN MATHMATICS IS A SPECIAL PURPOSE
LANGUAGE FOR FLOATING-POINT COMPUTATIONS. JUST AS THERE'S MORE
MATHEMATICS THAN THE ACCOUNTING AND BOOKKEEPING PROPERTIES
PRESENT IN "GENERAL PURPOSE" PROGRAMMING LANGUAGES, THERE'S
MUCH MORE TO LISP THAN "JUST ANOTHER PROGRAMMING LANGUAGE."
  THE BEST DESCRIPTION OF THE LISP PROGRAMMING LANGUAGE IS THAT
IT IS A "HIGH LEVEL MACHINE LANGUAGE." THAT IS, IT SHARES MANY
OF THE FACETS OF CONTEMPORARY MACHINE LANGUAGE - THE NECESSITY
FOR ATTENTION TO DETAIL AND THE FREEDOM TO MANIPULATE THE
MACHINE'S DATA AND PROGRAMMS WITHOUT RESTRICTION - YET LISP IS
HIGH LEVEL IN THAT THE LANGUAGE CONTAINS EXPRESSIVE POWER AND
CONVENIENCE OF TRADITIONAL HIGH LEVAL LANGUAGES. THE
CONTRADICTION IS RESOLVABLE: A LISP MACHINE IS JUST A HIGHER
LEVEL MACHINE WHOSE DATA ITEMS ARE ORGANIZED DIFFERENTLY FROM
THE BINARY BIT PATTERNS OF MOST MACHINES, AND THE LISP
PROGRAMMING LANGUAGE IS THE "ASSEMBLY LANGUAGE" FOR THIS
MACHINE.
                                - JOHN ALLEN FROM BYTE AUG79 -




































---                                                           ---

PAGE 5     HALISP-B SYSTEM


  <2> HALISP-B SYSTEM
--THE HALISP-B--
THE HALISP-B IS THE LATEST IN A SERIES OF THE HALISP LIST
PROCESSOR. THE SYSTEM USES BULK MEMORY AS THE LIST CELL SPACE
THAT IS COMPLETELY INDEPENDENT OF CPU'S MAIN MEMORY SPACE. SO
THAT THIS EFFECTS AN EFFICIENT USAGE OF BOTH BULK AND MAIN
MEMORY.
--SYSTEM REQUIREMENTS--
HALISP-B RUNS ON DEC PDP-11 SERIES PROCESSOR UNDER THE STANDARD
RT-11 OPERATING SYSTEM WITH THE BULK MEMORY WHICH IS ALSO
SUPPLIED BY Hashimoto-lab, University of Electro-Communications.
--GETTING STARTED--
FIRST, MAKE SURE THAT THE FILE NAMED "LISP.SAV" IS ON THE
SYSTEM DISK DEVICE "SY:", AND THE POWER SWITCH OF THE BULK
MEMORY IS ON.
IF YOU ARE ENTERED THE KEYBOAD MONITOR FROM THE SYSTEM STARTUP,
NOW YOU MAY TYPE,
 .R LISP<RETURN>
AND IN A FEW SECONDS HALISP WILL BE UP AND THE NEXT MESSAGES
WILL APPEAR.
   HALISP-B 0001
 65300 CELLS FREE  7168 WORDS FOR STACK  7982 WORDS FOR DAS
 :
<RETUEN> MEANS PRESSING THE CARRIAGE RETURN KEY.
THE 2'ND LINE OF THIS MESSAGE DISPLAYS THE SYSTEM INFORMATION
ABOUT ITS FREE SPACES. "DAS" STANDS FOR "DYNAMIC ALLOCATED
SPACE".
AT THIS POINT, HALISP WAIT FOR YOUR S-EXPRESSION INPUT: TO THE
ARGUMENT OF FUNCTION "EVAL". THIS ARGUMENT IS CALLED "FORM",
AND "EVAL" IS CALLED "UNIVERSAL FUNCTION" IN LISP. NEXT THE
ENTERING MESSAGES THERE IS A COLON MARK WHICH IS THE PROMPT
CHARACTER THAT INDICATES THE SYSTEM CONTROL IS IN "READ"
 - A PRIMITIVE I/O FUNCTION OF LISP. HERE HALISP READS ONE
S-EXPRESSION, AND "EVAL" FUNCTION EVALUATES THE READ FORM, THEN
THE SYSTEM PRINTS THE VALUE. HALISP REPEATS ONLY THIS PROCEDURE
ETERNALLY.
FOR EXSAMPLE,
 :(CAR(QUOTE(A B C D))<RETURN>
THEN HALISP WILL RESPOND,
   A
RESPONSES ARE INDENTED BY TWO SPACES.



---                                                           ---

PAGE 6     HALISP-B SYSTEM


DO ANOTHER,
 :(CDR '(A B C D))<RETURN>
   (B C D)
AN S-EXPRESSION TAGGED A SINGLE QUOTATION MARK IS PARSED TO BE
QUOTED VALUE. SO IT EQUALS TO THE FUNCTION "QUOTE".
IF YOU ARE UNFAMILIAR WITH LISP NOW INVOKE DEMO-PROGRAM TO SHOW
YOU ITS ABILITY, AND POWER.
THIS PROGRAM DIFFERENTIATE A SIMPLE NUMERICAL EXPRESSION THAT
YOU WANT. TRY TO TYPE,
 :(DIFF)<RETURN>
THEN HALISP WILL BEGIN TO READ THE PROGRAM FROM DISK. AFTER
ABOUT A FEW SECONDS HALISP FINISH IT AND PRINT MESSAGE,
 THE DERIVATIVE OF
 3*X^3+2*X^2+X+3
 WITH RESPECT TO
 X
 IS
 9*X^2+4*X+1
 THE DERIVATIVE OF
 3*(X^2+X)+2*X^3
 WITH RESPECT TO
 X
 IS
 3*(2*X+1)+6*X^2
 THE DERIVATIVE OF
 BYE
   BYE
 :
THE NEXT DEMO-PROGRAM IS FAMOUS AS "DOCTOR" OR "ELIZA" PROGRAM.
THIS PROGRAM INTERACT WITH PERSONS MUCH LIKE THE WAY ONE TYPE
OF PSYCHIATRIST INTERACTS WITH A PATIENT ON THE COUCH.
  NOW CALL HIM UP,
 :(DOCTOR)
  TELL ME YOUR PROBLEM.



---                                                           ---

PAGE 7     HALISP-B SYSTEM



 MY NAME IS TOM.
  I HAVE NO INTEREST IN NAMES.
 I DO NOT LIKE COMPUTERS.
  DO MACHINES FRIGHTEN YOU?
 NOT LIKE MY MOTHER.
  TELL ME MORE ABOUT YOUR FAMILY.
 YES.
  PLEASE DO NOT BE SHORT WITH ME.
 I AM WORRIED ABOUT FOOD.
  HOW LONG HAVE YOU BEEN WORRIED ABOUT FOOD.
--START UP FILE--
IF A LISP FILE NAMED "STARTL.LSP" IS ON DEFAULT DISK DEVICE
"DK:" WHEN YOU START HALISP, THAT FILE IS AUTOMATICALLY LOADED
AND EXCUTED. THE REASON WHY THIS FILE IS NECESSARY IS ONE THAT
SOME SYSTEM PROVIDED READ MACROS CAN'T BE LOADED WHEN NEEDED.
ANOTHER ONE IS THAT IT ALLOWS YOU TO CREATE A "TURNKEY" SYSTEM.
IF YOU STORE PROGRAM WHICH IS OFTEN USED INTO THIS FILE, YOU
DON'T HAVE TO DO ANY SET UP PROCEDURES TO START IT.
--SPECIAL CONTROL KEYS--
THREE SORTS OF SPECIAL ACTIONS CAN BE INVOKED BY SEQUENCES OF
SOME CONTROL KEYS WHICH ARE FOLLOWING,
  <CONTROL-B><RETURN>
      EXITS FROM HALISP TO KEYBOAD MONITOR.
  <CONTROL-C><CONTROL-C>
      BREAKES YOUR PROGRAM EXCUTION. THIS SEQUENCE ONLY WORKS
      WHEN YOUR PROGRAM IS BEING EXCUTED.
  <CONTROL-Y><OPTION> <FILE NAME><RETURN>
      ENTERS EDITOR WITH THAT OPTION AND FILE NAME.
  EX. TO QUIT HALISP
  :^B<RETURN>
  .
  EX. TO EDIT THE FILE "DOCTOR.LSP"
  :^Y DOCTOR<RETURN>
  *
  EX. TO CREATE A NEW FILE "NEWFIL.LSP"
  :^Y/C NEWFIL<RETURN>
  *



---                                                           ---

PAGE 8     DEFINITIONS


  <3> SYNTACTIC DEFINITIONS
--HALISP SYNTAX--
 < > ::= METASYMBOL USED TO ENCLOSE MATERIAL WHICH
         IS NONTERMINAL SYMBOL
 ,   ::= METASYMBOL USED TO SEPARATE ALTERNATIVES
 <LETTER>
   ::= A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
   ::= !,#,$,%,&,*,:,@,-,=,+,,,<,>,?,^
 <CTRL>
   ::= ALL CONTROL CHARACTERS
 <EOL>
   ::= A PRESS OF THE RETURN KEY
 <SPECIAL>
   ::= (,),.,[,], ,/,',;,",<CTRL>
 <DIGIT>
   ::= 1,2,3,4,5,6,7,8,9,0
 
 <CHARACTER>
   ::= <LETTER>,<SPECIAL>,<DIGIT>
 <ATOMIC LETTER>
   ::= <LETTER>,/<SPECIAL>
 <STRING>
   ::= <CHARACTER>,<STRING><CHARACTER>
 <LITERAL PART>
   ::= <ATOMIC LETTER>,<LITERAL PART><ATOMIC LETTER>
   ::= <LITERAL PART><DIGIT>
 <LITERAL ATOM>
   ::= <LITERAL PART>,<LITERAL PART><EOL>,"<STRING>"
   ::= <LITERAL PART>;<EOL><LITERAL PART>
       A LITERAL ATOM HAS NO LIMITATON IN ITS LENGTH.
       EXAMPLE ATOMS OF INCLUDING SPECIALS:
           --READ FORM--          => --INTERNAL LITERAL ATOM--
           THIS/ IS/ A/ MESSAGE/. => THIS IS A MESSAGE.
           "1*(2+3)"              => 1*(2+3)
           THISISVERYLON;
           GATOM                  => THISISVERYLONGATOM
 <UNSIGNED NUMBER>
   ::= <DIGIT>,<UNSIGNED NUMBER><DIGIT>
 <NUMERIC PART>
   ::= <UNSIGNED NUMBER>,+<UNSIGNED NUMBER>,-<UNSIGNED NUMBER>






---                                                           ---

PAGE 9     DEFINITIONS


 <NUMERIC ATOM>
   ::= <NUMERIC PART>,<NUMERIC PART><EOL>
   ::= <NUMERIC PART>;<EOL><NUMERIC PART>
       HALISP PROVIDES INDEFINITE PRECISION RATIONAL INTEGER
       ARITHMETIC, SO NUMBER OF DIGITS IS LIMITED ONLY BY THE
       NUMBER OF REMAINING FREE CELLS.
 <ATOM>
   ::= <LITERAL ATOM>,<NUMERIC ATOM>
 <S-EXPRESSION>
   ::= <ATOM>,(<LIST OF S-EXP>.<S-EXPRESSION>)
   ::= (<LIST OF UNBALANCED>.<UNBALANCED>]
   ::= (),[),(],[],(<LIST OF S-EXP>),[<LIST OF S-EXP>)
   ::= (<LIST OF UNBALANCED>],[<LIST OF UNBALANCED>]
 <LIST OF S-EXP>
   ::= <S-EXPRESSION>,<LIST OF S-EXP> <S-EXPRESSION>
 <LIST OF UNBALANCED>
   ::= <UNBALANCED>,<LIST OF UNBALANCED> <UNBALANCED>
 <UNBALANCED>
   ::= <S-EXPRESSION>,(<UNBALANCED>
       THE PAIR OF "[" AND "]" ARE CALLED SUPER PARENTHESES.
       THEY FUNCTION AS PARENTHESES BALANCER IN S-EXPRESSIONS.
       ONE RIGHT SUPER PARENTHESIS EQUALS TO ONE OR MORE RIGHT
       NORMAL PARENTHESES.
       HERE ARE SOME EXAMPLES OF TWO S-EXPRESSIONS
       THAT ARE WHOLLY EQUIVALENT:
            [(((A] = ((((A))))
            (((A] = (((A)))
            ([(A)(((A B][(A]) = (((A)(((A B))))((A)))
 <VARIABLE>
   ::= <LITERAL ATOM>
 <CONSTANT>
   ::= (QUOTE <S-EXPRESSION>),'<S-EXPRESSION>
 <FUNCTION NAME>
   ::= <LITERAL ATOM>
 <LAMBDA EXPRESSION>
   ::= (LAMBDA (<LIST OF VARIABLES>) <LIST OF FORMS>)
 <LIST OF VARIABLES>
   ::= <VARIABLE>,<LIST OF VARIABLES> <VARIABLE>
 <FUNCTION>
   ::= <FUNCTION NAME>,<LAMBDA EXPRESSION>,<COMPUTED FUNCTION>
 <FORM>
   ::= <CONSTANT>,<VARIABLE>,(<FUNCTION> <LIST OF FORMS>)
       FORM MAY ALSO INCLUDE SUPER PARENTHESES.




---                                                           ---

PAGE 10    DEFINITIONS


 <LIST OF FORMS>
   ::= <FORM>,<LIST OF FORMS> <FORM>
 <COMPUTED FUNCTION>
   ::= <FORM>
       THE VALUE OF THE COMPUTED FUNCTION MUST BE A FUNCTION
       NAME OR A LAMBDA EXPRESSION.
 <COMMENT>
   ::= ;<STRING><EOL>
       A SEMICOLON ";" CAN BE ALSO USED AS A COMMENT HEADER IN
       PROGRAM TEXT. THE CHARACTERS AFTER A ";" ARE IGNORED
       UNTIL THE END OF LINE.
--READ MACRO--
HALISP HAS THE "READ MACRO" FACILITY WHICH CAN CHANGE THE
SYNTAX OF THE INPUT PARSER. THE MACROS ARE EXPANDED DURING
THE READ PHASE. READ MACROS ARE ALWAYS SINGLE CHARACTERS. WHEN
THE READ FUNCTION COMES ACROSS A CHARACTER DEFINED AS A READ
MACRO, THE MACRO IS EXCUTED AND THE RESULT IS SUBSTITUTED FOR
OLD CODE.
A SINGLE QUOTATION MARK IS ALREADY DEFINED AS A READ MACRO.
THE EXPLICIT DEFINITION IS AS FOLLOWS.
  (READMACRO ' (LIST (QUOTE QUOTE) (READ)))
THIS DEFINITION SHOWS THAT WHEN A SINGLE QUOTE IS FOUND, THE
READ PARSER SHOULD REPLACE IT WITH A LIST OF "QUOTE" AND THE
THE NEXT S-EXPRESSION IN THE INPUT. FOR EXAMPLE,
  'APPLE IS EXPANDED INTO (QUOTE APPLE)
THE GENERAL FORM OF READ MACRO DEFINITION IS,
  (READMACRO <SINGLE CHARACTER> <FORM>)
THE <FORM> IS AN EXPRESSION WHICH PRODUCES AN EXPECTED CODE.
ANOTHER EXAMPLE,
  :(READMACRO + (LIST 'PLUS (READ) (READ)))
    +
  :+1 2
    3
  :++1 2 3
    6
THE LAST ONE IS EXPANDED INTO "(PLUS (PLUS 1 2) 3)".
THE BODY OF THE READ MACRO IS ATTACHED ON THE PROPERTY LIST OF
THAT ATOM UNDER THE INDICATOR "READMACRO". SO IN THE CASE OF
THE LAST EXAMPLE,



---                                                           ---

PAGE 11    DEFINITIONS



  :(GET '/+ 'READMACRO)
    (LIST (QUOTE PLUS) (READ) (READ))
TO UNDEFINE THE READMACRO, RE-DEFINE THE MACRO'S BODY TO NIL.
  :(READMACRO /+ NIL)
    +
THE SPECIAL HEADER "/" MUST BE USED, BECAUSE "+" IS DEFINED AS
A READ MACRO IN THAT CONTEXT OR YOU WILL GET AN UNEXPECTED
MACRO EXPANSION - IT MAY ALSO CAUSE AN UNEXPECTED ERROR. SO YOU
HAD BETTER USE A "/" FOR READ MACRO DEFINITIONS USUALLY.
--QUASI-QUOTE READ MACRO--
THE && (QUASI-QUOTE) READ MACRO IS DEFINED AS A READ MACRO IN
HALISP START UP FILE, AND IS NOT BUILT-IN.
IT CAN BE THOUGHT OF AS AN EXTENSION OF "QUOTE". USING
THIS MACRO FOR EXAMPLE, THE NEXT EXPRESSION,
  &&(PROG @VARS
          LOOP &@EXPESSIONS
               (GO LOOP))
WILL BE EXPANDED INTO,
  (CONS 'PROG
        (CONS VARS
              (CONS 'LOOP
                    (APPEND EXPRESSIONS
                            '((GO LOOP]
THIS MACRO SOLVES THE PROBLEM THAT FREQUENTLY OCCURS IN LISP
PROGRAMS IS THE CREATION OF COMPLEX LIST STRUCTURES.
HERE @ SAYS TO EVALUATE THE FOLLOWING EXPRESSION TO FIND OUT
WHAT GOES HERE (I.E., UNQUOTE), WHEREAS &@ SAYS TO DO THE SAME
BUT TO SPLICE IN THE RESULTS (SPLICE-UNQUOTE).
FOR EXAMPLE,
  :(SETQ VARS '(X Y Z))
    (X Y Z)
  :(SETQ EXPRESSIONS
     '((PRINT X)
       (SETQ X (CONS (CAR Y) X))
       (SETQ Y (CDR Y]
    ((PRINT X) (SETQ X (CONS (CAR Y) X)) (SETQ Y (CDR Y)))








---                                                           ---

PAGE 12    DEFINITIONS


  :&&(PROG @VARS
           LOOP &@EXPESSIONS
                (GO LOOP))
    (PROG (X Y Z) LOOP (PRINT X) (SETQ X (CONS (CAR Y) X))
  (SETQ Y (CDR Y)) (GO LOOP))

























































---                                                           ---

PAGE 13    FUNCTION DEFINITION


  <4> FUNCTION DEFINITION
--FUNCTION TYPES--
HALISP PROVIDES NINE DIFFERENT FUNCTION TYPES DISCRIMINATED
AGAINST THERE ARGUMENTS TREATMENT AND DEFINED FORM: MACHINE
LANGUAGE OR S-EXPRESSION. AND THERE ARE TWO ASPECTS ON THE
ARGUMENTS TREATMENT, THE FIRST IS THERE NUMBER AND THE SECOND
IS THERE EVALUATION BEFORE THE ACTUAL FUNCTION CALL.
FUNCTION TYPES AND THERE MEANINGS ARE AS FOLLOWS. MACRO IS
EXPLAINED LATER.
   TYPE NAME :   ARGUMENTS,   NUMBER,       DEFINED-BY
        SUBR :   EVALUATED,    FIXED, MACHINE LANGUAGE
       KSUBR : UNEVALUATED,    FIXED, MACHINE LANGUAGE
       LSUBR :   EVALUATED, VARIABLE, MACHINE LANGUAGE
       FSUBR : UNEVALUATED, VARIABLE, MACHINE LANGUAGE
        EXPR :   EVALUATED,    FIXED,     S-EXPRESSION
       KEXPR : UNEVALUATED,    FIXED,     S-EXPRESSION
       LEXPR :   EVALUATED, VARIABLE,     S-EXPRESSION
       FEXPR : UNEVALUATED, VARIABLE,     S-EXPRESSION
       MACRO : UNEVALUATED, VARIABLE,     S-EXPRESSION
--DEFINITION OF THE FUNCTION--
TO DEFINE A NEW FUNCTION, FIRST THE FUNCTION BODY <BODY> ITSELF
SHOULD BE ASSIGNED TO THE FUNCTION NAME ATOM <FN> USING THE
FUNCTION "SETQ" OR "SET".
THAT IS,
   :(SETQ <FN> '<BODY>)
OR,
   :(SET '<FN> '<BODY>)
BUT IT IS NOT NECESSARY THAT THE ASSIGNMENT IS IN THE TOP
LEVEL.
AND THE NEXT, THE FUNCTION TYPE IDENTIFIER <TPYE> MUST BE SET
TO THE FUNCTION NAME ATOM <FN> USING THE FUNCTION "PUTTYP".
THAT IS,
   :(PUTTYP '<FN> '<TYPE>)
THE <TYPE> IS ALLOWED ONE OF THE NINE FUNCTION TYPE NAMES. BUT
USUALLY USER CAN SET ONLY EXPR,KEXPR,LEXPR AND FEXPR OF EXPR'S.
BECAUSE THE <BODY> MUST BE AN S-EXPRESSION.
IT IS POSSIBLE TO GATHER THESE TWO PROCEDURES INTO ONE
FUNCTION. THE NEXT PROCEDURES DEFINE A FUNCTION THAT DEFINES
A EXPR FUNCTION.







---                                                           ---

PAGE 14    FUNCTION DEFINITION


   :[SETQ DEF '(LAMBDA (FNL BODY)
   :            (PROGN [SET (CAR FNL)
   :                        (LIST 'LAMBDA (CDR FNL) BODY]
   :                   (PUTTYP (CAR FNL) 'EXPR)
   :                   (CAR FNL]
     ...
   :(PUTTYP 'DEF 'KEXPR)
     KEXPR
THE FUNCTION THAT IS DEFINED IN THIS WAY CAN BE USED IN YOUR
PROGRAMS IMMEDIATELY.
INSTANTLY, WE DEFINE A NEW EXPR FUNCTION USING "DEF".
   :[DEF (COUNTATOMS S)
   :  (COND ((NULL S) 0)
   :        ((ATOM S) 1)
   :        (T (PLUS (COUNTATOMS (CAR S))
   :                 (COUNTATOMS (CDR S))]
     COUNTATOMS
   :(COUNTATOMS '((BASIC) ((PROLOG) LISP) (PASCAL) SMALLTALK]
     5
--MACRO FACILITY--
HALISP ALSO PROVIDES MACRO EXPANSION FACILITY. A MACRO FUNCTION
IS GIVEN A PIECE OF PROGRAM AS ITS ARGUMENT AND COMPUTES A NEW
FORM OF PROGRAM FROM IT. THIS FACILITY IS IMPLEMENTED BY
EVALUATING THE RESULT OF THE MACRO FUNCTION AGAIN IN THE
PRECEDING CONTEXT TO THAT MACRO FUNCTION CALL.
NORMALY, MACRO FUNCTION IS GIVEN ONLY ONE ARGUMENT THAT IS
WHOLE UNEVALUATED EXPRESSION OF EVALUATING FORM.
TO DEFINE THE MACRO, FIRST SET THE <BODY> TO THE FUNCTION NAME
<FN>, NEXT PUT A MACRO TYPE TO THE FUNCTION NAME ATOM.
FOR EXAMPLE, SUPPOSING INCREASER OF VARIABLE'S VALUE,
  :(SETQ INC '(LAMBDA (B)
  :  (LIST 'SETQ (CADR B) (LIST 'ADD1 (CADR B]
    INC
  :(PUTTYP 'INC 'MACRO)
    MACRO
  :(PROGN (SETQ A 1) (INC A) A) ;ARGUMENT OF INC IS "(INC A)"
    2






---                                                           ---

PAGE 15    FUNCTION DEFINITION


--DEFINITION AUTOMATIC LOADING MECHANISM--
IF HALISP DETECTS AN UNDEFINED FUNCTION DURING THE EVALUATION,
HALISP TRYS TO LOOK FOR A DISK FILE OF THE NAME OF THE FUNCTION
NAME ON THE DEFAULT DISK DEVICE "DK:", AND IF FOUND, THE SYSTEM
READS ONE S-EXPRESSION FROM THAT FILE AND EVALUATE IT. AFTER
ITS EVALUATION, THE PENDING EVALUATION IS RESUMED. SO, IF YOU
WRITE "EXPR"S DEFINITIONS TO THOSE DISK FILES, NO COMMANDS ARE
REQUIRED TO READ THOSE FILES BEFORE USING THE FUNCTIONS IN
HALISP.
UNDEFINED GLOBAL CONSTANTS ARE THE SAME AS THE FUNCTIONS.



















































---                                                           ---

PAGE 16    BUILT-IN FUNCTIONS


  <5> BUILT-IN FUNCTIONS
--ARGUMENTS NOTATION--
  SYMBOL : MEANING
  <ATM>  : ANY LITERAL OR NUMERIC ATOM
  <LATM> : ANY LITERAL ATOM
  <N>    : ANY NUMERIC ATOM
  <S>    : ANY S-EXPRESSION
  <FN>   : FUNCTION NAME OR LAMBDA EXPRESSION OR FORM FOR
           COMPUTED FUNCTION
  <L>    : A LIST LIKE (<L1> <L2> ... <LN>) OR NIL
  <P>    : TRUE OR FALSE, TRUE MAY BE NOT NIL, AND FALSE IS NIL
  <A>    : AN ASSOCIATION LIST LIKE
           ((ATOM1.S1) (ATOM2.S2) ... (ATOMN.SN))
  <VAR>  : ANY LITERAL ATOM FOR VARIABLE NAME
  <E>    : ANY S-EXPRESSION TO BE EVALUATED
  <PROP> : ANY LITERAL ATOM FOR PROPERTY NAME
  <VALUE>: ANY S-EXPRESSION FOR PROPERTY VALUE
  <FILE> : ANY LITERAL ATOM FOR FILE SPECIFICATION
  <CH>   : ANY NUMERIC ATOM FOR CHANNEL NUMBER
  <FTYPE>: ONE OF THE NINE FUNCTION TYPES
  '<..>  : ARGUMENT WHICH IS NOT EVALUATE BEFORE AND AFTER CALL
  [<..>] : ARGUMENT WHICH IS OPTIONAL
  ,      : USED TO SEPARATE ALTERNATIVES
  .      : USED TO REPEAT MATERIAL
NOTE: IF SUBR'S ARGUMENTS ARE DEFAULT OR EXCESSIVE, IT CAUSES
      ARGUMENTS-NUMBER-MISMATCH ERROR.
--FUNCTION NOTATION--
 (<FUNCTION NAME> <ARG1> <ARG2> ... <ARGN>) : FUNCTION TYPE
--BUILT-IN FUNCTIONS AND MACROS--
 [1] ELEMENTARY FUNCTIONS AND PREDICATES
(ATOM <S>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS AN ATOM. OTHERWISE
   IT RETUNRS NIL.
   EX.
   :(ATOM 'METAL)
     T
   :(ATOM 1)
     T
   :(ATOM '(A B C))
     NIL
(CAR <L>) : SUBR
   RETURNS A FIRST ELEMENT OF LIST <L>.



---                                                           ---

PAGE 17    BUILT-IN FUNCTIONS



   EX.
   :(CAR '(HEAD BODY TAIL))
     HEAD
(CDR <L>) : SUBR
   RETURNS A VALUE REPRESENTING THE LIST <L> WITH THE FIRST
   ELEMENT REMOVED.
   EX.
   :(CDR '(HEAD BODY LEG TAIL))
     (BODY LEG TAIL)
(C...R <L>) : SUBR
   EQUIVALENT TO A SERIES OF CAR AND CDR OPERATIONS.
   FOR EXAMPLE (CADDR '(A B C)) IS COMPLETELY EQUIVALENT TO
   (CAR (CDR (CDR '(A B C)))).
   EX.
   :(CADDDDAR '((A B C D HERE F G H) (I J K]
     HERE
(CONS <S1> <S2>) : SUBR
   ADDS THE S-EXPRESSION <S1> TO THE SECOND S-EXPRESSION <S2>
   AS THE FIRST ELEMENT. OR MAKES DOTTED PAIR OF <S1> FOR CAR
   AND <S2> FOR CDR.
   EX.
   :(CONS 'STACK '(QUEUE DEQUE))
     (STACK QUEUE DEQUE)
(ELEMENT <N> <L>) : SUBR
   RETURNS <N> TIMES CDRS OF THE LIST <L>. IF NUMBER <N>
   IS NEGATIVE IT GETS FROM THE TAIL OF THE LIST <L>.
   EX.
   :(ELEMENT 2 '(A B C D))
     (C D)
   :(ELEMENT 0 '(A B C))
     (A B C)
   :(ELEMENT -2 '(A B C D E))
     (D E)
   :(ELEMENT 3 '(A B))
     NIL




---                                                           ---

PAGE 18    BUILT-IN FUNCTIONS


(EQ <LATM1> <LATM2>) : SUBR
   COMPARE TWO LITERAL ATOMS, AND RETURNS TRUE JUST IN CASE
   THOSE TWO ARE THE SAME, OTHERWISE IT RETUNRS NIL.
   EX.
   :(EQ 'CAT 'NEKO)
     NIL
   :(EQ 'JUNE 'JUNE)
     T
   :(SETQ X 'APRIL)
     APRIL
   :(EQ X 'APRIL)
     T
   :(SETQ X '(JAPAN CHINA KOREA))
     (JAPAN CHINA KOREA)
   :(EQ X X)
     T
   :(EQ X '(JAPAN CHINA KOREA))
     NIL
   :(EQ 8080 8080)
     NIL
(EQUAL <S1> <S2>) : SUBR
   RETURNS TRUE IF THE TWO S-EXPRESSIONS ARE IDENTICAL.
   THE S-EXPRESSION MAY ALSO INCLUDE NUMERICAL ATOMS
   IN ITS LIST.
   EX.
   :(EQUAL 'INTEL 'MOTOROLA)
     NIL
   :(EQUAL '((A) B C) '((A) B C))
     T
   :(SETQ X '(I SAID I HATE YOU))
     (I SAID I HATE YOU)
   :(EQUAL X X)
     T



---                                                           ---

PAGE 19    BUILT-IN FUNCTIONS



   :(EQUAL X '(I SAID I HATE YOU))
     T
   :(EQUAL 8088 8088)
     T
(LAST <L>) : SUBR
   RETURNS THE LIST OF THE LAST ELEMENT OF LIST <L>.
   EX.
   :(LAST '(A B C D))
     (D)
(LENGTH <L>) : SUBR
   RETURNS A NUMBER OF THE TOP LEVEL ELEMENTS OF A LIST <L>.
   EX.
   :(LENGTH '(A ((B) C) D (E F]
     4
(LITERALP <S>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS A LITERAL ATOM.
   OTHERWISE RETURNS NIL.
   EX.
   :(LITERALP '(THIS MAY RETURN NIL))
     NIL
   :(LIST (LITERALP 'SEVEN) (LITERALP 7))
     (T NIL)
(MEMBER <S> <L>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS EQUAL TO A TOP-LEVEL
   ELEMENT OF THE LIST <L>. IF <S> IS AN ATOM, IT IS
   RECOMMENDED TO USE "MEMQ" INSTEAD OF "MEMBER".
   EX.
   :(MEMBER '(DET INDEF) '((NUMB SINGLE) (DET INDEF]
     T
   :(MEMBER 'DOG '(ALBATROSS DOG PENGUIN TIGER))
     T
(MEMQ <LATM> <L>) : SUBR
   RETURNS TRUE IF THE ATOM IS EQUAL TO A TOP-LEVEL ELEMENT OF
   THE LIST <L>.



---                                                           ---

PAGE 20    BUILT-IN FUNCTIONS



   EX.
   :(MEMQ 'SHI '(SA SHI SU SE SO))
     T
   :(MEMQ 'NI '(HA HI HU HE HO))
     NIL
(NATOM <S>) : SUBR
   RETUNRS TRUE IF THE S-EXPRESSION IS NOT AN ATOM. OTHERWISE
   RETUNRS NIL.
   EX.
   :(NATOM 'NOUN34)
     NIL
(NCONS <S>) : SUBR
   EQUALS TO (CONS <S> NIL). SLIGHTLY FASTER AND SAVE FREE
   STORAGE THAN USING (CONS <S> NIL).
   EX.
   :(NCONS 'ENCLOSE-ME)
     (ENCLOSE-ME)
(NEQ <LATM1> <LATM2>) : SUBR
   RETURNS TRUE IF THE TWO ATOMS ARE NOT THE SAME. OTHERWISE
   RETURNS NIL.
   EX.
   :(NEQ 'I 'YOU)
     T
(NOT <S>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS NIL OR NIL OTHERWISE.
   EQUIVALENT TO "NULL".
   EX.
   :(NOT T)
     NIL
   :(NOT (NOT T))
     T
(NULL <S>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS AN EMPTY LIST () OR NIL
   OTHERWISE. EQUIVALENT TO "NOT".





---                                                           ---

PAGE 21    BUILT-IN FUNCTIONS


   EX.
   :(NULL NIL)
     T
   :(NULL '(A B))
     NIL
(NUMBERP <S>) : SUBR
   RETURNS TRUE IF THE S-EXPRESSION IS A NUMERICAL ATOM.
   EX.
   :(NUMBERP 5)
     T
   :(NUMBERP 'VERB)
     NIL
(QUOTE '<S>) : KSUBR
   RETURNS S-EXPRESSION <S> ITSELF. EQUIVALENT TO THE FORM OF
   '<S>.
   EX.
   :(QUOTE DONT-EVALUATE)
     DONT-EVALUATE
   :'DONT-EVALUATE
     DONT-EVALUATE
   :'''DONT-EVALUATE
     (QUOTE (QUOTE DONT-EVALUATE))
(RPLACA <L> <S>) : SUBR
   CHAINGES CAR POINTER OF <L> TO <S> AND RETURNS THE VALUE
   <L>, SO THAT EFFECT IS GLOBAL AND LASTING. USE WITH CARE.
   
   EX.
   :(RPLACA '(HEAD BODY TAIL) 'NEW)
     (NEW BODY TAIL)
(RPLACD <L> <S>) : SUBR
                            
   CHAINGES CDR POINTER OF <L> TO <S> AND RETURNS THE VALUE
   <L>, SO THAT EFFECT IS GLOBAL AND LASTING. USE WITH CARE.
   EX.
   :(RPLACD '(HEAD BODY TAIL) '(NECK BUST STOMACH))
     (HEAD NECK BUST STOMACH)




---                                                           ---

PAGE 22    BUILT-IN FUNCTIONS


(SET <S1> <S2>) : SUBR
   RETURNS THE SECOND S-EXPRESSION <S2>. THE FIRST S-EXPRESSION
   <S1> MUST EVALUATE TO AN ATOM AND THAT ATOM'S VALUE BECOMES
   THE VALUE OF SECOND S-EXPRESSION <S2>. SEE "SETQ".
   EX.
   :(SET 'X '(ADJ NOUN))
     (ADJ NOUN)
   :(CONS 'DET X)
     (DET ADJ NOUN)
(SETQ '<LATM> <S>) : KSUBR
   RETURNS THE S-EXPRESSION <S> BUT HAS THE IMPORTANT SIDE
   EFFECT OF MAKING THE S-EXPRESSION <S> BE THE VALUE OF
   THE ATOM <LATM>. NOTE THAT THE ATOM IS NOT EVALUATED.
   EX.
   :(SETQ FRIENDS '(TOM DICK JANE SALLY))
     (TOM DICK JANE SALLY)
   :(MEMQ 'SALLY FRIENDS)
     T
 [2] LIST MANIPULATION FUNCTIONS
(ASSOC <LATM> <A>) : SUBR
   USES ITS FIRST ARGUMENT AS A KEY AND LOOKS FOR THAT KEY IN
   THE ALIST SUPPLIED AS THE SECOND ARGUMENT. THE VALUE IS THE
   ENTIRE ELEMENT WHOSE CAR MATCHES TO THE KEY. IF THE KEY IS
   NOT FOUND, NIL IS RETURNED.
   EX.
   :(ASSOC 'W '((U.LOGO) (V.BASIC) (W.LISP]
     (W.LISP)
   :(ASSOC 'X '((U.LOGO) (V.BASIC) (W.LISP]
     NIL
(ASSOCIATE <S> <A>) : SUBR
   USES ITS FIRST ARGUMENT AS A KEY AND LOOKS FOR THAT KEY IN
   THE ALIST SUPPLIED AS THE SECOND ARGUMENT. THE VALUE IS THE
   ENTIRE ELEMENT WHOSE CAR EQUALS TO THE KEY. IF THE KEY IS
   NOT FOUND, NIL IS RETURNED.
   
   EX.
   :(ASSOCIATE '(HIGH LOW) '(((LOW LOW).BAD) ((HIGH.LOW).GOOD)
                             ((HIGH HIGH).NOGOOD]
     ((HIGH LOW).GOOD)



---                                                           ---

PAGE 23    BUILT-IN FUNCTIONS



   :(ASSOCIATE 3 '((0.POINT) (1.LINE) (2.PLANE) (3.SOLID]
     (3.SOLID)
(APPEND <L1> <L2> ... <LN>) : LSUBR
   RETURNS A NEW SINGLE LIST WHOSE ELEMENTS ARE THE ELEMENTS OF
   ALL LISTS OF ARGUMENT STRUNG TOGETHER BY COPYING <L1> TO
   <LN-1> USING "CONS".
   EX.
   :(APPEND '(A B) '(C D))
     (A B C D)
   :(SETQ L '(A B C))
     (A B C)
   :(APPEND L L L)
     (A B C A B C A B C)
(COPY <S>) : SUBR
   RETURNS A NEW S-EXPRESSION <S>. BUT THE S-EXPRESSION IS
   FULLY RE-CONSTRUCTED USING "CONS".
   EX.
   :(COPY '(A (FULLY) COPIED LIST))
     (A (FULLY) COPIED LIST)
(DELETE <S> <L>) : SUBR
   ACTUALLY REMOVES INSTANCES OF THE S-EXPRESSION <S> WHICH
   APPEAR AS TOP ELEMENTS OF THE LIST <L>. PHYSICAL STRUCTURE
   OF THE LIST <L> IS ACTUALLY MODIFIED, SO THAT EFFECT IS
   GLOBAL AND LASTING. USE WITH CARE.
     DELETE = [LAMBDA (S L)
                (COND ((NULL L) NIL)
                      [(EQUAL (CAR L) S) (DELETE S (CDR L]
                      (T (RPLACD L (DELETE S (CDR L]
   EX.
   :(DELETE '(CAT MAN) '((SUPER MAN) (CAT MAN) (PAR MAN]
     ((SUPER MAN) (PAR MAN))
(DELQ <LATM> <L>) : SUBR
   ACTUALLY REMOVES INSTANCES OF THE ATOM <LATM> WHICH APPEAR
   AS TOP ELEMENTS OF THE LIST <L>. PHYSICAL STRUCTURE OF THE
   THE LIST <L> IS ACTUALLY MODIFIED, SO THAT EFFECT IS GLOBAL
   AND LASTING. USE WITH CARE.






---                                                           ---

PAGE 24    BUILT-IN FUNCTIONS


     DELQ = [LAMBDA (S L)
              (COND ((NULL L) NIL)
                    [(EQ (CAR L) S) (DELQ S (CDR L]
                    (T (RPLACD L (DELQ S (CDR L]
   EX.
   :(DELQ 'GOOD '(TOM HAS A GOOD FRIEND))
     (TOM HAS A FRIEND)
(DREVERSE <L>) : SUBR
   RETURNS A LIST WHOSE ELEMENTS ARE ACTUALLY REVERSED
   THE ORDER OF THE ELEMENTS IN THE GIVEN LIST <L>.
   NOTE THAT THE ARGUMENT LIST <L> DOES NOT EXIST IN THE MEMORY
   AFTER THE REVERSAL. CONTRAST WITH "REVERSE".
   THE PHYSICAL STRUCTURE OF THE LIST <L> IS ACTUALLY MODIFIED.
   USE WITH CARE.
     DREVERSE = [LAMBDA (L)
                  (COND ((NULL L) NIL)
                        (T (NCONC (DREVERSE (CDR L))
                                  (RPLACD L NIL]
   EX.
   :(DREVERSE '(A B))
     (B A)
(DSUBST <S1> <S2> <S3>) : SUBR
   RETURNS A S-EXPRESSION WHICH S-EXPRESSION <S1> HAS
   SUBSTITUTED FOR ALL OCCURENCES OF S-EXPRESSION <S2>
   IN S-EXPRESSION <S3>.
   THE PHYSICAL STRUCTURE OF THE <S3> IS ACTUALLY MODIFIED.
   USE WITH CARE.
     DSUBST = [LAMBDA (S1 S2 S3)
                (COND ((EQUAL S2 S3) S1)
                      ((ATOM S3) S3)
                      (T (RPLACA S3 (DSUBST S1 S2 (CAR S3))
                         (RPLACD S3 (DSUBST S1 S2 (CDR S3]
   EX.
   :(DSUBST 'NEW 'OLD '(OLD FRIENDS BECOME OLD))
     (NEW FRIENDS BECOME NEW)
(LIST <S1> <S2> ... <SN>) : LSUBR
   RETURNS A LIST OF N ELEMENTS CONSTRUCTED FROM
   THE N ARGUMENTS.
   EX.
   :(LIST 'HEAD 'NECK '(BODY) 'TAIL)
     (HAED NECK (BODY) TAIL)






---                                                           ---

PAGE 25    BUILT-IN FUNCTIONS


   :(LIST 'PLUS 2 3 4 5)
     (PLUS 2 3 4 5)
(NCONC <L1> <L2> ... <LN>) : LSUBR
   RETURNS A SINGLE LIST WHOSE ELEMENTS ARE THE ELEMENTS OF ALL
   LISTS OF ARGUMENT STRUNG TOGETHER BY REPLACING THE POINTER
   OF THE LAST ELEMENT CDR OF <L1> TO <L2>, <L2> TO <L3> ...
   <LN-1> TO <LN>. "NCONC" IS LIKE "APPEND", AND IT IS MORE
   EFFICIENT BUT ALSO MEANS THAT THE EFFECTS ARE GLOBAL AND
   LASTING. USE WITH CARE.
   EX.
   :(NCONC '(A B C) '(D E) '(F (G) H I))
     (A B C D E F (G) H I)
(NCONC1 <L> <S>) : SUBR
   ADDS THE S-EXPRESION <S> AS THE LAST ELEMENT OF THE LIST
   <L> AND RETURNS THE LIST. THE EFFECTS ARE GLOBAL AND
   LASTING. USE WITH CARE. THIS IS THE SAME AS
   (NCONC <L> (NCONS <S>)).
   EX.
   :(NCONC1 '(THIS IS THE) 'LAST)
      (THIS IS THE LAST)
(PAIR <L1> <L2> [<A>]) : LSUBR
   RETURNS A ASSOCIATION LIST MADE FROM THE ELEMENTS OF
   THE LISTS <L1> <L2> AND APPEND TO ASSOCIATION LIST <A> IF
   EXISTS. AN ERROR IS OCCURED IF THE LENGTH OF THE LIST <L1>
   AND <L2> ARE DIFFERENT.
   EX.
   :(PAIR '(A B C D) '(ONE TWO THREE FOUR))
     ((D.FOUR) (C.THREE) (B.TWO) (A.ONE))
   :(PAIR '(X Y) '(HAPPY SORRY) '((Z.SAD) (U.PLEASING]
     ((Y.SORRY) (X.HAPPY) (Z.SAD) (U.PLEASING))
(POP '<LATM>) : KSUBR
   SETS ATOM <LATM> TO THE CDR OF LIST ITSELF AND RETURS THE
   CAR OF THE OLD ATOM'S VALUE.
   EX.
   :(SETQ STACK '(A B C))
     (A B C)
   :(POP STACK)
     A




---                                                           ---

PAGE 26    BUILT-IN FUNCTIONS


   :STACK
     (B C)
(PUSH <E> '<LATM>) : KSUBR
   SETS ATOM <LATM> TO THE LIST WHICH FIRST ELEMENT IS THE <E>
   AND THE REST IS THE LIST WHICH IS SETED TO THE <LATM>
   BEFORE. RETURNS THE VALUE OF <E>.
   EX.
   :(SETQ STACK '(A B))
     (A B)
   :(PUSH 'ADDED STACK)
     ADDED
   :STACK
     (ADDED A B)
(REMOVE <S> <L>) : SUBR
   MAKES A NEW LIST OF REMOVED INSTANCES OF THE S-EXPRESSION
   <S> WHICH APPEAR AS TOP ELEMENTS OF THE LIST <L>. PHYSICAL
   STRUCTURE OF THE LIST <L> IS NOT ACTUALLY MODIFIED.
     REMOVE = [LAMBDA (S L)
                (COND ((NULL L) NIL)
                      [(EQUAL (CAR L) S) (REMOVE S (CDR L]
                      (T (CONS (CAR L) (REMOVE S (CDR L]
   EX.
   :(REMOVE 'APPLE '(I HAVE APPLE TREES AND APPLE COMPUTERS))
     (I HAVE TREES AND COMPUTERS)
(REVERSE <L>) : SUBR
   RETURNS A NEW LIST WHOSE ELEMENTS ARE REVERSED THE ORDER OF
   THE ELEMENTS IN THE GIVEN LIST <L>.
   NOTE THAT REVERSAL TAKES PLACE ONLY AT THE TOP LEVEL.
   PHYSICAL STRUCTURE OF THE LIST <L> IS NOT ACTUALLY MODIFIED.
     REVERSE = [LAMBDA (L)
                 (COND ((NULL L) NIL)
                       (T (NCONC (REVERSE (CDR L))
                                 (NCONS (CAR L]
   EX.
   :(REVERSE '((A B) (C D) (E F]
     ((E F) (C D) (A B))
(SUBST <S1> <S2> <S3>) : SUBR
   RETURNS A NEW S-EXPRESSION WHICH S-EXPRESSION <S1> HAS
   SUBSTITUTED FOR ALL OCCURENCES OF S-EXPRESSION <S2>



---                                                           ---

PAGE 27    BUILT-IN FUNCTIONS


   IN S-EXPRESSION <S3>.
     SUBST = [LAMBDA (S1 S2 S3)
               (COND ((EQUAL S2 S3) S1)
                     ((ATOM S3) S3)
                     (T (CONS (SUBST S1 S2 (CAR S3))
                              (SUBST S1 S2 (CDR S3]
   EX.
   :(SUBST '(GOOD) 'BAD '(I AM A BAD BOY AND A BAD STUDENT))
     (I AM A (GOOD) BOY AND A (GOOD) STUDENT)
   :(SUBST 'NEW '(VERY OLD)
           '((VERY (VERY OLD)) FRIENDS BECOME (VERY OLD]
     ((VERY NEW) FRIENDS BECOME NEW)
 [3] EVALUATION SEQUENCE CONTROL FUNCTIONS
(AND <E1> <E2> ... <EN>) : FSUBR
   RETURNS NIL IF ANY OF THE S-EXPRESSIONS ARE NIL AND RETURNS
   <EN> OTHERWISE. IT DOES NOT EVALUATE ANY OF THE ARGUMENTS
   BEYOND THE FIRST NIL VALUE ENCOUNTERED.
   EX.
   :(AND T T T)
     T
   :(AND T NIL (PRINT 'NOT-EVALUATE) T)
     NIL
   :(AND T (CDR '(A B C]
     (B C)
(APPLY <FN> <L>) : SUBR
   OPERATES ON THE ARGUMENTS OF ARGUMENTS LIST <L> WITH
   THE FUNCTION <FN> GIVEN AS IF THAT FUNCTION APPEARED AS
   THE FIRST ELEMENT IN THE LIST. BUT FEXPR,LEXPR AND FSUBR ARE
   NOT PERMITTED AS THE FUNCTION <FN>.
   EX.
   :(SETQ L '(2 3 4))
     (2 3 4)
   :(APPLY 'PLUS L)
     9
   :(SETQ AND2 '(LAMBDA (X Y) (AND X Y]
     (LAMBDA (X Y) (AND X Y))





---                                                           ---

PAGE 28    BUILT-IN FUNCTIONS


   :(APPLY (SUBST 'OR 'AND AND2) '(T NIL]
     T
(CASE <S>
      ('<S1> <E11> ... <E1M>)
      ('<S2> <E21> ... <E2M>)
         ...
      ('<SN> <EN1> ... <ENM>)
      <ELSE>)                 : FSUBR
   USES ITS FIRST ARGUMENT <S> AS A KEY AND LOOKS FOR THAT KEY
   IN THE FIRST ELEMENT OF THE LISTS SUPPLIED AS THE FOLLOWING
   ARGUMENTS. IF THEY ARE EQUAL OF <SX>, EVALUATION BEGINS FROM
   THE NEXT ELEMENT TO THE LAST ONE <EXM> IN ORDER. THE VALUE
   OF "CASE" IS <EXM> AFTER ALL. UNFORTUNATELY THE KEY IS NOT
   FOUND, THE LAST ELEMENT OF ARGUMENT <ELSE> EVALUATED IS
   RETURNED AS THE RESULT OF "CASE".
   EX.
   :(CASE 'CAT
   :  (DOG (PRINT 'NOT-OCCURED))
   :  (MOUSE (SETQ X 'NOT-OCCURED) 'NOT-RETURNED)
   :  (CAT (SETQ X 'SIDE-EFFECT) (PRINT 'HIT!) 'RETURNED)
   :  (NOT-TESTED 'NOT-RETURNED)
   : 'ELSE-RETURNED-BUT-NOT-RETURNED)
   HIT!
     
     RETURNED
   :X
     SIDE-EFFECT
(CATCH '<LATM> <E1> ... <EN>) : FSUBR
   EVALUATES ITS SECOND ARGUMENT <E1> TO THE LAST ONE <EN> IN
   ORDER IN THE CURRENT CONTEXT, AND RETURNS THAT LAST <EN>'S
   VALUE, EXCEPT THAT IF DURING THAT EVALUATION, A "THROW" WITH
   THE SAME LABEL <LATM> IS EVALUATED, THEN THE VALUE OF
   "THROW"S IS RETURNED IMMEDIATELY AS THE VALUE OF THE
   CORRESPONDING "CATCH" AND ALSO PENDING ARGUMENTS ARE NOT
   EVALUATED.
   EX.
   :(DEF (LIST-ADD1 L)
   :  (CATCH NEGATIVE
   :         (MAPCAR L
   :                 '(LAMBDA (X)
   :                    (COND [(MINUSP X) (THROW NEGATIVE X]
   :                          (T (ADD1 X]
     LIST-ADD1
   :(LIST-ADD1 '(3 4 2 5))
     (4 5 3 6)





---                                                           ---

PAGE 29    BUILT-IN FUNCTIONS


   :(LIST-ADD1 '(3 4 -6 2))
     -6
(COND (<P1> [<E11> ... <E1M>] )
      (<P2> [<E21> ... <E2M>] )
        ...
      (<PN> [(EN1) ... <ENM>] )) : FSUBR
   
   ONE OF THE EVALUATED LIST ELEMENT <EXM> WILL BE THE VALUE OF
   THE ENTIRE "COND". THE IDEA IS TO CRUISE THROUGH THE LIST
   LOOKING ONLY AT THE FIRST ELEMENTS <PX> UNTIL ONE IS FOUND
   WHOSE VALUE IS "NOT" NIL. THEN EVERYTHING ELSE IN
   THE WINNING LIST IS EVALUATED AND THE LAST THING <EXM>
   EVALUATED IS RETURNED AS THE VALUE OF "COND".
   THERE ARE TWO SPECIAL CASES:
     * IF NO WINNING LIST IS FOUND, "COND" RETURNS "NIL".
     * IF THE WINNING LIST CONSISTS OF ONLY ONE ELEMENT, THEN
       THE VALUE OF THAT ELEMENT ITSELF IS RETURNED.
       SAID ANOTHER WAY, THE TEST <PX> AND RESULT <EXM>
       ELEMENTS MAY BE THE SAME.
   EX.
   :(COND ((EQ 'A 'B) (SETQ X 'NOT-OCCURED) 'NOT-RETURNED)
   :      ((NULL NIL) (SETQ X 'SIDE-EFFECT) 'RETURNED)
   :      ('NOT-TESTED 'NOT-RETURNED]
     RETURNED
   :X
     SIDE-EFFECT
(DO (('<VAR1> <EINIT1> <ESTEP1>)
     ('<VAR2> <EINIT2> <ESTEP2>)
        ...
     ('<VARN> <EINITN> <ESTEPN>))
     (<P> <EXIT>)
     <E1> <E2> ... <EN>)          : MACRO
   EACH VARIABLE <VARX> IS INITIALIZED TO ITS VALUE OF <EINITX>
   SIMULTANEOUSLY. EACH <ESTEPX> IS A FORM WHICH WILL BE
   EVALUATED SIMULTANEOUSLY UPON PROPER COMPLETION OF EACH
   CYCLE OF THE "DO". THE "DO" CYCLE BEGINS FROM THE EVALUATION
   OF <P>, AND ON GIVING VALUE NON-NIL THE LOOP WILL TERMINATE,
   RETURNING THE VALUE OF <EXIT> AS THE RESULT OF THE "DO". IF
   <P> GIVES NIL THEN <E1> TO <EN> ARE EVALUATED IN ORDER.
   AFTER THE LAST ONE <EN> IS EVALUATED, THE <ESTEPX> FORMS ARE
   EVALUATED AND ASSIGNED TO THE VARIABLE <VARX>'S, AND ANOTHER
   CYCLE OF THE "DO" IS BEGUN.








---                                                           ---

PAGE 30    BUILT-IN FUNCTIONS


   EX.
   :(DO ([Y NIL (CONS (CAR X) Y]
   :     [X '(A B C D) (CDR X])
   :    ((NULL X) Y)
   :    (PRINT X)
   :    (PRINT Y)
   :    (TERPRI]
   (A B C D)
   NIL
   (B C D)
   (A)
   (C D)
   (B A)
   (D)
   (C B A)
     (D C B A)
(EVAL <E>) : SUBR
   RETURNS THE VALUE OF THE EVALUATED S-EXPRESSION <E>.
   THIS MEANS THAT EVALUATION OF <E> OCCURS TWICE.
   EX.
   :(SETQ FORM '(PLUS 2 3 4))
     (PLUS 2 3 4)
   :(EVAL (APPEND FORM '(5 6]
     20
(EVLIS <L>) : SUBR
   RETURNS A NEW LIST WHOSE ELEMENTS ARE EVALUATED OF
   THE AREGUMENT LIST <L>.
   EX.
   :(EVLIS '((OR T NIL T) (AND T T) (NOT T) (TIMES 2 3]
     (T T NIL 6)
(EXIT <E>) : SUBR
   EXITS FROM THE RECENT LEVEL OF "ITERATE" LOOP.
   THE VALUE OF THE "ITERATE" IS EQUAL TO THE VALUE OF <E>.
   SEE "ITERATE".
(FUNCALL <FN> <E1> <E2> ... <EN>) : LSUBR
   OPERATES ON THE ARGUMENTS OF ARGUMENTS <E1> ... <EN> WITH
   THE FUNCTION <FN> GIVEN AS IF THAT FUNCTION APPEARED AS
   THE FIRST ELEMENT IN THE LIST.






---                                                           ---

PAGE 31    BUILT-IN FUNCTIONS


   EX.
   :(FUNCALL 'PLUS 2 3 (ADD1 3) 5)
     14
(GO '<LATM>) : KSUBR
   EVALUATION CONTROL IS TRANSFERRED TO THE LABEL ATOM <LATM>
   WITHIN RECENT LEVEL OF "PROG". SEE "PROG".
(ITERATE <E1> ... <EN>) : FSUBR
   THE ARGUMENTS TO A "ITERATE" ARE MOSTLY S-EXPRESSIONS WHICH
   ARE EVALUATED ONE AFTER ANOTHER. IF CONTROL RUNS OFF THE END
   OF A "ITERATE", THEN THE CONTROL IS RETURNED TO <E1>.
   WHENEVER THE FUNCTION "EXIT" IS REACHED WHEN EVALUATING
   A "ITERATE", THE "ITERATE" IS TERMINATED.
   THE VALUE OF THE TERMINATED "ITERATE" IS THE VALUE OF THE
   ARGUMENT TO THE "EXIT" THAT STOPPED THE "ITERATE".
   EX.
   :(SETQ X '(A B C))
     (A B C)
   :(ITERATE (PRINT X)
             (AND (NULL X) (EXIT 'END))
             (SETQ X (CDR X]
   (A B C)
   (B C)
   (C)
   NIL
     END
(LET ('<VAR1> <E1> '<VAR2> <E2> ... '<VARN> <EN>)
     <E1> <E2> ... <EM>)                          : MACRO
   THE ARGUMENTS TO A "LET" ARE MOSTLY S-EXPRESSIONS WHICH ARE
   EVALUATED ONE AFTER ANOTHER. IF CONTROL RUNS OFF THE END OF
   A "LET", THEN THE VALUE OF <EM> IS RETURNED, JUST AS WITH
   "PROGN".
   THE FIRST POSITION IN A "LET" IS ALWAYS OCCUPIED BY A LIST
   OF VARIABLES AND INITTIAL VALUE WHICH ARE ALL BOUND ON
   ENTERING THE "LET" AND RESTORED TO OLD VALUES ON EXIT.
   EX.
   :(SETQ GLOBAL 'TOMATO)
     TOMATO
   :(LET (GLOBAL 'ONE VAR 'TWO)
      (PRINT GLOBAL) (PRINT VAR))
   ONE
   TWO
     TWO



---                                                           ---

PAGE 32    BUILT-IN FUNCTIONS


   
   :GLOBAL
     TOMATO
(LOOP [(INITIAL '<VAR1> <E1> ... '<VARN> <EN>)]
      [(WHILE <P1>)]
      [(DO <E1> ... <EN>)]
      [(NEXT '<VAR1> <E1> ... '<VARN> <EN>)]
      [(UNTIL <P2>)]
      [(RESULT <E>)] )                          : MACRO
   LOOP CONSTRUCTS ITERATIVE LOOP.
   LOOP TAKES AN ARBITRARY NUMBER (LESS THAN 7) OF ARGUMENTS,
   EACH OF WHICH IS A LIST OF A KEYWORD AND ARGUMENTS. THE
   KEYWORDS ARE "INITIAL","WHILE","DO","NEXT","UNTIL" AND
   "RESULT". THE MEANING OF THESE FORMS ARE:
   INITIAL: INITIALIZE EACH <VAR> TO <E>, THE EXPRESSION
            FOLLOWING. IN DEFAULT OF THIS FORM, NO INITIALIZE
            IS OCCURED.
   WHILE  : STOP THE LOOP ON ENTERING IF THE <P1> EVALUATES TO
            FALSE. IN DEFAULT, THE VALUE OF <P1> IS CONSIDERED
            TO BE TRUE.
   DO     : EVALUATE THE EXPRESSIONS FROM <E1> TO <EN>. IN
            DEFAULT, NOTHING IS DONE.
   NEXT   : RESET EACH <VAR> TO <E>, THE EXPRESSION FOLLOWING,
            AFTER THE "DO" ARGUMENTS ARE EVALUATED. IN DEFAULT,
            NO RESETING IS OCCURED.
   UNTIL  : STOP THE LOOP AT THE END OF IT IF THE EXPRESSION
            <P2> EVAUATES TO TRUE (NON-NIL). IN DEFAULT, THE
            VALUE OF THE <P2> IS CONSIDERED TO BE NIL.
   RESULT : RETURN THE VALUE OF THE EXPRESSION <E> WHEN THE
            LOOP STOPS. IN DEFAULT, THE VALUE OF <E> IS NIL.
   NOTE THAT THE ORDER OF THESE KEYWORD FORMS DO NOT EFFECT THE
   CONSTRUCTION OF THE LOOP.
   EX.
   :(DEF (SUM N)
      (LOOP (RESULT S)
            (INITIAL S 0)
            (WHILE (GREATERP N 0))
            (NEXT S (PLUS N S)
                  N (SUB1 N))
            (DO (PRIN1 S) (PRIN1 '" "]
     SUM
   :(SUM 10)
   0 10 19 27 34 40 45 49 52 54 55
     55





---                                                           ---

PAGE 33    BUILT-IN FUNCTIONS


(OR <E1> <E2> ... <EN>) : FSUBR
   RETURNS THE FIRST NON-"NIL" S-EXPRESSION. IF NONE ARE
   NON-"NIL" THE NIL IS RETURNED. NO ARGUMENTS ARE EVALUATED
   BEYOND THE FIRST WINNER.
   EX.
   :(OR T NIL T T)
     T
   :(OR NIL NIL 'HERE (PRINT 'NOT-EVALUATE))
     HERE
(PROG '(<VAR1> ... <VARN>)
       <E1> <E2> ... <EM>) : FSUBR
   
   THE ARGUMENTS TO A "PROG" ARE MOSTLY S-EXPRESSIONS WHICH ARE
   EVALUATED ONE AFTER ANOTHER. IF CONTROL RUNS OFF THE END OF
   A "PROG", THEN THE VALUE OF <EM> IS RETURNED, JUST AS WITH
   "PROGN".
   THE FIRST POSITION IN A "PROG" IS ALWAYS OCCUPIED BY A LIST
   OF VARIABLES WHICH ARE ALL BOUND ON ENTERING THE "PROG" AND
   RESTORED TO OLD VALUES ON EXIT. EACH IS GIVEN AN INITIAL
   VALUE OF "NIL" AUTOMATICALLY.
   WHENEVER THE FUNCTION "RETURN" IS REACHED WHEN EVALUATING
   A "PROG", THE "PROG" IS TERMINATED IMMEDIATELY. THE VALUE OF
   THE TERMINATED "PROG" IS THE VALUE OF THE ARGUMENT TO THE
   "RETURN" THAT STOPPED THE "PROG".
   ANY ATOM APPEARING AS AN ARGUMENT <EX> TO PROG IS CONSIDERED
   TO BE A POSITION MARKER LABEL. THESE ATOMS MARK PLACES TO
   WHICH CONTROL IS TRANSFERRED BY "GO" FUNCTIONS. (GO <LATM>)
   TRANSFERS CONTROL TO A MARKER NAMED <LATM>.
   "PROG"S CAN BE NESTED, LIKE OTHER FUNCTIONS, BUT IT IS ONLY
   POSSIBLE TO GO TO A LABEL THAT IS THE SAME OR HIGHER "PROG"
   AS THE "GO".
   EX.
   :(PROG (X)
   :      (SETQ X '(ONE TWO THREE FOUR))
   : LOOP (PRINT (CAR X))
   :      (COND ((SETQ X (CDR X)) (GO LOOP))
   :            (T (RETURN 'END]
   ONE
   TWO
   THREE
   FOUR
     END








---                                                           ---

PAGE 34    BUILT-IN FUNCTIONS


(PROGN <E1> <E2> ... <EN>) : FSUBR
   RETURNS A VALUE OF <EN> AFTER THE EVALUATION OF PREVIOUS
   ARGUMENTS.
   EX.
   :(PROGN (SETQ X NIL)
   :       (SETQ X (CONS 'A X))
   :       (SETQ X (CONS 'B X))
   :       (SETQ X (CONS 'C X))
   :       X)
     (C B A)
(PROG1 <E1> <E2> ... <EN>) : FSUBR
   RETURNS A VALUE OF <E1>. BUT THE FOLLOWING ARGUMETS ARE
   EVALUATED IN ORDER.
   EX.
   :(PROG1 (TIMES 2 4) (SETQ Y 'APPLEPIE))
     8
   :Y
     APPLEPIE
(RETURN <E>) : SUBR
   CAUSES THE VALUE OF <E> TO BE RETURNED IMMEDIATELY
   AS THE VALUE OF THE "PROG" IT APPEARS IN. SEE "PROG".
(THROW '<LATM> <E1> ... <EN>) : FSUBR
   EVALUATES ITS SECOND ARGUMENT <E1> TO THE LAST ONE <EN> IN
   ORDER IN THE CURRENT CONTEXT, AND RETURNS THE VALUE OF THE
   LAST ONE <EN> AS THE VALUE OF "CATCH" HOLDING THE SAME
   LABEL <LATM> OF THE HIGHER CONTEXT LEVEL. SEE "CATCH" FOR
   EXAMPLES.
 [4] PROPERTY LIST MANIPULATION FUNCTIONS
   EACH LITERAL ATOM CAN HOLD A PROPERTY LIST MADE OF SOME
   PAIRS OF PROPERTY NAME AND ITS VALUE. THIS LIST IS LIKE AS,
     (<PROP1> <VALUE1> <PROP2> <VALUE2) ... <PROPN> <VALUEN>)
   NOTE A VARIABLE ATOM, A FUNCTION NAME OR A LABEL ATOM FOR
   "PROG" CANNOT HAVE A PROPERTY LIST WITH IN THE SAME LEVEL.
(ADDPROP <LATM> <PROP> <S>) : SUBR
   ADDS <S> AS A ELEMENT OF THE LIST WHICH IS ATTACHED UNDER
   THE PROPERTY NAME <PROP>. THIS IS NEARLY SAME AS
   (PUTPROP <LATM> <PROP> (CONS <S> (GET <LATM> <PROP>)))
   EXCEPT THAT NOTHING IS CHANGED IF <S> IS ALREADY AN ELEMENT
   OF THE LIST.





---                                                           ---

PAGE 35    BUILT-IN FUNCTIONS


   EX.
   :(ADDPROP 'TOM 'FRIENDS 'JERRY)
     TOM
   :(ADDPROP 'TOM 'FRIENDS 'JERRY)
     TOM
   :(ADDPROP 'TOM 'FRIENDS 'GEORGE)
     TOM
   :TOM
     (FRIENDS (GEORGE JERRY))
(GET <LATM> <PROP>) : SUBR
   RETURNS THE VALUE OF THE NAMED PROPERTY <PROP> ASSOCIATED
   WITH THE ATOM <LATM>. IF IT IS NOT FOUND, THE VALUE IS NIL.
   EX.
   :(SETQ + '(INFIX (50 50) FUNC PLUS A-KIND-OF OPERATOR]
     (INFIX (50 50) FUNC PLUS A-KIND-OF OPERATOR)
   :(GET '+ 'INFIX)
     (50 50)
   :(APPLY (GET '+ 'FUNC) '(5 6))
     11
(GETL <LATM> <L>) : SUBR
   FINDS THE FIRST PROPERTY IN THE PROPERTY LIST OF <LATM>
   THAT IS A MEMBER OF LIST <L> AND RETURNS THE PROPERTY LIST
   FROM THAT POINT ON. IF NONE IS FOUND, NIL IS RETUNRED.
   EX. --CONTINUED FROM THE EX. OF "GET"--
   :(GETL '+ '(FUNC OP))
     (FUNC PLUS A-KIND-OF OPERATOR)
   :(GETL '+ '(FUNC INFIX))
     (INFIX (50 50) FUNC PLUS A-KIND-OF OPERATOR)
(PUTPROP <LATM> <PROP> <VALUE>) : SUBR
   INSTALLS THE S-EXPRESSION <S> AS THE GIVEN PROPERTY <PROP>
   OF THE ATOM <LATM>. AND RETURNS THE VALUE OF <VALUE>.
   EX. --CONTINUED FROM THE EX. OF "GET"--
   :(PUTPROP '+ 'PREFIX '(0 100))
     (0 100)




---                                                           ---

PAGE 36    BUILT-IN FUNCTIONS


   :+
     (PREFIX (50 50) FUNC PLUS A-KIND-OF OPERATOR PREFIX (0 100
   ))
   :(PUTPROP '+ 'PREFIX '(49 50))
     (49 50)
   :+
     (PREFIX (49 50) FUNC PLUS A-KIND-OF OPERATOR PREFIX (0 100
   ))
(REMPROP <LATM> <PROP>) : SUBR
   REMOVES THE PROPERTY NAME <PROP> AND ITS VALUE FROM THE
   ATOM <LATM>. AND RETURNS THE VALUE OF <LATM>.
   EX. --CONTINUED FROM THE EX. OF "PUTPROP"--
   :(REMPROP '+ 'INFIX)
     +
   :+
     (FUNC PLUS A-KIND-OF OPERATOR PREFIX (0 100))
 [5] MAP FUNCTIONS
(EVERY <FN> <L1> <L2> ... <LN>) : LSUBR
   "EVERY" APPLIES THE FUNCTION <FN> TO THE "CAR" OF SUCCESSIVE
   "CDR"S OF LIST <L>S, AND RETURNS NIL, AS SOON AS ONE OF
   THESE APPLICATIONS RETURN NIL. IF ALL APPLICATIONS BUT LAST
   ONE RETURN A NON-NIL VALUE, THEN THE LAST ONE IS RETURNED.
   EX.
   :(EVERY 'EQ '(I AM A CAT) '(I AM A CAT))
     T
   :(EVERY '(LAMBDA (X) X) '(FIRST END))
     END
(FOR (<VAR1> IN <L1>) ... (<VARN> IN <LN>)
     [(WHEN <E1>)]
     (DO,SAVE,FILTER,SPLICE,RETURN,ALL <E2>)) : MACRO
   "FOR" MACRO EXPANDS ARGUMENTS INTO AN APPROPRIATE MAPPING
   FUNCTION WITH THE VARIABLES <VAR> AS THE LAMBDA VARIABLES
   AND THE LISTS <L> AS ARGUMENTS. THE LAMBDA BODY IS SUCH THAT
   WHENEVER <E1> EVALUATES TO NON-NIL FOR SOME SETTING OF THE
   LAMBDA VARIABLES, THEN <E2> IS EVALUATED.
   THE MEANING OF THE KEYWORDS ARE FOLLOWING.
     WHEN   : IF THE ARGUMENT <E1> IS NO-NIL, ANOTHER KEYWORD
              CLAUSE IS EXCUTED. THIS CLAUSE IS OPTIONAL.



---                                                           ---

PAGE 37    BUILT-IN FUNCTIONS


              IF ABSENT, <E1> IS ASSUMED TO BE TRUE.
     DO     : MEANS THAT NO RESULTS ARE SAVED. BUT EXECUTES THE
              ARGUMENT.
     SAVE   : MEANS THAT A LIST OF ALL RESULTS IS RETURNED AS
              "FOR".
     FILTER : MEANS THAT A LIST OF ALL NON-NIL RESULTS IS
              RETURNED.
     SPLICE : MEANS THAT THE LIST FORMED BY APPLYING "NCONC" TO
              ALL THE RESULTS IS RETURNED.
     RETURN : MEANS THAT THE VALUE OF <E2> IS RETURNED, AS SOON
              AS ONE OF THE EVALUATIONS RETURNS NON-NIL VALUE.
              OTHERWISE RETURNS NIL.
     ALL    : MEANS THAT NIL IS RETURNED, AS SOON AS ONE OF THE
              EVALUATIONS RETURNS NIL. OTHERWISE RETURNS THE
              LAST EVALUATION.
   EX.
   :(FOR (X IN '(A B C)) (DO (PRINT X]
   A
   B
   C
     NIL
   :(FOR (X IN '(1 2 3)) (SAVE (LIST (ADD1 X]
     ((2) (3) (4))
   :(FOR (X IN '(1 2 3)) (SPLICE (LIST (ADD1 X]
     (2 3 4)
   :(DEF (NEKOP X)
      (AND (EQ (GET X 'TYPE) NEKO) X]
     NEKOP
   :(PUTRPOP 'TOM 'TYPE 'NEKO) (PUTPROP 'AHO 'TYPE 'NEKO)
     TOM
     AHO
   :(FOR (X IN '(AHO JERRY TOM FOO))
      (FILTER (NEKOP X]
     (AHO TOM)
   :(FOR (X IN '(AHO JERRY TOM FOO))
      (WHEN (NEKOP X)) (DO (PRINT X]
   AHO
   TOM
     NIL



---                                                           ---

PAGE 38    BUILT-IN FUNCTIONS



   :(FOR (X IN '(AHO JERRY TOM FOO))
      [WHEN (EQ (GET X 'TYPE) 'NEKO]
      (SAVE X]
     (AHO TOM)
   :(FOR (X IN '(AHO JERRY TOM FOO))
         (Y IN '(1 2 3 4))
      (WHEN (NEKOP X))
      (SAVE (LIST X Y]
     ((AHO 1) (TOM 3))
   :(FOR (X IN '(10 8 4 0 2))
      [WHEN (NOT (ZEROP X]
      (SPLICE (LIST X (QUOTIENT X 2]
     (10 5 8 4 2 1)
   :(FOR (X IN '(FOO TOM JERRY AHO))
      (WHEN (NEKOP X))
      (RETURN X]
     TOM
   :(FOR (X IN '(AHO TOM))
      (ALL (NEKOP X)))
     TOM
   :(FOR (X IN '(TOM FOO AHO))
      (ALL (NEKOP X)))
     NIL
(MAP <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAP" APPLIES THE FUNCTION <FN> TO LIST <L>S AND SUCCESSIVE
   "CDR"S OF LIST <L>S. THE RESULT IS ALWAYS NIL. NOTE "MAP" IS
   USED ONLY FOR THE SIDE EFFECTION.
   EX.
   :(MAP 'PRINT '(A B C D))
   (A B C D)
   (B C D)
   (C D)
   (D)
     NIL
(MAPC <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAPC" IS SIMILAR TO "MAP" EXCEPT THAT THE "MAPC" APPLIES
   FUCTION <FN> TO THE "CAR" OF SUCCESSIVE "CDR"S OF LIST <L>S.
   EX.
   :(MAPC '(X Y Z) '(LAMBDA (VAR) (SET VAR 'INIT]
     NIL



---                                                           ---

PAGE 39    BUILT-IN FUNCTIONS



   :(LIST X Y Z)
     (INIT INIT INIT)
(MAPCAN <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAPCAN" IS SIMILAR TO "MAPC" EXCEPT THAT THE RESULT OF
   "MAPCAN" IS A "NCONC"ED LIST OF ALL THE RESULT OF APPLYING
   FUNCTION <FN> TO THE "CAR" OF SUCCESSIVE "CDR"S OF
   LIST <L>S.
   EX.
   :(DEF (NOT-Z X) (AND (NEQ X 'Z) (NCONS X]
     NOT-Z
   :(MAPCAN 'NOT-Z '(A B Z C Z D))
     (A B C D)
(MAPCAR <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAPCAR" IS SIMILAR TO "MAPC" EXCEPT THAT THE RESULT OF
   "MAPCAR" IS A LIST OF ALL THE RESULT OF APPLYING FUNCTION
   <FN> TO THE "CAR" OF SUCCESSIVE "CDR"S OF LIST <L>S.
   EX.
   :(MAPCAR 'ADD1 '(1 2 3))
     (2 3 4)
   :(MAPCAR 'EQ '(A S C S W) '(R S S C W))
     (NIL T NIL NIL T)
(MAPCON <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAPCON" IS SIMILAR TO "MAP" EXCEPT THAT THE RESULT OF
   "MAPCON" IS A LIST FORMED BY CONCATENATING ALL RESULTS OF
   APPLYING FUNCTION <FN> TO SUCCESSIVE "CDR"S OF LIST <L>S.
   THE RESULT OF EACH APPLICATION OF <FN> MUST THEREFORE ITSELF
   BE A LIST. NOTE THAT THE LIST STRUCTURE IS MODIFIED
   PHYSICALLY.
   EX.
   :(MAPCON 'COPY '(A B C D))
     (A B C D B C D C D D)
(MAPLIST <FN> <L1> <L2> ... <LN>) : LSUBR
   "MAPLIST" IS SIMILAR TO "MAP" EXCEPT THAT THE RESULT OF
   "MAPLIST" IS A LIST OF ALL RESULTS OF APPLYING FUNCTION <FN>
   TO SUCCESSIVE "CDR"S OF LIST <L>S.
   EX.
   :(MAPLIST '(LAMBDA (X) X) '(A B C D]
     ((A B C D) (B C D) (C D) (D))



---                                                           ---

PAGE 40    BUILT-IN FUNCTIONS



(SOME <FN> <L1> <L2> ... <LN>) : LSUBR
   "SOME" APPLIES THE FUNCTION <FN> TO THE "CAR" OF SUCCESSIVE
   "CDR"S OF LIST <L>S, UNTIL ONE OF THEM RETURNS A NON-NIL
   VALUE. IF THIS HAPPENS, THEN "SOME" RETURNS THE RESULT OF
   THE APPLICATION.
   EX.
   :(DEF (MANP X) (AND (EQ (GET X 'TYPE) 'MAN) X]
     MANP
   :(PUTPROP 'TOM 'TYPE 'MAN)
     TOM
     
   :(SOME 'MANP '(MARRY TOM JERRY))
     TOM
   :(SOME 'MANP '(MARY JERRY))
     NIL
(SUBSET <FN> <L1> <L2> ... <LN>) : LSUBR
   "SUBSET" APPLIES THE FUNCTION <FN> TO THE "CAR" OF
   SUCCESIVE "CDR"S OF LIST <L>S, AND RETURNS A LIST OF THE
   NON-NIL RESULTS VALUE.
   EX. --CONTINUE FROM THE EXAMPLE OF "SOME"--
   :(PUTPROP 'JOHN 'TYPE 'MAN)
     JOHN
   :(SUBSET 'MANP '(JERRY TOM MARY JOHN))
     (TOM JOHN)
 [6] ARITHMETIC FUNCTIONS AND PREDICATES
(ABS <N>) : SUBR
   RETURNS THE ABSOLUTE VALUE OF NUMBER <N>.
   EX.
   :(ABS -5)
     5
   :(ABS 5)
     5
(ADD1 <N>) : SUBR
   RETURNS THE NUMBER <N> PLUS ONE.





---                                                           ---

PAGE 41    BUILT-IN FUNCTIONS


   EX.
   :(ADD1 3)
     3
(DIFFERENCE <N1> <N2>) : SUBR
   RETURNS THE VALUE OF <N1>-<N2>.
   EX.
   :(DIFFERENCE 5 6)
     -1
(DIV <N1> <N2> <LATM>) : SUBR
   RETURNS (QUOTIENT <N1> <N2>) AND THE VALUE OF
   (REMAINDER <N1> <N2>) IS SET TO THE ATOM <LATM> FOR THE
   SIDE EFFECTION.
   EX.
   :(DIV 11 4 'R)
     2
   :R
     3
(EQP <N1> <N2>) : SUBR
   RETURNS TRUE IF THE NUMBERS ARE EQUAL.
   EX.
   :(EQP 2 3)
     NIL
   :(EQP -1 -1)
     T
(EXPT <N1> <N2>) : SUBR
   RAISES THE NUMBER <N1> TO THE POWER GIVEN BY
   THE NUMBER <N2>.
   EX.
   :(EXPT 2 3)
     8
   :(EXPT 2 99)
     633825300114114700748351602688
(GCD <N1> <N2>) : SUBR
   RETURNS THE GREATEST COMMON DIVISOR OF <N1> AND <N2>.




---                                                           ---

PAGE 42    BUILT-IN FUNCTIONS


   EX.
   :(GCD 18 24)
     6
(GREATERP <N1> <N2>) : SUBR
   RETURNS TRUE IF <N1> IS GREATER THAN <N2>.
   EX.
   :(GREATERP 10 7)
     T
(LESSP <N1> <N2>) : SUBR
   RETURNS TRUE IF <N1> IS LESS THAN <N2>.
   EX.
   :(LESSP 6 7)
     T
   :(LESSP 6 6)
     NIL
(MAX <N1> <N2> ... <NN>) : LSUBR
   RETURNS THE BIGGEST NUMBER.
   EX.
   :(MAX 5 6 -2 4 5)
     6
(MIN <N1> <N2> ... <NN>) : LSUBR
   RETURNS THE SMALLEST NUMBER.
   EX.
   :(MIN 5 6 -2 4 5 7)
     -2
(MINUS <N>) : SUBR
   RETURNS THE NEGATIVE OF THE NUMBER <N>.
   EX.
   :(MINUS 4)
     -4
(MINUSP <N>) : SUBR
   RETURNS TRUE IF <N> IS NAGATIVE.






---                                                           ---

PAGE 43    BUILT-IN FUNCTIONS


   EX.
   :(LIST (MINUSP -2)
          (MINUSP 0))
     (T NIL)
(ONEP <N>) : SUBR
   RETURNS TRUE IF <N1> IS ONE.
   EX.
   :(ONEP 1)
     T
(PLUS <N1> <N2> ... <NN>) : LSUBR
   RETURNS THE SUM OF ALL THE NUMBERS.
   EX.
   :(PLUS 1 2 3 4 5 6 7 8 9 10)
     55
(QUOTIENT <N1> <N2>) : SUBR
   RETURNS THE RESULT OF DIVIDING <N1> BY <N2>.
   EX.
   :(QUOTIENT 20 7)
     2
(RANDOM <N>) : SUBR
   RETURNS THE RANDOM NUMBER BETWEEN 0 AND <N>-1, IF <N> IS
   POSITIVE; IF MINUS, IT RETURNS THE SAME RANDOM NUMBER
   BETWEEN -32768 AND 32767 EACH TIME IT IS USED WITH
   THE SAME <N>. THE REASON FOR USING A NEGATIVE ARGUMENT FOR
   "RANDOM" IS TO INITIALIZE (OR "SEED") A REPEATABLE SEQUENCE
   OF RANDOM NUMBERS. IF <N> IS ZERO, "RND" RETURNS THE MOST
   RECENT PREVIOUS RANDOM NUMBER GENERATED BETWEEN -32768 AND
   32767.
   EX.
   :(RANDOM 10000)
     6809
(RANDOMIZE) : SUBR
   RANDOMIZES THE VALUES OF ALL FUTURE CALLS TO "RANDOM".
   EX.
   :(RANDOM 0)
     11






---                                                           ---

PAGE 44    BUILT-IN FUNCTIONS


   :(RANDOMIZE)
     NIL
   :(RANDOM 0) (RANDOM 0)
     8088
     8088
    
(REMAINDER <N1> <N2>) : SUBR
   RETURNS THE REMAINDER AFTER DIVISION OF <N1> BY <N2>.
   EX.
   :(REMAINDER 100 33)
     1
(SUB1 <N>) : SUBR
   RETURNS ONE LESS THAN THE NUMBER <N>.
   EX.
   :(SUB1 0)
     -1
(TIMES <N1> <N2> ... <NN>) : LSUBR
   RETURNS THE PRODUCT OF ALL THE NUMBERS.
   EX.
   :(TIMES 5 4 3 2)
     120
(ZEROP <N>) : SUBR
   RETURNS TRUE IF <N> IS ZERO.
   EX.
   :(ZEROP 0)
     T
   :(ZEROP 2)
     NIL
 [7] INPUT/OUTPUT FUNCTIONS
(CHRCT [<CH>]) : LSUBR
   RETURNS THE NUMBER OF CHARACTERS THAT CAN BE PRINTED ON THE
   CURRENT LINE OF THE CHANNEL <CH>. IF <CH> IS DEFAULT, IT
   RETURNS THE CASE OF THE CURRENT SYSTEM INPUT.






---                                                           ---

PAGE 45    BUILT-IN FUNCTIONS


   EX. IN THE CASE OF THE LINELENGTH IS 79
   :(PROGN (PRINT 'ABCD) (PRIN1 'EFG) (CHRCT))
   ABCDEFG
     72
(CURCOL [<CH>]) : LSUBR
   RETURNS THE NUMBER OF THE CURRENT COLUMN WHERE THE NEXT
   CHARACTER TO BE PRINTED ON THE OUTPUT CHANNEL <CH>, OR ON
   THE CURRENT SYSTEM OUTPUT IF <CH> IS DEFAULT.
   EX.
   :(PROGN (PRIN1 'AUGUST) (PRIN1 'JULY) (CURCOL))
   AUGUSTJULY
     10
(CLOSE [<CH>]) : LSUBR
   CLOSE THE CHANNEL NUMBER <CH>. IF IT IS DEFAULT, ALL OPENED
   CHANNES ARE CLOSED. THE RESULT "CLOSE" IS <CH> OR NIL FOR
   DEFAULT. SEE EX. OF "OPEN".
(ESC <LATM>) : SUBR
   CAUSES THE DISPLAY TERMINAL THE "ESCAPE SEQUENCE". IT SENDS
   A ESCAPE CODE AND FOLLOWED BY THE CHARACTER <LATM> TO THE
   DISPLAY TERMINAL. SEE THE DISPLAY TERMINAL'S MANUAL ABOUT
   WHAT IS HAPPEN WHEN THESE CODES ARE SENT.
   
   EX.
   :(ESC 'A)
     A
   
   :(ESC 'B)

     B
(GOTOXY <N1> <N2>) : SUBR
   MOVES THE CURSOR OF THE DISPLAY TERMINAL TO THE LOCATION
   <N1>,<N2>. <N1> IS THE HORIZONTAL, AND <N2> IS THE VERTICAL
   POSITION. (ONLY FOR VDS VG-470 DISPLAY)
(LINELENGTH [<N>]) : LSUBR
   SETS THE LENGTH OF THE OUTPUT LINES TO <N>. IF <N> IS
   DEFAULT, RETURNS THE CURRENT LINELENGTH.
   EX.
   :(PROGN (LINELENGTH 132) (LINELENGTH))
     132
   :(CHRCT)
     132





---                                                           ---

PAGE 46    BUILT-IN FUNCTIONS


(OPEN <FILE> <CH> <MODE>) : SUBR
   OPENS A CHANNEL NUMBER <CH> OF ITS FILE SPECIFICATION
   <FILE> AS ITS CHANNEL MODE <MODE>. THE RESULT IS
   THE NUMBER <CH>. <CH> MUST BE IN RANGE 0 TO 7.
   THE FILE SPECIFICATION HAS THE NEXT FORM,
     <DEVICE NAME>:<FILE NAME>.<EXTENSION>
   OF COURSE A DOT "." IS A SPECIAL CHARACTER FOR "READ",
   WHEN WRITING A PROGRAM, A SLASH "/" MUST BE USED FOR THE
   PREPOSITION.
   USE THE DEVICE NAME AMONG THE NEXT TABLE,
          DEVICE NAME : MEANING
        DK,SY,DY0,DY1 : EACH DISK DEVICE
        TT            : TERMINAL DEVICE
        LP            : LINE PRINTER DEVICE
   IN THE CASE OF USING "TT" OR "LP" FOR THE DEVICE NAME,
   THE FILE NAME AND THE EXTENSION ARE NOT REQUIRED.
   <FILE NAME> AND <EXTENSION> ARE THE SAME SYNTAX OF THE
   RT-11'S.
   IF <DEVICE NAME> IS DEFAULT, IT IS ASSUMED TO BE CURRENTLY
   SELECTED DEFAULT DISK DEVICE (DK).
   IF <EXTENSION> IS DEFAULT, IT IS IMPLICITLY ASSUMED TO BE
   "LSP".
   CHOOSE THE CHANNEL MODE AMONG THE NEXT TABLE,
      CHANNEL MODE : MEANING
          READ     : OPEN AN OLD FILE FOR READ
          PRINT    : OPEN AN NEW FILE FOR WRITE
          APPEND   : OPEN AN OLD FILE FOR APPEND
   FOR EXAMPLE,
    (OPEN 'DK:HAL 2 'PRINT) : MAKE A NEW FILE NAMED "HAL.LSP"
                              ON A DEVICE "DK", AND OPENED AS
                              CHANNEL 2 FOR WRITE.
    (OPEN 'TOM/.MAC 1 'READ) : OPEN AN OLD FILE NAMED "TOM.MAC"
                               ON A DEFAULT DEVICE "DK"
                               AS CHANNEL 1 FOR READ.
   
    (OPEN 'TT: 3 'PRINT) : OPEN A CHANNEL TO THE TERMIAL
                           AS CHANNEL NUMBER 3 FOR WRITE.
    (OPEN 'LP: 4 'PRINT) : OPEN A CHANNEL TO THE LINE PRINTER
                           AS CHANNEL NUMBER 4 FOR WRITE.







---                                                           ---

PAGE 47    BUILT-IN FUNCTIONS


   EX.
   :(OPEN 'FILE 1 'PRINT)
     1
   :(PRINT '(THIS IS A FILE OF A SINGLE LIST) NIL 1)
     (THIS IS A FILE OF A SINGLE LIST)
   :(CLOSE 1)
     1
   :(OPEN 'FILE 1 'READ) (READ 1) (CLOSE 1)
     1
     (THIS IS A FILE OF A SINGLE LIST)
     1
(PRIN1 <S> [<P> <CH>]) : LSUBR
   "PRIN1" IS SIMILAR TO "PRINT" EXCEPT THAT "PRIN1" DOES NOT
   OUTPUT A CARRIAGE RETURN WHEN STARTING. SEE "PRINT".
(PRINT <S> [<P> <CH>]) : LSUBR
   CAUSES A CARRIAGE RETURN AND THE S-EXPRESSION <S> TO BE
   PRINTED OUT TO THE CHANNEL NUMBER <CH>. IF <P> IS NOT NIL,
   A SLASH "/" WILL BE PRINTED WHEN PRINTING A SPCIAL CHARACTER
   OF AN ATOM. IF <CH> IS DEFAULT, "PRINT" OUTPUTS TO THE
   CURRENT SYSTEM OUTPUT. AND IF <P> IS DEFAULT, IT IS ASSUMED
   TO BE NIL.
   EX.
   :(PROGN (PRINT 'CATTLE) (PRIN1 'MUTILATION)
   :       (PRINT 'THIS/ IS/ A/ PEN/.)
   :       (TERPRI)
   :       (PRIN1 'THIS/ IS/ A/ PEN/. T]
   CATTLEMUTILATION
   THIS IS A PEN.
   THIS/ IS/ A/ PEN/.
     THIS IS A PEN.
(RATOM [<CH>]) : LSUBR
   RETURNS AN ATOM READING FROM THE CHANNEL NUMBER <CH>.
   NOTE THAT "RATOM" READS A SPECIAL CHARACTER AS ONE ATOM.
   IF <CH> IS DEFAULT, IT READS FROM CURRENT SYSYTEM INPUT.
   EX.
   :(PRINT (LIST (RATOM) (RATOM)) T)
   ?)EXAMPLE
     (/) EXAMPLE)





---                                                           ---

PAGE 48    BUILT-IN FUNCTIONS


(READ [<CH>]) : LSUBR
   RETURNS THE NEXT S-EXPRESSION READ FROM THE CHANNEL
   NUMBER <CH>.
   IF <CH> IS DEFAULT, IT READS FROM CURRENT SYSTEM INPUT.
   EX.
   :(READ)
   ?(EXAMPLE)
     (EXAMPLE)
   :(READ)(INSTANCE)
     (INSTANCE)
(READCH [<CH>]) : LSUBR
   RETURNS THE NEXT ATOM OF ONE CHARACTER READ FROM
   THE CHANNEL NUMBER <CH>.
   IF <CH> IS DEFAULT, IT READS FROM CURRENT SYSYTEM INPUT.
   EX.
   :(READCH)
   ?X
     X
   :(READCH)A
     A
(READKEY) : SUBR
   READ ONE CHARACTER FROM CONSOLE KEYBOAD. RETURNS A CHARACTER
   AS SOON AS READ IT. A PRESS OF THE RETURN KEY IS NOT
   NECESSARY FOR THE LINE TERMINATER.
   EX.
   :(READKEY)
   A
     A
(READMACRO '<LATM> '<E>) : KSUBR
   DEFINES THE CHARACTER <LATM> AS READ MACRO. THE MACRO BODY
   IS <E>. IF <E> IS NIL, THE CHARACTER IS NO MORE A READ
   MACRO.
   EX.
   :(READMACRO * (LIST 'TIMES (READ) (READ]
     *
   :* 2 * 3 4
     24
   :(READMACRO /* NIL)



---                                                           ---

PAGE 49    BUILT-IN FUNCTIONS



     *
   :* 2 * 3 4
   ?UNBOUND VARIABLE
   => *
   >
(SPACE <N> [<CH>]) : LSUBR
   OUTPUTS <N> SPACES TO THE OUTPUT CHANNEL <CH>. IN DEFAULT OF
   <CH>, OUTPUTS TO THE CURRENT SYSTEM OUTPUT.
   EX.
   :(PROGN (PRIN1 'A) (SPACE 3) (PRIN1 'B) (SPACE 3)
   :       (PRIN1 'C))
   A   B   C
     C
(SYSIN <FILE>) : SUBR
   CHANGES CURRENT SYSTEM INPUT TO THE FILE SPECIFICATION
   <FILE>. SEE "OPEN" ABOUT THE FILE SPECIFICATION.
(SYSOUT <FILE>) : SUBR
   CHANGES CURRENT SYSTEM OUTPUT TO THE FILE SPECIFICATION
   <FILE>. SEE "OPEN" ABOUT THE FILE SPECIFICATION.
(TAB <N> [<CH>]) : LSUBR
   MOVES OUTPUT COLUMN POSITION TO <N> OF THE OUTPUT CHANNEL
   <CH>, OR OF THE CURRENT SYSTEM OUTPUT FOR DEFAULT.
   EX.
   :(PROGN (TAB 10) (PRINT 'HELLO))
             HELLO
     HELLO
(TERPRI [<CH>]) : LSUBR
   CAUSES A CARRIAGE RETURN AND LINE FEED TO BE PRINTED TO
   CHANNEL NUMBER <CH>. IF DEFAULT <CH>, IT CAUSES TO CURRENT
   SYSOUT. THE RESULT IS NIL.
   EX.
   :(PROG (X)
   :      (SETQ X 1)
   : LOOP (PRIN1 X) (PRIN1 '/ )
   :      [COND ((ZEROP (REMAINDER X 10)) (TERPRI]
   :      [COND ([EQP 31 (SETQ X (ADD1 X] (RETURN 'END]
   :      (GO LOOP]
   1 2 3 4 5 6 7 8 9 10
   11 12 13 14 15 16 17 18 19 20
   21 22 23 24 25 26 27 28 29 30
     END



---                                                           ---

PAGE 50    BUILT-IN FUNCTIONS



 [8] DEBUGGING FUNCTIONS
  SEE "APPENDIX C" ABOUT THE EXAMPLE OF DEBUGGING.
(BAKTRACE) : SUBR -NOT IMPLEMENTED-
   CAUSES BACK TRACING.
(DISKOFF <P>) : SUBR
   STOPS AUTO LOADING OF UNDEFINED FUNCTION OR VALUE FROM DISK,
   IF <P> IS TRUE. IF <P> IS NIL, THIS MECHANISM WILL RECOVER.
(ERROR <S> <N>) : EXPR
   UNIVERSAL ERROR FUNCTION FOR SYSTEM AND USER.
   IF HALISP DETECTS AN ERROR, CONTROL TRANSFER TO THIS
   FUNCTION. <S> AND <N> ARE MESSAGES TO THE ERROR FUNCTION.
   SEE "<6> ERROR FUNCTION".
(GETCNT <LATM>) : SUBR
   RETURN THE VALUE OF THE COUNTER WHICH IS HELD BY THE ATOM
   <LATM>. THE COUNTER IS USED AS THE TRACE COUNTER FOR EXPRS,
   OR HOLDS FORMAL ARGUMENTS NUMBER OF SUBRS. SEE "<7> FUNCTION
   TRACER".
   EX.
   :(GETCNT 'EQ) ; SUBR "EQ"
     2
   :(GETCNT 'NEKO) ; NOT FUNCTION
     0
(MON <P>) : SUBR
   IF <P> IS TRUE, HALISP ECHO BACKS READING OR WRITING
   CHARACTER BETWEEN DISK TO TERMIAL OUTPUT. IF <N> IS NIL,
   OFF THE ECHO BACK.
(PUTCNT <LATM> <N>) : SUBR
   SET THE VALUE <N> TO THE COUNTER WHICH IS HELD BY THE ATOM
   <LATM>. SEE "GETCNT".
(TRACE '<LATM1> '<LATM2> ... '<LATMN>) : FSUBR
   CAUSES PRINTING A TRACE MESSAGE OF THE FUNCTION NAME
   <LATM1> ... <LATMN> WHEN ENTERING OR EXITING THE FUNCTIONS.
   IF THAT ATOM IS USED AS VARIABLE AND WHEN SET OR SETQ
   OCCURS, ALSO PRINTS OUT A MESSAGE.
(TRACER <FN> <L>) : EXPR
   TRACE FUNCTION FOR EXPRS. SEE "<7> FUNCTION TRACER".





---                                                           ---

PAGE 51    BUILT-IN FUNCTIONS


(UNTRACE '<LATM1> '<LATM2> ... '<LATMN>) : FSUBR
   STOPS TRACING OF THE FUNCTIONS OR VARIABLES <LATM1> ...
   <LATMN>.
 [9] FUCTION DEFINITION FUNCTIONS
   EVERY LITERAL ATOM CAN HOLD FUNCTION TYPE INFORMATIONS TO
   BE RECOGNIZED BY HALISP INTERPRETATIVE FUNCTION "EVAL" AND
   "FUNCALL".
(DE '<FN> ['<FTYPE>] '(<VAR1> ... <VARN>)
    '<E1> ... '<EN>)                      : FEXPR
   DEFINES FUNCTION <FN> TO BE THE FUNCTION TYPE <FTYPE> WITH
   <VAR>S AS THE FORMAL ARGUMENTS AND THE <E>S AS THE FUNCTION
   BODY. IF THE <FTYPE> IS DEFAULT, EXPR IS ASSUMED.
   EX.
   :(DE ADD2 (X) (PLUS X 2))
     ADD2
   :(ADD2 3)
     5
   :(DE INC KEXPR (ARG-OF-INC)
      (SET ARG-OF-INC (ADD1 (EVAL ARG-OF-INC]
     
     INC
   :(SETQ X 0)
     0
   :(INC X)
     1
   :X
     1
(DEF '(<FN> <VAR1> ... <VARN>)
     '<E1> ... '<EN>)          : FEXPR
   DEFINES A EXPR FUNCTION, WHICH NAME IS <FN>, WITH <VAR>S
   AS THE FORMAL ARGUMENTS AND THE EXPRESSIONS <E>S AS THE
   FUNCTION BODY.
   EX.
   :(DEF (ADD2 X) (PLUS X 2))
     ADD2
   :(ADD2 4)
     6




---                                                           ---

PAGE 52    BUILT-IN FUNCTIONS


(DM '<FN> '(<VAR>)
    '<E1> ... '<EN>) : FEXPR
   DEFINES FUNCTION <FN> TO BE A MACRO WITH <VAR> AS THE FORMAL
   ARGUMENT AND THE EXPRESSIONS <E>S AS THE FUNCTION BODY.
   THE DIFFERENCE BETWEEN USING "DE" FOR MACRO DEFINITION AND
   USING "DM" IS THAT THE NEW CODE WHICH IS EXPANDED BY THE
   MACRO USING "DM" IS PHYSICALLY SUBSTITUTED FOR THE OLD CODE
   DURING THE EVALUATION. SO YOUR FUNCTION WHICH USES THE
   MACROS ARE EXCUTED VERY EFFICIENTLY, BECAUSE THE EXPANSION
   OCCURS ONLY ONCE WHEN IT IS ACTUALLY CALLED.
   EX.
   :(DM INC (BODY)
      &&(SETQ @(CADR BODY) (ADD1 @(CADR BODY]
     INC
   :(DEF (AHO X)
      (INC X) (INC X))
     AHO
   :AHO
      (LAMBDA (X) (INC X) (INC X))
   :(AHO 1)
     3
   :AHO
      (LAMBDA (X) (SETQ X (ADD1 X)) (SETQ X (ADD1 X)))
(GETTYP <LATM>) : SUBR
   RETURNS A FUNCTION TYPE OF <LATM>. RETURNS NIL IF THE ATOM
   DOES NOT HAVE ANY FUNCTION TYPE. SEE "FUNCTION TYPES".
   EX.
   :(GETTYP 'CAR)
     SUBR
(REMTYP <LATM>) : SUBR
   REVOVES A FUNCTION TYPE FROM THE ATOM <LATM>. THE VALUE IS
   <LATM>.
(PUTTYP <LATM> <FTYPE>) : SUBR
   PUT A TYPE <FTYPE> TO THE ATOM <LATM>. THE FUNCTION TYPES
   ARE EXPR, FEXPR, LEXPR, KEXPR, SUBR, FSUBR, LSUBR, KSUBR,
   AND MACRO FOR EACH FUNCTION TYPES.
   EX.
   :(PUTTYP 'FUNC 'EXPR)




---                                                           ---

PAGE 53    BUILT-IN FUNCTIONS


     EXPR
   :(GETTYP 'FUNC)
     EXPR
 [10] DATA TYPE & STORE MACRO
(RECORD '<LATM1> ['<LATM2>] '<L>) : MACRO
   RECORD DEFINES DATA TYPE CONSTRUCTING, ACCESSING, AND TEST
   FUNCTIONS. HERE <LATM1> IS THE TYPE NAME, <LATM2> IS A FLAG
   FOR TYPE CHECKING, AND <L> IS THE TYPE EXPRESSION WHICH IS
   AN ARBITRARY LIST STRUCTURE OF SLOT NAMES.
   IF <LATM2> IS NIL, THE TYPE CHECK FUNCTION IS NOT DEFINED.
   OR IF <LATM2> IS DEFAULT, THE TYPE NAME IS ALSO USED AS THE
   TYPE FLAG AND THE TYPE CHECK FUNCTION IS DEFINED.
   EX.
   :(RECORD HUMAN ((SEX AGE) HEIGHT.HOBBY))
     HUMAN:
   :(SETQ TOM (HUMAN: MALE 27 175 (TENNIS SCIENCE]
     (HUMAN (MALE 27) 175 TENNIS SCIENCE)
   :(SEX:HUMAN TOM)
     MALE
   :(HOBBY:HUMAN TOM)
     (TENNIS SCIENCE)
   :(IS-HUMAN TOM)
     T
   IN THIS CASE, THE NEXT FUNCTIONS ARE DEFINED.
     HUMAN:    : DATA TYPE CONSTRUCTING EXPR FUNCTION
     SEX:HUMAN : SLOT ACCESSING MACRO FUNCTIONS
     AGE:HUMAN
     HEIGHT:HUMAN
     HOBBY:HUMAN
     IS-HUMAN  : DATA TYPE CHECKING MACRO FUNCTION
   EX.
   :(RECORD HUMAN WHO (SEX AGE))
     HUMAN:
   :(SETQ WOMAN1 (HUMAN: FEMALE 24))
     (WHO FEMALE 24)




---                                                           ---

PAGE 54    BUILT-IN FUNCTIONS


   :(AGE:HUMAN WOMAN1)
     24
   :(IS-HUMAN WOMAN1)
     T
   :(RECORD HUMAN NIL (SEX AGE))
     HUMAN:
   :(SETQ MAN1 (HUMAN: MALE 23))
     (MALE 23)
   :(AGE:HUMAN MAN1)
     23
   THE LAST RECORD DEFINITION IS NOT DEFINED THE TYPE CHECKING
   FUNCTION SUCH LIKE (IS-HUMAN ...)
   AND ALWAYS THE TYPE FLAG IS SET ON THE HEAD OF THE DATA TYPE
   STRUCTURE IF THE FLAG IS DEFINED.
(STORE '<E1> <E2>) : MACRO
   STORE EXPANDS TO APPROPRIATE FUNCTION THAT MAKES <E1> EQUAL
   TO <E2>. FOR EXPAMPLE,
                 => EXPAND INTO =>
     (STORE X 5)                 =>(SETQ X 5)
     (STORE (CAR X) 'AHO)        =>(RPLACA X 'AHO)
     (STORE (CADR X) 'TOM)       =>(RPLACA (CDR X) 'TOM)
     (STORE (CDDR '(A B C)) 'CAT)=>(RPLACD (CDR '(A B C)) 'CAT)
     (STORE (GET X 'SEX) 'MALE)  =>(PUTPROP X 'SEX 'MALE)
     (STORE (GET X 'PLAN)        =>(PUTPROP X 'PLAN
            (CONS '(GO TO BED) **]          (CONS '(GO TO BED)
                                                  (GET X 'PLAN]
     (STORE (AGE:HUMAN X) 22)    =>(RPLACA (CDR X) 22)
   THE LAST EXAMPLE IS IN THE CONTEXT OF THE LAST EXPAMPLE OF
   RECORD MACRO'S. IT MEANS <E1> MAY BE A MACRO EXPRESSION AND
   ALSO MEANS THAT "STORE" CAN BE USED AS A MODIFIER OF DATA
   STRUCTURES.
   THE DOUBLE ASTERISK "**" MEANS <E1> IF IN <E2>.
 [11] SYSTEM SWITCHES AND MISCELLANEOUS
(ALPORDER <ATM1> <ATM2>) : SUBR
   RETURNS TRUE IF THE ATOMS ARE IN ALPHABETICAL ORDER.
   OTHERWISE RETURNS NIL.
   EX.
   :(ALPORDER 'APPLD 'APPLE)
     T



---                                                           ---

PAGE 55    BUILT-IN FUNCTIONS



   :(LIST (ALPORDER 'CAT 'CAT) (ALPORDER 'CATS 'CAT))
     (T NIL)
(ATOMLENGTH <ATM>) : SUBR
   RETURNS THE NUMBER OF CHARACTERS IN THE ATOM.
   EX.
   :(ATOMLENGTH 'FRUIT)
     5
   :(LESSP (ATOMLENGTH 'ELEVEN) (ATOMLENGTH 11))
     NIL
(BOUNDP <LATM>) : SUBR
   RETURNS TRUE IF THE ATOM <LATM> IS BOUND TO SOME S-EXPR.
   OTHERWISE NIL IS RETURNED.
   EX.
   :(BOUNDP 'UNBOUND-ATOM)
     NIL
   :(SETQ UNBOUND-ATOM 'NOW-BOUND)
     NOW-BOUND
   :(BOUNDP 'UNBOUND-ATOM)
     T
(BUCKET <N>) : SUBR
   RETURNS <N>'TH BUCKET ELEMENT OF THE FIRST ATOM THAT IS
   CURRENTLY LINKED. IF NOTHING IS LINKED, NIL IS RETURNED.
   <N> MUST BE IN RANGE 0 TO 127, BECAUSE THE SYSTEM HAS ONLY
   128 BUCKETS FOR THE OBJECT LIST (OBLIST).
   EX.
   :(BUCKET 1)
     NCONS
(COLD [<N>]) : LSUBR
   CAUSES COLD START HALISP, WITH STACK SIZE OF <N> WORDS. IF
   <N> IS DEFAULT, THE PREVIOUS STACK SIZE IS ASSUMED.
   NOTE: SYSTEM SETS STACK THE SIZE TO 7168 WORDS INITIALLY.








---                                                           ---

PAGE 56    BUILT-IN FUNCTIONS


   EX.
   :(COLD 9000)
   65500 CELLS FREE  9000 WORDS FOR STACK  7232 WORDS FOR DAS
   :
(COMPILE '<FILE>) : KEXPR -NOT IMPLEMENTED-
   COMPILES ALL FUNCTIONS IN THE FILE SPECIFICATION <FILE> INTO
   NATIVE MACHINE CODE AND MAKES A RELOCATABLE OBJECT FILE
   NAMED "<FILE>.COD". THE OBJECT FILE IS LOADED AUTOMATICALLY
   INTO MACHINE CODE AREA OF THE SYSTEM WHEN NEEDED.
   
   EX.
   :(COMPILE COMPILE)
     COMPILE
   NOW THE COMPILE FUNCTION IS COMPILED INTO MACHINE CODE, AND
   MAKES THE FILE "COMPILE.COD".
(EDITL <S>) : EXPR
   EDITS THE S-EXPRESSION <S>.
(EDIT '<FILE>) : KEXPR
   EDITS THE TEXT FILE <FILE>.
(EXPLODE <ATM>) : SUBR
   CONVERTS THE ATOM INTO A LIST OF SINGLE CHARACTER ATOMS.
   EX.
   :(EXPLODE 'APPLE)
     (A P P L E)
   :(EXPLODE 246)
     (2 4 6)
(FLIST) : EXPR
   PRINTS ALL EXISTING FUNCTION NAMES AND THEIR TYPES.
   EX.
   :(FLIST)
   TIMER:LSUBR CAR:SUBR ERROR:EXPR ...
   .
   .
   .
     132 FUNCTIONS EXIST.
(GENSYM [<LATM>]) : LSUBR
   MAKES A NEW LITERAL ATOM BY ADDING A NUMBER TO THE END OF
   ATOM <LATM>. IF <LATM> IS DEFAULT, "G" IS ASSUMED.




---                                                           ---

PAGE 57    BUILT-IN FUNCTIONS


   EX.
   :(GENSYM)
     G0
   :(GENSYM)
     G1
   :(GENSYM 'L)
     L0
   :(LIST (GENSYM) (GENSYM) (GENSYM 'L))
     (G2 G3 L1)
(GETNXT <LATM>) : SUBR
   RETURNS THE NEXT LINKED ATOM OF THAT ATOM IN THE SAME
   BUCKET. IF NO MORE ATOM IS LINKED NEXT, NIL IS RETURNED.
   EX.
   :(GETNXT 'CAR)
     ABS
(IMPLODE <L>) : SUBR
   FORMES THE ATOMS OF LIST <L> INTO A SINGLE ATOM AND RETURNS
   IT.
   EX.
   :(IMPLODE '(O R A N G E))
     ORANGE
   EX.
   :(IMPLODE '(CAT MAN 1))
     CATMAN1
(OBLIST) : EXPR
   PRINTS ALL EXISTING ATOMS IN THE CURRNET SYSTEM.
   THE NUMBER IN THE OUTPUT LIST MEANS THE BUCKET NUMBER OF THE
   FOLLOWING ATOMS.
   EX.
   :(OBLIST)
   0 1 CAR CDR 2 CONS ...
   .
   .
   .
     145 ATOMS EXIST.
(PP <S>) : EXPR
   PRETTY PRINTS THE S-EXPRESSION <S>.



---                                                           ---

PAGE 58    BUILT-IN FUNCTIONS



   EX.
   :(DEF (NOTHING X)
   :  (COND ((ATOM X) X)
   :        (T (RPLACA (NOTHING (CAR X)))
   :           (RPLACD (NOTHING (CDR X]
     NOTHING
   :NOTHING
     (LAMBDA (X) (COND ((ATOM X) X) (T (RPLACA (NOTHING (CAR X)
   )) (RPLACD (NOTHING (CDR X))))))
   :(PP NOTHING)
   (LAMBDA (X)
     (COND ((ATOM X) X)
           (T (RPLACA (NOTHING (CAR X)))
              (RPLACD (NOTHING (CDR X))))))
     END OF PRETTY PRINT
(PROMPT <LATM>) : SUBR
   CHAINGES THE PROMPT CHARACTER TO <LATM> USING FOR TERMINAL
   INPUT.
   EX.
   :(PROGN (PROMPT '*) (READ))
   *(READLIST)
     (READLIST)
   :
(QUIT) : SUBR
   EXITS FROM HALISP.
   EX.
   :(QUIT)
   .
(RECLAIM) : SUBR
   CAUSES GARBAGE COLLECTION.
(REMOB <LATM>) : SUBR
   DELETES THE ATOM FROM THE SYSTEM OBJECT LIST.
   EX.
   :(SETQ X T)
     T
   :(PROGN (REMOB 'X) (BOUNDP 'X))
     NIL



---                                                           ---

PAGE 59    BUILT-IN FUNCTIONS



(RESET) : SUBR
   RESETS SYSTEM STACKS AND CLOSES ALL OPEN CHANNELS, AND THE
   CONTROL RETURNS TO MAIN LOOP (TOP LEVEL).
   EX.
   :(PROGN (PRINT 'ONE) (PRINT 'TWO) (RESET) (PRINT 'THREE))
   ONE
   TWO
   :
(SLEEP '<FN1> '<FN2> ... '<FNN>) : FSUBR
   KILLS THE FUNCTION BODYS OF ARGUMENT'S FUNCTIONS.
   "SLEEP" IS USED FOR EXCUTING LARGE PROGRAMS BY "SLEEP"ING
   THE FUNCTIONS THAT MAY BE NOT USED FOR LONG TIME IN
   EXCUTION. SEE "APPENDIX D" FOR EXAMPLE.
(TIMER [<N>]) :LSUBR
   RETURNS THE CURRENT VALUE OF THE TIMER IN DEFAULT OF THE
   ARGUMENT. OTHERWISE SETS THE TIMER AT THE VALUE OF THE
   ARGUMENT <N>. THE UNIT IS 1/10 SECOND.
   EX.
   :(TIMER 0)
     0
   :(TIMER)
     55 ;5.5 SECONDS PASSED
(VERBOS <P>) : SUBR
   IF <P> IS NOT NIL, A MESSAGES IS PRINTED OUT WHEN GARBAGE
   COLLECTION OCCURS. IF <P> IS NIL, IT IS NOT PRINTED.
   EX.
   :(VERBOS T)
     T
   :(RECLAIM)
   ENTERED GARBAGE COLLECTION, 12345 CELLS REMAIN
   ACCOMPLISHED THE COLLECTION, 61234 CELLS FREE
     NIL
   :
(XBIND <P>) : SUBR
   SETS THE SYSTEM IN SPECIAL LAMBDA BINDING MODE IF <P> IS
   NON-NIL. OTHERWIZE SETS NORMAL LAMBDA BINDING MODE. SEE
   "APPENDIX F" ABOUT SPECIAL LAMBDA BINDING.
   NOTE: THE SYSTEM SELECTS SPECIAL BINDING INITIALLY.



---                                                           ---

PAGE 60    BUILT-IN FUNCTIONS



 [12] PRIMITIVES FOR COMPILER
(ADDRESS <S>) : SUBR
  RETURNS A NUMBER EQUAL TO THE CELL ADDRESS OF <S>.
  EX.
  :(ADDRESS '(LIST ADDRESS))
    5678
(ALLOCATE <L>) : SUBR
  ALLOCATES THE LIST OF BINARY CODES TO THE DYNAMIC ALLOCATED
  SPACE (DAS) WHILE EACH ELEMENT IS EVALUATED ONCE. AND RETURNS
  THE POINTER TO THE HEAD OF THE ALLOCATED BLOCK.
  EX.
  :(PROGN [SETQ FOO (ALLOCATE '(10 9 (ADDRESS '(TOM)) 8 7] NIL)
    NIL
  :(PUTTYP 'FOO 'SUBR) ;FOO IS NOW A SUBR
    ABC
  :(PUTCNT 'FOO 4) ;ITS ARGUMENTS NUMBER IS 2
    ABC
(POINTER <N>) : SUBR
  RETURNS THE POINTER WHICH NUMERIC VALUE OF THE ADDRESS IS
  EQUAL TO <N>.
  EX.
  :(POINTER (ADDRESS '(RETURN THIS LIST]
    (RETURN THIS LIST)
(RELEASE <PTR>) : SUBR
  FREES THE ALLOCATED SPACE IN DAS. THE ARGUMENTS IS THE
  PONITER TO THAT HEAD OF THE BLOCK.
 [13] SPECIAL DEVICE FUNCTIONS
(MIPLOT <COM> <ARG1> ... <ARGN>) : LSUBR
  SENDS A COMMAND TO X-Y PLOTTER (MIPLOT). <COM> IS THE COMMAND
  CHARACTER FOR THE PLOTTER. SEE "MIPLOT REFERENCE MANUAL".
  EX.
  :(MIPLOT 'H) ;MOVES THE PEN HOME
    NIL
  :(MIPLOT 'M 500 800) ;MOVES THE PEN TO THAT X-Y POSITION




---                                                           ---

PAGE 61    BUILT-IN FUNCTIONS


    NIL
 
(MANIP <COM> <ARG1> ... <AGRN>) : LSUBR
  SENDS A COMMAND TO MANIPULATOR (MOVEMASTER). <COM> IS THE
  COMMAND CHARACTER FOR THE MANIPULATOR.
  SEE "MOVEMASTER REFERENCE MANUAL".
  EX.
  :(MANIP 'I 1000 100 100 0 0 0)
    NIL
 [14] SYSTEM CONSTANTS AND INDICATORS
  EXPR : = EXPR
  FEXPR : = FEXPR
  FSUBR : = FSUBR
  KEXPR : = KEXPR
  KSUBR : = KSUBR
  LAMBDA : = LAMBDA
  LEXPR : = LEXPR
  LSUBR : = LSUBR
  MACRO : = MACRO
  NIL : = NIL
  SUBR : = SUBR
  T : = T
  %EOF : = %EOF
  %EOL : = %EOL
  %UNDEF : = %UNDEF



















---                                                           ---

PAGE 62    ERROR HANDLING


  <6> ERROR FUNCTION
--IMPLEMENTATION OF ERROR RECOVERING--
WHEN AN ERROR IS DETECTED DURING THE EVALUATION, THE ERROR
DETECTED FUNCTION TRANSFERS THE CONTROL TO THE FUNCTION "ERROR"
AND THE RESULT OF THE ERROR DETECTED FUNCTION IS THE RESULT OF
THE "ERROR" FUNCTION. THE "ERROR" FUNCTION TAKES TWO ARGUMENTS,
A MESSAGE AND AN IDENTIFICATION NUMBER.
IT IS CONVENIENT THAT THE "ERROR" FUNCTION IS DEFINED BY THE
FORM OF S-EXPRESSION(EXPR). IT MEANS THAT YOU CAN DEFINE YOUR
OWN "ERROR" FUNCTION FREELY.
--DEFINITION OF THE TYPICAL ERROR FUNCTION--
[DEF (ERROR MSG ERR#)
  (PRINT '?)
  (CASE ERR#
    ( 0 (PRIN1 '"ARITHMETIC OVERFLOW") (CONT MSG))
    ( 1 (PRIN1 '"NUMERIC ARGUMENT(S) EXPECTED") (CONT MSG))
    ( 2 (PRIN1 '"ZERO DEVISION") (CONT MSG))
    ( 3 (PRIN1 '"UNDEFINED FUNCTION - APPLY") (CONT MSG))
    ( 4 (PRIN1 '"UNDEFINED FUNCTION - EVAL") (CONT MSG))
    ( 5 (PRIN1 '"UNBOUND VARIABLE") (CONT MSG))
    ( 6 (PRIN1 '"APPLY IMPROPER FUNCTION TYPES") (CONT MSG))
    ( 7 (PRIN1 '"PAIRLIST LENGTH MISMATCH") (CONT MSG))
    ( 8 (PRIN1 '"CAN'T USE RESERVED ATOM AS PROPERTY LIST
                 OBJECT") (CONT MSG))
    ( 9 (PRIN1 '"GO(THROW) REFERS UNDEFINED LABEL") (STOP MSG))
    (10 (PRIN1 'BREAKED) (CONT MSG))
    (11 (PRIN1 '"CHANNEL NOT OPEN") (CONT MSG))
    (12 (PRIN1 '"CAN'T SET(Q) TO RESERVED ATOM") (CONT))
    (13 (PRIN1 '"ILLEGAL FILE SPECIFICATION") (CONT MSG))
    (14 (PRIN1 '"FILE NOT FOUND") (CONT MSG))
    (15 (PRIN1 '"CHANNEL IN USE") (CONT MSG))
    (16 (PRIN1 '"CHANNEL MODE MISMATCH")) (RESET))
    (17 (PRIN1 '"ILLEGAL CHANNEL MODE")) (CONT MSG))
    (18 (PRIN1 '"ILLEGAL CHANNEL NUMBER") (CONT MSG))
    (19 (PRIN1 '"CAN'T USE RESERVED ATOMS AS PROG VARIABLES OR
                 LABELS") (CONT MSG))
    (20 (PRIN1 '"(K)SUBR ARGUMENTS NUMBER MISMATCH") (RESET))
    (21 (PRIN1 '"MAPS ARGUMENTS LIST LENGTH MIS") (CONT MSG))
    (22 (PRIN1 '"IMPROER CATCH LABEL - MAY BE FUNCTION NAME OR
                 VARIABLE") (STOP MSG))
    (23 (PRIN1 '"CAN'T USE RESERVED ATOMS AS LAMBDA VARIABLES")
        (STOP MSG))
    (24 (PRIN1 '"SPECIAL DEVICE ERROR") (CONT MSG))
    (PROGN (PRIN1 '"USER-PROGRAM-ERROR OCCURED")
           (CONT MSG]













---                                                           ---

PAGE 63    ERROR HANDLING


[DEF (CONT MSG)
  (PROG (INP)
        (PRINT '=>/ ) (PRIN1 MSG)
   LOOP (PROMPT '>)
        (TERPRI)
        (SETQ INP (READ))
        (COND [(AND (NATOM INP)
                    (EQ (CAR INP) 'RESUME))
               (PROMPT '?)
               (RETURN (COND [(NULL (CDR INP)) (EVAL MSG]
                             [T (EVAL (CADR INP]]
              [T (PRINT (EVAL INP])
        (TERPRI)
        (GO LOOP]
[DEF (STOP MSG)
  (PRINT '=>/ ) (PRINT MSG) (RESET]
--EXAMPLES OF ERROR RECOVERING--
PLEASE THINK THE CASE OF DEFINE THE FUNCTION "SUBLIS",
  :[DEF (SUBLIS A S)
  :     (COND ((ATOM S) (SUB2 A S))
  :           (T (CONS (SUBLIS A (CAR S) (SUBLIS A (CDR S]
    SUBLIS
  :(SUBLIS '((X.TOM) (Y.AN/ APPLE)) '(X EATS Y TODAY))
WILL GET MESSAGE,
  ?UNDEFINED FUNCTION - EVAL
  => (SUB2 A S)
CHECK THE VARIABLE'S VALUE,
  >A
  ((X.TOM) (Y.AN APPLE))
  >S
  X
SO DEFINE "SUB2",
  >[DEF (SUB2 A X)
  >     (COND ((NULL A) X)
  >           ((EQ (CAAR A) X) (CDAR A))
  >           (T (SUB2 (CDR A) X]
  SUB2
NOW "SUB2" IS DEFINED,
  >(RESUME (SUB2 A S))
OR TYPE,
  >(RESUME 'TOM)
OR,




---                                                           ---

PAGE 64    ERROR HANDLING


  >(RESUME)
    (TOM EATS AN APPLE TODAY)
OH, THAT'S RIGHT!


























































---                                                           ---

PAGE 65    TRACE HANDLER


  <7> FUNCTION TRACER
--THE TRACING MECHANISM--
WHEN THE HALISP EVALUATER DETECTS TRACED FUNCTION DURING THE
EVALUATION, IT INVOKES THE "TRACER" FUNCTION INSTEAD OF CALLING
THE BODY OF THE DEFINITION. THE "TRACER" IS TYPICALY DEFINED TO
DISPLAY THE ARGUMENTS AND THE RESULT OF THE TRACED FUNCTION BY
INDENTED FORM THAT REFLECTS THE LEVEL OF THE RECURSION.
SEE "APPENDIX C: DEBUGGING" ABOUT FUNCTION TRACING EXAMPLE.
--DEFINITION OF THE TYPICAL TRACER FUNCTION--
(SETQ TRACLEV 0)
(DEF (TRACER FUNC ARGS)
  [PUTCNT FUNC (ADD1 (GETCNT FUNC]
  (TERPRI)
  (TAB TRACLEV)
  (PRIN1 (GETCNT FUNC)) (PRIN1 '/ =>/ )
  (PRIN1 (CONS FUNC ARGS))
  (SETQ TRACLEV (ADD1 TRACLEV))
  (SETQ RESULT (APPLY (EVAL FUNC) ARGS))
  (SETQ TRACLEV (SUB1 TRACLEV))
  (TERPRI)
  (TAB TRACLEV)
  (PRIN1 (GETCNT FUNC)) (PRIN1 '/ <=/ )
  (PRIN1 FUNC) (PRIN1 '/ ) (PRIN1 RESULT)
  [PUTCNT FUNC (SUB1 (GETCNT FUNC]
  RESULT)
































---                                                           ---

PAGE 66    APPENDICES


--APPENDIX A: FATAL ERRORS--
THE FATAL ERROR IS A KIND OF ERROR THAT HAS NO RECOVERING
POSSIBILITY. THE MESSAGES AND THE MEANINGS ARE FOLLOWING,
  MESSAGE     : THE MEANING
  UNMATCHED (
    : TOO MANY LEFT PARENTHESES
      MAYBE UNEXPECTED EOF IS ENCOUNTERED ON THE INPUT FILE
  UNEXPECTED ).'
    : TOO MANY RIGHT PARENTHESES OR
      READ AN S-EXPRESSION STARTED FROM A DOT OR A RIGHT
      PARENTHESIS OR
      ') OR '. IS ENCOUNTERD
  DOT OUT OF CONTEXT
    : DOT NOTATION OUT OF CONTEXT
      MAYBE TOO MANY DOTS ARE USED IN A LIST
  INPUT DEVICE ERROR
  OUTPUT DEVICE ERROR
    : I/O DEVICE HARD ERROR
  OUTPUT DEVICE FULL
    : INSUFFICIENT FILE SPACE ON THE OUTPUT DEVICE
  FREE CELL SPACE IS EXHAUSTED
    : INSUFFICIENT LIST CELLS ON BULK MEMORY
  DAS IS EXHAUSTED
    : INSUFFICIENT DYNAMIC ALLOCATED SPACE ON MAIN MEMORY
      TO AVOID THIS ERROR, SET THE STACK SIZE SMALLER THAN THE
      CURRENT SIZE USING "COLD" FUNCTION
      
  STACK SPACE IS EXHAUSTED
    : EXCEEDED THE RECURSION OR FUNCTION NESTING LIMIT
      TO AVOID THIS ERROR, SET THE STACK SIZE LARGER THAN THE
      CURRENT SIZE USING "COLD" FUNCTION























---                                                           ---

PAGE 67    APPENDICES


--APPENDIX B: DATA DRIVEN PROGRAMMING--
GOOD PROGRAMMING AND DEBUGGING GO HAND IN HAND BECAUSE
ATTENTION TO SOME BASIC RULES OF GOOD PROGRAMMING PRACTICE BOTH
ELIMINATES SOME DEBUGGING AND SIMPLIFIES THE REST.
FACILITATING SMOOTH SUBPROCEDURE CALL IN TURN FACILITATES THE
USE OF THE FOLLOWING RULES:
  * PROCEDURES SHOULD BE SHORT.
  * PROCEDURES SHOULD BE BUILT AROUND GOALS.
  * PROCEDURES SHOULD PRESUME AS LITTLE AS POSSIBLE ABOUT THE
    SITUATION IN EFFECT WHEN THEY ARE CALLED.
  * PROCEDURES SHOULD SIGNAL WHEN BAD BUT PREDICTABLE
    SITUATIONS OCCUR.
  * PROCEDURES SHOULD BE COMMENTED LIBERALLY.
SUPPOSE, FOR EXAMPLE, THAT WE MAKE A DIFFERENTIATION PROGRAM.
THE RULES ARE FOLLOWING:
   DC/DX = 0
   DX/DX = 1
   D(U + V)/DX = DU/DX + DV/DX
   D(U - V)/DX = DU/DX - DV/DX
   D(U * V)/DX = U * DV/DX + V * DU/DX
   D(U / V)/DX = D(U * V ^ -1)/DX
   D(U ^ N)/DX = N * U ^ (N - 1) * DU/DX
NOW WRITE A FUNCTION "DIFF" THAT DIFFERENTIATE EXPRESSIONS THAT
ARE GIVEN IN LISP PREFIX NOTATION OR FUNCTIONAL NOTATION.
EXAMPLE OF NOTATIONS ARE:
   PREFIX NOTATION                   INFIX NOTATION
   (+ (* A (^ X 2)) (+ (* B X) C)) = A * X ^ 2 + B * X + C


















---                                                           ---

PAGE 68    APPENDICES


THE "DIFF" FUNCTION TAKES TWO ARGUMENTS: THE FIRST IS THE
EXPRESSION, AND THE SECOND IS THE DIFFERENTIAL VARIABLE.
THE BAD EXAMPLE OF "DIFF" FUNCTION IS:
(DEF (DIFF E X)
  (COND [(ATOM E) (COND ((EQ E X) 1)
                        (T 0]
        [(OR (EQ (CAR E) '+)
             (EQ (CAR E) '-))
         (LIST (CAR E)
               (DIFF (CADR E) X)
               (DIFF (CADDR E) X]
        [(EQ (CAR E) '*)
         (LIST '+
               (LIST '*
                     (CADR E)
                     (DIFF (CADDR E) X))
               (LIST '*
                     (CADDR E)
                     (DIFF (CADR E) X]
        [(EQ (CAR E) '//)
         (DIFF [LIST '*
                     (CADR E)
                     (LIST '^ (CADDR E) -1] X]
        [(EQ (CAR E) '^)
         (LIST '*
               (CADDR E)
               (LIST '*
                      [LIST '^
                            (CADR E)
                            (SUB1 (CADDR E]
                      (DIFF (CADR E) X]]
A LITTLE PRETTIER VERSION IS:
(RECORD SUM + (ARG1 ARG2))
(RECORD DIF - (ARG1 ARG2))
(RECORD PROD * (ARG1 ARG2))
(RECORD DIVI // (ARG1 ARG2))
(RECORD EXPO ^ (ARG1 ARG2))
(DEF (DIFF E X)
  (COND ((IS-VAR E) (DIFF-VAR E X))
        ((IS-SUM E) (DIFF-SUM E X))
        ((IS-DIF E) (DIFF-DIF E X))
        ((IS-PROD E) (DIFF-PROD E X))
        ((IS-DIVI E) (DIFF-DIVI E X))
        ((IS-EXPO E) (DIFF-EXPT E X))
        (T (ERROR E 99]
(DEF (DIFF-VAR E X)
  (COND ((EQ E X) 1)
        (T 0]
(DEF (DIFF-SUM E X)
  (SUM: (DIFF (ARG1:SUM E) X)
        (DIFF (ARG2:SUM E) X]





---                                                           ---

PAGE 69    APPENDICES


(DEF (DIFF-DIF E X)
  (DIF: (DIFF (ARG1:DIF E) X)
        (DIFF (ARG2:DIF E) X]
(DEF (DIFF-PROD E X)
  (SUM: [PROD: (ARG1:PROD E)
               (DIFF (ARG2:PROD E) X]
        (PROD: (ARG2:PROD E)
               (DIFF (ARG1:PROD E) X]
(DEF (DIFF-DIVI E X)
  (DIFF [PROD: (ARG1:DIVI E)
               (EXPO: (ARG2:DIVI E) -1] X]
(DEF (DIFF-EXPT E X)
  (PROD: (ARG2:EXPO E)
         (PROD: [EXPO: (ARG1:EXPO E)
                       (SUB1 (ARG2:EXPO E]
                (DIFF (ARG1:EXPO E) X]
THE VARIABLE RECOGNIZING FUNCTION IS:
(DEF (IS-VAR X)
  (ATOM X))
OF COURSE THE "CASE" FUNCTION IS SUITED FOR "DIFF":
(RECORD EXP NIL (FUNC ARG1 ARG2))
(DEF (DIFF E X)
  (COND ((IS-VAR E) (DIFF-VAR E X))
        (T (CASE (FUNC:EXP E)
             (+ (DIFF-SUM E X))
             (- (DIFF-DIF E X))
             (* (DIFF-PROD E X))
             (// (DIFF-DIVI E X))
             (^ (DIFF-EXPT E X))
             (ERROR E 99]
"ERROR" FUNCTION IS USED FOR PREDICTABLE APPEARANCE OF
UNDEFINED OPERATOR IN A GIVEN EXPRESSION.
BUT WE MUST NOT FORGET THE COMPUTED FUNCTION IN LISP.
THE MOST SOPHISTICATED VERSION IS:
(DEF (DIFF E X)
  (COND ((IS-VAR E) (DIFF-VAR E X))
        (T ((GET (FUNC:EXP E) 'DIFF) E X]
                    
ALTERNATIVE "DIFF" THAT USES COMPUTED FUNCTION EXPLICITLY BY
USING "FUNCALL" IS:
(DEF (DIFF E X)
  (COND ((IS-VAR E) (DIFF-VAR E X))
        (T (FUNCALL (GET (FUNC:EXP E) 'DIFF) E X]
OR USING "APPLY",
(DEF (DIFF E X)
  (COND ((IS-VAR E) (DIFF-VAR E X))
        (T (APPLY (GET (FUNC:EXP E) 'DIFF) (LIST E X]



---                                                           ---

PAGE 70    APPENDICES



(PUTPROP '+ 'DIFF
  '(LAMBDA (E X)
     (EXP: '+ (DIFF (ARG1:EXP E) X)
              (DIFF (ARG2:EXP E) X]
(PUTPROP '- 'DIFF
  '(LAMBDA (E X)
     (EXP: '- (DIFF (AGR1:EXP E) X)
              (DIFF (ARG2:EXP E) X]
(PUTPROP '* 'DIFF
  '(LAMBDA (E X)
     (EXP: '+ [EXP: '* (ARG1:EXP E)
                       (DIFF (ARG2:EXP E) X]
              (EXP: '* (ARG2:EXP E)
                       (DIFF (ARG1:EXP E) X]
(PUTPROP '// 'DIFF
  '(LAMBDA (E X)
     (DIFF [EXP: '* (ARG1:EXP E)
                    (EXP: '^ (ARG2:EXP E) -1] X]
(PUTPROP '^ 'DIFF
  '(LAMBDA (E X)
     (EXP: '* (ARG2:EXP E)
              (EXP: '* [EXP: '^ (ARG1:EXP E)
                                (SUB1 (ARG2:EXP E]
                       (DIFF (ARG1:EXP E) X]
"COND" OR "CASE" FUNCTION USES "IF-THEN-ELSE" TYPE COMPARISON
FOR INTERNAL CONTROL, SO IN THIS CASE OF "DIFF" FUNCTION,
INCREASE OF THE OPERATOR'S VARIETY CAUSES INEFFICIENCY AND
FATTENS THE "DIFF" FUNCTION. BUT THE LAST VERSION IS NOT
INEFFICIENT FOR SUCH EXTENSION AND IS EVEN PRETTY. THIS IS
CALLED "DATA-DRIVEN-PROGRAMMING".
--APPENDIX C: DEBUGGING--
SUPPOSE FOR SOME REASON THAT THINGS ARE JUST NOT WORKING OUT.
THINGS DROP DEAD, PERHAPS WITH AN ERROR MESSAGE THAT IS TOO
OPAQUE TO HELP. FOR THE SAKE OF ILLUSTRATION, SUPPOSE THE USER
IS SUSPICIOUS ABOUT THE FUNCTION "DIFF" IN APPENDIX B. HE
THINKS IT MAY NOT BE GETTING CALLED OR THAT IT IS CALLED WITH A
STRANGE ARGUMENTS. A APPROACH TO TESTING SUCH A THEORY WOULD BE
TO PUT A TRACE TAG TO THE FUNCTION "DIFF" SO THAT SYSTEM PRINTS
USEFUL INFORMATION ON ENTRY AND EXIT. THIS TRACE WILL HAVE THE
ADDITIONAL FEATURE OF PRINTING THE DEPTH NUMBER OF FUNCTION
CALL ENCLOSED BY BRACKETS.
FUNCTION "TRACE" PERFORMS TO PUT A TAG TO THE FUNCTION NAME:
  :(TRACE DIFF)
    (DIFF)








---                                                           ---

PAGE 71    APPENDICES


  :(DIFF '(+ X A) 'X)
  1 => (DIFF (+ X A) X)
   2 => (DIFF X X)
   2 <= DIFF 1
   2 => (DIFF A X)
   2 <= DIFF 0
  1 <= DIFF (+ 1 0)
    (+ 1 0)
  :(DIFF '(// A X) 'X)
  1 => (DIFF (/ A X) X)
   2 => (DIFF (* A (^ X -1)) X)
    3 => (DIFF (^ X -1) X)
     4 => (DIFF X X)
     4 <= DIFF 1
    3 <= DIFF (* -1 (* (^ X -2) 1))
    3 => (DIFF A X)
    3 <= DIFF 0
   2 <= DIFF (+ (* A (* -1 (* (^ X -2) 1))) (* (^ X -1) 0))
  1 <= DIFF (+ (* A (* -1 (* (^ X -2) 1))) (* (^ X -1) 0))
    (+ (* A (* -1 (* (^ X -2) 1))) (* (^ X -1) 0))
"TRACE" IS ALSO USED FOR TRACING THE SIDE-EFFECTION CAUSED BY
"SET" OR "SETQ". SUPPOSE THE NEXT ILLUSTRATION:
  :(TRACE X Y)
    (X Y)
  :(DEF (REV X)
  :  (PROG (Y)
  :   LOOP [COND ((NULL X) (RETURN Y]
  :        [SETQ Y (CONS (CAR X) Y]
  :        (SETQ X (CDR X))
  :        (GO LOOP]
    REV
  :(REV '(A B C D))
  Y = (A)
  X = (B C D)
  Y = (B A)
  X = (C D)
  Y = (C B A)
  X = (D)
  Y = (D C B A)
  X = NIL
    (D C B A)









---                                                           ---

PAGE 72    APPENDICES


--APPENDIX E: RESTRICTIONS--
YOU MUST BE CAREFUL HOW TO MANAGE THE INFORMATIONS ATTACHED ON
LITEARAL ATOMS. IN LISP, AN ATOM KEEPS A PROPERTY LIST WHICH
ALSO CONTAINS THE VALUE AS A VARIABLE AND THE FUNCTION BODY AS
A FUNCTION NAME. BUT HALISP DOES NOT USE THIS GENERAL PROPERTY
LIST SCHEME BECAUSE OF ITS INEFFICIENCY ON THE FREQUENT ACCESS
TO SUCH SYSTEM INFORMATIONS. INSTEAD OF THIS, HALISP USES THE
SIMPLE PRINCIPLE OF THE ATOM STRUCTURE: WHAT YOU SEE AS A
VARIABLE VALUE IS EVERYTHING WHAT YOU GET. SO THE VALUE MAY NOT
BE ONLY AN ARBITRARY S-EXPRESSION BUT ALSO A FUNCTION BODY OR
A PROPERTY LIST. REASONABLY THIS PRINCIPLE CAUSES THE
SIGNIFICANT RESTRICTION THAT YOU CAN'T USE A FUNCTION NAME AS
A VARIABLE OR A PROPERTY LIST AND VICE VERSA. BUT THIS
RESTRICTION IS IMPOSED IN THE SAME LEVEL OF THE LAMBDA BINDING,
SO THE LAMBDA BINDER MAKES THE LOCAL FUNCTION AND PROPERTY LIST
POSSIBLE.
--APPENDIX F: SPECIAL LAMBDA BINDER--
HALISP EVALUATER HAS TWO MODES OF LAMBDA BINDING, THE NORMAL
AND THE SPECIAL. IN SPECIAL MODE THE SAME VALUE IS NEVER BOUND
TO THE SAME IDENTIFIER (ATOM). IT RESULTS IN EFFICIENT STACK
USAGE DURING THE BINDING PROCESS. USUALLY USING THE SPECIAL
MODE MAKES NO PROBLEMS DURING THE EVALUATION. BUT IN SOME
CASES, THE SPECIAL MODE PRODUCES DIFFERENT RESULTS FROM THE
NORMAL MODE. CONSIDER THE NEXT EXAMPLE,
  :(DEF (BOO X)
     (SETQ X 'DOG))
    BOO
  :(DEF (FOO X)
     (BOO X) X)
        
    FOO
    
  :(XBIND NIL) ;SET NORMAL MODE
    NIL
  :(FOO 'CAT)
    CAT
  :(XBIND T) ;SET SPECIAL MODE
    T
  :(FOO 'CAT)
    DOG










---                                                           ---

PAGE 73    APPENDICES


--APPENDIX G: MEMORY MAP--
 ADDRESS        MAIN MEMORY
        0 +-------------------------+
          I                         I
          I RESERVED FOR RT-11      I
          I                         I
     1000 +=========================+
          I                         I
          I HALISP SUBCONSCIOUS     I
          I                         I
          I * PRIMITIVE FUNCTIONS   I
          I * MEMORY MANAGER        I
          I * INTERPRETER           I
          I * I/O FUNCTIONS         I
          I * HASH BUCKET TABLE     I
          I                         I
          +:::::::::::::::::::::::::+
          I                         I
          I BUILT-IN FUNCTION'S     I
          I                         I
          I  FUNCTION TYPES         I
          I  PRINT NAMES            I
          I                         I
  DASTOP->+:::::::::::::::::::::::::+
  AVAIL ->I                         I
          I BULK INITIALIZING CODE  I
          I                         I
          ///////////////////////////
          I                         I
          I DYNAMIC ALLOCATED SPACE I
          I   (DAS)                 I
          I                         I
          I * ATOM PRINT NAMES      I
          I * FUNCTION TYPES        I
          I * I/O BUFFERS           I
          I * COMPILED MACHINE CODE I
          I * DEVICE HANDLERS       I
          I * ETC.                  I
          I                         I
   FENCE->+:::::::::::::::::::::::::+
          I                         I
          I ARGUMENT PASSING STACK  I
          I                         I
      R5->I.........................I
          I          !              I
          I          V              I
          I     STACK SPACE         I
          I          ^              I
          I          !              I
      SP->I.........................I
          I                         I
          I RETURN ADDRESS STACK    I
          I                         I
   HIMEM->+=========================+
          I                         I
          I RT-11 OPERATING SYSTEM  I
          I DEVICE HANDLERS         I
          I                         I
      28K +-------------------------+



---                                                           ---

PAGE 74    APPENDICES


 CELL ADDR       BULK MEMORY
        0 +-------------------------+
          I                         I
          I  BUILT-IN FUNCTION'S    I
          I  ATOM HEADER            I
          I                         I
   FRTOP->+:::::::::::::::::::::::::+
   FREE ->I                         I
          I                         I
          I                         I
          I  FREE CELL SPACE        I
          I                         I
          I   * LIST CELL           I
          I   * ATOM HEADER         I
          I   * NUMERIC ATOM        I
          I                         I
          I                         I
          I                         I
      64K +-------------------------+












































---                                                           ---