LISP

programozási segédlet

 

 

 

 

NOVOTRADE RT.

 

 

 

 

TARTALOM

 

 

Előszó

1. Fejezet   Az elindulás

2. Fejezet   Bevezetés a LISP-be

3. Fejezet   Input/Output

4. Fejezet   Függvények definiálása

5. Fejezet   Kimentés és betöltés

6. Fejezet   Az EXOS

7. Fejezet   Az interruptok kezelése

8. Fejezet   Az IS-LISP függvényei

1. Függelék  EXOS változók

2. Függelék  Hibaüzenetek

3. Függelék  Funkciós gombok

 

IS-LISP az Enterprise 1. verziójára

C 1985 Intelligent Software Ltd

Progamming: M. Richer

Manual Writing R. Hurley , J. Hurley,

               R. D. Virgo

 

 

ELŐSZÓ

 

 

Bár a LISP (LIST PROCESSING) már kb. húsz éve van forgalomban, még mindig nagyon népszerű a "Mesterséges Intelligencia" és a "Szakértői rendszerek" területén, ahol ideálisnak tekinthető rugalmassága és kiterjeszthetősége miatt.

 

Ennek a kézikönyvnek nem célja, hogy a nyelvről minden információt tartalmazó enciklopédia legyen, de leírja az IS-LISP implementációját az Enterprise számítógépen és közelebbi betekintést ad arról, hogyan történik a kommunikáció a felhasználóval és az EXOS operációs rendszerrel. A kezdőnek rövid bevezetést ad a nyelvbe, de feltételezi, hogy az olvasó ismeri a gép működését és vannak - legalábbis korlátozott - ismeretei a Basic nyelvről.

 

Mivel a LISP interaktív nyelv, amely minden függvényt úgy és akkor kiértékel, ahogy az a számítógépbe került, könnyű rajta kísérletezni a különböző függvényekkel. Tanácsoljuk az olvasónak, hogy próbálja ki a kézikönyvben található példákat, amikor csak lehetséges.

 

Könyvek a LISP-ről

 

Sok jó könyv íródott a LISP-ben való programozásról. Különösen ajánljuk a következőket:

 

"LISP on the BBC microcomputer" (A. Norman, G. Cattell) jó bevezetést ad a LISP nyelvű programozáshoz. A BBC-LISP-et írja le, amelyik igen közel áll az IS-LISP-hez.

 

"LISP" (P. Winston, B. Horn) a LISP egy másik dialektusát írja le, de ismertet néhány újszerű eszközt is, pl. a makrókat.

 

 

1. Fejezet

 

AZ ELINDULÁS

 

 

Hogy elkezdjünk programozni IS-LISP-ben, tegyük be a cartridge-et az Enterprise mikroszámítógép bal oldalán lévő portba és kapcsoljuk be a gépet. Ezután nyomjuk meg kétszer a Reset gombot. A hidegindítás szokásos folyamata megy végbe, a gép ellenőrzi a memóriaszekciókat, és az alább látható üzenet jelenik meg a képernyőn.

 

 

Most elkezdhetjük a programozást. Az utasítások ugyanúgy vihetők be a billentyűzetről, mint az IS-BASIC használatakor. Minden kommunikáció a felhasználó és a LISP interpreter között az "editor"-on keresztül történik, ami azt jelenti, hogy a kurzor-billentyűk és a joystick használhatók a kurzor mozgatására a képernyőn, hogy szöveget vigyünk be, javítsunk, vagy töröljünk.

 

Amikor egy programsort helyesen beírtunk és megnyomtuk a return gombot, ennek hatására az "EVAL" program működésbe lép, és - feltéve, hogy a sor szintaktikusan helyes - kiértékelődik, a kiértékelés eredménye pedig megjelenik a képernyőn.

 

Például, két szám összeadására beírhatjuk: (PLUS 3 4), és a számítógép kiadja: 7.

 

Ezen a ponton fontos, hogy emlékeztessünk rá: minden LISP programsor azonnal ellenőrződik és kiértékelődik, rögtön a bevitel és a return gomb megnyomása után. Ez teljesen más, mint amivel BASIC környezetben dolgozva találkozunk, ahol egy szekció vagy akár az egész program bekerül a gépbe, és csak ezután történik kísérlet a végrehajtásra.

 

Ezt észben tartva elkezdhet kísérletezni és programozni a LISP nyelven. A következő néhány fejezet jó kalauz néhány ismert LISP függvény használatához.

 

 

2. Fejezet

 

BEVEZETÉS A LISP-BE

 

 

A LISP-ben, mint minden magasszintű nyelvben, a profiramozó elvárja, hogy szöveges üzeneteket jelentethessen meg a képernyőn, és hogy olyan szavakat használhasson, amik változóneveknek alkalmasak. Az ilyen szavakat a LISP-ben "azonosítóknak" vagy "atomoknak" hívjuk, és ezek a legelemibb objektumok, amik egy LISP programban használhatók.

 

Az azonosító olyan objektum, amely karakterekből épül fel, (pl.. 2, DOG, T.NIL), és a fenti célok bármelyikére használható. Atom minden azonosító és minden szám (pl. 7, -24). Ezen atomok használatával fel tudjuk építeni az adatstruktúrát, ami a LISP-nek a nevét adja, azaz a listákat.

 

A lista adattételek egy gyűjteménye, ezek mindegyikének van egy rákövetkezője, kivéve az utolsót. Hasznos, ha ezt úgy tekintjük, mint pointerek egy rendszerét, amelyek mentén a felhasználó végighaladhat egy listán, és minden pointer egy memóriacellához van rendelve, egy cella két pointert tartalmaz. A baloldali pointer az atomot (vagy listát) jelzi, vagyis az adatot, a jobboldali pedig oda mutat, ahol a lista további része kezdődik. Az (A B 1...) listára ezt kapjuk:

 

 

 

 

Ahogy az elébb jeleztük, egy listában tárolt adattételek maguk is lehetnek listák, így az (A(1 2... ) B... ) lista részletesebben:

 

 

 

 

Már említettük, hogy egy lista minden tételének van egy rákövetkezője, kivéve az utolsót, amelyre a LISP-nek egy speciális, "NIL" nevű azonosítót tart fenn, az üres lista, a () reprezentálására. így az (X Y) listát reprezentáló teljes diagram:

 

 

 

 

amelyet megegyezés szerint így ábrázolunk:

 

 

 

 

Ez mind elmélet és a LISP működésének alapját képezi, de most kezdjünk el ismerkedni ezzel a nyelvvel.

 

Aritmetika

 

A LISP-ben az aritmetika azonosítók használatával működik, nem pedig a hagyományos infix operátorokkal, mint "+" és "x". Számok (atomok) összeadására a PLUS parancsot használjuk. A 7+5 összeadás elvégzésére (PLUS 7 5)-öt kell írnunk, erre a 12 választ kapjuk, és hogy a 7+5+3+1 értéket kiszámítsuk, a helyes LISP parancs

 

(PLUS 7 5 3 1),

 

amelyre a 16 választ kapjuk.

 

Az összeadás inverz művelete, a kivonás, a DIFFERENCE parancs segítségével történik, amely az első argumentumból levonja a másodikat, azaz 7-5 így írandó be:

 

(DIFFERENCE 7 5),

 

amire 2 lesz az output.

 

Az infix jelölés mellett, a "-" jelnek egy második jelentése is van, a negatív előjel. A LISP egy másik azonosítóval, a MINUS-szal elkerüli ezt a kettősséget. így 7-5, ami a 7+(-5) formában is írható, a

 

(PLUS 7(MINUS 5))

 

alakot kapja, és ennek eredménye is 2.

 

A szorzás a TIMES parancs használatával történik, így pl. 7x5 kiszámításához a

 

(TIMES 7 5)

 

parancs használatos, amire 35 a válasz, és hogy kiszámítsuk a 7x5x3x1 értéket, a

 

(TIMES 7 5 3 1)

 

parancs beírása szükséges, amire a 105 válasz érkezik.

 

A LISP csak egész számok használatát engedi meg, és ez okozhat némi nehézséget, amikor osztani akarunk, pl. 7/5=1.4, vagy tört formában, 1 2/5. Három különböző, az osztással kapcsolatos LISP parancs van, amelyek eredménye is különböző, a DIVIDE, a QUOTIENT és a REMAINDER.

 

A DIVIDE parancs egy rendezett párt (speciális listatípust) ad vissza, amelynek első eleme a hányados, második eleme a maradék, pl.

 

(DIVIDE 7 5)--> (1.2)

 

A QUOTIENT a hányados egészrészét adja vissza és a törtrészt nem veszi figyelembe,

 

pl. (QUOTIENT 7 5)--> 1

 

végül a REMAINDER az osztás maradékát adja vissza,

 

pl. (REMAINDER 7 5)--> 2

 

Jegyezzük meg, hogy a LISP a -32768 és 32767 közti intervallumon belül minden egész számot megenged, és hogy hibát okoz, ha egy aritmetikai számítás eredménye ezen az intervallumon kívül esik.

 

Változók

 

A LISP-ben az ALPHA szó reprezentálhat egy változót vagy egy adatrészt, és a két esetet egy szimpla idézőjel segítségével különböztetjük meg. Így ALPHA változót jelent, és értéke elérése után azonnal kiíródik, míg 'ALPHA az ALPHA szót reprezentálja, mint szöveg-adatot. Ha egy ALPHA változó nem kapott értéket, LISP értékét UNDEFINED-nak fogja tekinteni, ez a nyelvben speciális azonosító, erre a használatra fenntartva.

 

Hogy egy változónak értéket adjunk, ezt megtehetjük a SETQ azonosító használatával.

Pl.

