--- --- 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 1 DEC 1981 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) 1978,1980 BY Yasuyuki Kinoshita COPYRIGHT (C) 1978,1980 BY MMA, University of Electro-Communications PRINTED IN TOKYO JAPAN --- --- PAGE 3 TABLE OF CONTENTS -----TABLE OF CONTENTS----- SECTION TITLE PAGE <1> OVERVIEW 4 INTRODUCTION DATA STRUCTURES <2> HALISP SYSTEM 5 HALISP SYSTEM REQUIREMENTS GETTING STARTED <3> SYNTACTIC DEFINITIONS 9 <4> FUNCTION DEFINITION 11 FUNCTION TYPES DEFINITION OF THE FUNCTION MACRO FACILITY FUNCTION AUTO LOADING MECHANISM <5> BUILT-IN FUNCTIONS 13 ARGUMENTS NOTATION FUNCTION NOTATION BUILT-IN FUNCTIONS [1] ELEMENTARY FUNCTIONS AND PREDICATES 13 [2] LIST MANIPULATION FUNCTIONS 19 [3] EVALUATION SEQUENCE CONTROL FUNCTIONS 22 [4] PROPERTY LIST MANIPULATION FUNCTIONS 28 [5] FUNCTIONALS 29 [6] ARITHMETIC FUNCTION AND PREDICATES 31 [7] INPUT/OUTPUT FUNCTIONS 35 [8] DEBUGGING FUNCTIONS 39 [9] TAG FUNCTIONS 39 [10] SYSTEM SWITCHES AND MISCELLANEOUS 41 [11] GRAPHICS FUNCTIONS 43 [12] SYSTEM CONSTANTS AND INDICATORS 44 <6> ERROR FUNCTION 46 IMPLEMENTATION OF ERROR RECOVERING DEFINITION OF THE TYPICAL ERROR FUNCTION EXAMPLES OF ERROR RECOVERING APPENDICES APPENDIX A: PROGRAM EDITING APPENDIX B: ONE WAY TO GOOD PROGRAMMING 48 APPENDIX C: DEBUGGING 52 APPENDIX D: CONFLICT OF VARIABLE NAMES APPENDIX E: SPACE SAVERS APPENDIX F: LARGE PROGRAM EXCUTION APPENDIX G: MEMORY MAP APPENDIX H: TYPICAL DEFINITIONS OF BUILT-IN EXPRS --- --- PAGE 4 OVERVIEW <1> OVERVIEW --INTRODUCTION-- HALISP IS A LIST PROCESSOR FOR MOTOROLA MC6800 BASED MICRO COMPUTER SYSTEM. ABSTRACTION OF LISP IS AS FOLLOWS. 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. --DATA STRUCTURES-- IN A TRADITIONAL LANGUAGE WE WOULD FIND NUMERIC CONSTANTS. IN LISP, THE ANALOGOUS CONSTANTS ARE CALLED "ATOMS". AN ATOM IS EITHER A NUMERAL OR A LITERAL ATOM - A STRING OF UPPER CASE ALPHANUMERIC CHARACTERS SUCH THAT THE ONE CHARACTER IN THE STRING IS AN ALPHABETIC CHARACTER. FOR EXAMPLE, "ABC123", "12", "1ABC", AND "NIL" ARE ATOMS, BUT "(A.B)" AND "(C D)" ARE NOT. LISP ALSO HAS COMPOSITE CONSTANTS CALLED "LISTS". LISTS ARE BUILT OUT OF ATOMS AND OTHER LISTS AS FOLLOWS: * ANY ATOM OR LIST CAN BE AN ELEMENT OF A LIST. * GIVEN ANY COLLECTION E1,...,EN OF LIST ELEMENTS,THEN (E1 ... EN) IS ALSO A LIST. SO, (A B) IS A LIST; AS IS (A B C), AND (A 1 (ABC 23)). THE LAST EXAMPLE IS A LIST OF THREE ELEMENTS; ITS THIRD ELEMENT IS ALSO A LIST - OF TWO ELEMENTS: THE ATOM "ABC" AND THE NUMERAL "23". ATOMS AND LISTS ARE THE BASIC LISP DATA STRUCTURES. - JOHN ALLEN FROM BYTE AUG79 - --- --- PAGE 5 HALISP SYSTEM <2> HALISP SYSTEM --HALISP-- HALISP WAS IMPLEMENTED AS ONE STEP TO REALIZE THE MACHINE INTELLIGENCE AND UNDERSTAND WHAT IS THE SUBSTANCE OF HUMAN INTELLIGENCE. SO APPROXIMATION OF HUMAN BEHAVIOUR, FOR INSTANCE EMOTION, CREATION OR RECOGNITION OF PATTERNS, LANGUAGE MANIPULATION, PROBLEM SOLVING, LEARNING, PERSONALITY, ART, OR THESE RELATION ARE MOST INTERESTING OBJECTS TO HALISP. IN THE NEAR FUTURE WE BELIEVE THAT THE FREE-TALK COMPUTER WILL APPEAR. MAYBE IT-NO! "HE" WILL HAVE HIS OWN INTENT AND EMOTION. THE CREATER OF SUCH FRIENDLY COMPUTER IS JUST YOU! --SYSTEM REQUIREMENTS-- HALISP CAN RUN ON THE MOTOROLA MC6800 PROCESSOR UNDER THE MMA STANDARD OPERATING SYSTEM. AND RECOMMEND TO USE WITH THE INTERACTIVE TEXT SCREEN EDITOR FOR CREATING OR EDITING PROGRAM AND DATA. --GETTING STARTED-- AFTER OS BOOTED AND SYSTEM CONTROL TRANSFERED TO CONSOLE COMMAND PROCESSOR(CCP) NOW TYPE, A> LISP AND IN A FEW SECONDS HALISP WILL BE UP AND THE NEXT MESSAGE WILL APPEAR. *** WELCOME TO HALISP 6800 *** *** COPYRIGHT 1978,1981 BY MMA *** 4192256 CELLS FREE : AT THIS POINT, SYSTEM 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 SYSTEM REPEATS ONLY THIS PROCEDURE ETERNALLY. FOR EXSAMPLE, :(CAR(QUOTE(A B C D)) THEN HALISP WILL RESPOND, A RESPONSES ARE INDENTED BY TWO SPACES. DO ANOTHER, :(CDR '(A B C D)) --- --- PAGE 6 HALISP SYSTEM (B C D) AN S-EXPRESSION TAGGED A SINGLE QUOTATION MARK IS PARSED TO BE QUOTED VALUE. SO IT EQUALS TO THE FUNCTION "QUOTE". MEANS PRESSING THE CARRIAGE RETURN KEY. IF YOU ARE UNFAMILIAR WITH LISP NOW INVOKE DEMO-PROGRAM TO SHOW YOU ITS ABILITY, INTEREST AND POWER! THIS PROGRAM DIFFERENTIATE A SIMPLE NUMERICAL EXPRESSION THAT YOU WANT. TRY TO TYPE, :(DIFF) THEN HALISP WILL BEGIN TO READ THE PROGRAM FROM DISK. AFTER ABOUT A FEW SECONDS HALISP FINISH IT AND PRINT MESSAGE, THE DERIVATIVE OF- 3X^3+2X^2+X+3, WITH RESPECT TO- X, IS- 9 X^2 + 4 X + 1 THE DERIVATIVE OF- 3(X^2+X)+2X^3, WITH RESPECT TO- X, IS- 3 (2 X + 1) + 6 X^2 THE DERIVATIVE OF- . FINIS : 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. MY NAME IS TOM. --- --- PAGE 7 HALISP SYSTEM 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. THIS IS QUITE INTERESTING. AND THE NEXT PROGRAM IS "HAL". HE LEARNS WHAT YOU SAID, AND HE CAN ANSWER YOUR QUESTIONS. :(HAL) GOOD MORNING DR.CHANDRA. THIS IS HAL. I AM READY FOR MY FIRST LESSON TODAY. YOU ARE COMPUTER. OK, I AM COMPUTER. ALL COMPUTER IS MACHINE. OK, ALL COMPUTER IS MACHINE. ALL MACHINE IS MADE-BY-HUMAN. OK, ALL MACHINE IS MADE-BY-HUMAN. ARE YOU MADE-BY-HUMAN? YES, I AM MADE-BY-HUMAN. WHY? BECAUSE I AM MACHINE. WHY? BECAUSE I AM COMPUTER. WHY? BECAUSE YOU SAID TO ME SO. I AM TEACHER. OK, YOU ARE TEACHER. ALL TEACHER IS HUMAN. --- --- PAGE 8 HALISP SYSTEM OK, ALL TEACHER IS HUMAN. ALL HUMAN IS FRIEND. OK, ALL HUMAN IS FRIEND. BOWMAN IS BOY. OK, BOWMAN IS BOY. ALL BOY IS HUMAN. OK, ALL BOY IS HUMAN. AM I FRIEND? YES, YOU ARE FRIEND. WHY I AM FRIEND? BECAUSE YOU ARE HUMAN. WHY? BECAUSE YOU ARE TEACHER. IS BOWMAN FRIEND? YES, BOWMAN IS FRIEND. WHY? BECAUSE BOWMAN IS HUMAN. WHY? BECAUSE BOWMAN IS BOY. BYE. THANKS FOR YOUR KINDLY LESSON TO ME. GOOD BYE. --- --- PAGE 9 DEFINTIONS <3> SYNTACTIC DEFINITIONS < > ::= METASYMBOL USED TO ENCLOSE MATERIAL WHICH IS NONTERMINAL SYMBOL , ::= METASYMBOL USED TO SEPARATE ALTERNATIVES ::= 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 ::= !,",#,$,%,&,*,:,@,-,=,+,,,<,>,?,^ ::= (,),.,[,], ,/,',; ::= 1,2,3,4,5,6,7,8,9,0 ::= ,, ::= A PRESS OF THE RETURN KEY ::= ,/ ::= , ::= , ::= ::= , A LITERAL ATOM MAY BE UP TO 80 CHRACTERS IN LENGTH. EXAMPLE ATOMS OF INCLUDING SPECIALS: THIS/ IS/ A/ MESSAGE/. : THIS IS A MESSAGE. 1*/(2+3/) : 1*(2+3) ::= , ::= ,+,- ::= , HALISP PROVIDES INDEFINITE PRECISION RATIONAL INTEGER ARITHMETIC, SO NUMBER OF DIGITS IS LIMITED ONLY BY THE NUMBER OF REMAINING FREE CELLS. ::= , --- --- PAGE 10 DEFINTIONS ::= ,(.) ::= (.] ::= (),[),(],[],(),[) ::= (],[] ::= , ::= , ::= ,( 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))) ::= ::= (QUOTE ),' ::= ::= (LAMBDA () ) ::= , ::= ,,
::= ,,( ) FORM MAY ALSO INCLUDE SUPER PARENTHESES. ::= , ::= THE VALUE OF THE COMPUTED FUNCTION MUST BE A FUNCTION NAME OR A LAMBDA EXPRESSION. ::= ; --- --- PAGE 11 FUNCTION DEFINITION <4> FUNCTION DEFINITION --FUNCTION TYPES-- HALISP PROVIDES EIGHT DIFFERENT FUNCTION TYPES DISCRIMINATED AGAINST THERE ARGUMENTS TREATMENT AND DEFINED FORM: MACHINE LANGUAGE OR S-EXPRESSION. AND THERE ARE TWO ASPECTS ON ARGUMENT TREATMENTS, THE FIRST IS THERE NUMBER AND THE SECOND IS THERE EVALUATION BEFORE THE FUNCTION CALL. FUNCTION TYPES AND THERE MEANINGS ARE AS FOLLOWS. 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 --DEFINITION OF THE FUNCTION-- TO DEFINE FUNCTIONS, FIRST THE FUNCTION BODY ITSELF ASSIGN TO FUNCTION NAME ATOM USING THE FUNCTION "SETQ" OR "SET". THAT IS, :(SETQ ') OR, :(SET ' ') BUT IT IS NOT NECESSARY THAT ASSIGN IS TOP LEVEL BINDING. AND THE NEXT THE FUNCTION TYPE IDENTIFIER SET TO FUNCTION NAME ATOM USING THE FUNCTION "TAG". THAT IS, :(TAG ' ') IS ALLOWED ONE OF EIGHT FUNCTION TYPE NAMES. BUT USUALLY USER CAN SET ONLY EXPR,KEXPR,LEXPR AND FEXPR OF EXPR'S. BECAUSE THE 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. :[SETQ DE '(LAMBDA (FNL BODY) : (PROGN [SET (CAR FNL) : (LIST 'LAMBDA (CDR FNL) BODY] : (TAG (CAR FNL) 'EXPR) : (CAR FNL] :(TAG 'DE 'KEXPR) THE FUNCTION THAT IS DEFINED IN THIS WAY CAN BE USED IN USER PROGRAMS IMMEDIATELY. --- --- PAGE 12 FUNCTION DEFINITION INSTANTLY, WE DEFINE A NEW EXPR FUNCTION USING "DE". :[DE (COUNTATOMS S) : (COND ((NULL S) 0) : ((ATOM S) 1) : (T (PLUS (COUNTATOMS (CAR S)) : (COUNTATOMS (CDR S))] COUNTATOMS :(COUNTATOMS '((LISP) ((FORTRAN) BASIC) (PASCAL) (HAL))) 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 IMPLEMETED BY EVALUATING THE RESULT OF THE MACRO FUNCTION AGAIN IN THE PRECEDING CONTEXT TO THAT MACRO FUNCTION CALL. HALISP MACRO FUNCTION HAS THE SAME FUNCTION TYPE OF NORMAL FUNCTION. BUT USUALY ONLY THE FEXPR OR KEXPR TYPE ARE USED. TO DEFINE THE MACRO, FIRST DEFINE A NORMAL FEXPR OR KEXPR FUNCTION, NEXT PUT A MACRO TAG TO THE FUNCTION NAME ATOM USING THIS FORM: :(MACRO ') FOR EXAMPLE, SUPPOSING INCREASER OF VARIABLE'S VALUE, :(DEF KEXPR (INC X) : (LIST 'SETQ X (LIST 'ADD1 X] INC :(MACRO 'INC) INC :(PROGN (SETQ A 1) (INC A) A) 2 --FUNCTION AUTOMATIC LOADING MECHANISM-- IF HALISP DETECTS AN UNDEFINED FUNCTION DURING THE EVALUATION HALISP TRYS TO LOOK FOR DISK FILES OF THAT FUNCTION NAME, AND READ ONE S-EXPRESSION FROM THAT FILE AND EVALUATE IT. SO, IF USER WRITE "EXPR"S DEFINITION TO THE DISK FILES, NO COMMANDS ARE REQUIRED TO READ THAT FILE BEFORE USING THE FUNCTION IN HALISP. UNDEFINED CONSTANTS ARE THE SAME AS THE FUNCTIONS. --- --- PAGE 13 BUILT-IN FUNCTIONS <5> BUILT-IN FUNCTIONS --ARGUMENTS NOTATION-- SYMBOL : MEANING : ANY LITERAL OR NUMERIC ATOM : ANY LITERAL ATOM : ANY NUMERIC ATOM : ANY S-EXPRESSION : FUNCTION NAME OR LAMBDA EXPRESSION OR FORM FOR COMPUTED FUNCTION : A LIST LIKE ( ,,, ) OR NIL

: TRUE OR FALSE, TRUE MAY BE NOT NIL, AND FALSE IS NIL : AN ASSOCIATION LIST LIKE ((ATOM1.S1) (ATOM2.S2) ,,, (ATOMN.SN)) : ANY LITERAL ATOM FOR VARIABLE NAME : ANY LITERAL ATOM FOR PROPERTY NAME : ANY S-EXPRESSION FOR PROPERTY VALUE : ANY LITERAL ATOM FOR FILE SPECIFICATION '< > : ARGUMENT THAT IS NOT EVALUATE /< > : ARGUMENT THAT CAN BE DEFAULT NOTE: IF DEFAULT SUBR'S ARGUMENTS, IT CAUSES AN ERROR OF ARGUMENTS-NUMBER-MISMATCH. --FUNCTION NOTATION-- ( ,,, ) : FUNCTION TYPE --BUILT-IN FUNCTIONS-- [1] ELEMENTARY FUNCTIONS AND PREDICATES (ATOM ) : SUBR RETURNS TRUE IF THE S-EXPRESSION IS AN ATOM. OTHERWISE IT RETUNRS NIL. EX. :(ATOM 'METAL) TRUE :(ATOM 1) TRUE :(ATOM '(A B C)) NIL (CAR ) : SUBR RETURNS A FIRST ELEMENT OF LIST . EX. :(CAR '(HEAD BODY TAIL)) HEAD --- --- PAGE 14 BUILT-IN FUNCTIONS (CDR ) : SUBR RETURNS A VALUE REPRESENTING THE LIST WITH THE FIRST ELEMENT REMOVED. EX. :(CDR '(HEAD BODY LEG TAIL)) (BODY LEG TAIL) (C...R ) : 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 ) : SUBR ADDS THE S-EXPRESSION TO THE SECOND S-EXPRESSION AS THE FIRST ELEMENT. OR MAKES DOTTED PAIR OF FOR CAR AND FOR CDR. EX. :(CONS 'STACK '(QUEUE DEQUE)) (STACK QUEUE DEQUE) (ELEMENT ) : SUBR RETURNS -1 TIMES CDRS OF THE LIST . IF NUMBER IS NEGATIVE IT GETS FROM THE TAIL OF THE LIST . EX. :(ELEMENT 3 '(A B C D)) (C D) :(ELEMENT 1 '(A B C)) (A B C) :(ELEMENT -2 '(A B C D E)) (D E) :(ELEMENT 4 '(A B)) NIL (EQ ) : SUBR COMPARE TWO LITERAL ATOMS, AND RETURNS TRUE JUST IN CASE THOSE TWO ARE THE SAME, OTHERWISE IT RETUNRS NIL. --- --- PAGE 15 BUILT-IN FUNCTIONS EX. :(EQ 'CAT 'NEKO) NIL :(EQ 'JUNE 'JUNE) TRUE :(SETQ X 'APRIL) APRIL :(EQ X 'APRIL) TRUE :(SETQ X '(JAPAN CHINA KOREA)) (JAPAN CHINA KOREA) :(EQ X X) TRUE :(EQ X '(JAPAN CHINA KOREA)) NIL :(EQ 8080 8080) NIL (EQN ) :SUBR COMPARE TWO LITERAL OR NUMERIC ATOMS, AND RETURNS TRUE JUST IN CASE THOSE TWO ARE THE SAME, OTHERWISE IT RETUNRS NIL. EX. :(EQN 'MOTOROLA 'MOTOROLA) TRUE :(EQN 6800 6800) TRUE :(EQN 6809 6808) NIL (EQUAL ) : SUBR RETURNS TRUE IF THE TWO S-EXPRESSIONS ARE IDENTICAL. THE S-EXPRESSION MAY ALSO INCLUDE NUMERICAL ATOMS IN ITS LIST. --- --- PAGE 16 BUILT-IN FUNCTIONS EX. :(EQUAL 'INTEL 'MOTOROLA) NIL :(EQUAL '((A) B C) '((A) B C)) TRUE :(SETQ X '(I SAID I HATE YOU)) (I SAID I HATE YOU) :(EQUAL X X) TRUE :(EQUAL X '(I SAID I HATE YOU)) TRUE :(EQUAL 8088 8088) TRUE (LAST ) : SUBR RETURNS THE LIST OF THE LAST ELEMENT OF LIST . EX. :(LAST '(A B C D)) (D) (LIST ,,, ) : LSUBR RETURNS A LIST OF N ELEMENTS CONSTRUCTED FROM THE N ARGUMENTS. EX. :(LIST 'HEAD 'NECK '(BODY) 'TAIL) (HAED NECK (BODY) TAIL) :(LIST 'PLUS 2 3 4 5) (PLUS 2 3 4 5) (MEMBER ) : SUBR RETURNS TRUE IF THE S-EXPRESSION IS EQUAL TO A TOP-LEVEL ELEMENT OF THE LIST . IT IS FASTER TO SEARCH BY USING "MEMQ" IF IS AN ATOM. EX. :(MEMBER '(DET INDEF) '((NUMB SINGLE) (DET INDEF] TRUE :(MEMBER 'DOG '(ALBATROSS DOG PENGUIN TIGER)) --- --- PAGE 17 BUILT-IN FUNCTIONS TRUE (MEMQ ) : SUBR RETURNS TRUE IF THE ATOM IS EQUAL TO A TOP-LEVEL ELEMENT OF THE LIST . EX. :(MEMQ 'SHI '(SA SHI SU SE SO)) TRUE :(MEMQ 'NI '(HA HI HU HE HO)) NIL (NATOM ) : SUBR RETUNRS TRUE IF THE S-EXPRESSION IS NOT AN ATOM. OTHERWISE RETUNRS NIL. EX. :(NATOM 'NOUN34) NIL (NCONS ) : SUBR EQUALS TO (CONS NIL). SLIGHTLY FASTER AND SAVE FREE STORAGE THAN USING (CONS NIL). EX. :(NCONS 'ENCLOSE-ME) (ENCLOSE-ME) (NEQ ) : SUBR RETURNS TRUE IF THE TWO ATOMS ARE NOT THE SAME. OTHERWISE RETURNS NIL. EX. :(NEQ 'I 'YOU) TRUE (NOT ) : SUBR RETURNS TRUE IF THE S-EXPRESSION IS NIL OR NIL OTHERWISE. EQUIVALENT TO "NULL". EX. :(NOT T) NIL :(NOT (NOT T)) TRUE --- --- PAGE 18 BUILT-IN FUNCTIONS (NULL ) : SUBR RETURNS TRUE IF THE S-EXPRESSION IS AN EMPTY LIST () OR NIL OTHERWISE. EQUIVALENT TO "NOT". EX. :(NULL NIL) TRUE :(NULL '(A B)) NIL (NUMBERP ) : SUBR RETURNS TRUE IF THE S-EXPRESSION IS A NUMERICAL ATOM. EX. :(NUMBERP 5) TRUE :(NUMBERP 'VERB) NIL (QUOTE ') : KSUBR RETURNS S-EXPRESSION ITSELF. EQUIVALENT TO THE FORM OF '. EX. :(QUOTE DONT-EVALUATE) DONT-EVALUATE :'DONT-EVALUATE DONT-EVALUATE :'''DONT-EVALUATE (QUOTE (QUOTE DONT-EVALUATE)) (RPLACA ) : SUBR CHAINGES CAR POINTER OF TO . AND RETURNS THE VALUE . EX. :(RPLACA '(HEAD BODY TAIL) 'NEW) (NEW BODY TAIL) (RPLACD ) : SUBR CHAINGES CDR POINTER OF TO . AND RETURNS THE VALUE . --- --- PAGE 19 BUILT-IN FUNCTIONS EX. :(RPLACD '(HEAD BODY TAIL) '(NECK BUST STOMACH)) (HAED NECK BUST STOMACH) (SET ) : SUBR RETURNS THE SECOND S-EXPRESSION . THE FIRST S-EXPRESSION MUST EVALUATE TO AN ATOM AND THAT ATOM'S VALUE BECOMES THE VALUE OF SECOND S-EXPRESSION . SEE "SETQ". EX. :(SET 'X '(ADJ NOUN)) (ADJ NOUN) :(CONS 'DET X) (DET ADJ NOUN) (SETQ ' ) : KSUBR RETURNS THE S-EXPRESSION BUT HAS THE IMPORTANT SIDE EFFECT OF MAKING THE S-EXPRESSION BE THE VALUE OF THE ATOM . NOTE THAT THE ATOM IS NOT EVALUATED. EX. :(SETQ FRIENDS '(TOM DICK JANE SALLY)) (TOM DICK JANE SALLY) :(MEMQ 'SALLY FRIENDS) TRUE [2] LIST MANIPULATION FUNCTIONS (APPEND ,,, ) : LSUBR RETURNS A NEW SINGLE LIST WHOSE ELEMENTS ARE THE ELEMENTS OF ALL LISTS OF ARGUMENT STRUNG TOGETHER BY COPYING TO 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 ) : SUBR RETURNS A NEW S-EXPRESSION . BUT THE S-EXPRESSION IS --- --- PAGE 20 BUILT-IN FUNCTIONS FULLY RE-CONSTRUCTED USING "CONS". EX. :(COPY '(A (FULLY) COPIED LIST)) (A (FULLY) COPIED LIST) (DELETE ) : SUBR ACTUALLY REMOVES INSTANCES OF THE S-EXPRESSION WHICH APPEAR AS TOP ELEMENTS OF THE LIST . PHYSICAL STRUCTURE OF THE LIST IS ACTUALLY MODIFIED. 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 ) : SUBR ACTUALLY REMOVES INSTANCES OF THE ATOM WHICH APPEAR AS TOP ELEMENTS OF THE LIST . PHYSICAL STRUCTURE OF THE LIST IS ACTUALLY MODIFIED. 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 FREIND) (LENGTH ) : SUBR RETURNS A NUMBER OF THE TOP LEVEL ELEMENTS OF A LIST . EX. :(LENGTH '(A ((B) C) D (E F] 4 (NCONC ,,, ) : 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 TO , TO ,,, TO . PHYSICAL STRUCTURES OF THE LISTS TO ARE ACTUALLY MODIFIED. EX. :(NCONC '(A B C) '(D E)) (A B C D E) --- --- PAGE 21 BUILT-IN FUNCTIONS (PAIR /) : LSUBR RETURNS A ASSOCIATION LIST MADE FROM THE ELEMENTS OF THE LISTS AND APPEND TO ASSOCIATION LIST . AN ERROR IS OCCURED IF THE LENGTH OF THE LIST , 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)) (REMOVE ) : SUBR MAKES A NEW LIST OF REMOVED INSTANCES OF THE S-EXPRESSION WHICH APPEAR AS TOP ELEMENTS OF THE LIST . PHYSICAL STRUCTURE OF THE LIST 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 ) : SUBR RETURNS A NEW LIST WHOSE ELEMENTS ARE REVERSED THE ORDER OF THE ELEMENTS IN THE GIVEN LIST . NOTE THAT REVERSAL TAKES PLACE ONLY AT THE TOP LEVEL. PHYSICAL STRUCTURE OF THE LIST 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] ((C D) (A B)) (REVERSIP ) : SUBR RETURNS A LIST WHOSE ELEMENTS ARE ACTUALLY REVERSED THE ORDER OF THE ELEMENTS IN THE GIVEN LIST . NOTE THAT THE ARGUMENT LIST DOES NOT EXIST IN THE MEMORY AFTER THE REVERSAL. CONTRAST WITH "REVERSE". PHYSICAL STRUCTURE OF THE LIST IS ACTUALLY MODIFIED. --- --- PAGE 22 BUILT-IN FUNCTIONS REVERSIP = [LAMBDA (L) (COND ((NULL L) NIL) (T (NCONC (REVERSIP (CDR L)) (RPLACD L NIL] EX. :(REVERSIP '(A B)) (B A) (SUBLIS ) : SUBR RETURNS A NEW S-EXPRESSION WHOSE EVERY ATOM IS SUBSTITUTED FOR THE S-EXPRESSION ASSOCIATED FROM A-LIST WITH THAT ATOM AS A KEY. IF THE KEY IS NOT FOUND SUBSTITUTION IS NOT OCCURED. SUBLIS = [LAMBDA (A S) (COND ((ATOM S) (SUB2 A X)) (T (CONS (SUBLIS A (CAR X)) (SUBLIS A (CDR X] SUB2 = [LAMBDA (A X) (COND ((NULL A) X) ((EQ (CAAR A) Z) (CDAR A)) (T (SUB2 (CDR A) X] EX. :(SUBLIS '((X.TOKYO) (Y.OSAKA)) '((A B (X Y Z)) C] ((A B (TOKYO OSAKA Z)) C) (SUBST ) : SUBR RETURNS A NEW S-EXPRESSION WHICH S-EXPRESSION HAS SUBSTITUTED FOR ALL OCCURENCES OF S-EXPRESSION IN S-EXPRESSION . 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 'NEW 'OLD '(OLD FRIENDS BECOME OLD)) (NEW FRIENDS BECOME NEW) [3] EVALUATION SEQUENCE CONTROL FUNCTIONS (AND ,,, ) : FSUBR RETURNS NIL IF ANY OF THE S-EXPRESSIONS ARE NIL AND RETURNS OTHERWISE. IT DOES NOT EVALUATE ANY OF THE ARGUMENTS BEYOND THE FIRST NIL VALUE ENCOUNTERED. EX. :(AND T T T) TRUE --- --- PAGE 23 BUILT-IN FUNCTIONS :(AND T F (PRINT 'NOT-EVALUATE) T) NIL :(AND T (CDR '(A B C] (B C) (APPLY ) : SUBR OPERATES ON THE ARGUMENTS OF ARGUMENTS LIST WITH THE FUNCTION GIVEN AS IF THAT FUNCTION APPEARED AS THE FIRST ELEMENT IN THE LIST. BUT FEXPR,LEXPR AND FSUBR ARE NOT PERMITTED AS THE FUNCTION . 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)) :(APPLY (SUBST 'OR 'AND AND2) '(T F] TRUE (CASE (' ,,, ) (' ,,, ) ,,, (' ,,, ) ) : FSUBR USES ITS FIRST ARGUMENT 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 , EVALUATION BEGINS FROM THE NEXT ELEMENT TO THE LAST ONE IN ORDER. THE VALUE OF "CASE" IS AFTER ALL. UNFORTUNATELY THE KEY IS NOT FOUND, THE LAST ELEMENT OF ARGUMENT 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 --- --- PAGE 24 BUILT-IN FUNCTIONS :X SIDE-EFFECT (CATCH ' ,,, ) : FSUBR EVALUATES ITS SECOND ARGUMENT TO THE LAST ONE IN ORDER IN THE CURRENT CONTEXT, AND RETURNS THAT LAST 'S VALUE, EXCEPT THAT IF DURING THAT EVALUATION, A "THROW" WITH THE SAME LABEL 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) :(LIST-ADD1 '(3 4 -6 2)) -6 (COND ( ,,, /) ( ,,, /) ,,, ( ,,, /)) : FSUBR ONE OF THE EVALUATED LIST ELEMENT WILL BE THE VALUE OF THE ENTIRE "COND". THE IDEA IS TO CRUISE THROUGH THE LIST LOOKING ONLY AT THE FIRST ELEMENTS UNTIL ONE IS FOUND WHOSE VALUE IS "NOT" NIL. THEN EVERYTHING ELSE IN THE WINNING LIST IS EVALUATED AND THE LAST THING 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 AND RESULT 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 --- --- PAGE 25 BUILT-IN FUNCTIONS :X SIDE-EFFECT (DO ((' ) (' ) ,,, (' )) (

) ,,, ) : FSUBR EACH VARIABLE IS INITIALIZED TO ITS VALUE OF SIMULTANEOUSLY. EACH 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

, AND ON GIVING VALUE NON-NIL THE LOOP WILL TERMINATE, RETURNING THE VALUE OF AS THE RESULT OF THE "DO". IF

GIVES NIL THEN TO ARE EVALUATED IN ORDER. AFTER THE LAST ONE IS EVALUATED, THE FORMS ARE EVALUATED AND ASSIGNED TO THE VARIABLE 'S, AND ANOTHER CYCLE OF THE "DO" IS BEGUN. EX. :(DO ([Y NIL (CONS (CAR X) Y] : [X '(A B C D) (CDR X]) : ((NULL X) Y) : (TERPRI) : (PRINT X) : (PRINT Y] (A B C D) NIL (B C D) (A) (C D) (B A) (D) (C B A) (D C B A) (EVAL ) : SUBR RETURNS THE VALUE OF THE EVALUATED S-EXPRESSION . THIS MEANS THAT EVALUATION OF OCCURS TWICE. EX. :(SETQ FORM '(PLUS 2 3 4)) (PLUS 2 3 4) :(EVAL (APPEND FORM '(5 6] 20 --- --- PAGE 26 BUILT-IN FUNCTIONS (EVLIS ) : SUBR RETURNS A NEW LIST WHOSE ELEMENTS ARE EVALUATED OF THE AREGUMENT LIST . EX. :(EVLIS '((OR T F T) (AND T T) (NOT T) (TIMES 2 3] (T T NIL 6) (FUNCALL ,,, ) : LSUBR OPERATES ON THE ARGUMENTS OF ARGUMENTS ,,, WITH THE FUNCTION GIVEN AS IF THAT FUNCTION APPEARED AS THE FIRST ELEMENT IN THE LIST. EX. :(FUNCALL 'PLUS 2 3 (ADD1 3) 5) 14 (GO ) : KSUBR EVALUATION CONTROL IS TRANSFERRED TO THE LABEL ATOM WITHIN RECENT LEVEL OF "PROG". IF IS NOT ATOMIC, IS EVALUATED UNTIL THE VALUE IS ATOMIC. SEE "PROG". (OR ,,, ) : 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 F T T) TRUE :(OR F NIL 'HERE (PRINT 'NOT-EVALUATE)) HERE (PROG '( ,,, ) ,,, ) : 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 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". --- --- PAGE 27 BUILT-IN FUNCTIONS ANY ATOM APPEARING AS AN ARGUMENT TO PROG IS CONSIDERED TO BE A POSITION MARKER LABEL. THESE ATOMS MARK PLACES TO WHICH CONTROL IS TRANSFERRED BY "GO" FUNCTIONS. (GO ) TRANSFERS CONTROL TO A MARKER NAMED , IF IS AN ATOM. OTHEWISE IS EVALUATED UNTIL AN ATOM. "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 (PROGN ,,, ) : FSUBR RETURNS A VALUE OF 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 ,,, ) : FSUBR RETURNS A VALUE OF . BUT THE FOLLOWING ARGUMETS ARE EVALUATED IN ORDER. EX. :(PROG1 (TIMES 2 4) (SETQ Y 'APPLEPIE)) 8 :Y APPLEPIE (RETURN ) : SUBR CAUSES THE S-EXPRESSION TO BE RETURNED IMMEDIATELY AS THE VALUE OF THE "PROG" IT APPEARS IN. SEE "PROG". (THROW ' ,,, ) : FSUBR EVALUATES ITS SECOND ARGUMENT TO THE LAST ONE IN --- --- PAGE 28 BUILT-IN FUNCTIONS ORDER IN THE CURRENT CONTEXT, AND RETURNS THE VALUE OF THE LAST ONE AS THE VALUE OF "CATCH" HOLDING THE SAME LABEL 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, ( ) NOTE A VARIABLE ATOM, A FUNCTION NAME OR A LABEL ATOM FOR "PROG" CANNOT HAVE A PROPERTY LIST WITH IN THE SAME LEVEL. (GET ) : SUBR RETURNS THE VALUE OF THE NAMED PROPERTY ASSOCIATED WITH THE ATOM . 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 (PROP ) : SUBR SIMILAR TO GET EXCEPT THAT THE RESULT IS THE ENTIRE PROPERTY LIST BEGINING WITH NAME . IF IT IS NOT FOUND, , WHICH MUST BE A FUNCTION OF NO ARGUMENTS, IS APPLIED AND THE RESULT IS THE VALUE OF "PROP". EX. (CONTINUED FROM THE EX. OF "GET") :(PROP '+ 'FUNC) (FUNC PLUS A-KIND-OF OPERATOR) :(PROP '+ 'PREFIX '(LAMBDA () (SETQ C 'FAIL] FAIL :C FAIL (PUTPROP ) : SUBR INSTALLS THE S-EXPRESSION AS THE GIVEN PROPERTY OF THE ATOM . AND RETURNS THE VALUE OF . EX. (CONTINUED FROM THE EX. OF "GET") :(PUTPROP '+ 'PREFIX '(0 100)) --- --- PAGE 29 BUILT-IN FUNCTIONS (0 100) :+ (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 ) : SUBR REMOVES THE PROPERTY NAME AND ITS VALUE FROM THE ATOM . AND RETURNS THE VALUE OF . EX. (CONTINUED FROM THE EX. OF "PUTPROP") :(REMPROP '+ 'INFIX) + :+ (FUNC PLUS A-KIND-OF OPERATOR PREFIX (0 100)) [5] FUNCTIONALS (MAP ) : LSUBR "MAP" APPLIES THE FUNCTION TO LIST AND SUCCESSIVE "CDR"S OF LIST . MUST DESCRIBE A FUNCTION OF ONLY ONE ARGUMENT. THE RESULT IS ALWAYS NIL. NOTE "MAP" IS USED ONLY FOR THE SIDE EFFECTION. MAP = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (FUNCALL FN L) (MAP (CDR L) FN] EX. :(MAP '(A B C D) 'PRINT) (A B C D) (B C D) (C D) (D) NIL (MAPC ) : LSUBR "MAPC" IS SIMILAR TO "MAP" EXCEPT THAT THE "MAPC" APPLIES FUCTION TO THE "CAR" OF SUCCESSIVE "CDR"S OF LIST . --- --- PAGE 30 BUILT-IN FUNCTIONS MAPC = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (FUNCALL FN (CAR L)) (MAPC (CDR L) FN] EX. :(MAPC '(X Y Z) '(LAMBDA (V) (SET V 'INIT] NIL :X Y Z INIT INIT INIT (MAPCAN ) : LSUBR "MAPCAN" IS SIMILAR TO "MAPC" EXCEPT THAT THE RESULT OF "MAPCAN" IS A "NCONC"ED LIST OF ALL THE RESULT OF APPLYING FUNCTION TO THE "CAR" OF SUCCESSIVE "CDR"S OF LIST . MAPCAN = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (NCONC [FUNCALL FN (CAR L] [MAPCAN (CDR L) FN]] EX. :(DEF (NOT-Z X) (COND ((NEQ X 'Z) (NCONS X] IS-Z :(MAPCAN '(A B Z C Z D) 'NOT-Z) (A B C D) (MAPCAR ) : LSUBR "MAPCAR" IS SIMILAR TO "MAPC" EXCEPT THAT THE RESULT OF "MAPCAR" IS A LIST OF ALL THE RESULT OF APPLYING FUNCTION TO THE "CAR" OF SUCCESSIVE "CDR"S OF LIST . MAPCAR = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (CONS [FUNCALL FN (CAR L] [MAPCAR (CDR L) FN]] EX. :(MAPCAR '(1 2 3) 'ADD1) (2 3 4) (MAPCON ) : LSUBR "MAPCON" IS SIMILAR TO "MAP" EXCEPT THAT THE RESULT OF "MAPCON" IS A LIST FORMED BY CONCATENATING ALL RESULTS OF APPLYING FUNCTION TO SUCCESSIVE "CDR"S OF LIST . --- --- PAGE 31 BUILT-IN FUNCTIONS THE RESULT OF EACH APPLICATION OF MUST THEREFORE ITSELF BE A LIST. NOTE THAT THE LIST STRUCTURE IS MODIFIED PHYSICALLY. MAPCON = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (NCONC (FUNCALL FN L) (MAPCON (CDR L) FN] EX. :(MAPCON '(A B C D) 'COPY) (A B C D B C D C D D) (MAPLIST ) : LSUBR "MAPLIST" IS SIMILAR TO "MAP" EXCEPT THAT THE RESULT OF "MAPLIST" IS A LIST OF ALL RESULTS OF APPLYING FUNCTION TO SUCCESSIVE "CDR"S OF LIST . MAPLIST = [LAMBDA (L FN) (COND ((NULL L) NIL) (T (CONS (FUNCALL FN L) (MAPLIST (CDR L) FN] EX. :(MAPLIST '(A B C D) '(LAMBDA (X) X] ((A B C D) (B C D) (C D) (D)) (SASSOC ) : 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, IS APPLIED TO NO ARGUMENTS AND THE RESULT IS THE VALUE OF "SASSOC". EX. :(SASSOC 'W '((U.PASCAL) (V.BASIC) (W.LISP] (W.LISP) :(SASSOC 'X '((U.PASCAL) (V.BASIC) (W.LISP)) '(LAMBDA () 'NOT-FOUND)) NOT-FOUND [6] ARITHMETIC FUNCTIONS AND PREDICATES (ABS ) : SUBR RETURNS THE ABSOLUTE VALUE OF NUMBER . EX. :(ABS -5) 5 --- --- PAGE 32 BUILT-IN FUNCTIONS :(ABS 5) 5 (ADD1 ) : SUBR RETURNS THE NUMBER PLUS ONE. EX. :(ADD1 3) 3 (DIFFERENCE ) : SUBR RETURNS THE VALUE OF -. EX. :(DIFFERENCE 5 6) -1 (DIVIDE ) : SUBR RETURNS (QUOTIENT ) AND THE VALUE OF (REMAINDER ) IS SET TO THE ATOM FOR THE SIDE EFFECTION. EX. :(DIVIDE 11 4 'R) 2 :R 3 (EQP ) : SUBR RETURNS TRUE IF THE NUMBERS ARE EQUAL. EX. :(EQP 2 3) NIL :(EQP -1 -1) TRUE (EXPT ) : SUBR RAISES THE NUMBER TO THE POWER GIVEN BY THE NUMBER . EX. :(EXPT 2 3) 8 --- --- PAGE 33 BUILT-IN FUNCTIONS :(EXPT 2 99) 633825300114114700748351602688 (GREATERP ) : SUBR RETURNS TRUE IF IS GREATER THAN . EX. :(GREATERP 10 7) TRUE (LESSP ) : SUBR RETURNS TRUE IF IS LESS THAN . EX. :(LESSP 6 7) TRUE :(LESSP 6 6) NIL (MAX ,,, ) : LSUBR RETURNS THE BIGGEST NUMBER. EX. :(MAX 5 6 -2 4 5) 6 (MIN ,,, ) : LSUBR RETURNS THE SMALLEST NUMBER. EX. :(MIN 5 6 -2 4 5 7) -2 (MINUS ) : SUBR RETURNS THE NEGATIVE OF THE NUMBER . EX. :(MINUS 4) -4 (MINUSP ) : SUBR RETURNS TRUE IF IS NAGATIVE. --- --- PAGE 34 BUILT-IN FUNCTIONS EX. :(MINUSP -2) TRUE :(MINUSP 0) NIL (REMAINDER ) : SUBR RETURNS THE REMAINDER AFTER DIVISION OF BY . EX. :(REMAINDER 100 33) 1 (ONEP ) : SUBR RETURNS TRUE IF IS ONE. EX. :(ONEP 1) TRUE (PLUS ,,, ) : LSUBR RETURNS THE SUM OF ALL THE NUMBERS. EX. :(PLUS 1 2 3 4 5 6 7 8 9 10) 55 (QUOTIENT ) : SUBR RETURNS THE RESULT OF DIVIDING BY . EX. :(QUOTIENT 20 7) 2 (RND ) : SUBR RETURNS THE RANDOM NUMBER BETWEEN 0 AND -1, IF IS POSITIVE; IF MINUS, IT RETURNS THE SAME RANDOM NUMBER BETWEEN -32767 AND 32767 EACH TIME IT IS USED WITH THE SAME . THE REASON FOR USING A NEGATIVE ARGUMENT FOR "RND" IS TO INITIALIZE (OR "SEED") A REPEATABLE SEQUENCE OF RANDOM NUMBERS. IF IS ZERO, "RND" RETURNS THE MOST RECENT PREVIOUS RANDOM NUMBER GENERATED BETWEEN -32767 AND 32767. EX. :(RND 10000) 6800 --- --- PAGE 35 BUILT-IN FUNCTIONS (SUB1 ) : SUBR RETURNS ONE LESS THAN THE NUMBER . EX. :(SUB1 0) -1 (TIMES ,,, ) : LSUBR RETURNS THE PRODUCT OF ALL THE NUMBERS. EX. :(TIMES 5 4 3 2) 120 (ZEROP ) : SUBR RETURNS TRUE IF IS ZERO. EX. :(ZEROP 0) TRUE :(ZEROP 2) NIL [7] INPUT/OUTPUT FUNCTIONS (CLOSE /) : LSUBR CLOSE THE CHANNEL NUMBER . IF DEFAULT , ALL OPENED CHANNES ARE CLOSED. THE RESULT "CLOSE" IS OR NIL FOR DEFAULT. SEE EX. OF "OPEN". (DRIVE ) : SUBR CHANGES THE CURRENTLY SELECTED DISK DEVICE NAME TO . THE RESULT IS . MUST BE A,B,C OR D. EX. :(DRIVE 'B) B (OPEN ) : SUBR OPENS A CHANNEL NUMBER OF ITS FILE SPECIFICATION AS ITS CHANNEL MODE . THE RESULT IS THE NUMBER . MUST BE IN RANGE 0 TO 63. THE FILE SPECIFICATION HAS THE NEXT FORM, :. --- --- PAGE 36 BUILT-IN FUNCTIONS OF COURSE A DOT "." IS A SPECIAL CHARACTER FOR "READ", WHEN WRITING A PROGRAM, A SLASH "/" MUST BE USED FOR THE SPECIAL CHARACTER'S PREPOSITION. USE THE DEVICE NAME AMONG THE NEXT TABLE, DEVICE NAME : MEANING A,B,C,D : EACH DISK DEVICE TT : TERMINAL DEVICE LP : LINE PRINTER DEVICE IN CASE OF "TT" OR "LP" USING FOR OPEN DEVICE, THE FILE NAME AND TYPE ARE NOT REQUIRED. AND ARE THE SAME FORMAT OF M/DOS'S. IF IS DEFAULTED, IT IS ASSUMED TO BE CURRENTLY SELECTED DISK DEVICE. IF IS DEFAULTED, IS ASSUMED TO BE "LSP" IMPLICITLY. YOU MUST USE THE CHANNEL MODE AMONG THE NEXT TABLE, CHANNEL MODE : MEANING NEW : MAKE A NEW FILE FOR WRITE READ : OPEN AN OLD FILE FOR READ PRINT : OPEN AN OLD FILE FOR WRITE APPEND : OPEN AN OLD FILE FOR APPEND FOR EXAMPLE, (OPEN 'A:HAL 2 'NEW) : MAKE A NEW FILE NAMED "HAL.LSP" ON A DRIVE "A", AND OPENED AS CHANNEL 2 FOR WRITE. (OPEN 'TOM/.MAC 1 'READ) : OPEN AN OLD FILE NAMED "TOM.MAC" ON A CURRENTLY SELECTED DRIVE 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. EX. :(OPEN 'FILE 1 'NEW) 1 :(PRINT '(THIS IS A FILE OF ONE LIST) NIL 1) (THIS IS A FILE OF ONE LIST) :(CLOSE 1) --- --- PAGE 37 BUILT-IN FUNCTIONS 1 :(OPEN 'FILE 1 'READ) (READ 1) (CLOSE 1) 1 (THIS IS A FILE OF ONE LIST) 1 (POS /) : LSUBR RETURNS THE CURRENT COLUMN POSITION NUMBER OF THE OUTPUT CHANNEL , OR OF THE CURRENT SYSTEM OUTPUT FOR DEFAULT. EX. :(PROGN (PRIN1 'AUGUST) (PRIN1 'JULY) (POS)) AUGUSTJULY 10 (PRIN1 /

/) : LSUBR "PRIN1" IS SIMILAR TO "PRINT" EXCEPT THAT "PRIN1" DOES NOT OUTPUT A CARRIAGE RETURN WHEN STARTING. SEE "PRINT". (PRINT /

/) : LSUBR CAUSES A CARRIAGE RETURN AND THE S-EXPRESSION TO BE PRINTED OUT TO THE CHANNEL NUMBER . IF

IS NOT NIL, A SLASH "/" WILL BE PRINTED WHEN PRINTING A SPCIAL CHARACTER OF AN ATOM. IF IS DEFAULT, "PRINT" OUTPUTS TO THE CURRENT SYSTEM OUTPUT. AND IF

IS DEFAULT, IT IS ASSUMED TO BE NIL. EX. :(PROGN (PRINT 'CATTLE) (PRIN1 'MUTILATION) : (PRINT 'THIS/ IS/ A/ PEN/. T) : (TERPRI) : (PRIN1 'THIS/ IS/ A/ PEN/.] CATTLEMUTILATION THIS/ IS/ A/ PEN/. THIS IS A PEN. NIL (RATOM /) : LSUBR RETURNS AN ATOM READING FROM THE CHANNEL NUMBER . NOTE THAT "RATOM" READS A SPECIAL CHARACTER AS ONE ATOM. IF IS DEFAULT, IT READS FROM CURRENT SYSYTEM INPUT. EX. :(RATOM) ?EXAMPLE EXAMPLE --- --- PAGE 38 BUILT-IN FUNCTIONS (READ /) : LSUBR RETURNS THE NEXT S-EXPRESSION READ FROM THE CHANNEL NUMBER . IF IS DEFAULT, IT READS FROM CURRENT SYSTEM INPUT. EX. :(READ) ?(EXAMPLE) (EXAMPLE) :(READ)(INSTANCE) (INSTANCE) (READC /) : LSUBR RETURNS THE NEXT ATOM OF ONE CHARACTER READ FROM THE CHANNEL NUMBER . IF IS DEFAULT, IT READS FROM CURRENT SYSYTEM INPUT. EX. :(READC) ?X X :(READC)A A (SYSIN ) : SUBR CHANGES CURRENT SYSTEM INPUT TO THE FILE SPECIFICATION . SEE "OPEN" ABOUT THE FILE SPECIFICATION. (SYSOUT ) : SUBR CHANGES CURRENT SYSTEM OUTPUT TO THE FILE SPECIFICATION . SEE "OPEN" ABOUT THE FILE SPECIFICATION. (TAB /) : LSUBR MOVES OUTPUT COLUMN POSITION TO OF THE OUTPUT CHANNEL , OR OF THE CURRENT SYSTEM OUTPUT FOR DEFAULT. EX. :(PROGN (TAB 10) (PRINT 'HELLO)) HELLO HELLO (TERPRI /) : LSUBR CAUSES A CARRIAGE RETURN AND LINE FEED TO BE PRINTED TO CANNEL NUMBER . IF DEFAULT , IT CAUSES TO CURRENT SYSOUT. THE RESULT IS NIL. --- --- PAGE 39 BUILT-IN FUNCTIONS 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 [8] DEBUGGING FUNCTIONS SEE "APPENDIX C" ABOUT THE EXAMPLE OF DEBUGGING. (BAKTRACE) : SUBR NOT IMPLEMENTED CAUSES BACK TRACING. (DISKOFF

) : SUBR STOPS AUTO LOADING OF UNDEFINED FUNCTION OR VALUE FROM DISK, IF

IS TRUE. IF

IS NIL, THIS MECHANISM WILL RECOVER. (ERROR ) : EXPR UNIVERSAL ERROR FUNCTION FOR SYSTEM AND USER. IF HALISP DETECTS AN ERROR, CONTROL TRANSFER TO THIS FUNCTION. AND ARE MESSAGES TO THE ERROR FUNCTION. SEE "<6> ERROR FUNCTION". (MON

) : SUBR IF

IS TRUE, HALISP ECHO BACKS READING OR WRITING CHARACTER BETWEEN DISK TO TERMIAL OUTPUT. IF IS NIL, OFF THE ECHO BACK. (TRACE ' ' ,,, ') : FSUBR CAUSES PRINTING A TRACE MESSAGE OF THE FUNCTION NAME ,,, WHEN ENTERING OR EXITING THE FUNCTIONS. IF THAT ATOM IS USED AS VARIABLE AND WHEN SET OR SETQ OCCURS, ALSO PRINTS OUT A MESSAGE. (UNTRACE ' ' ,,, ') : FSUBR STOPS TRACING OF THE FUNCTIONS OR VARIABLES ,,, . [9] TAG FUNCTIONS EVERY LITERAL ATOM CAN HOLD TAG INFORMATIONS TO BE RECOGNIZED BY HALISP INTERPRET FUNCTION "EVAL","APPLY". THE TAG IS USED AS AN IDENTIFIER OF ITS FUNCTION TYPE. (DEF /' '( ,,, ) ') : KEXPR DEFINE A FUNCTION WHOSE FUNCTION TYPE IS , FUCTION --- --- PAGE 40 BUILT-IN FUNCTIONS NAME IS , FORMAL ARGUMENTS ARE TO , AND THE BODY IS . IF THE TYPE IS DEFAULT, THE TYPE IS ASSUMED TO BE "EXPR". SEE "FUNCTION TYPES". EX. :(DEF (ADD2 X) (PLUS X 2)) ADD2 :(ADD2 4) 6 :(DEF KEXPR (INC ARG-OF-INC) : (SET ARG-OF-INC (ADD1 (EVAL ARG-OF-INC] INC :(PROGN (SETQ X 2) (INC X) (PRINT X)) 3 3 (GETF ) : SUBR RETURNS A FUNCTION TYPE OF . SEE "FUNCTION TYPES". EX. :(GETF 'CAR) SUBR (MACRO ) : SUBR PUT A MACRO TAG TO THE ATOM . THE RESULT IS . (REMTAG ) : SUBR REVOVES A FUNCTION TAG FROM THE ATOM . THE VALUE IS . AND ALSO REMOVES THE MACRO TAG. (TAG ) : SUBR PUT A TAG TO THE ATOM . THE TAG TYPES ARE EXPR, FEXPR, LEXPR, KEXPR, SUBR, FSUBR, LSUBR, AND KSUBR FOR EACH FUNCTION TYPES. EX. :(TAG 'FUNC 'EXPR) FUNC :(GETF 'FUNC) EXPR --- --- PAGE 41 BUILT-IN FUNCTIONS [10] SYSTEM SWITCHES AND MISCELLANEOUS (BOUNDP ) : SUBR RETURNS TRUE IF THE ATOM 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) TRUE (COLD) : SUBR CAUSES COLD START HALISP. EX. :(COLD) 4192256 CELLS FREE : (COMPILE ) : EXPR COMPILES ALL FUNCTIONS IN THE FILE SPECIFICATION INTO NATIVE MACHINE CODE AND MAKES A RELOCATABLE OBJECT FILE NAMED ".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 MAKE THE FILE "COMPILE.COD". (EDITL ) : EXPR EDITS A S-EXPRESSION . (EDITS ) : EXPR EDITS A SOURCE TEXT . (EXPLODE ) : SUBR CONVERTS THE ATOM INTO A LIST OF SINGLE CHARACTER ATOMS. --- --- PAGE 42 BUILT-IN FUNCTIONS EX. :(EXPLODE 'APPLE) (A P P L E) (IMPLODE ) : SUBR FORMES THE CHARACTERS OF LIST INTO A SINGLE ATOM AND RETURNS IT. EX. :(IMPLODE '(O R A N G E)) ORANGE (POBLIST) : SUBR PRINTS ALL EXISTING ATOMS IN SYSTEM AND ON DISK. EX. :(POBLIST) CAR CDR CONS ... . . . DISK: (PROMPT ) : SUBR CHAINGES THE PROMPT CHARACTER TO USING FOR TERMINAL INPUT. EX. :(PROMPT '*) * *(RESET) : (QUIT) : SUBR EXITS FROM HALISP. EX. :(QUIT) A > (RECLAIM) : SUBR CAUSES GARBAGE COLLECTION. (REMOB ) : SUBR DELETES THE ATOM FROM THE SYSTEM OBLIST. EX. :(SETQ X NIL) --- --- PAGE 43 BUILT-IN FUNCTIONS NIL :(PROGN (REMOB 'X) (BOUNDP 'X)) NIL (RESET) : SUBR RESETS SYSTEM STACKS AND CLOSES ALL OPEN CHANNELS, AND SETS PROMPT CHARACTER TO COLLON ":", THEN CONTROL RETURNS TO MAIN LOOP (TOP LEVEL) OF SYSTEM. EX. :(PROGN (PRINT 'ONE) (PRINT 'TWO) (RESET) (PRINT 'THREE)) ONE TWO : (SLEEP ' ' ,,, ') : 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 F" FOR EXAMPLE. (VERBOS

) : SUBR IF

IS NOT NIL, A MESSAGES IS PRINTED OUT WHEN GARBAGE COLLECTION OCCURS. IF

IS NIL, IT IS NOT PRINTED. EX. :(VERBOS T) TRUE :(RECLAIM) GARBAGE COLLECTION ENTERED, 4192254 CELLS REMAIN END OF COLLECT, 4192256 CELLS FREE : [11] GRAPHICS FUNCTIONS (CLR) : SUBR CLEARS GRAPHICS SCREEN. THE VALUE IS NIL. (COLOR

) : SUBR IF

IS TRUE, PLOT OR LINE WITH WHITE FROM THIS TIME. IF

IS NIL, IT WILL BECOME BLACK. (LINE ,,, ) : LSUBR DRAWS LINES ON THE SCREEN FROM COORDINATE , TO ,,, ,. THE VALUE IS NIL. --- --- PAGE 44 BUILT-IN FUNCTIONS (LINETO ,,, ) : LSUBR DRAWS LINES ON THE SCREEN FROM LAST PLOTED OR LINED COORDINATE TO COORDINATE , TO , ,,, ,. THE VALUE IS NIL. (ORG ) : SUBR CHANGES THE GRAPHICS ORIGIN TO COORDINATE ,. (PAGE ) : SUBR CHANGES THE GRAPHICS PAGE TO . MUST BE IN RANGE FROM 0 TO 512. (PLOT ,,, ) : LSUBR PLOTS DOTS ON THE SCREEN AT COORDINATE , , ,,, ,. THE VALUE IS NIL. [12] SYSTEM CONSTANTS AND INDICATORS EXPR : = EXPR F : = NIL FEXPR : = FEXPR FSUBR : = FSUBR KEXPR : = KEXPR KSUBR : = KSUBR LAMBDA : = LAMBDA LEXPR : = LEXPR LP: : = LP: LSUBR : = LSUBR NEW : = NEW NIL : = NIL SUBR : = SUBR T : = TRUE TRUE : = TRUE TT: : = TT: %EOF : = %EOF %EOL : = %EOL ( : = ( --- --- PAGE 45 BUILT-IN FUNCTIONS ) : = ) [ : = [ ] : = ] . : = . ' : = ' --- --- PAGE 46 ERROR HANDLING <6> ERROR FUNCTION --IMPLEMENTATION OF ERROR RECOVERING-- WHEN AN ERROR IS DETECTED DURING THE EVALUATION, AN 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. USUALLY THE "ERROR" FUNCTION RECEIVES A MESSAGE AND AN IDENTIFICATION NUMBER. IT IS IMPORTANT THAT THE "ERROR" FUNCTION IS DEFINED BY THE FORM OF S-EXPRESSION(EXPR). SEE ANOTHER POINT, YOU CAN DEFINE YOUR OWN "ERROR" FUNCTION FREELY. --DEFINITION OF THE TYPICAL ERROR FUNCTION-- [DEF (ERROR MSG #NO) (PORGN (PRINT '?) (CASE #NO ( 1 (PARITH 'OVERFLOW) (CONT MSG)) ( 2 (PARITH 'ILLEGAL/ ARGUMENT) (CONT MSG)) ( 3 (PARITH 'ZERO/ DEVIDE) (CONT MSG)) ( 4 (PUND 'IN/ APPLY) (CONT MSG)) ( 5 (PUND 'IN/ EVAL) (CONT MSG)) ( 6 (PRIN1 'UNBOUND/ VARIABLE) (CONT MSG)) ( 7 (PRIN1 'APPLY/ ILLEGAL/ FUNCTION/ TYPES) (CONT MSG)) ( 8 (PRIN1 'PAIRLIST/ LENGTH/ MISMATCH) (CONT MSG)) ( 9 (PRIN1 'ILLEGAL/ P-LIST/ OPERATION) (CONT MSG)) (10 (PRIN1 'ATTEMPT/ SET/ TO/ RESERVED/ ATOM) (CONT)) (11 (PUND 'LABEL) (STOP MSG)) (12 (PRIN1 'BREAKED) (CONT MSG)) (13 (PRIN1 'DISK/ FULL) (RESET)) (14 (PRIN1 'CHANNEL/ NOT/ OPEN) (CONT MSG)) (15 (PRIN1 'CHANNEL/ EXHAUSTED) (CONT MSG)) (16 (PRIN1 'DRIVE/ NOT/ READY) (CONT MSG)) (17 (PRIN1 'ASSIGNEE/ IS/ NOT/ ATOM) (CONT MSG)) (18 (PRIN1 'ILLEGAL/ FILE/ SPEC) (CONT MSG)) (19 (PRIN1 'FILE/ NOT/ FOUND) (CONT MSG)) (20 (PRIN1 'CHANNEL/ IN/ USE) (CONT MSG)) (21 (PRIN1 'CHANNEL/ MODE/ MISMATCH)) (RESET)) (22 (PRIN1 'ILLEGAL/ CHANNEL/ MODE)) (CONT MSG)) (23 (PRIN1 'FILE/ PROTECTED) (CONT MSG)) (24 (PRIN1 'FILE/ ALREADY/ OPEN) (CONT MSG)) (25 (PRIN1 'ILLEGAL/ CHANNEL/ NUMBER) (CONT MSG)) (26 (PRIN1 'FILE/ ALREADY/ EXIST) (CONT MSG)) (27 (PRIN1 'ARGUMENTS/ #/ MISMATCH) (RESET)) (CONT MSG] [DEF (CONT MSG) (PROG (INP) (PRINT '@) (PRIN1 MSG) (PROMPT '>) LOOP (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]) (GO LOOP] --- --- PAGE 47 ERROR HANDLING [DEF (STOP MSG) (PROGN (PRINT '@) (PRINT MSG) (RESET] [DEF (PARITH MSG) (PROGN (PRIN1 'ARITHMETIC/ ) (PRIN1 MSG] [DEF (PUND MSG) (PROGN (PRIN1 'FUNCTION/ OBJECT/ HAS/ NO/ DEFINITION/ ) (PRIN1 MSG] --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, ?FUNCTION OBJECT HAS NO DEFINITION IN 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, >(RESUME) (TOM EATS AN APPLE TODAY) OH, THAT'S RIGHT! --- --- PAGE 48 APPENDICES --APPENDIX B: ONE WAY TO GOOD 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. EXAMPLE OF NOTATIONS ARE: PREFIX NOTATION INFIX NOTATION (+ (* A (^ X 2)) (+ (* B X) C)) = A * X ^ 2 + B * X + C --- --- PAGE 49 APPENDICES 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) (DOFF (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: (DEF (DIFF E X) (COND ((VAR? E) (DIFF-VAR E X)) ((SUM? E) (DIFF-SUM E X)) ((PRODUCT? E) (DIFF-PROD E X)) ((DIVIDE? E) (DIFF-DIV E X)) ((EXPT? E) (DIFF-EXPT E X)) (T (ERROR E 0] (DEF (DIFF-VAR E X) (COND ((EQ E X) 1) (T 0] (DEF (DIFF-SUM E X) (LIST (FUNC E) (DIFF (ARG1 E) X) (DIFF (ARG2 E) X] (DEF (DIFF-PROD E X) (MAKE-SUM [MAKE-PROD (ARG1 E) (DIFF (ARG2 E) X] (MAKE-PROD (ARG2 E) (DIFF (ARG1 E) X] (DEF (DIFF-DIV E X) (DIFF [MAKE-PROD (ARG1 E) (MAKE-EXPT (ARG2 E) -1] X] --- --- PAGE 50 APPENDICES (DEF (DIFF-EXPT E X) (MAKE-PROD (ARG2 E) (MAKE-PROD [MAKE-EXPT (ARG1 E) (SUB1 (ARG2 E] (DIFF (ARG1 E) X] SOME RECOGNIZING FUNCTIONS ARE: (DEF (VAR? X) (ATOM X)) (DEF (SUM? E) (OR (EQ (FUNC E) '+) (EQ (FUNC E) '-] (DEF (PRODUCT? E) (EQ (FUNC E) '*)) (DEF (DIVIDE? E) (EQ (FUNC E) '/)) (DEF (EXPT? E) (EQ (FUNC E) '^)) SOME SELECTING FUNCTIONS ARE: (DEF (FUNC E) (CAR E)) (DEF (ARG1 E) (CADR E)) (DEF (ARG2 E) (CADDR E)) SOME CONSTRUCTING FUNCTIONS ARE: (DEF (MAKE-SUM X Y) (LIST '+ X Y)) (DEF (MAKE-PROD X Y) (LIST '* X Y)) (DEF (MAKE-EXPT X Y) (LIST '^ X Y)) OF COURSE THE "CASE" FUNCTION IS SUITED FOR "DIFF": (DEF (DIFF E X) (COND ((VAR? E) (DIFF-VAR E X)) (T (CASE (FUNC E) (+ (DIFF-SUM E X)) (- (DIFF-SUM E X)) (* (DIFF-PROD E X)) (/ (DIFF-DIV E X)) (^ (DIFF-EXPT E X)) (ERROR E 0] "ERROR" FUNCTION IS USED FOR PREDICTABLE APPEARANCE OF UNDEFINED OPERATOR IN A GIVEN EXPRESSION. --- --- PAGE 51 APPENDICES BUT WE MUST NOT FORGET THE COMPUTED FUNCTION IN LISP. THE MOST SOPHISTICATED VERSION IS: (DEF (DIFF E X) (COND ((VAR? E) (DIFF-VAR E X)) (T ((GET (FUNC E) 'DIFF) E X] ALTERNATIVE "DIFF" THAT USES COMPUTED FUNCTION EXPLICITLY BY USING "FUNCALL" IS: (DEF (DIFF E X) (COND ((VAR? E) (DIFF-VAR E X)) (T (FUNCALL (GET (FUNC E) 'DIFF) E X] OR USING "APPLY", (DEF (DIFF E X) (COND ((VAR? E) (DIFF-VAR E X)) (T (APPLY (GET (FUNC E) 'DIFF) (LIST E X] (PUTPROP '+ 'DIFF '(LAMBDA (E X) (MAKE-SUM (DIFF (ARG1 E) X) (DIFF (ARG2 E) X] (PUTPROP '- 'DIFF '(LAMBDA (E X) (MAKE-DIF (DIFF (AGR1 E) X) (DIFF (ARG2 E) X] (PUTPROP '* 'DIFF '(LAMBDA (E X) (MAKE-SUM [MAKE-PROD (ARG1 E) (DIFF (ARG2 E) X] (MAKE-PROD (ARG2 E) (DIFF (ARG1 E) X] (PUTPROP '/ 'DIFF '(LAMBDA (E X) (DIFF [MAKE-PROD (ARG1 E) (MAKE-EXPT (ARG2 E) -1] X] (PUTPROP '^ 'DIFF '(LAMBDA (E X) (MAKE-PROD (ARG2 E) (MAKE-PROD [MAKE-EXPT (ARG1 E) (SUB1 (ARG2 E] (DIFF (ARG1 E) X] ADD A CONSTRUCT FUNCTION: (DEF (MAKE-DIFF X Y) (LIST '- X Y] "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". --- --- PAGE 52 APPENDICES --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) :(DIFF '(+ X A) 'X) [1] ENTER (DIFF (+ X A) X) [2] ENTER (DIFF X X) [2] EXIT DIFF 1 [2] ENTER (DIFF A X) [2] EXIT DIFF 0 [1] EXIT DIFF (+ 1 0) (+ 1 0) :(DIFF '(/ A X) 'X) [1] ENTER (DIFF (/ A X) X) [2] ENTER (DIFF (* A (^ X -1)) X) [3] ENTER (DIFF (^ X -1) X) [4] ENTER (DIFF X X) [4] EXIT DIFF 1 [3] EXIT DIFF (* -1 (* (^ X -2) 1)) [3] ENTER (DIFF A X) [3] EXIT DIFF 0 [2] EXIT DIFF (+ (* A (* -1 (* (^ X -2) 1))) (* (^ X -1) 0)) [1] EXIT 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 --- --- PAGE 53 APPENDICES :(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) --- ---