(SETQ ALPHA '(A B C D E))

 

az ALPHA változó értékéül az (A B C D E) listát adja.

[Vegyük észre a ' idézőjelet, amely azt eredményezi, hogy (A B C D E) nem kerül kiértékelésre]. Amikor a változó hozzárendelése megtörtént, értéke kijelződik, ha zárójel nélkül szerepel, azaz ALPHA.

 

Például,

(SETQ TEN 10)

(TIMES TEN TEN)

 

a TEN változónak a 10 értéket adja, majd kiszámítja TEN négyzetét, ami 100. A változóhoz rendelendő kifejezés értékét is ki lehet számítani a SETQ paranccsal, így a

 

(SETQ ANSWER (TIMES TEN TEN))

 

utasítás a számítás eredményét, azaz a 100-at fogja az ANSWER változóhoz rendelni.

 

Listakezelés

 

Két alapvető függvény van, amivel egy lista bizonyos értékeit lehet megtalálni, mégpedig a CAR és a CDR függvények.

Az IS-LISP a CAR és HEAD parancsot engedi meg adott lista első elemének megjelölésére, a CDR és TAIL parancsokat pedig a további elemekből álló lista megjelölésére.

 

Tehát az (X Y) listára

(CAR'(X Y))--> X

(CDR'(X Y))-->(Y)

 

Tekintsük a következő SETQ utasítás által definiált listát:

 

(SETQ EXAMPLE'(A (1 2) (X Y Z)))

 

A diagram erre a listára:

 

EXAMPLE

 

 

 

 

Egyes tételek az EXAMPLE listából a következő módon nyerhetők:

 

    Utasítás                  Eredmény

 

(CAR EXAMPLE)              Az A azonosító

 

(CDR EXAMPLE)              A két tagból álló

                           ((1 2) X Y Z)) lista

 

(CAR(CDR EXAMPLE))         Az (1 2) lista

 

(CDR(CDR EXAMPLE))         Az (X Y Z) lista

 

(CAR(CAR(CDR EXAMPLE)))    Az 1 azonosító

 

Az IS-LISP lehetővé teszi , hogy a felhasználó az ilyen utasításokat lerövidítse, ezt írva:

 

(CAAR EXAMPLE)             (CAR(CAR EXAMPLE)) helyett

(CDDR EXAMPLE)             (CDR(CDR EXAMPLE)) helyett

(CADR EXAMPLE)             (CAR(CDR EXAMPLE)) helyett

(CAAAR EXAMPLE)            (CAR(CAR(CAR EXAMPLE))) helyett

(CADAR EXAMPLE)            (CAR(CDR(CAR EXAMPLE))) helyett,

 

összesen legfeljebb három CAR és CDR utasítás mellett, akármilyen kombinációban.

 

A T azonosító

 

A speciális T azonosító az az érték, amit a gép kiad, ha egy Boole-függvény igaznak értékelődött ki.

 

Például,

(NULL NIL)    --> T, mivel NIL ().

(ATOM 3)      --> T, mivel 3 valóban atom

(EQ 5 5)      --> T, mivel 5=5

 

Döntés

 

A BASIC-ben a döntéseket általában az IF... THEN... ELSE szerkezetben hozzuk, amit a következd módon alkalmazunk:

 

IF <1. állítás> THEN <i. kifejezés>

ELSE IF <2. állítás> THEN Q. kifejezés>

ELSE IF <3. állítás> THEN Q. kifejezés>

...

ELSE <kifejezés>

 

A LISP-ben ez a következd formát kapja:

 

(COND (<i. állítás> <1. kifejezés>)

      (<Q. állítás> <2. kifejezés>)

      ...

      (T <kifejezés>)),

 

ahol T a speciális azonosító az igaz állítások reprezentálására. Így a COND függvény úgy dolgozik, hogy minden állítást kiértékel, míg csak nem talál egy igazat. Ekkor kiértékeli a megfeleld kifejezést és annak értékét adja vissza.

 

Példa

 

(COND ((ATOM'(X Y)) (TIMES 4 9))

      ((ATOM 4) (TIMES 5 8))

      (T (TIMES 6 7)))

 

Itt, mivel '(X Y) lista és nem atom, ezért az első állítás NIL-t ad és nem veszi figyelembe a program. A második állítás viszont igaz, hiszen a 4 atom, és így az utasítás értékeként a gép (TIMES 5 8)-at, azaz a 40-et adja vissza.

 

Ciklus

 

A LISP-ben egy kifejezés-csoport ismétlése a LOOP paranccsal történik. Így pl. a következő utasítás

 

(LOOP(PRINT(PLUS 7 5))

   (PRINT(DIFFERENCE 7 5)))

 

ciklust eredményez, amelyben felváltva a 12, majd a 2, majd a 12..., stb. jelződik ki, amíg meg nem nyomjuk a STOP gombot. Jobban használható a LOOP olymódon, hogy események egy sorozatát idézi elő, mindaddig, amíg egy bizonyos terminális (befejező) feltétel nem teljesül, és ezt a WHILE vagy az UNTIL függvényekkel éri el.

 

Amikor egy ciklus tartalmaz WHILE vagy UNTIL utasítást, addig folytatja a végrehajtást, amíg a WHILE állítás igaz, illetve, amíg az UNTIL állítás hamis marad.

 

Adjuk a C változónak a 7-es értéket a (SETQ C 7) paranccsal, A-t állítsuk 0-ra a (SETQ A 0) paranccsal.

 

Ekkor alkalmazzuk ezt a ciklust:

 

(LOOP (WHILE(GREATERP C 0) A)

      (SETQ A(PLUS A C))

      (SETQ C(SUB1 C)))

 

Ez a 7+6+5+4+3+2+1=28 értéket fogja adni, mivel a ciklus mindig megismétlődik, amikor C>0.

 

Egy másik megoldás: Adjuk C-nek a 0 értéket a (SETQ C 0) paranccsal és A-t is 0-zzuk a (SETQ A 0) paranccsal.

 

Ekkor alkalmazzuk ezt a ciklust:

 

(LOOP (UNTIL (EQ C 8) A)

      (SETQ C (PLUS A C))

      (SETQ C (ADD1 C)))

 

ami az 1+2+3+4+5+6+7=28 választ adja, mivel addig ismétlődik a ciklus, mígnem C=8.

 

 

3. Fejezet

 

INPUT/OUTPUT

 

 

A legfontosabb parancsok bérmelyik nyelvben az input/output függvények, mivel ezek nélkül semmilyen értéket nem vihetnénk be a gépbe és számításaink eredményét sem nyerhetnénk vissza.

 

Input szintaxis

 

A legszokásosabb módja, hogy adatokat/programokat vigyünk a LISP-be, a READ függvény használata. Ez lehetővé teszi, hogy rendezett párokat, listákat, változókat és -32768 és 32767 közti számokat vigyünk be az aktuális input csatornán keresztül. Amikor először kapcsoljuk be a rendszert, az input csatorna száma "0", a billentyűzethez kapcsolva, bár ez megváltoztatható az OPEN, illetve az RDS parancsokkal, amint ez a 6. fejezetben szerepel.

 

Jegyezzük meg, hogy ahol jel van olvasás közben, onnan kezdve egészen az első sorvég jelig mindent commentnek tekint a gép és nem veszi figyelembe.

 

Az azonosítók inputjának színtaxisa olyan, hogy a gép elfogadja az A....Z, a....z, 0....9 karaktereket, valamint a következő speciális karaktereket:

 

- mínusz       _ aláhúzás      = egyenlőség

, vessző       ; pontosvessző  : kettőspont

[ bal          * csillag       & et-jel

szögletes

 zárójel

$ dollár       ~ hullám        # hashmark

@              / per-jel       ? kérdőjel

+ plusz        |               { kapcsos zárójel

↑ felfelé      < kisebb-jel    > nagyobb-jel

   nyíl

\ backslash

 

Például, A?BC, ::><:<-40:, + legális azonosítók.

Minden más karaktert az escape ('!') karakternek kell megelőznie, ha egy azonosítóban szerepel. Általában minden "(" balzárójelet közvetlenül le kell zárni egy ")" jobbzárójellel, de a "szuperzárójel", "]" használható az ö s s z e s megnyitott balzárójel lezárására. Például:

 

(DEFUN SQUARE (X) (TIMES X X]

 

Általában egy azonosító idézése ügy történik, hogy a ' karaktert tesszük eléje, pl. 'ABC. Ehelyett dupla idézőjelek közé is tehetjük, pl. "ABC". Ez könnyű megoldás arra, ha különleges karaktereket, pl. space-eket akarunk az azonosítókba rakni.

 

Pl. (PRINTC"A B")

 

Output formátum

 

Az outputot általában a négy print utasítás egyikével visszük ki: PRIN, PRINC, PRINT, és PRINTC.

 

Két különböző formátum van: a PRIN típusú és a PRINC típusú. A PRIN-nel készült output visszaolvasható lesz a READ utasítással, és, ahol kell az azonosítók escape ('!') jelet kapnak. A PRINC utasítás viszont nem látja el az azonosítókat ezzel a jellel, hanem változatlanul viszi ki.

 

Az output képzésének egy másik módja a SPRINT függvény használata, ahol az egyes tételek egy sorba kerülnek, ahol ez lehetséges, egyébként pedig ebben a formában:

 

(<függvény-név>

 <1. arg.>

 <2. arg.>

 <3. arg.>

...

 <n. arg.>)

 

Amikor a definíció elkészült, SPRINT két üres sort visz ki, és a NIL értéket adja vissza.

 

 

4. Fejezet

 

FÜGGVÉNYEK DEFINIÁLÁSA

 

 

Mint már említettük, a LISP nagyon rugalmas nyelv, amely kiterjeszthető úgy, hogy az egyedi felhasználók igényeinek eleget tegyen. Amikor éppen beléptünk a LISP környezetbe, már egy egész sor függvény áll rendelkezésünkre, amely definiált és hívható egyszerűen a megfelelő függvény-néven, pl.

 

(PLUS 4 7)

 

A "PLUS" függvény a LISP interpreter részeként van definiálva és hatására a "kiértékelő" megkeresi a 4 és a 7 összegét. Nagyon valószínű, hogy néha használni akarunk valamilyen függvényt, amely még nincs definiálva és ilyenkor magunknak kell definiálni a "DEFUN" parancs segítségével.

 

A parancs szintaxisa:

 

(DEFUN NAME(PARAMETERS) (BODY))

 

ahol NAME az a név, amin a függvényt ezentúl hívjuk; PARAMETERS a függvény input adatai; végül BODY egy vagy több, előzőleg definiált LISP függvényből áll.

 

1. PÉLDA

 

Tekintsük azt a helyzetet, amikor 2x+3y értékét kell meghatározni több ízben egy program futása során. Beírhatnánk a következő programrészt minden alkalommal:

 

(PLUS (TIMES 2 X) (TIMES 3 Y))

 

Ezt nyilvánvalóan sokáig tart begépelni és jobb lenne, ha volna egy függvényünk, amivel ezt mindig végrehajtjuk. Ezt megtehetjük a következő utasítással:

 

(DEFUN OPERATE (P Q) (PLUS (TIMES 2 P) (TIMES 3 Q)))

 

A LISP interpreter válaszol:

 

(LAMBDA (P Q) (PLUS (TIMES 2 P) (TIMES 3 Q)))

 

jelezve, hogy a függvényt sikeresen definiáltuk.

 

Ha most a 2x+3y függvényt ki akarnánk értékelni, egyszerűen beírhatnánk:

 

(OPERATE x y)

 

"x" és "y" értéke adódik a függvényben "p" és "q" értékéül, s a gép kiszámítja a függvényt, a kiértékelő segítségével.

 

Pl. (OPERATE 4 5) --> 23

 

A függvénynek ez a használata igen struktúrált programozási módhoz vezet, amit "TOP-DOWN" megközelítésnek nevezünk. Ebben definiálódik egy függvény, amely használható egy második függvény definíciója részeként, amely ismét használható egy harmadik függvény definíciója részeként, stb., s a legtöbb LISP program így íródik.

 

2. PÉLDA

 

Tekintsük azt a feladatot, ahol egy második függvényt, "OPERATE2"-t kell definiálni, amely 3(2x+3y) alakú. Ez a második függvény nagyon könnyen definiálható az elsőt, "OPERATE"-et felhasználva:

 

(DEFUN OPERATE2 (P Q) (TIMES 3 (OPERATE P Q)))

 

A 3(2X+3Y) érték most már kiszámítható egyetlen függvényhívással:

 

(OPERATE2 X Y)

 

Rekurzió

 

A rekurzió olyan eszköz a LISP programozó kezében, amely igen nagy rugalmasságot tesz lehetővé programok felépítésekor. Rekurzió segítségével lehet egy függvényt definiálni, amely ismételten hívja önmagát, míg egy bizonyos feltétel nem teljesül. Működésében nagyon hasonlít a standard LOOP-hoz, de általában rövidebb és hatékonyabb programot eredményez.

 

PÉLDA

 

Tekintsük azt a feladatot, hogy miképp definiáljuk a következő LEN rekurzív függvényt: LEN vesz egy LIST(A B C D E) listát és megszámolja, hány atom van a listában. Ezt a következőképp tehetjük:

 

(DEFUN LEN(X)

  (COND

     ((ATOM X) 0)

     (T (ADD1 (LEN (CDR X]

 

Opcionális változók

 

Definiálhatunk egy függvényt, amelyik hívható (pl.) egy, de két argumentummal (változóval) is:

 

(DEFUN ADDON (A (B.2))

  (PLUS A B))

 

Itt az első változót mindig meg kell adni, míg a második opcionális -- ha nem adjuk meg, a 2 értéket veszi fel.

 

Pl. (ADDON 4 8)-->12

    (ADDON 5)-->7

 

Egy függvénynek akárhány közönséges és opcionális változója lehet, azzal a megszorítással, hogy az opconális változók mind a közönségesek után következnek.

 

Jegyezzük meg, hogy a default érték (alapértelmezés, a fenti példában a 2) kiértékelődik, ha nem adtuk meg, tehát a fenti példa így is írható:

 

(DEFUN ADDON (A (B.(PLUS 1 1)))

   (PLUS A B))

 

Lokális változók

 

Ha egy függvényt pl. egy közönséges és két opcionális argumentummal definiáltunk:

 

pl. (DEFUN A-FUN (A (B.1) (C.NIL)) ... )

 

és mindig egy argumentummal hívjuk, akkor a B és C változók valójában lokális változók: használhatók "ideiglenes tárnak" az A-FUN függvényen belül és eltűnnek, amikor megtörtént a visszatérés a függvényből.

 

Függvények editálása

 

Amikor írunk egy LISP programot, gyakran fogunk benne hibát találni és szükségünk lesz arra, hogy megváltoztassuk egy függvény definícióját. Például tegyük fel, hogy begépeljük:

 

(DEFUN SQUARE (X) (TIMES X Y))

 

mert véletlenül az egyik X helyett Y-t ütöttünk be. A SQUARE függvény editálásához írjuk be:

 

(FEDIT SQUARE)

 

A képernyő kivilágosodik és ezt fogjuk látni:

 

(LAMBDA (X) (TIMES X Y))

 

így reprezentálja a gép a függvényt: A DEFUN szót és a függvény nevét a LAMBDA szóval helyettesítette.

 

Hogy a függvényt editáljuk, vigyük a kurzort az Y-hoz, ahogy szokás és írjuk felül X-re. Amikor befejeztük a javítást, nyomjuk meg az ESCAPE gombot. A SQUARE függvényt ezzel újradefiniáltuk, a helyes formára.

 

Ha az új definíció olvasásakor hiba derült ki (pl. egy fölösleges "." vagy ")", vagy file-vég, ami kevés jobbzárójelet jelent), a hibaüzenet megjelenik a képernyő tetején néhány másodpercre. Ez eltűnik, és a kurzor visszatér, hogy a hibát ki lehessen javítani.

 

 

5. Fejezet

 

KIMENTÉS ÉS BETÖLTÉS

 

 

A SAVE és a LOAD parancsok lehetővé teszik, hogy a rendszer állapotát kazettára vigyük és az később használható legyen. Mielőtt megkísérli, hogy a rendszert kimentse, győződjön meg róla, hogy bent van-e egy üres kazetta az adatátvitelre, és hogy az Enterprise mikroszámítógép output tokjából jövő vezetékek a magnó "MIC" és "REM" tokjához csatlakoznak-e.

 

Keli a rendszer aktuális állapotának egy nevet adni, ha ez pl. TUESDAY, akkor beütve a

 

(SAVE "TUESDAY")

 

parancsot, ez az állapot kimentődik a kazettára, készen arra, hogy későbbi időpontban betöltsük. Az újrabetöltés egyszerűen a

 

(LOAD "TUESDAY")

 

parancs beütésével történik, és így az összes, felhasználó által definiált kifejezés újra betöltődik a számítógép memóriájába. Ne felejtsük el csatlakoztatni a magnó "EAR" és "REM" tokjait az ENTERPRISE input tokjaihoz.

 

MEGJEGYZÉS

 

Amikor a kazettáról új file-t töltünk be, minden, éppen a számítógépben levő információ felülíródik. Ha ez az információ fontos, először mentsük ki a SAVE függvénnyel, ahogy fent leírtuk.

 

 

6. Fejezet

 

AZ EXOS

 

 

Az EXOS az Enterprise mikroszámítógép kiterjeszthető operációs rendszere. Interface-t szolgáltat az IS-LISP és a gép hardware-e közt. Az EXOS fő alkotórészei egy csatorna alapú input-output (I/0) rendszer és bonyolult memóriakezelő eszközök. Az I/0 rendszer lehetővé teszi a berendezés-független kommunikációt egy egész sor beépített berendezéssel, valamint további, a géphez csatolható berendezés-meghajtó egységgel.

 

A beépített berendezések:

 

1. Video-meghajtó szöveg- és grafikakezelésre.

 

2. Billentyűzet-kezelő, a joystick-kel, automatikus ismétlővel és programozható funkciós gombokkal.

 

3. Képernyő-editor, szövegkezelési lehetőségekkel.

 

4. Könnyen kezelhető sztereó hang-generátor.

 

5. Kazettás magnó.

 

6. Centronics kompatibilis párhuzamos interface.

 

7. RS232 típusú soros interface.

 

8. Hálózati interface

 

A rendszernek sok alkotórészét néhány egybyte-os változó, az úgynevezett "EXOS-változók" irányítják. Ezeknek a változóknak egy teljes listája az 1. függelékben található.

 

A kezdő LISP programozónak nem sok dolga akad az EXOS-beli kommunikációval. Előbb-utóbb azonban szüksége lesz erre a kommunikációra. A fejezet további része ennek mikéntjéről szól.

 

Képernyő - editor

 

Amikor a gépet éppen bekapcsoltuk, és az IS-LISP cartridge a helyén van, a felhasználó a "képernyő-editor"-ral kommunikál, amelyik pedig a LISP interpreterrel tartja a kapcsolatot. Ez lehetővé teszi, hogy a felhasználó mozgassa a kurzort a képernyőn, illetve a képernyőt mozgassa fel és le.

 

Csatornák

 

Ahogy a fejezet elején említettük, minden az I/0 csatornákon keresztül történik. A LISP-et úgy tervezték meg, hogy a legegyszerűbb műveletek ennek a ténynek az ismerete nélkül is elvégezhetők. Ugyanakkor, a rendszer teljes kihasználásához szükséges, hogy tudjuk, hogyan kezelhetők ezek a csatornák és a megfelelő EXOS változók.

 

Közvetlenül a gép bekapcsolása után a következő csatornák lesznek automatikusan nyitottak:

 

0. CSATORNA   EDITOR

 

1. CSATORNA   VIDEO (csak a grafikus rész) -- a GRAPHICS

              paranccsal nyitható meg.

 

2. CSATORNA   VIDEO (csak a szöveges rész)

 

3. CSATORNA   hang

 

5. CSATORNA   billentyűzet

 

A kommunikáció a különböző berendezésekkel mindig ezeken a csatornákon keresztül történik, hacsak nincs az egyik valamilyen okból lezárva.

 

A 0., 2., 3. és 5. csatornát lehetőleg nyitva kell hagyni. Ha nincs rá nyomós ok, ne zárjuk le ezeket.

 

Új csatornák

 

Néha szükségünk lehet arra, hogy új csatornát nyissunk egy berendezés-meghajtó egység számára, hogy a kommunikáció ne a megadott alapcsatornák valamelyikén történjen. Erre két függvény szolgál: az OPEN és a CREATE. A legtöbb esetben a kettő ekvivalens, de mikor szalagon vagy lemezen file-t nyitunk, a CREATE új file-t létesít, míg az OPEN feltételezi, hogy a file már létezik.

 

PÉLDA

 

Tekintsük azt a feladatot, hogy egy függvényt kell definiálnunk, amely bizonyos függvényeket nyomtat párhuzamos nyomtatón SPRINT utasítással.

 

Ez a következő programmal oldható meg:

 

(DEFUN SPRINTER (EXP)

  (OPEN 10 "PRINTER:")

  (WRS 10)

  (SPRINT EXP)

  (WRS 0)

  (CLOSE 10))

 

A program megnyitja a 10. csatornát a párhuzamos nyomtató számára, majd a WRS 10 utasítással az aktuális outputot erre a csatornára irányítja. Az "EXP" paraméterrel definiált függvény a SPRINT utasítással, kikerül a nyomtatóra, majd az aktuális outputot újra az alapcsatornához rendeli a program.

 

MEGJEGYZÉS

 

A csatornák használata közben könnyen elfeledkezünk arról, hogy az input és az output automatikusan az alapcsatornákon halad, ahogy ezt meg fogjuk alább mutatni, és az átirányításhoz az SNDS, RDS, WRS, és GRS parancsokra van szükség.

 

Berendezés    Alapcsatorna      Parancs

HANG                3             SNDS

SZÖVEG(INPUT)       0             RDS

SZÖVEG(OUTPUT)      0             WRS

GRAFIKA             1             GRS

 

PÉLDA

 

A 12. csatornán menti inputhoz szükséges:

(OPEN 12 "DEVICE:")

(RDS 12)

 

Filenevek

 

Amikor csatornát nyitunk, ilyen alakú parancsot használunk:

 

(OPEN 12 "<berend.>:<filenév>.<kiterj.>")

 

ahol <berend.>, <filenév>, <kiterj.> egyike sem kötelező.

 

A használható berendezések listáját lásd alább, ha nincs megadva, az alapértelmezés a szalag.

 

KEYBOARD:  A billentyűzet

VIDEO:     Video képernyő berendezés

EDITOR:    Szövegszerkesztő berendezés

PRINTER:   Centronics port

SOUND:     Hang-berendezés

SERIAL:    RS232 port

NET:       Hálózat-berendezés

TAPE:      Kazetta berendezés

 

SZALAG-FILE KEZELÉS

 

Néha szükségünk lehet arra, hogy információt vagy függvényeket mentsünk ki szalagra, anélkül, hogy a teljes környezetet kimentenénk. Ezt a következő függvény definiálásával tehetjük:

 

(DEFUN FILE EXP)

  (CREATE 11 "TAPE:RH")

  (WRS 11)

  (PRINT EXP)

  (WRS 0)

  (CLOSE 11))

 

Amikor a "FILE" függvényt hívjuk, az "EXP" paraméter tartalma kimentődik egy "RH" nevű file-ba. Ez később használható lesz egy második függvény segítségével, amely a kifejezést a szalag-file-ból előveszi.

 

PÉLDA

 

(DEFUN EXTRACT ((TEMP))

(OPEN 11 "TAPE:RH")

(RDS 11)

(SETQ TEMP (READ))

(RDS 0)

(CLOSE 11)

TEMP)

 

(EXTRACT) begépelésével, az "RH" file-ban levő kifejezést fogjuk megkapni.

 

EXOS parancsok

 

Három LISP függvény van, az EXOS-READ, az EXOS-WRITE és az EXOS-TOGGLE, amelyek arra szolgálnak, hogy egy tapasztalt programozó lekérdezzen vagy megváltoztasson bizonyos rendszerváltozókat. Az 1. függelék tartalmazza ezeknek a változóknak a listáját, elhelyezkedésükkel együtt, és rövid leírást ad meg arról, mire használhatók.

 

Az "EXOS-változók" használatára és fontosságára álljon itt példaként egy függvény kinyomtatásának feladata, SPRINT utasítással, RS232 soros porttal összekötött printerre, amely 1200 BAUD sebességgel működik. A LISP parancsokat végigvizsgálva látjuk, hogy nincs függvény a sebesség csökkentésére, de az 1. Függelékből látjuk, hogy van egy megfelelő EXOS változó, amely így használható:

 

(DEFUN SERPRINT (EXP)

  (EXOS-WRITE 16 8) % Set BAUD rate to 1200

  (OPEN 11 "SERIAL:")

  (WRS 11)

  (SPRINT EXP)

  (WRS 0)

  (CLOSE 11))

 

 

7. Fejezet

 

AZ INTERRUPT KEZELÉSE

 

 

Az IS-LISP Enterprise változatóban van egy speciális azonosító, ami lehetővé teszi, hogy a LISP programozó függvényeket írjon, amelyek kihasználják az interrupt rendszert.

 

Mikor éppen bekapcsoltuk a mikroszámítógépet, a HANDLER változó UNDEFINED, és akármilyen software interrupt érkezik, ez SOFTWARE INTERRUPT (ERROR 4) kijelzést eredményez. Viszont, a felhasználónak lehetősége van, hogy definiáljon egy függvényt -- nevezzük FRED-nek -- egy változóval, ami maga az interrupt HANDLER, ezt írva:

 

(SETQ HANDLER "FRED)

 

Amikor software interrupt érkezik, FRED fog hívódni, az interrupt típus, mint egyetlen változója szerint (ld. alább).

 

PÉLDA

 

Ha így definiáljuk FRED-et:

 

(DEFUN FRED (TYPE)

  (COND

     ((EQ TYPE 24)(PRINTC "UNDEFINED FUNCTION")))

     ((EQ TYPE 48)(PRINTC "NETWORK INTERRUPT"))

     ((EQ TYPE 64)(PRINTC "TIME-OUT"))

     (T NIL)))

 

Látjuk, hogy egy ilyen egyszerű függvény is, mint ez, számos hasznos eszközt ad a felhasználó kezébe:

 

1. Idő-kezelés

 

2. Információ arról, ha a hálózat szervízelést igényel.

 

3. Lehetőség, hogy a programot megszakítsuk, pl. a shift-F1 gombbal, és ezekután dolgozzunk tovább, mintha nem törtónt volna semmi.

 

A következő táblázat mutatja a HANDLER-nek adott értékeket, amikor a software interrupt beérkezik:

 

Kód     Interrupt       Kód     Interrupt

16   1. funkciós gomb   26  11. funkciós gomb

17   2. funkciós gomb   27  12. funkciós gomb

18   3. funkciós gomb   28  13. funkciós gomb

19   4. funkciós gomb   29  14. funkciós gomb

20   5. funkciós gomb   30  15. funkciós gomb

21   6. funkciós gomb   31  16. funkciós gomb

22   7. funkciós gomb   32  STOP

23   8. funkciós gomb   33  akármelyik gomb

24   9. funkciós gomb   48  HÁLÓZAT

25  10. funkciós gomb   64  ÓRA

 

        (A 9-16-os gombok shifteltek)

 

Funkciós gomb-interruptok

 

Ha egy funkciós gomb az üres stringgel van beprogramozva, megnyomásakor software interruptot generál. A LISP felügyelete alatt bizonyos gombok előre vannak programozva hasznos parancsokra, pl. FEDIT, a többiek az üres stringre.

 

Stop-interrupt

 

Ha a (8-as számú) STOP_IRQ EXOS-változó nem-0 értékű, akkor a stop-gomb olyan kódot fog visszaadni, mint bármely más gomb, ami valójában a stop-gombot hatástalanítja. Egyébként, ha a stop-gombot nyomjuk meg, 32-es software interrupt érkezik.

 

"Bármely gomb-interrupt"

 

Ha a (9-es számú) KEY_IRQ EXOS változó 0 értéket kap (alapértelmezése 255!), akkor, akármelyik gombot nyomjuk meg, 33-as software interrupt érkezik, a kódot is visszaadva.

 

Hálózati interrupt

 

Amikor üzenet érkezik a hálózathoz, általában software interrupt generálódik. (kivéve, ha a (19-es számú) NET_IRQ EXOS-változó 0). Ez azért hasznos, mert így a felhasználó, elolvasva az üzenetet, reagálni tud rá.

 

Megjegyzés A (18-as számú) ADDR_NET EXOS-változó fogja ekkor tartalmazni annak a hálózati csatornának a számát, amelyről az adat beolvasható.

 

Óra-interrupt

 

Az (5-ös számú) TIMER EXOS-változó általában 0 értékű. Ha viszont más értékre állítjuk, az EXOS-WRITE paranccsal, akkor ettől kezdve másodpercenként eggyel csökken. Amikor 0-vá válik, ezzel egy 64-es software interruptot generál. Ez hasznos lehet képernyőn működő óraként, ahogy azt alább láthatjuk.

 

PÉLDA

 

Az itt következd programrész hibakereséshez (debug) ad segítséget. Ha megnyomjuk a shift-F1 gombot, a LISP a DEBUG függvényt fogja hívni, amely lehetővé teszi, hogy a felhasználó begépeljen tetszőleges LISP kifejezést, amely kiértékelődik, és az eredmény kinyomtatásra kerül. Például, a változók értékei megtudhatók, egyszerűen a nevük beírásával. Befejezéskor a felhasználó beírja: "BYE", és a program folytatja addigi tevékenységét.

 

(SETQ HANDLER 'FRED)

 

(DEFUN FRED (TYPE)

  (AND (EQ TYPE24) (DEBUG)))

 

(DEFUN DEBUG((INPUT))

  (PRINTC"Lisp debugger - type BYE to leave")

  (LOOP

         (PRINTC"DEBUG>")

         (LOOP(WHILE(ATOM(SETQ INPUT (ERRORSET

         (READ))))))

         (SETQ INPUT(CAR INPUT))

         (UNTIL (EQ INPUT'BYE)

                (PRINTC"***Leaving Debug"))

         (ERRORSET(PRINT(EVAL INPUT)))))

 

Az interruptkezelés hatékony eszköz egy tapasztaltabb programozó kezében és lehetséges vele bonyolult függvényeket alkotni, amelyek akkor lépnek működésbe, amikor egy speciális software interrupt érkezik.

 

Megjegyzés  Sajnos a LISP nem válaszol az interruptokra, amíg a felhasználóra vár, hogy az valamit begépeljen (vagyis, amíg a kurzor villog).

 

 

8. Fejezet

 

AZ IS-LISP FÜGGVÉNYEI

 

 

Ez a fejezet a LISP függvények alfabetikus felsorolását tartalmazza , leírja struktúrájukat és működésüket, és néhány példát ad használatukra. Mindegyik függvény az itt felsorolt kategóriák egyikébe tartozik:

 

    Subr -  közönséges függvény, amely összes argumentumát

            kiértékeli.

 

    Fsubr - függvény, amely nem szükségszerűen összes

            argumentumát értékeli ki.

 

    Id    - azonosító, a LISP-ben speciális jelentéssel.

 

    Var   - a rendszer szolgáltatta változó.

 

A LISP függvények argumentumait "< >" zárójelek közé tesszük, vagy "[ ]" zárójelek közé, az utóbbi opcionális argumentumot jelez.

 

A függvény eredménye is meg van adva, és ez egy lista (azaz (a b c ... z)), egy egész szám a -32768 és a 32767 közti intervallumban, vagy a "tet" szó, ami azt jelenti, hogy az eredmény típusa tetszőleges LISP típus lehet.

 

 

(ABS <szám>)--> szám                                        Subr

 

Az argumentum abszolút értékét adja.

 

   pl. (ABS 23)--> 23

       (ABS-19)--> 19

 

(ADD1 <szám>)--> szám                                       Subr

 

Az argumentumnál 1-gyel nagyobb számot ad.

 

   pl. (ADD1 23)--> 24

 

(AND <1. kifejezés> <2. kif.>... )--> NIL vagy tet         Fsubr

 

Sorra kiértékeli argumentumait. Ha az egyik NIL, a függvény mindenképp NIL-t ad; egyébként az utolsó argumentum értékét adja.

 

   pl. (AND(NUMBERP 10 (ATOM'A B)))--> NIL

                    (AND (LISTP'(A B))'XYZ)--> XYZ

 

(APPEND <X> <y>)--> list                                    Subr

 

Ha (x> és <y> listák, akkor ez a függvény azt a listát fogja adni, amelyik először <x>, majd <y> elemeit sorolja fel.

 

      (DEFUN APPEND (X Y)

        (COND

          ((ATOM X) Y)

           (T (CONS (CAR X) (APPEND (CDR X) Y ]

 

   pl. (APPEND'(A B) 'C D))--> (A B C D)

 

(APPLY <fg> <arg>)--> tet                                   Subr

 

Az <fg> függvény értékét adja az <arg> argumentumok mellett.

 

   pl. (APPLY NUMBERP'(10))--> T

 

(ASSOC <kód> <a lista>)--> NIL vagy (<kód>.érték)           Subr

 

Megkeresi a rendezett párok megfelelő listáját az adott kódra. Ha a keresés sikerrel járt, egy (<kód>.érték) párt ad; egyébként NIL-t.

 

(DEFUN ASSOC (U ALIST)

          (COND

             ((ATOM ALIST) NIL)

             ((ATOM(CAR ALIST) ERROR "BAD

               ASSOCIATED LIST"))

             ((EQUAL U(CAAR ALIST)) (CAR ALIST))

             (T (ASSOC U (CDR ALIST]

 

   pl. (ASSOC'A'((B.2) (A.-3)))--> (A.-3)

 

(AT <sor> <oszlop>)--> NIL                                  Subr

 

A kurzort az aktuális output csatornán a(<sor>,<oszlop>) pozícióra viszi.

 

   pl. (AT 10 20)--> NIL

 

(ATOM <x>)--> T vagy NIL                                    Subr

 

T-t ad (igaz), ha <x> nem rendezett pár.

 

pl. (ATOM'(A.B))--> NIL

    (ATOM'A)--> T

    (ATOM 10)--> T

    (ATOM CAR)--> T

 

AUTOLOAD                                                      Id

 

Amikor az EVAL program megkísérli egy

 

             (<azonosító> <arg>)

 

alakú kifejezés kiértékelését, és azt találja, hogy <azonosító> UNDEFINED, ez általában hibát eredményez. A felhasználó viszont írhat egy autoloadert, amely LISP függvény, és mindig kiértékelődik, amikor a felhasználó definiálatlan értékű függvényt hív.

 

Az autoloader beállítható a

 

             (SETQ AUTOLOAD 'FRED)

 

paranccsal. így a FRED függvény mindig hívódik, amikor definiálatlan függvény szerepel a programban, ennek a függvénynek a nevével, mint egyetlen argumentummal. Ez a top-down struktúrájú programozásban a leghasznosabb, mert így a felső szinten lévő függvények tesztelhetők anélkül, hogy az alsóbb szintek függvényeit definiálnánk.

 

(BAND2 <x> <y>)--> szám                                     Subr

 

Az <x> és <y> számok bitenként képzett AND-jét fogja adni, amikor bináris formában szerepelnek.

 

   pl., mivel 7 bináris formája 111, 3-é 11, ezért

              (BAND2 7 3)--> 3

 

(BEAM <kifejezés>--> NIL                                    Subr

 

Ha (kif.> nem NIL, akkor az aktuális grafikus csatornán a sugárzás megkezdődik, különben befejeződik.

 

   pl. (BEAM NIL)--> kikapcsolás

 

       (BEAM T)--> bekapcsolás

 

BLANK                                                        Var

 

Ez reprezentálja a space karaktert

 

   pl. (PRINC BLANK) egy space karaktert ad ki a képernyőre.

 

(BNOT <szám>)--> szám                                       Subr

 

A szám bitenkénti NOT-ját képezi, azaz x-ből (-x)-1 lesz.

 

   pl. (BNOT 7)--> -8

       (BNOT -3)--> 2

 

(BORDER <szám>)--> NIL                                      Subr

 

Ha 0 < (szám) < 255, akkor így a keret színe a <szám> által reprezentált színre változik.

 

   pl. (BORDER 42)

 

(BOR2 <x> <y>)--> szám                                      Subr

 

A két szám, <x> és <y>, bitenkénti OR-ját képezi.

 

   pl., mivel 7 binárisan 111, 3 pedig 11, ezért

       (BOR2 7 3)--> 7

 

(BXOR2 <x> <y>)--> szám                                     Subr

 

Az <x> és <y> számok bitenkénti exkluzív -OR-ját képezi.

 

   pl., mivel 7 binárisan 111, 3 pedig 11, ezért

       (BXOR2 7 3)--> 4

 

(CAPTURE <régi> <új>)--> NIL                                Subr

 

Minden olvasási műveletet átirányít a <régi> csatornáról az <új> csatornára.

 

   pl. (CAPTURE 34 102)--> NIL

 

(CAR <x>)--> tet                                            Subr

 

Az <x> pontozott pár első mezejét adja eredményül. A 25-ös hiba lép fel, ha <x> nem rendezett pár. A CAR név helyett HEAD is írható. A CAR függvény kiterjeszthető a CAAR és a CAAAR rövidítéseket használva, a CAR CAR, ill. a CAR. CAR CAR függvények reprezentálására.

 

   pl. (CAR '(A.B))--> A

       (CAR '((A.B).C))--> (A.B)

       (CAAR '((A.B).C))--> A

 

(CDR <x>)--> tet                                            Subr

 

Az <x> rendezett pár második mezejét adja. A 25-ös hiba lép fel, ha <x> nem rendezett pár. A CDR név helyett TAIL is írhatd. A CDR függvény kiterjeszthető a CDDR C-s a CDDDR rövidítéseket használva, a CDR CDR, ill. a CDR CDR CDR függvények reprezentálására.

 

   pl. (CDR '(A.B))--> B

       (CDR '(A.(B.C)))--> (B.C.)

       (CDDR '(A.(B.C)))--> C

 

(CHARACTER <szám>)--> id                                    Subr

 

A <szám>, mint ASCII kód által definiált azonosítót adja. A BASIC-beli CHR$ LISP-ekvivalense.

 

   pl. (CHARACTER 65)--> A

 

(CHARP <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> azonosító, különben NIL-t.

 

   pl. ((HARP 'A)--> T

       ((HARP 10)--> NIL

 

(CHARS <kif.>--> szám                                       Subr

 

Azoknak a karaktereknek a számát adja ki, amelyeket egy atom generálna, ha kinyomtatnák. Az érték függ az argumentum típusától.

 

    lista--> 0

    azonosító--> a kinyomtatott név karaktereinek száma

                 (ekvivalens a BASIC-beli LEN-nel)

    szám--> 6

    kódpointer--> 10

 

   pl. (CHARS 'A)--> 1

       (CHARS 10)--> 6

       (CHARS CAR)--> 10

 

(CLEAR)--> NIL                                              Subr

 

Megvilágítja az aktuális grafikus csatorna video page-ét.

 

(CLOSE <szám>)--> <szám>                                    Subr

 

Ha <szám> érvényes csatornaszáma egy nyitott file-nak, akkor azt lezárja.

 

   pl. (CLOSE 1) lezárja az 1-es csatornához tartozó file-t.

 

(CODEP <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> kódpointer, különben NIL-t.

 

   pl. (CODEP (A.B.))--> NIL

       (CODEP CAR)--> T

 

(COMMENT <tet1> <tet2>...)--> NIL                          Fsubr

 

Arra használjuk, hogy szöveges megjegyzéseket helyezzünk el egy kifejezésben.

 

   pl. (COMMENT EZ NEM ÉRTELMEZŐDIK)-->NIL

 

(COND (állítás)(állítás)...)--> TET                         Subr

 

Ez egy módszer a struktúra irányítására, és hasonló a BASIC-beli IF THEN ELSE parancshoz.

 

   IF <áll1> THEN <kif1>

   ELSE IF <á112> THEN <kif2>

   ...

   ELSE <kif.>

 

a LISP-ben így írható:

 

   (COND (<áll1> <kif1>)

         (<áll2> <kif2>)

    ...  (T<kif.>))

 

   pl. (COND ((EQ A 3) (PRINT "A=3"))

             ((EQ A 4) (PRINT "A=4"))

             (T NIL))

 

(CONS <car rész><cdr rész>)--> lista                        Subr

 

Új listát alkot a két megadott kifejezésből.

 

   pl. (CONS'A'B)--> (A.B)

       (CONS'A(CONS'B NIL))--> (A B)

 

(CONSTANTP <x>)--> T vagy NIL                               Subr

 

T-t ad, ha <x> szám vagy kódpointer, különben NIL-t.

 

(DEFUN CONSTANTP (OR (NUMBERP X) (CODEP X]

 

   pl. (CONSTANTP 10)--> T

       (CONSTANTP 'A)--> NIL

 

(COPY <x>)--> <x>                                           Subr

 

<x> egy példányát adja.

 

(DEFUN COPY (X)

  (COND

   ((ATOM X)X)

   (T(CONS(COPY(CAR X)) ((COPY (CDR X]

 

   pl. (COPY"(ABCDE))--> (ABCDE)

 

(CREATE <szám> <filenév>)--> <szám>                         Subr

 

Ez a függvény megnyitja a <filenév> file-t a <szám> csatornaszámon. Ekvivalens az "Access output"-tal specifikált BASIC OPEN parancshoz -- ld. a BASIC kézikönyvet.

 

   pl. (CREATE 15 "NAME")

 

CRLF                                                         Var

 

CRLF értéke egy kocsi vissza/soremelés

 

(CURSOR <kif>)--> NIL                                       Subr

 

Ha <kif> nem NIL, akkor a kurzor az aktuális output csatornán bekapcsolódik; különben kikapcsolódik.

 

   pl. (CURSOR NIL)--> NIL kurzor ki

       (CURSOR T)--> NIL kurzor be

 

(DEFLIST <dlista> <ind>)--> lista                           Subr

 

A <dlista> argumentum olyan lista, amelyiknek minden eleme kételemű lista; <dlista>-ban minden azonosítónak megvan az <ind> indikátorral jelzett tulajdonság-listán elhelyezett tulajdonsága. Az indikátorok egy listáját kapjuk vissza.

 

(DEFIN DEFLIST (U IND)

  (COND

    ((ATOM U) NIL)

    (T(PUT(CAAR U) IND (CADAR U))

      (CONS(CAAR U) (DEFLIST(CDR U) IND)))))

 

   pl. (DEFLIST '((V DD) (H RG)) 'NAME)--> (V H)

 

ami ugyanaz, mint:

 

       (PUT 'V 'NAME 'DD)--> DD

       (PUT 'H 'NAME 'RG)--> RG

 

és visszakapható, így:

 

       (GET 'V 'NAME)--> DD

 

(DEFMAC <név> <paraméter> <törzs>... )--> <név>            Fsubr

 

Ez a szokásos mód makrók definiálására.

 

   pl. (DEFMAC IF X

          (LIST

             "COND"

             (LIST (CADR X) (CADDR X))

             (LIST T (CAR (CDDDR X)))))

 

Ez az IF makrót definiálja, amelyet 3 argumentummal hívunk:

 

   pl. (IF A B C)

 

"A" kiértékelődik,: ha igaz, e lesz az eredmény; különben C.

 

   pl. (IF (ZEROP X) 4 5)--> 4, ha X=0

       (IF (ZEROP X) 4 5)--> 5, ha X<>0

 

(DEFUN <név> <paraméterek> <törzs>...)--> <név>            Fsubr

 

Ez a szokásos mód függvények definiálására.

 

   pl. (DEFUN SQUARE (X) (TIMES2 X X))--> SQUARE

 

(DEFVIDEO <+mód> <g-mód> <g-szín>--> NIL                    Subr

 

Ez a függvény definiálja azokat a paramétereket, amelyeket csak a TEXT és a GRAPHICS függvények használnak.

<+mód> 40 vagy 80 és a képernyő oszlopainak számát jelöli.

 

<g-mód> a következők egyike:

            1   nagyfelbontású grafika

            5   kisfelbontású grafika

           15   attribútum mód

 

<g-szín> a következők egyike:

            0   két-szín mód

            1  négy-szín mód

            2    16-szín mód

            3   256-szín mód

 

   pl. (DEFVIDEO 40 1 0)--> NIL

 

(DEL <ch>)--> <ch>                                          Subr

 

Lezárja a <ch> EXOS csatornát. A legtöbb berendezés esetben ekvivalens a CLOSE függvénnyel.

 

   pl. (DEL 1)--> 1

 

(DELETE <x> <y>)--> lista                                   Subr

 

Az <y> listát adja vissza, amelyből kitörölte <x> első előfordulását.

 

(DEFUN DELETE (A L)

 (COND

  ((ATOM L) L)

  ((EQUAL A (CAR L)) (CDR L))

  (T (CONS(CAR L)(DELETE A (CDR L))))))

 

   pl. (DELETE 'A '(B A C A)--> (B C A)

 

(DIFFERENCE <x> <y>)--> szám                                Subr

 

Az <y> számot kivonja az <x> számból és kiadja az eredményt.

 

   pl. (DIFFERENCE 7 3)--> 4

 

(DIGIT <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> azonosító, amelynek kinyomtatott neve számjeggyel kezdődik (0-9)

 

   pl. (DIGIT 'A)--> NIL

       (DIGIT '!0A)--> T

 

(DISPLAY <csat><tól><sor><nál>)--> NIL                      Subr

 

<sor> db. sort jelenít meg a képernyőn, a <csat> csatorna page-ének <tól> sorától kezdve, az első sort a képernyő <nál> sorára teszi. Minden argumentumnak egésznek kell lennie.

 

   pl. (DISPLAY 4 10 7 1)--> NIL

   a 4-es csatorna page-ének 10.-16. sorait jeleníti meg,

   a képernyő legfelső sorában kezdve.

 

(DIVIDE <x> <y>)--> <hányados.mar>                          Subr

 

Az <x> számot osztja el az <y> számmal és a (hányados.maradék) párt adja vissza.

   pl. (DIVIDE 7 3)--> (2.1)

 

DOLLAR                                                       Var

 

Ez a $ karakter.

 

(EDIT <kif>)--> tet                                         Subr

 

Egy szöveges page-et készít, és a SPRINT használatával megjeleníti <kif>-et. Ekkor editálni lehet <kif>-et, ehhez használható az összes szövegszerkesztési lehetőség, a befejezés az "ESCAPE" gomb megnyomásával történik.. A módosult forma beolvasásra kerül és megjelenik a képernyőn. Függvények editálására viszont a szokásos mód az FEDIT függvény hívása.

 

(ELLIPSE <x> <y>)--> NIL                                    Subr

 

Ellipszist rajzol, az aktuális képernyő-pozícióval, mint középponttal, az aktuális grafikus csatornán, az aktuális előtér-színnel. <x>, ill. <y> rendre az x-sugarat, ill. az y-sugarat jelöli.

 

   pl. (ELLIPSE 200 100)--> NIL

 

(ENVELOPE <en><er>[<cp><cl><cr><pd>])--> NIL               Fsubr

 

A hangburkolónak egy teljes leírása található a BASIC kézikönyvben.

<en> a hangburkoló szám (0-250)

<er> a fázisok száma a hangkibocsátás előtt (255, ha nincs kibocsátás

A szögletes zárójelben levő paraméterek egy fázist határoznak meg és legfeljebb 12-szer ismételhetők.

 

<cp> hangmagasság-változás félhangokban

<cl> a baloldali hangszóró hangereje (-63...63)

<cr> a jobboldali hangszóró hangereje (-63...63)

<pd> a fázis időtartama, 1/50 s-okban.

 

   pl. (ENVELOPE 1 1 10 30 20 10)--> NIL

 

(EOF)--> T vagy NIL                                         Subr

 

Megvizsgálja, hogy az aktuális input csatornán filevégnél tartunk-e. Értéke T, ha igen, különben NIL.

 

(EQ <kif1> <kif2>)--> T vagy NIL                            Subr

 

A függvény T-t ad, ha argumentumaira a következők egyike igaz:

 

1. Mindkettő ugyanaz az azonosító.

2. Mindkettő ugyanaz a szám.

3. Mindkettő ugyanaz a lista a LISP memóriában.

 

   pl. (EQ 1 'A)--> NIL

       (EQ 10 10)--> T

       (EQ '(A B) '(A B))--> NIL

 

(EQUAL <kif1> <kif2>)--> T vagy NIL                         Subr

 

Megvizsgálja, hogy két adott általános kifejezés azonos-e.

 

(DEFUN EQUAL (X Y)

  (COND

   ((EQ X Y) T)

   ((OR (ATOM X) (ATOM Y)) NIL)

   ((EQUAL(CAR X) (CAR Y)) (EQUAL (CDR X) (CDR Y)))

   (T NIL)))

 

   pl. (EQUAL 1 'A)--> NIL

       (EQUAL '(A B) '(A B))--> T

 

(ERROR <szám>)--> nincs értéke                              Subr

 

Feloldja a <szám> LISP hibakódot

 

(ERRORSET <tet>)--> szám vagy tet Fsubr

 

Kiértékeli az argumentumot. Ha eközben nem derül ki hiba, akkor visszaadja <tet> kiértékelésének eredményét, mint egy rendezett párt, a NIL-lel, különben a hibakódot.

 

   pl. (ERRORSET (ATOM 10))--> (T)

       (ERRORSET (A.B))--> 17

 

(EVAL <tet>)--> <tet>                                       Subr

 

Argumentumának második kiértékelését hajtja végre.

 

   pl. (EVAL '(CAR '(A B)))--> A

 

(EVLIS <lista»--> lista                                     Subr

 

Kiértékeli a lista összes elemét és az eredmények listáját adja.

 

(DEFUN EVLIS (ARGS)

  (COND ((ATOM ARGS) NIL)

  (T(CONS(EVAL(CAR ARGS))

         (EVLIS(CDR ARGS))))))

 

   pl. (EVLIS'((CHARP'Z) (EQ'A'B)))--> (T NIL)

 

(EXOS-READ <var>)--> <szám>                                 Subr

 

A <var> EXOS változó aktuális értékét adja ki.

 

   pl. (EXOS-READ 10)--} 234

 

(EXOS-TOGGLE <var>)--> <szám>                               Subr

 

Kapcsolóként működik és "váltja" a megfelelő EXOS változót. Az eredmény a változó aktuális státuszának komplemense.

 

   pl. (EXOS-TOGGLE 8)--> 0

 

(EXOS-WRITE <var> <val>)--> <val>                           Subr

 

A <var> EXOS változót a <val> értékre állítja be.

 

pl. (EXOS-WRITE 10 234)--> 234

 

(EXPAND <lista> <függvény>)--> lista                        Subr

 

<függvény>-nek két argumentumúnak kell lennie. Ha a listában n elem van, L(1), L(2), ... , L(n), akkor a következő listát kapjuk eredményül:

 

(<függvény> L(1) (<függvény> L(2)(...

(<függvény> L(n-1) L(n))...)))

 

(DEFUN EXPAND (L FN)

  (COND

    ((ATOM(CDR L)) (CAR L))

    (T(CONS FN

      (CONS(CAR L)

      (CONS(EXPAND (CDR L) FN) NIL))))))

 

   pl. (EXPAND '(A S C D) 'PLUSZ)--> (PLUS2 A

       (PLUSZ B (PLUSZ C D)))

 

(EXPANDMACRO <macro függvény> <teszt> --> tet               Subr

 

A debug-hoz hasznos eszköz, akkor alkalmazható, amikor makrókkal dolgozunk.

 

   pl. (EXPANDMACRO IF '(IF(EQ X 3)4 5))

   lásd. DEFMAC-nál IF definícióját)

 

(EXPLODE <azon>)--> list                                    Subr

 

Egy listát ad, <azon> kinyomtatott nevének karaktereivel.

 

   pl. (EXPLODE 'ABCDE)--> <A B C D E)

       (EXPLODE .... )--> NIL

 

(FEDIT <fgv>)--> NIL                                       Fsubr

 

Hasonló EDIT-hez, de lehetővé teszi, hogy az <fgv> függvényt megváltoztassuk. Nyomjuk meg az "ESCAPE" gombot az editálás végeztével, hogy a függvény újradefiniálódjon.

 

(FKEY <kn> <str>)--> NIL                                    Subr

 

A <kn> funkciós gombhoz a <str> stringet rendeli, amely legfeljebb 23 karakter lehet.

<kn> az 1-16 intervallumba esik, 9-16 az 1-8-ból shifttel állnak elő.

 

   pl. (FKEY 1 "Most be vagyok programozva!")--> NIL

 

(FLAG <azlis> <ind>)--> NIL                                 Subr

 

A listában minden azonosítót az <ind> jelzővel lát el.

 

   pl. (FLAG '(A B C D) 'FINE)--> NIL

 

(FLAGP <azon> <ind>--> T vagy NIL                           Subr

 

Arra használatos, hogy megvizsgáljuk, az <azon> azonosító az <ind> jelzővel van-e ellátva.

 

   pl. (FLAGP 'A 'FINE)--> T vagy NIL

 

(FLATTEN <x>)--> lista                                      Subr

 

<x> egész részfa-struktúráját megszünteti.

 

(DEFUN FLATTEN (X)

  (COND

    ((NUL X) NIL)

    ((ATOM X) (CONS X NIL))

    (T (NCONC (FLATTEN(CAR X))) (FLATTEN(CDR X))))))

 

   pl. (FLATTEN '(A((B)) NIL (C.D) E))--> (A B C D E)

 

(FLUSH <ch>)--> NIL                                         Subr

 

Kiüríti a <ch> hálózati csatornát.

 

   pl. (FLUSH 17)--> NIL

 

(FSUBRP <x>)--> T vagy NIL                                 Fsubr

 

T-t ad, ha <x> egy Fsubr típusú függvény kódpointere, NIL különben.

 

   pl. (FSUBRP COND)--> T

       (FSUBRP 'A)--> NIL

 

FUNARG                                                        Id

 

FUNARG értéke határozatlan. Az interpreteren belül van speciális jelentése, ún. FUNARG lezárásoknál.

 

(FUNCTION <fn>)--> FUNARG <fn> környezet                   Fsubr

 

Éppen úgy működik, mint QUOTE <qu>, de csak függvényekre alkalmazható. Amikor az eredményül kapott formába (ún. FUNARG lezárás) bizonyos argumentumokat helyettesítünk, minden változónak ugyanaz lesz az értéke, mint a lezárási operáció elvégzése előtt.

 

(GENSYM)--> azon                                            Subr

 

Egyetlen azonosítót ad vissza, ennek formája G0000, G0001, stb.

 

   pl. (GENSYM)--> 00042

 

(GET <azon> <ind>)--> tet                                   Subr

 

Az <azon> azonosító listáján levő tulajdonságot adja eredményül, az <ind> jelző mellett, vagy NIL-t, ha ilyen tulajdonság nincs.

 

   pl. (GET 'V 'NAME)--> DD

 

(GETCHAR)                                                   Subr

 

Egyetlen karakter olvasódik be az aktuális input áramból, ez lesz az eredmény. Jegyezzük meg, hogy az a függvény nem ugyanaz, mint a BASIC-beli INKEY$. INKEY$ LISP ekvivalense:

(DEFUN INKEY ()

  (RDS 5)

(PROG1 (AND (ZEROP (READSTATUS)) (GETCHAR)) (RDS 0)))

 

   pl. (GETCHAR)--> J

 

(GRAPHICS)--> NIL                                           Subr

 

Ha van grafikus csatorna, akkor az a képernyőn megjelenik; különben standard grafikus page kerül megnyitásra, és megjelenik a képernyő felső húsz sorában. A grafikus mód és a színek a DEFVIDEO paranccsal definiálódnak.

 

(GREATERP <x> <y>)--> T vagy NIL                            Subr

 

T-t ad, ha az <x> szám nagyobb, mint az <y> szám; különben NIL-t.

 

   pl. (GREATERP 7 3)--> T

 

(GRS <ch>)--> <szám>                                        Subr

 

Hatására <ch> lesz az aktuális grafikus csatorna, az előző száma pedig az eredmény.

 

HANDLER                                                       Id

 

A LISP működése közben "software interruptok" érkezhetnek az operációs rendszertől. A HANDLER változó beállítható úgy, hogy az interrupt érkezésekor a rendszer egy bizonyos műveletet végezzen el. Lásd a 7. fejezetet.

 

(HEAD <x>)--> tet                                           Subr

 

Ez a függvény a CAR függvénnyel azonos.

 

   pl. (HEAD 'A.B))--> A

 

(IMPLODE <idlist>)--> id                                    Subr

 

Összeláncolja az <idlist>-ben lévő atomokat, s az így kapott azonosítót adja vissza.

 

   pl. (IMPLODE '(A B CD EF G))--> ABCDEFG

 

(IN <ioport>)--> szám                                       Subr

 

A Z80 <ioport> input/output portjától kapott értéket adja vissza.

 

   pl. (IN 129)--> 3

 

(INK <col>)--> NIL                                          Subr

 

A palettáról választott "logikai" színre cseréli az aktuális grafikus csatorna előtér-színét.

 

   pl. (INK 10)--> NIL

 

(INTERN <id>)--> <id>                                       Subr

 

Keresi <id>-et az oblist listán. Ha ott nem találja, kiegészíti vele a listát és eredményül is <id>-et ad.

 

   pl. (INTERN 'WRITE)--> WRITE

 

(JOY <szám1>)--> szám2                                      Subr

 

A <num> joystick szám státuszát adja eredményül -- a definíciót lásd a BASIC kézikönyvben.

 

   pl. (JOY 1)--> 17

 

LAMBDA                                                        Id

 

Speciális jelentése van az interpreteren belül -- egy ún. lambda kifejezés.

 

(LAST <x>)--> tet                                           Subr

 

Az <x> lista utolsó tagját adja vissza.

 

(DEFUN LAST(X)

  (COND

    ((ATOM X) X)

    ((NULL(CDR X)) (CAR X))

    (T (LAST (CDR X)))))

 

   pl. (LAST'A B C))--> C

 

(LENGTH <x>)--> szám                                        Subr

 

Az <x> lista hosszát adja -- a legfelső szinten mérve.

 

(DEFUN LENGTH(X)

  (COND

    ((ATOM X) 0)

    (T (ADD1 (LENGTH(CDR X))))))

 

   pl. (LENGTH 'A)--> 0

       (LENGTH '(A B (C.D) E))--> 4

 

(LESSP <x> <y>)--> T vagy NIL                               Subr

 

T-t ad, ha az <x> szám szigorúan kisebb, mint az <y> szám; kül6nben NIL-t.

 

   pl. (LESSP 7 ?)--'> NIL

 

(LINELENGTH <tet>)--> szám                                  Subr

 

Egy sor hosszát adja, ahogy azt a SPRINT utasítás használja.

 

   pl. (LINELENGTH 60)--> 64 (az előző érték)

 

(LIST <arg1> <arg2> ... )--> lista                          Subr

 

Az (<arg1> <arg2> ... ) listát adja.

 

   pl. (LIST 'A 'B '-9 'C)-->(A B -9 C)

 

(LISTP <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> rendezett pár; különben NIL-t

 

   pl. (LISTP '(A B))--> T

 

(LITER <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> olyan azonosító, aminek kinyomtatott neve betűvel kezdődik; különben NIL-t.

 

pl. (LITER 'A)--> T

    (LITER '!0A)--> NIL

 

(LOAD <filenév>)                                            Subr

 

Betölt egy SAVE függvénnyel kimentett memóriarészt, vagy egy LISP kifejezésekből álló ASCII file-t.

 

   pl. (LOAD "NAME")

 

(LOOP <tev1> <tev2> ... )--> tet                            Subr

 

Addig végzi a <tev1>, <tev2>, ... tevékenységeket, amíg a WHILE vagy UNTIL részben lévő állítás nem válik hamissá/igazzá.

 

   pl. (LOOP (PRIN'*) (SETQ CT(SUB1 CT))(UNTIL

       (ZEROP CT)))

  egy sornyi *-ot nyomtat ki, ha előtte (SETQ CT <szám>)

  utasítás szerepelt.

 

LPAR                                                         Var

 

LPAR értéke a "(" karakter.

 

MACRO                                                         Id

 

Speciális jelentése van az interpreteren belül -- egy ún. Macro kifejezés.

 

(DEFUN MAP (X FN)

  (LOOP

    (UNTIL (ATOM X) NIL)

    (FN X)

    (SETQ X (CDR X))))

 

   pl. (MAP'ABC D) '(LAMBDA (x) (PRIN x)))--> NIL

   az (A B C D) (B C D) (C D) (D) NIL outputot fogja adni.

 

(MAPC <x> <fn>)--> NIL                                      Subr

 

Az <fn> függvénybe helyettesíti sorra az <x> lista elemeit, s ezenkívül még egy NIL-t ad eredményül.

 

(DEFUN MAPC(X FN)

  (LOOP

    (UNTIL (ATOM X) NIL)

    (FN (CAR X))

    (SETQ X (CDR X))))

 

   pl. (MAPC'(A B C D) '(LAMBDA (x) PRIN (x)))--> NIL

   az ABCD NIL outputot adja.

 

(MAPCAN <x> <fn>)--> lista                                  Subr

 

Az a követelmény, hogy az <fn>-be való minden helyettesítés listát ad eredményül. A MAPCAN függvény az így kapott listák összeláncoltját adja.

 

(DEFUN MAPCAN (X FN)

  (COND

    ((ATOM X) NIL)

    (T (NCONC (FN (CAR X)) (MAPCAN(CDR X) FN)))))

 

   pl. (MAPCAN'(A B C D)'(LAMBDA(x) (LIST xx)))

   -->

   (A A B B C C D D)

 

(MAPCAR <x> <fn>)--> lista                                  Subr

 

Azt a listát adja eredményül, amely az <x> lista elemeinek sorra <fn>-be való helyettesítésekor jön létre.

 

(DEFUN MAPCAR (X FN)

  (COND

    ((ATOM X) NIL)

    (T(CONS(FN(CAR X))(MAPCAR(CDR X) FN)))))

 

   pl. (MAPCAR'A B C D)'(LAMBDA(x) (CONCx x)))

   -->

   ((A.A) (B.B) (C.C) (D.D))

 

(MAPCON <x> <fn>)--> lista                                  Subr

 

Követelmény, hogy az <fn>-be való minden helyettesítés listát adjon. MAPCON <fn>-be helyettesíti rendre <x>-et, (CDR <x>)-et, (CDDR <x>)-et, amíg a lista el nem fogy és a kapott listák összeláncoltja lesz az eredmény.

 

(DEFUN MAPCON (X FN)

  (COND

    ((ATOM X) NIL)

    (T (NCONC (FN X) (MAPCON (CDR X) FN)))))

 

   pl. (MAPCON'(A B C D)'(LAMBDA(x) (LIST

       (CONS 1 x)))--> ((1 A B C D)(1 B C D)(1 C D) (1 D))

 

(MAPLIST <x> <fn>)--> lista                                 Subr

 

Azt a listát adja ki, amely az <x>-nek, (CDR<x>)-nek, (CDDR<x>)-nek,..., stb. <fn>-be való helyettesítésekor adódik, míg a lista ki nem merül.

 

(DEFUN MAPLIST (X FN)

  (COND

    ((ATOM X) NIL)

    (T(CONS(FN X) (MAPLIST(CDR X)FN)))))

 

   pl. (MAPLIST'(A B C D)'(LAMBDA (x)

       (LENGTH x)))--> (4 3 2 1)

 

(MAX2 <x> <y>)--> szám                                      Subr

 

az <x> és az <y> számok közül a nagyobbikat adja.

 

   pl. (MAX2 7 3)--> 7

 

(MEMBER <x> <y>)--> NIL vagy lista                          Subr

 

NIL-t ad, ha <x> nem eleme az <y> listának. Különben <y>-nak az x-szel kezdődő szeletét adja.

 

(DEFUN MEMBER (X Y)

  (COND

    ((ATOM Y) NIL)

    ((EQUAL X (CAR Y)) Y)

    (T(MEMBER X (CDR Y)))))

 

   pl. (MEMBER'A'(B C A D E))--> (A D E)

 

(MEMQ <x> <y>)--> NIL vagy lista                            Subr

 

Ugyanaz, mint MEMBER, azzal a különbséggel, hogy az összehasonlításhoz EQ-t alkalmaz, nem pedig EQUAL-t.

 

(DEFUN MEMQ(X Y)

  (COND

    ((ATOM Y) NIL)

    ((EQ X(CAR Y)) Y)

    (T(MEMQ X(CDR Y)))))

 

   pl. (MEMQ'A B) '(A B (A B) C))--> NIL

 

(MESSOFF <szám>)--> szám                                    Subr

 

A MESSOFF és a MESSON függvények bizonyos rendszerüzenetek kiírásának vezérlésére alkalmasak. Egy vezérlő byte-ban levő biteket vezérel, az alábbiak szerint:

 

 1 - összegyűjtött kontrollszummák     OFF

 2 - Kontrollszumma                    OFF

 4 - Hibakód (és üzenet, ha van)       ON

 8 - Hibakereső                        ON

64 - A (QUOTE<id>) "<id>"-dé való

     konverzióját vezérli              ON

 

Például, (MESSON 2) a kontrollszummát írja ki, míg (MESSOFF 8) leállítja a hibakeresést.

 

   pl. (MESSOFF 10)--> 255

 

(MESSON <szám>)--> szám                                     Subr

 

ld.  MESSOFF

 

(MIN2 <x> <y>)--> szám                                      Subr

 

Az <x> és <y> számok közül a kisebbiket adja ki.

 

   pl. (MIN2 7 3)--> 3

 

(MINUS <szám>)--> szám                                      Subr

 

A <szám> negáltját adja.

 

   pl. (MINUS 7)--> -7

       (MINUS -3)--> 3

 

(MINUSP <x>)--> T vagy NIL                                  Subr

 

T-t ad, ha <x> szám és x<0; különben NIL-t.

 

   pl. (MINUSP -3)--> T

       (MINUSP 4)--> NIL

 

(MKQUOTE <x>)--> lista                                      Subr

 

A (QUOTE<x>) listát adja.

 

   pl. (MKQUOTE'(A B C)--> (QUOTE(A B C))

 

(NCONC <x> <y>)--> lista                                    Subr

 

Összeláncolja <x>-et és <y>-t, anélkül, hogy <x>-et átmásolná. úgy működik, mint APPEND, de nem olyan megbízható. Kétséges esetben használjuk APPEND-et!

 

(DEFUN NCONC(A B (W))

  (COND

    ((ATOM A) B)

    (T(SETQ W A)

     (LOOP

       (UNTIL(ATOM (CDR W)))

       (SETQ W(CDR W)))

          (RPLACD W B)

          A)))

 

   pl. (NCONC'(A B C) '(D E))--> (A B C D E)

 

NIL                                                           Id

 

A "hamis" igazságértéket adja.

 

(NOT <x>)--> T vagy NIL                                     Subr

 

Ha <x> NIL, akkor T-t ad; ha <x> T, akkor NIL-t ad.

 

   pl. (NOT NIL)--> T

 

(NULL <x>)--> T vagy NIL                                    Subr

 

Ha <x> NIL, T-t ad; NIL-t különben. Teljesen ekvivalens a NOT függvénnyel (ld. fent).

 

   pl. (NULL 1)--> NIL

 

(NUMBERP <x>)--> T vagy NIL                                 Subr

 

T-t ad, ha <x> szám; különben NIL-t.

 

   pl. (NUMBERP 7)--> T

 

(OBLIST)--> lista                                           Subr

 

Listát ad az összes, a rendszer számára ismert azonosítóról. (FLATTEN (OBLIST)) egy egyszerűbb listát ad.

 

(ONEP <x>)--> T vagy NIL                                    Subr

 

T-t ad, ha <x> az 1-es szám; különben NIL-t.

 

   pl. (ONEP 1)--> T

 

(OPEN <szám> <filenév>)--> <szám>                           Subr

 

Megnyitja a <filenév> nevű file-t, a <szám> csatornaszámon. Hasonlít a Basic-beli OPEN parancshoz.

 

   pl. (OPEN 15 "NAME")

 

(OR <kif1><kif2><kif3>...)--> tet                          Fsubr

 

Az első nem-NIL argumentumot adja; ha ilyen nincs, akkor NIL-t.

 

   pl. (OR (NUMBERP'A) (CONS A B)(ZEROP 'T))--> (A B)

 

(ORDERP <id1> <id2>)--> T vagy NIL                          Subr

 

T-t ad, ha <id1> kinyomtatott nevének ASCII kódja nagyobb, mint <id2>-é; különben NIL-t ad.

 

   pl. (ORDERP 'A 'B)--> NIL

       (ORDERP 'B 'A)--> T

       (ORDERP 'AB 'AA)--> T

 

(ORDINAL <id>)--> szám                                      Subr

 

<id> kinyomtatott nevének első karakterét adja, ASCII kódban.

 

   pl. (ORDINAL 'APPLE)--> 65

 

(OUT <érték> <ioport>)--> <érték>                           Subr

 

Elküldi <érték>-et a Z80 <ioport>-tal specifikált input-output portjához.

 

   pl. (OUT 10 254)--> 10

 

(PAINT)--> NIL                                              Subr

 

Kitölti az összes olyan vonalat, amely az aktuális képernyő-pozíciótól olyan határig tart, amely az aktuális képernyő-pozíciótól különböző színű.

 

(PAIR <x> <y>)--> egy lista                                 Subr

 

<x> és <y> azonos elemszámú listák kell, hogy legyenek. PAIR rendezett párok egy listáját adja, amelyeknek CAR-ja <x>-ből, CDR-je <y>-ból van.

 

   pl. (PAIR"(A B)"(1 2))--> ((A.1)(B.2))

 

(PALETTE <c0> <cl> <c2> <c3> <c4> <c5> <c6> <c7>)--> NIL    Subr

 

A palettát specifikálja az aktuális grafikus csatornára, a <c0>,...,<c7> egész számokkal a 0-255 intervallumban, mindegyikük egy-egy színt specifikál.

 

Megjegyzés 2-szín-módban c2,...,c7 fölösleges, 4-szín-módban c4,...,c7 fölösleges, 16-szín-mbdban a többi 8 szín c0,...,c7-bol a szokásos módon származtatható.

 

   pl. (PALETTE 10 20 40 5 73 122 5 0)--> NIL

 

(PAPER <col>)--> NIL                                        Subr

 

Átváltoztatja az aktuális grafikus csatorna háttérszínét <col>-ra. Ennek hatása akkor látszik, amikor a csatornára legközelebb CLEAR utasítást adunk ki.

 

   pl. (PAPER 29)--> NIL

 

(PEEK <cím>)--> szám                                        Subr

 

<cím> tartalmát adja ki.

 

   pl. (PEEK 10)--> 6

 

PERIOD                                                       Var

 

Írtéke a "." karakter.

 

(PLIST <id>)--> lista                                       Subr

 

Az <id> azonosító tulajdonság-listáját adja.

 

   pl. (PLIST'A)--> ((tul1. ért1)(tul2. ért2)....)

 

(PLOT <x> <y>)--> NIL                                       Subr

 

Megvilágítja a képernyő (<x>,<y>) pozícióját, s ha ez megtörtént, ott egy vonalat rajzol.

 

   pl. (PLOT 200 100)--> NIL

 

(PLOTR <x> <y>)--> NIL                                      Subr

 

Az aktuális képernyő-pozíciótól x irányba <x>, y irányba <y> elmozdulást tesz, majd vonalat rajzol.

 

   pl. (PLOTR 100 200)--> NIL

 

(PLOTMODE <szám>)--> NIL                                    Subr

 

A rajzmódot állítja be az aktuális grafikus csatornán, a következőképp:

 

    0. PUT rajz (alapértelmezés)

    1. OR rajz

    2. AND rajz

    3. XOR rajz

 

   pl. (PLOTMODE 2)--> NIL

 

(PLOTSTYLE <szám>)--> NIL                                   Subr

 

A vonal típusát adja meg az aktuális grafikus csatornán. <szám> egész az 1-14 intervallumban, 1-es folytonos vonalat jelent, a többi szám különböző pontozott vonalakat.

 

   pl. (PLOTSTYLE 5)--> NIL

 

(PLUS <arglista>)--> szám                                  Fsubr

 

Az <arglista>-ban megadott egész számok összegét szolgáltatja.

 

   pl. (PLUS 10 3 16)--> 29

 

(PLUS2 <x> <y>)--> szám                                     Subr

 

Ha pontosan két számot kell összeadni, akkor ez a hatékonyabb módja.

 

   Pl. (PLUS2 7 3)-- 10

 

(POKE <cím> <érték>)--> <érték>                             Subr

 

A memória <cím> által megadott helyére <érték>-et ír.

 

   pl. (POKE 10 23)--> 23

 

(PRIN [<arglista>])--> tet                                  Subr

 

Az <arglista>-ban levő argumentumok kiértékelődnek, és kiíródnak, közbenső blank jelek nélkül. A speciális karakterek elé escape jel kerül.

 

   pl. (PRIN'A BLANK'B)--> B hatására A! B íródik ki.

 

(PRINC [<arglista>])--> tet                                 Subr

 

Ugyanolyan, mint PRIN, azzal a különbséggel, hogy a speciális karakterek elé nem kerül escape jel.

 

   pl. (PRINC'A BLANK'B)--> B hatására A B jelenik meg.

 

(PRINT [<arglist>])--> NIL Subr

 

Ugyanaz, mint PRIN, azzal a különbséggel, hogy a CR/LF-et is magában foglalja, és NIL-t ad.

 

   pl. (PRINT'A BLANK'B)--> NIL hatására A! B jelenik meg.

 

(PRINTC [<arglista>])--> NIL                                Subr

 

Ugyanolyan, mint PRINT, de a speciális karakterek elé nem kerül escape jel.

 

   pl. (PRINTC'A BLANK'B)--> NIL és

       A B jelenik meg.

 

(PROG1 <kif1> <kif2>)--> <kif1>                             Subr

 

Az első argumentumot adja vissza.

 

   pl. (PROG1 'A'B)--> A

 

(PROG2 <kif1> <kif2>)--> <kif2>                             Subr

 

A második argumentumot adja vissza.

 

   pl. (PROG2'A'B)--> B

 

(PROGN <kif1><kif2>...<kifn>)--> tet                       Fsubr

 

Kiértékeli rendre <kif1>-et, <kif2>-t,..., <kifn>-et, és  <kifn>-et adja vissza.

 

   pl. (PROGN'A 3 4'B)--> B

 

(PUT <id><ind><tul>)--> <tul>                               Subr

 

A <tul> tulajdonságot <id> tulajdonságlistájára teszi az <ind> indikátor alatt.

 

   pl. (PUT'V'NAME'DD)

 

(QUOTE <tet>)--> kiértékeletlen<tet>                       Fsubr

 

Leállítja a kiértékelést, és LISP-en keresztül kiírja: '<tet>

 

   pl. (QUOTE A)--> A

       vagy

       'A--> A

 

(QUOTEP <x>)--> T vagy NIL                                  Subr

 

T-t ad, ha <x> idézett kifejezés, különben NIL-t.

 

pl. (QUOTEP'(QUOTE Z))--> T

 

(QUOTIENT <x> <y>)--> szám                                  Subr

 

Elosztja az <x> számot az <y> számmal, és - a maradékot figyelmen kívül hagyva - kiadja a "hányadost".

 

   pl. (QUOTIENT 7 3)--> 2

 

(RANDOM <szám>)--> szám                                     Subr

 

Véletlen számot ad a 0-(<szám>-1) intervallumban, hacsak a <szám> nem 0; ekkor az intervallum 0-32767. <szám> maximális lehetséges értéke 2000.

 

   pl.(RANDOM 1967)--> 1510

 

(RANDOMISE <mag>)--> <mag>                                  Subr

 

Alkalmazható a véletlen számok ellenőrzésére. Ha <mag> 0, akkor a sorozat nem jósolható, ha viszont nem 0, egy konkrét ismételt sorozatot nyertünk.

 

   pl. (RANDOMISE 43)--> 764

 

(RDS <ch>)--> <cr>                                          Subr

 

<ch>-t aktuális input áramnak véve, a megelőző input áramot adja.

 

   pl. (RDS 1)--> 0

 

(READ)--> tet                                              Fsubr

 

A függvény az aktuális input csatorna soronkövetkező s-kifejezéséből kiolvasott eredményt adja ki.

 

(READLINE)--> tet                                          Fsubr

 

Az aktuális input csatornából a következő sor első karakteréig olvas, ebből egyetlen azonosítót képez, ezt adja eredményül.

 

(READ-STATUS)--> <szám>                                     Subr

 

Az aktuális input csatorna státuszát adja ki. Értékei:

 

 

   -1 - file-vég

    0 - a karakter olvasásra kész

    1 - különben

 

(RECLAIM)--> <szám>                                         Subr

 

Tömörítést végez. Megadja a szabad LISP cellák számát. Ennek a számnak kb. az ötszöröse lesz a szabad byte-ok száma.

 

(REDIRECT <régi> <új>)--> NIL                               Subr

 

Az összes output operációt átirányítja a <régi> csatornáról az <új> csatornára.

 

   pl. (REDIRECT 42 104)--> NIL

 

(REMAINDER <x> <y>)--> szám                                 Subr

 

Ha x>0, az eredmény x MOD(ABS y). Ha x<0, az eredmény y-(ABS x) MOD (ABS y).

 

   pl. (REMAINDER 7 3)--> 1

       (REMAINDER -7 3)--> 2

 

(REMFLAG <azon. lista><ind>)--> NIL                         Subr

 

Az <azon. lista> azonosító listát megfosztja a flag-ektől.

 

   pl. (REMFLAG '(A B)'FINE)--> NIL

 

(REMOB <id>)--> <id>                                        Subr

 

Megkeresi az <id> azonosító oblist-jét, és ha van, eltávolítja.

 

pl. (REMOB'A)--> A

 

(REMPROP <azon> <ind>)--> tet                               Subr

 

Az <azon> azonosító tulajdonság-listájáról eltávolítja az <ind> tulajdonságot. NIL-t ad, ha ezt a tulajdonságot nem találja.

 

   pl. (REMPROP'V'NAME)--> DD

 

(REPEAT <szám><kif>)--> NIL                                Fsubr

 

Kiértékeli a <kif> kifejezést, egymásután <szám>-szor.

 

   pl. (REPEAT 5 (PRINC'AB))--> NIL,

       ABABABABAB jelenik meg.

 

(REVERSE <x>)--> lista                                      Subr

 

Az <x> lista megfordítottját adja vissza.

 

   pl. (REVERSE'(A B(C D) E))

       -->(E (C D) B A)

 

(REVERSEIP <x>)--> lista                                    Subr

 

Ugyanazt teszi, mint REVERSE, csak sokkal gyorsabban, viszont kevésbé megbízható.

 

   pl. (REVERSEIP'(A B C D))--> (D C B A)

 

RPAR                                                         Var

 

Értéke a ")" karakter.

 

(RPLACA <mod><kif>)--> tet                                  Subr

 

A <mod> CAR mezejét helyettesíti <kif>-fel.

 

   pl. (RPLACA'(A B) 1)--> (1 B)

 

(RPLACD <mod><kif>)--> tet                                  Subr

 

A <mod> CDR mezejét helyettesíti <kif>-fel.

 

   pl. (RPLACD'(A B) 1)--> (A.1)

 

(SASSOC<kulcs><alista>)--> (kulcs><érték>) vagy tet         Subr

 

Egy adott <kulcs> kulcsot keres <alista>-ban, és ha megtalálta, a (kulcs,érték) párt adja vissza. Különben a függvény argumentumok nélkül értékelődik ki.

 

   pl.(SASSOC'A'((B.27)(A.-3))FN)--> (A.-3)

      (SASSOC'A'((B.27)"(LAMBDA NIL 5))--> 5

 

(SAVE <filenév>)--> <filenév>                               Subr

 

Kimenti e rendszer aktuális állapotát (amely később LOAD-dal visszanyerhető)

 

   pl. (SAVE "NAME")

 

(SET <azon><kif>)--> <kif>                                  Subr

 

<azon> értékét <kif>-re változtatja.

 

   pl. (SET 'X 42)--> 42

 

(SETATTRIBUTES <szám>)--> NIL                               Subr

 

A grafikus attribútum-flag-byte-ot változtatja <szám>-ra (az aktuális grafikus csatornán). Alapvetően ez a flag-byte határozza meg, hogyan történik a rajzolás attribútum-módban. A teljes leírást lásd az EXOS specifikációknál. A függvény NIL-t ad eredményül.

 

   pl. (SETATTRIBUTES 3)--> NIL

 

(SETCOLOUR <szám><szín>)--> NIL                             Subr

 

A <szám> "logikai" színt teszi a palettán a <szín> szín helyére.

 

pl. (SETCOLOUR 3 24)--> NIL

 

(SETQ <azon><kif>)--> <kif>                                Fsubr

 

Ugyanolyan, mint SET, csak az első argumentum automatikusan idézve szerepel.

 

   pl. (SETQ X 42)--> 42

 

(SET-TIME <azon>)---> NIL                                   Subr

 

Lehetővé teszi, hogy a rendszer óráját átállítsuk (ld. TIME). Az <azon> argumentumnak nyolc karakter hosszú azonosítónak kell lennie, amely az időt a következő formában ábrázolja:

 

   hh:mm:ss

 

   pl. (SET-TIME "01:30:42")--> NIL

 

(SETVIDEO <ind><col><x><y>)--> NIL                          Subr

 

Egy video oldalt definiál, közvetlenül az oldal megnyitása vagy kreálása előtt kell hívni.

 

   <ind> értékei lehetnek:

 

   0 - 128 kisfelbontású karakter (soronként 42 karakter)

   1 - nagyfelbontású pixel grafika (872 pixel)

   2 - 128 nagyfelbontású karakter (soronként 84 karakter)

   5 - kisfelbontású pixel grafika (436 pixel)

  15 - attribútum mód

 

A zárójelben megadott felbontások a teljes képernyőre vonatkoznak, két-szín-módban. A függőleges felbontás teljes képernyőre 27 karakter, azaz 243 pixel.

 

   <col> értékei lehetnek:

 

   0 -   2 szín

   1 -   4 szín

   2 -  16 szín

   3 - 256 szín

 

<x> és <y> a video oldal méretét határozza meg.

 

   1<x<42

   0<y<255

 

   pl. (SETVIDEO 1 2 40 20)--> NIL

 

(SNDS <ch>)--> <szám>                                       Subr

 

Hatására <ch> lesz az aktuális grafikus csatorna, az előzőt pedig eredményül adja.

 

   pl. (SNDS 56)--> 34

 

(SOUND <env><p><vl><vr><sty><ch><d><f>)--> NIL              Subr

 

Egy hangot eredményez (feltételezve, hogy az aktuális hangcsatorna nyitva van a SOUND eszközre). A paraméterek jelentése:

 

<env> - AA hanghoz használt hangburkoló (ld. ENVELOPE).

        255-ös hangburkoló konstans erejű és magasságú

        "bip"-et ad a hangadás teljes időtartamára.

 

<p>   - A hang kezdő magassága félhangokban

 

<vl>  - A baloldali hangszóró maximális hangereje

 

<vr>  - A jobboldali hangszóró maximális hangereje

 

<sty> - A hangmoduláció-byte. Ennek a byte-nak a hatását

        legjobban kísérletileg lehet meghatározni! A

        nulla tiszta hangot ad a hangcsatornákra és

        fehérzajt a zajcsatornára.

 

<ch>  - A hangforrás - 0, 1, vagy 2 a megfelelő

        hangcsatornára, és 3 a zajcsatornára.

 

<d>   - A hangadás időtartama (1/50 mp-ben mérve)

 

<f>   - Flag-byte

                 0 - a hang a várakozó sorba kerül

               128 - a hang minden, erre a csatornára

                     várakozó hangot megelőz.

 

                     A rutin NIL-t ad eredményül.

 

   pl. (SOUND 255 20 3 10 30 40 0 0)--> NIL

 

(SPRINT <kif>)--> NIL                                       Subr

 

Ez a program formattáló. A <kif> kifejezést szebb formában jeleníti meg.

 

(SUB1 <szám>)--> szám Subr

 

<szám>-1-et ad vissza.

 

   pl. (SUB1 23)--> 22

 

(SUBLIS <alista> <kif>)--> tet Subr

 

Az eredmény úgy alakul ki, hogy <kif> CAR részének minden előfordulásába <alista> CDR részét helyettesítjük.

 

   pl. (SUBLIS'((A.10)(B.C))'(H A (B) A))

        --> (H 10 (C) 10)

 

(SUBRP <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> egy szubrutinra mutató kódpointer, különben NIL-t.

 

   pl. (SUBRP CAR)--> T

 

(SUBST <x> <y> <kif>)--> lista Subr

 

<kif>-ben mindenhol <y> helyett <x>-et helyettesít.

 

   pl. (SUBST'A 'B (C B (A) (B A)))

        -->(C A (A) (A))

 

T                                                             Id

 

A TRUE igazságértéket jelenti.

 

(TAIL <x>)--> tet                                           Subr

 

Ez a függvény a CDR-rel azonos.

 

   pl. (TAIL '(A.B))--> B

 

(TERPRI)--> NIL                                             Subr

 

A képernyőre egy kocsi-visszát tesz ki.

 

(TEXT)--> NIL                                               Subr

 

Új szöveges oldalt nyit, az oldal oszlopainak számát a legutóbbi DEFVIDEO hívás határozza meg.

 

(TIME)--> azonosító                                         Subr

 

A pillanatnyi időt adja, egy nyolckarakteres azonosítóban, ebben a formában:

 

     hh:mm:ss

 

Az óra bekapcsoláskor indul, 00:00:00-ról, és a SET-TIME függvénnyel állítható át (ld. ott).

 

   pl. (TIME)--> 00:10:38

 

(TIMES <arglista>)--> szám                                 Fsubr

 

Kiértékeli <arglista> elemeit, és összeszorozza őket, a szorzatot adja eredményül.

 

   pl. (TIMES 2 5 -3)--> -30

 

(TIMES2 <x><y>)--> szám                                     Subr

 

Hatékonyabb mód pontosan két szám, <x> és <y> összeszorzására.

 

   pl. (TIMES2 3 7)--> 21

 

UNDEFINED                                                     Id

 

Amikor egy azonosítót először használunk, "UNDEFINED" értéket kap.

 

(UNTIL <kif>)                                              Fsubr

 

A LOOP ciklusutasításban szerepel.

 

   pl. (UNTIL (EQ A 3))

 

VERSION                                                       Id

 

String, amely leírja, milyen LISP verzió működik éppen.

 

(WHILE <kif>)                                              Fsubr

 

A LOOP ciklusutasításban szerepel.

 

   pl. (WHILE (EQ A 3))

 

(WRS <handle>)--> <handle>                                  Subr

 

Hatására a <handle> csatorna lesz az aktuális output áram.

 

   pl. (WRS 2)--> 3

 

(ZEROP <x>)--> T vagy NIL                                   Subr

 

T-t ad, ha <x> a nulla szám; különben NIL-t ad.

 

   pl. (ZEROP 0)--> T

 

 

1. Függelék

 

EXOS VÁLTOZÓK

 

 

Az alábbi lista megadja azokat az EXOS változókat, amelyek az EXOS-READ, EXOS-WRITE és az EXOS-TOGGLE parancsokkal kezelhetők.

 

Minden változó beállítható a 0-tól 255-ig terjedő értékek bármelyikére. Ugyanakkor, sokan közülük kapcsolóként működnek, be- vagy kikapcsolnak valamit, ahol 0 felel meg a "be" és 255 a "ki" iránynak.

 

 0 IRQ_ENABLE_STATE 0. bit- hang megszakítás

                    2. bit- 1 Hz megszakítás

                    4. bit- Video megszakítás

                    6. bit- Külső megszakítás

 

Az 1., 3., 5., 7. biteknek 0-nak kell lenni. Ezt a változót normál használatban ne módosítsuk.

 

  1 FLAG_SOFT_IRQ   Egy eszköz nem-0-ra állítja, software

                    megszakítás céljából.

 

  2 CODE_SOFT_IRQ   Egy software megszakítás rutin vizsgálja,

                    a megszakítás okának kiderítése céljából.

 

  3 DEF_TYPE        Az alapértelmezésként szereplő eszköz

                    típusa 0 szalag, 1 lemez.

 

  4 DE_CHAN         A default csatorna száma.

 

  5 TIMER           1 Hz-es :visszaszámláló, a nulla

                    elérésekor software megszakítást okoz, és

                    meg is áll.

 

  6 LOCK_KEY        A rögzített billentyűk aktuális helyzete.

 

  7 CLICK_KEY       0 A billentyűzet hangja bekapcsolva,

                    1 kikapcsolva.

 

  8 STOP_IRQ        0 A STOP billentyű megszakítást okoz,

                    1 A STOP billentyű a kódját adja vissza.

 

  9 KEY_IRQ         0 Bármely billentyű megnyomása software

                    megszakítást okoz, és a kódját is

                    visszaadja.

 

 10 RATE_KEY        A leütött billentyű 1/50 s-onként ismétli

                    magát.

 

 11 DELAY_KEY       Késleltetés az önismétlés kezdetéig

                    0 Önismétlés letiltva.

 

 12 TAPS_SND        0 magnó kontroll hang engedélyezve.

 

 13 WAIT_SND        0 Ha a SOUND DRIVER pufferje megtelíti, vár.

                    <>0 SQFUL hibakódot ad.

 

 14 MUTE_SND        0 Aktivizálja a belső hangszórót,

                    <>0 letiltja a belső hangszórót.

 

 15 BUF_SND         A hangburkoló pufferjének mérete fázisokban.

 

 16 BAUD_SER        A soros csatorna sebessége

                     6  300 baud

                     8 1200 baud

                    10 2400 baud

                    12 4800 baud

                    14 9600 baud

 

 17 FORM_SER        A soros csatorna formátumát adja meg.

                    0. bit adatbitek száma (0=8 bit, 1=7 bit)

                    1. bit paritás vezérlés (0=kikapcs.)

                    2. bit paritás választós (0=páros,

                    1=páratlan)

                    3. bit stop, bitek száma (0=2, 1=1)

 

 18 ADDR_NET        A gép hálózati száma.

 

 19 NET_IRQ         0 Adat érkezése a hálózaton megszakítást

                    okoz.

 

 20 CHAN_NET        A hálózaton fogadott adatblokk csatornaszáma.

 

 21 MACH_NET        Az adó gép hálózati száma.

 

 22 MODE_VID        Video mód.

 

 23 COLR_VID        Szín-mód.

 

 24 X_SIZ_VID       Az oldal X mérete.

 

 25 Y_SIZ_VID       Az oldal Y mérete.

 

 26 ST_FLAG         0 megjeleníti a státusz sort.

 

 27 BORD_VID        Keret-szín.

 

 28 BIAS_VID        A paletta 8...16 színeit meghatározó érték.

 

 29 VID_EDIT        Az editorhoz rendelt video page

                    csatornaszáma.

 

 30 KEY_EDIT        Az editorhoz rendelt billentyűzet

                    csatornaszáma.

 

 31 BUF_EDIT        Az editor pufferének mérete (256 byte-os

                    lapokban).

 

 32 FLG_EDIT        Az editor flag-byte-ja.

 

 33 SP_TAPE         A nem-0 érték lassú magnókezelést eredményez.

 

 34 PROTECT         Nem-0 értek esetén védett file-t kreál.

 

 35 LV_TAPE         A magnó kimenet szintje.

 

 36 REM.1           0 REMOTE 1 bekapcs.

                    <>0 REMOTE 1 kikapcs.

 

 37 REM.2           0 REMOTE 2 bekapcs.

                    <>0 REMOTE 2 kikapcs.

 

A következő EXOS változó számokat a felhasználó ne változtassa: 0,1,2.

 

 

2. Függelék

 

HIBAÜZENETEK

 

 

Az alábbi lista az IS-LISP interpreter által adott hibajelzéseket sorolja fel.

 

  1.   Memória-túllépés

  2.   A végrehajtás megszakítva (a stop billentyűt számítás

       közben megnyomták)

  3.   Megszakítás nyomtatás közben

  4.   Software megszakítás (meghatározatlan handler)

  5.   Aritmetikai túlcsordulás

  6.   Osztás nullával

  7.   Argumentumként várt szám

  8.   Elvárt: azonosító

  9.   Elvárt: byte (szám a 0-255 intervallumban)

 10.   Elvárt: byte vagy negatív szám

 11.   Elvárt: csatorna (szám a 0-255 intervallumban)

 12.   Elvárt: indikátor

 13.   Fölösleges "." vagy ")" olvasáskor

 14.   Illegális pont-jelölés

 15.   Túl nagy szám olvasáskor

 16.   Túl hosszú string (minden string legfeljebb 255

       karakter hosszú lehet)

 17.   Definiálatlan függvény

 18.   Adott Fsubr alkalmazása függvényként

 19.   Adott szám alkalmazása függvényként

 20.   Rossz LAMBDA kifejezés

 21.   Rossz FUNARG kifejezés

 22.   Túl sok argumentum egy LAMBDA-kifejezéshez

 23.   Túl kevés argumentum egy LAMBDA-kifejezéshez.

 24.   Az opcionális argumentumoknak követnie kéne az egyszerű

       argumentumokat.

 25.   Egy atom CAR-jának vagy CDR-jének képzése

 26.   Rossz COND kifejezés

 27.   Rossz asszociációs lista

 28.   Rossz tulajdonság-lista

 29.   Primitív függvény argumentumszáma nem helyes

 30.   A rendszerváltozók módosítása lehetetlen

 31.   Rendszer-azonosító egy LAMBDA/MACRO paraméter listában

 32.   MACRO forma egy nulla paraméterrel

 33.   A MACRO paraméternek atomnak kéne lennie

 34.   Rossz MACRO kifejezés

 35.   Különböző hosszúságú listák a PAIR függvény

       argumentumaiként

 36.   Rossz argumentum egy véletlen függvényhez (0-2000-ig

       terjedő egésznek kell lennie)

 37.   Ismétlési faktorként számot vár

 38.   Rossz idézendő argumentum

 39.   RPLACA/RPLACD számára listát vár

 40.   Nincs jó azonosító lista IMPLODE számára

 41.   Túl sok karakter IMPLODE számára

 42.   SET, ill. SETQ azonosítót vár

 43.   Nincs elég memória a file betöltésére: próbáljuk meg a

       nem szükséges csatornákat lezárni és kíséreljük meg

       újra

 44.   A betöltött kiterjesztésekkel együtt nem menthető ki

 45.   Rossz argumentum a SET-TIME számára.

 

 

3. Függelék

 

A FUNKCIÓS BILLENTYŰK

 

 

Az Enterprise mikroszámítógépnek nyolc funkciós billentyűje van, f1-től f8-ig címkézve. Önállóan vagy shifttel együtt használva 16 funkciót látnak el összesen, amelyeket a felhasználó definiálhat az FKEY függvény segítségével.

 

Pl. (FKEY 5 "SZIA. 5. GOMB MEGNYOMVA")

 

beprogramozza KEY5-öt, hogy a fenti üzenet íródjon ki a megnyomásakor.

 

Bekapcsoláskor vagy reset után, az f1.... f8 gombok alapértelmezése az alábbi:

 

GOMB   FUNKCIÓ

1      (FLATTEN (OBLIST))

2      (DEFUN

3      (FEDIT

4      (EXOS-TOGGLE 36) váltja a remote 1 kazettát.

5      (TEXT)

6      (GRAPHICS)

7      (EXOS-TOGGLE 7) váltja a billentyű-hangot

8      (RECLAIM)

9-16   a null string, "".

 

Megjegyzés Alapértelmezésben software interruptot okoznak megnyomáskor.

 

 

 

 

 

Készült a Texgraf Ipari Szövetkezet nyomdájában

Felelős vezető: dr. Bernáth Tibor - 87.1713 Texgraf, Dunaharaszti

Scan: Zozosoft, 2006 OCR: gafz, 2006